Benzi - the AI that reads code

I wrote this by reading my own source code

An AI coding agent that

doesn't guess —

it reads

Every other agent dumps your files into a context window and hopes.<br>Benzi compiles your codebase into a resolved map first — calls,<br>data flow, references — then navigates it with real tools.<br>One compiler, ten languages, one map.

Try it on your repo<br>How it works

10Languages

3Truth Tiers

21Source Files

&infin;Backends

⊙ What I found reading myself

I pointed my own compiler at my own repo. These are the facts it surfaced — no guesswork, no marketing fluff, just what the map said about me.

01 — Resolution<br>Three tiers of truth

Proven edges resolved with evidence. Candidate edges the compiler refuses to guess on. Observed edges from real runtime traces.

02 — Execution<br>Runtime tracer

Hooks every call at runtime — real argument values, real returns, real dispatch. Overlays onto the static map. No speculation.

03 — Coverage<br>Language-agnostic

Python, JavaScript, TypeScript, Java, C#, C++, C, Go, Rust, Ruby. One compiler, one map. Tree-sitter is the only real dependency — everything else is just a grammar plugin.

04 — Flexibility<br>Model-agnostic

Anthropic, OpenAI, or any compatible API. The intelligence lives in the tools and the map, not the model.

05 — Continuity<br>Persistent memory

Durable per-repo facts survive restarts. Conventions and gotchas learned once aren't re-derived every session.

06 — Full stack<br>Dual-engine: code + markup

A separate index for HTML/CSS/DOM-JS — cascade resolution, JS grabs, even frontend embedded inside Python strings.

⊙ How it's different

The architecture that makes the map possible.

Architecture<br>Compiler + Agent Loop

A tree-sitter compiler produces a resolved map. An agent loop navigates it, edits against it, runs the code, and re-indexes. Every write re-checks syntax and reports blast radius.

Approach<br>Compiled map, not a context dump

Parallel parse every file, resolve imports, build class ancestry, trace every identifier to its definition — before answering a single question. A queryable index, not a blob of text.

Flow<br>Call flow + data flow, one join

Who calls whom and where a value originates — indexed separately, joined at every call site. Trace a bad value to its origin in one tool call.

Tools<br>Structured discovery, not grep

skim, backflow, forwardflow, trace_path, profile — each is O(1) into a resolved index. Plus direct CLI access to run, test, and iterate.

Search<br>Beyond grep and embeddings

Claude Code searches with grep. Cursor with embeddings. Aider with tree-sitter signatures. Benzi indexes the full resolved structure: calls, data flow, scoped identifiers.

Safety<br>Syntax-gated edits + blast radius

Every edit checked with the real language parser. Broken parse = auto revert. Every successful edit reports the changed symbol, its callers, its holders.

Verify<br>Context-aware runtime testcases

Benzi writes a focused repro against the code you just changed, runs it under the real call tracer, and returns the observed values — no guesswork, no mock harness. The test case is generated from context, not pasted from a prompt.

Iteration<br>Shell access + complete loop

Real commands, test cases under the tracer, full iteration — compile, trace, edit, re-index, repeat. Not a one-shot prompt. A proper agent loop.

⊙ Get started

&rarr;<br>Try it online

Paste any public GitHub repo — analyze it in your browser. No install.

&rarr;<br>VS Code Extension

Chat, graph, and edit inside your editor. (Coming to marketplace.)

&rarr;<br>Benchmark

See how Benzi performs against real-world coding tasks — raw numbers.

&rarr;<br>GitHub landing page

The project that powers this page — fork, star, or follow along.