DEV Community: Avinash Amudala

A local second brain for coding agents: context, memory and gates in Weftgate 0.2

Avinash Amudala — Sun, 13 Sep 2026 06:56:56 +0000

Coding agents need more than another large context dump. They need a small set of relevant source locations, decisions that are still current, and evidence that their changes connect to the project correctly.

I maintain Weftgate. Version 0.2 puts those three jobs in one local Python package: understand, remember and verify.

Watch the captioned 78-second demo. It uses real CLI output from an intentionally broken fixture, not a field benchmark.

Understand with bounded context

pip install weftgate
cd /path/to/your/repo
weftgate setup --agents codex,claude,cursor,antigravity --hooks --instructions
weftgate card "POST /orders" --budget 1200

Use a route that exists in your project. The card contains source locations and static relationships between declarations, dependencies, env reads and route handlers. It does not load file bodies or pretend to be a runtime call graph. Ambiguous names and missing capabilities remain visible.

The default response is capped at 6,000 UTF-8 JSON bytes, including its accounting fields. That is an estimate of 1,500 tokens, not a guarantee for every model tokenizer. The ledger records actual payload bytes and omissions. It does not invent a savings percentage.

Remember decisions, then recheck their sources

weftgate remember "Order idempotency" "Keep duplicate requests idempotent." --file app/orders.py
weftgate recall "orders"

The path must exist. Weftgate stores an explicit note in a repository-scoped local SQLite database. On recall it checks the cited file hashes. If a file changes or vanishes, the note is hidden by default. The original hashes stay intact until you review and explicitly replace the note.

An unchanged file does not prove the saved prose true. Notes are untrusted context, not higher-priority instructions. There is no automatic transcript capture, embedding download or API key. This mnemo-derived lexical notebook is included in the public package; the separate private companion is not required.

Verify connections and hand off evidence

The gate checks env names, Python and Node imports, and static FastAPI or Starlette references. DATABSE_URL can be rejected against a declared DATABASE_URL; os.environ[key] remains advisory when its key cannot be resolved statically.

[weftgate.workflow]
commands = ["python -m pytest -q"]

weftgate checkpoint --run --require-ready

A checkpoint checks the current changed code, including staged and untracked source files. With explicit execution enabled it observes configured, allowlisted test commands. It distinguishes a proven failure, incomplete evidence, review findings, and a repository that changed while checking. Ready means these checks and commands passed against an unchanged file fingerprint. It does not certify the entire app.

Use the same tools across editors

CLI and MCP use the same implementation. Setup writes project configuration and workflow rules for Codex, Claude Code, Cursor and Antigravity. Completion hooks request bounded repair passes when a proven failure remains. Claude also has a pre-edit adapter for supported Edit/Write/MultiEdit operations.

Trust and enable hooks in each editor. Codex uses /hooks. The other new adapters run after writes, and no local hook is a complete enforcement boundary. Keep the GitHub Action required in branch protection when merges must be gated.

Validation includes 199 local tests, about 91% line coverage, CLI/MCP parity, stale-memory regressions and isolated package installation. See the validation record and activation guide. Every editor build has not been interactively certified.

Try it on a project you know well. I would value reproducible reports about confusing setup, useful context and false blocks. Source and quickstart.

Disclosure: this article and launch assets were prepared with AI assistance. Code behavior is backed by the linked tests and reproducible fixture evidence.

Catch broken environment, import, and route connections with Weftgate

Avinash Amudala — Sun, 13 Sep 2026 05:51:19 +0000

I maintain Weftgate, an open-source verification gate for coding agents. It checks environment-variable reads, dependency imports, and FastAPI route references against contracts in the repository. It runs locally through a CLI, MCP, hooks, and CI.

The core has no runtime dependencies and makes no network calls on its default path. It is an early static analyzer with explicit limits. A passing gate does not prove that an application works.

Start with a small, reproducible case

Use Python 3.10 or later in a fresh directory:

