ZAP Coding Agent: The 31-Token Local Agent Bet

ZAP coding agent is worth testing before it's famous because it attacks two real coding-agent costs: lookup noise and prompt bloat. The June 2026 project-linked prompt-optimization writeup reports a greeting path that drops from about 4,096 tokens to about 31 through lazy-loaded skills, while its AST index uses Tree-sitter, SQLite, and PageRank-style ranking.

The caveat is hard: local-first is supported, but offline model execution and air-gapped readiness were not verified by the research.

That makes ZAP a pre-press local coding agent story. Its design puts code structure and per-turn context controls ahead of generic retrieval, which is where many RAG-based coding agents still spend too much context. The proof trail is thin, so run an evaluation before production use.

What is ZAP and how does it differ from other local coding agents?

ZAP is a terminal-first Rust AI coding tool centered on a local AST code index and lazy-loaded skills. Its differentiator is per-turn context control: it tries to load only the code structure and instructions a task needs, while established agents lean more on prompt files, IDE workflows, benchmarks, or larger ecosystems.

The ZAP repository frames the tool as terminal-first. The research also identifies a Rust single-binary posture without a Node.js or Python runtime dependency, which matters for teams that dislike runtime drift in local tooling.

The code indexing demo README confirms that ZAP ships code-indexing documentation. A HiFriendbot listing describes it as "a terminal-first AI coding agent with AST-based indexing," which matches the public positioning.

The big design claim comes from the June 2026 writeup: ZAP combines Tree-sitter parsing, SQLite symbol storage, PageRank-style ranking, and lazy-loaded skills. That source also says Gemini CLI/OpenCode-style prompt assembly loads about 954 lines, 68,410 characters, or roughly 4,096 tokens on an interactive turn.

Current evidence table

Public evidence is dated. The prompt-optimization writeup is from June 11, 2026, Sanjeev Gulati's ZAP posts are from 2026, and this status check is current to July 7, 2026.

The table is the adoption reality check. ZAP has a sharper retrieval thesis than many better-known tools, but the better-known tools have more public validation.

How does ZAP's AST code index work?

ZAP's AST code index parses source into syntax trees, stores symbol information in SQLite, and ranks important symbols with a PageRank-style method. The useful effect is structural lookup: the agent can search for definitions, calls, and central symbols without sending broad text chunks into context first.

Text search operates on characters. AST search operates on code structure.

That difference matters when the task is symbol-shaped: find callers of an API, identify the definition that owns a behavior, or locate central functions in a large module. The June 2026 writeup says ZAP uses Tree-sitter for parsing, SQLite for storage, and PageRank-style ranking for symbol importance.

Exact search still belongs in the workflow. The same writeup summarizes a third-party benchmark where AST-assisted lookup delivered a 62x token-efficiency improvement versus naive grep and reduced tool calls from 7-12 to 1, while a tuned ripgrep query beat AST by 9 F1 points.

That is the real trade. AST indexing can reduce context load when the question maps cleanly to code structure. Tuned ripgrep can still win when the human knows the exact naming pattern or file path.

How do lazy-loaded skills reduce prompt size?

Lazy-loaded skills reduce prompt size by keeping rarely needed instructions outside the active turn until a task calls for them. In ZAP's author-attributed greeting path, the initial prompt drops from about 4,096 tokens to about 31, a 99.2% reduction before real task context is loaded.

Coding agents accumulate permanent prompt material: tool schemas, coding rules, formatter hints, safety rules, repo conventions, and workflow instructions. ZAP's reported skill system turns that permanent load into on-demand instructions.

The June 2026 writeup says Gemini CLI/OpenCode-style prompt assembly loads roughly 954 lines and 68,410 characters per interactive turn. ZAP's greeting path reportedly starts around 31 tokens.

Read the chart narrowly. It covers a greeting path only, and real coding tasks will load skills, source snippets, diffs, errors, and test output.

The separate AST MCP article reported 70% token savings; this should be cited only as adjacent evidence, not evidence about ZAP.

Does ZAP run fully offline?

