AST and local parsing: when an agent stops reading code like a novel

Imagine asking an AI agent to “change the discount validation.” It opens the repository and finds 3,000 files. If it treats everything as text, it may search for discount, get 87 matches, and begin a sightseeing tour through the codebase. With luck, it returns before lunch.

A parser provides a better map. Instead of seeing a sequence of characters, it recognizes functions, classes, calls, arguments, and nesting. It is the difference between searching for “pharmacy” on every sign in town and using a map that already understands streets, buildings, and addresses.

This is where syntax trees and local parsing enter the story.

First: AST and CST are not quite the same thing

AST, or Abstract Syntax Tree, has become a popular shorthand for the structure of code. An AST removes details that are not relevant to analysis, such as some punctuation. A CST, or Concrete Syntax Tree, preserves more of the original syntax.

The distinction matters because Tree-sitter, a tool widely used in editors and coding agents, describes itself as an incremental parsing library that produces a concrete syntax tree. Calling it a “Tree-sitter AST” is common shorthand, but it is technically imprecise.

In practice, both turn text into related nodes. Consider:

const total = price + shipping;

A parser can identify a declaration, a name, an assignment, and a binary expression containing two identifiers. The system can now ask “where is this function declared?” or “which calls have three arguments?” without relying only on matching words.

What local parsing means

Local parsing means running this analysis on the developer's machine or execution environment before asking the model to reason. The parser is deterministic: it receives code plus a grammar and returns a tree. It does not need to guess whether something looks like a function.

Tree-sitter is also incremental. When a small portion of a file changes, it can reuse the previous tree and recalculate the affected regions. That helps editors respond while we type and lets tools follow living repositories without processing everything again.

Structural queries can then find patterns. Tree-sitter's query syntax matches node types, while tools such as ast-grep apply the same idea to structural search, linting, and rewriting across languages.

The flow becomes smarter:

1. files are discovered locally;
2. the parser creates or updates their trees;
3. relevant symbols and relationships are selected;
4. only the necessary context goes to the model;
5. the edit comes back and is checked by parsers, types, and tests.

The model remains important. It simply stops receiving the repository as if someone had packed an entire apartment into one unlabeled box.

Less context does not mean worse context

Large context windows invite an apparently simple answer: “send everything.” Real repositories can exceed the window, increase cost, and mix useful clues with dozens of similar files.

Aider describes a Tree-sitter-based repository map that extracts important definitions, connects references, and selects what fits the token budget. It is not a complete tree sent to the model; it is a compact view of the relevant architecture.

Recent research reinforces that retrieval is a problem of its own. The CORE-Bench preprint, with more than 180,000 queries, reports a sharp performance drop when retrieval moves from isolated snippets to repository-level agent scenarios. Agent Retrieval Bench, also a non-peer-reviewed preprint, found that no method dominates every task type. RepoMap delivered the best context yield under an 8K-token budget, while agent trajectories failed to retrieve every relevant file in 27% to 35% of samples.

This does not prove that “AST beats embeddings.” It shows something less marketable and more useful: code retrieval is hard, and different methods complement one another.

Where the tree helps — and where it shrugs

Syntax structure is excellent for:

• locating declarations, imports, calls, and inheritance;
• making repetitive changes without replacing innocent text;
• summarizing a file's shape without sending all of its contents;
• identifying regions affected by an edit;
• checking whether an answer is still syntactically valid code.

But the tree does not know the whole truth. By itself, it cannot tell whether a business rule is correct, whether a function is invoked through reflection, whether a value comes from configuration, or whether two services share an implicit contract. Without type resolution, call graphs, history, tests, and documentation, it can produce an organized — and incomplete — view.

There is also a privacy nuance: parsing locally does not make the entire workflow local. If the tool sends snippets, names, or maps to an external API, that data leaves the environment. The benefit is the ability to select and minimize what is transmitted, not invisibility by decree.

A pragmatic architecture for coding agents

The agent can begin cheaply and precisely: search by path and symbol, run a structural query, and read a few passages. It expands the radius only when the evidence requires it. After editing, it runs formatting, type analysis, and focused tests.

CodeMEM proposes AST-guided dynamic memory for development interactions. Its authors report improvements of 12.2% for current-turn instruction following and 11.5% at session level in their benchmarks, plus two to three fewer rounds. These are promising results from a preprint in a specific setup, not a blank check for every product.

The main point

Agents do not have to choose between “read everything” and “guess.” Local parsing creates an intermediate layer: it turns code into searchable structure, protects the context budget, and provides deterministic checks before and after the model.

ASTs and CSTs do not understand the product. LLMs do not replace parsers. Together, however, they make a capable pair: one organizes the bones of the code; the other tries to understand why that skeleton is charging discounted shipping.

References

• Tree-sitter. Introduction and Query syntax.
• Aider. Building a better repository map with Tree-sitter, 2023.
• Zhang et al. CORE-Bench, preprint, 2026.
• Qin and Xie. Agent Retrieval Bench, preprint, 2026.
• Wang et al. CodeMEM: AST-Guided Adaptive Memory, preprint, 2026.