mkdir weftgate-example
cd weftgate-example
python3 -m venv .venv
. .venv/bin/activate
pip install weftgate
printf 'DATABASE_URL=\n' > .env.example
printf 'import os\nurl = os.environ["DATABSE_URL"]\n' > app.py
weftgate check app.py

The environment oracle compares the read with .env.example. The misspelled hard claim rejects, exits 1, and suggests DATABASE_URL.

Correct the reference and check again:

printf 'import os\nurl = os.environ["DATABASE_URL"]\n' > app.py
weftgate check app.py

This time the reference resolves. Now try a computed key:

printf 'import os\nkey = "DATABASE_URL"\nurl = os.environ[key]\n' > app.py
weftgate check app.py

That returns review, with exit code 0. The environment parser does not establish the computed key's value, so the finding stays advisory.

These are constructed demonstrations, not field accuracy benchmarks.

Follow the connections across files

The 58-second demo traces three intentional mistakes in a fixture:

Reference	Repository evidence	Suggested correction
`import requestz`	Dependency declarations	`requests`
`os.environ["DATABSE_URL"]`	`.env.example`	`DATABASE_URL`
Route handler `helth`	Defined/imported handlers	`health`

You can reproduce the broader mutation fixture locally:

weftgate eval mutate --fixture --seed 13

The harness measures detection, blocking, and usable suggestions separately. Its fixture score is not a claim about arbitrary repositories.

Why the uncertain cases matter

An import absent from a manifest can be transitive. A router produced by a factory can register paths that a static scan cannot enumerate. A missing index cannot establish absence. These cases must review or be reported as unverifiable.

An accept result only describes the extracted claims. Continue running your tests, type checker, security checks, and normal review.

Try it on an existing project

weftgate doctor
weftgate audit
weftgate check app/main.py

doctor explains which contracts are available. Environment reads supplied externally should be documented in your declaration source. Python and Node dependency resolution can depend on workspace and runtime configuration, so review findings in context.

For a pull request:

name: Verify connections
on: [pull_request]
permissions:
  contents: read
jobs:
  verify:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v5
        with:
          fetch-depth: 0
      - uses: Avinash-Amudala/weftgate@v0.1.1

MCP clients can start weftgate mcp from the target repository. The tools and CLI call the same gate functions; no separate model API or server account is required.

Help improve the boundaries

The most useful feedback is a minimal example of a false block or a missing contract. There are also contribution issues for workspace fixtures and a first-project walkthrough.

Disclosure: this walkthrough was generated with AI and checked against the project's reproducible fixtures. It does not claim independent benchmark results.

Why Your AI Agent Has Root Access to Everything (And How to Fix It in 3 Lines of Python)

Avinash Amudala — Thu, 16 Apr 2026 23:52:35 +0000

I’ve been building AI agents at work and kept running into the same problem: every framework lets agents call any registered tool with zero safety checks. An agent with database access can run DROP TABLE users and nothing stops it.

So I built AgentShield-FW, a runtime firewall that intercepts every tool call and enforces configurable safety policies before execution.

• GitHub: https://github.com/Avinash-Amudala/AgentShield
• PyPI: pip install agentshield-fw

The simplest usage:

`import agentshield
shield = agentshield.Shield()

@shield.protect
def execute_sql(query: str) -> str:
return db.execute(query)

Agent tries: execute_sql("DROP TABLE users")
→ Blocked by AgentShield: Destructive SQL detected (ASI02)`

What makes it different:
• Zero required dependencies — core runs on Python stdlib only
• 40+ pre-built rules covering SQL injection, path traversal, credential leaks, prompt injection, shell commands, rate limiting
• Mapped to OWASP Agentic Security Top 10 (ASI01-ASI10)
• Works with LangChain, MCP, CrewAI, OpenAI SDK, or any Python function
• Sub-millisecond latency (<1ms p99)
• 94.56% test coverage
• Hash-chained audit logging for tamper detection

Other projects called "AgentShield" are static scanners (analyze config files). This is a runtime firewall (intercepts live tool calls). WAF vs SAST.

MIT license. Python 3.10-3.13.