The verified boundary for ZAP is local-first terminal posture. The research did not verify offline model execution, telemetry absence, package behavior, signed release assets, prebuilt binary provenance, supported platforms, or a reproducible air-gapped installation path as of July 7, 2026.

A local binary can still call a remote model endpoint, check for updates, download packages, emit telemetry, or fail when a model server is unreachable. None of those paths were independently tested in the available evidence.

The local-first claim is still useful. A Rust AI coding tool with no Node.js or Python runtime dependency can reduce installation surface area in locked-down environments.

For an air gapped coding agent evaluation, test the whole chain. Block egress, index the repository, ask for a code edit, run tests, inspect logs, and confirm that the model backend is local before restricted source enters the workflow.

How does AST indexing compare to RAG for code search?

AST indexing and RAG answer different retrieval questions. AST is better suited to symbol-shaped tasks such as definitions and callers, while RAG can help with prose-heavy or conceptual lookup. The research gives ZAP-specific architecture data, but it does not provide a ZAP head-to-head benchmark against RAG.

RAG typically chunks code or documentation, embeds those chunks, and retrieves semantically similar context. ZAP's reported design queries structured code data directly through the AST index.

The narrower conclusion is the useful one: test retrieval by query type. "Where is this function defined?" should be measured separately from "Which subsystem owns this customer-facing behavior?"

ZAP's missing benchmark is straightforward. Publish repo size, language mix, index time, memory, query latency, tokens per task, tool calls per task, solved-task rate, and network behavior under blocked egress.

What are ZAP's current limits?

ZAP's current limits are evidence limits: no independent solved-task benchmark, no verified setup time, no query-latency data, no memory profile, no release provenance, and no confirmed IDE plugin. The architecture is concrete, but the operational envelope has to be measured before restricted code depends on it.

The available public footprint is small. ZAP appears in niche directories such as Awesome Skills, AI Hunt, MCPMarket, and UIComet Launches, but those listings do not replace field reports.

Sanjeev Gulati's 2026 LinkedIn post framed ZAP around "context visibility and control." That is the right theme, and it is still a thin user-report base for a self hosted coding agent.

The report found no VS Code, JetBrains, Cursor, or hosted IDE plugin. If IDE integration is a hard requirement, compare ZAP against Cline, Zencoder, or Claude Code first.

When ZAP is worth trying

Try ZAP if your current coding-agent pain is measurable prompt waste. Start with a repo where you already log prompt tokens, retrieval misses, edit success, and test outcomes.

ZAP is also worth studying if you are building an internal coding agent. The pattern is portable: keep the baseline prompt small, index code structurally, route symbol-shaped questions to syntax-aware tools, and load task instructions only when needed.

Wait on broad rollout if you need public benchmarks, signed release assets, a verified air-gap install, or mature IDE workflows. Those are operational requirements, and the available ZAP evidence does not cover them yet.

For language support, avoid assumptions. The report did not provide a ZAP-specific language matrix or polyglot test, so run indexing and query tests on your actual repository before trusting the AST code index.

Practical takeaways

Use ZAP as a design probe. If your current local coding agent loads thousands of tokens before it reads code, the 31-token greeting-path claim gives you a concrete target to beat or falsify.

Build your benchmark around task classes. Measure exact-string lookup, definitions, callers, interface changes, config references, failing test traces, and broad conceptual questions separately.

For offline AI coding agent work, set acceptance criteria before the demo. Require blocked-egress operation, local model compatibility, transparent logs, deterministic index rebuilds, documented package behavior, and a clear failure mode when a skill cannot load.

ZAP's architecture deserves attention now because it attacks a real systems problem. Its production case begins when the AST index, lazy skills, and local-first posture survive independent measurement.

Sources

• ZAP coding agent GitHub repository
• ZAP code indexing demo README
• Edition 67: Automatic Prompt Optimization in 2026
• I Built a Code AST MCP That Saves 70% Tokens
• OpenCode adoption and star-count article
• Aider OpenAI 1106 benchmarks
• Aider benchmark README
• Google Gemini CLI announcement
• Cline vs OpenCode comparison
• Claude Code product page
• Zencoder AI coding agent
• Sanjeev Gulati ZAP context visibility post