Benzi
_{by Variant Technologies}

Benzi compiles your codebase into a resolved, queryable map of calls, data flow, and control flow first; then it explains, runs, edits and verifies your code using it. Includes a runtime tracer that settles what static analysis can’t.

Benzi is free to use — actively in development, a work in progress.

Full README, benchmarks, and demos on GitHub

What is Benzi

Most AI coding agents dump a repository into a context window and hope the model finds what matters. Benzi works differently: before answering anything, a real compiler — built on tree-sitter — parses every file in the project and resolves it into a precise, queryable map. Every symbol, every call edge, every reference, every class in its inheritance chain. One pass, done.

Call flow and data flow are joined at every call site, so a bad value traces to its origin in one tool call. Claude Code greps; Cursor embeds; Aider maps signatures; Benzi resolves — and answers in O(1). Ten languages so far, plus a second engine for markup (HTML, CSS, DOM-JS).

What people say

"78.2% for $37 is a slap in the face to the 'brute force wins' school." — Alex Xiang, zicode (translated)

"Benzi is proving that the core competency of coding tools is shifting from simple 'reading comprehension' to 'structural grasping ability.'" — Gi Pyeong Lee, Tech Blog

"Fewer tokens, no context drift. Wild idea, honestly." — prompt 🤖 AI News

"It analyzes changes before writing them — and beats Claude Code on benchmarks." — Ponte al dIA (translated)

SWE-bench Verified

The full SWE-bench Verified set — 500 real GitHub issues from twelve Python repositories — run end to end on DeepSeek v4-flash, one attempt per instance, graded by the official swebench.harness.run_evaluation inside its own per-instance Docker images, with network access to GitHub and PyPI blocked inside every container.

Full technical report and per-instance breakdowns: GitHub.

How it works

1. Compile. Tree-sitter parses every file; imports are resolved, class ancestry built, every identifier traced to its definition. The output is an index, not a blob of text.
2. Query. The agent answers questions and plans edits through structured tools over that index — profile, get_callers, backflow, trace_path, skim_source, and ~30 more.
3. Edit, gated. Every write passes syntax and semantic gates against the real language parser — a broken parse auto-reverts, checking blast radius before a change lands, not just after.
4. Verify by running it. A focused repro runs under a runtime tracer — real argument values, real returns, real dispatch — which both proves the change and settles the map.
5. Reindex, incrementally. The map follows the filesystem, never the agent's account of what it did — each turn re-parses only the files whose bytes actually moved.

Tools

A sample of Benzi's 35+ tools — the full list is on GitHub:

Full list of 35+: GitHub.

Features

• Six states, never a guess — every call site and file carries one: resolved, external, candidate, unresolved, observed, or unindexed. Whatever static analysis can't settle is flagged as unsettled, not guessed.
• Runtime tracer — hooks every call during execution and overlays the observations back onto the static map.
• Persistent memory — durable per-repo facts survive restarts.
• Dual-engine: code + markup — a separate index for HTML/CSS/DOM-JS.
• Model-agnostic — Anthropic, OpenAI, or any compatible API.

Language support

Python · JavaScript · TypeScript · Java · C# · C++ · C · Go · Rust · Ruby

One compiler, ten languages. Python is deepest — it's the only one with the runtime tracer. Depth varies elsewhere; see Language support on GitHub for specifics.

Install

pip install benzi

# one-time setup -- verify your email, then bring your own API key
benzi-login --login you@example.com
benzi-login --anthropic-key sk-ant-...       # or --nonanthropic-key for
                                              # groq/deepseek/kimi/etc

# then, from inside (or pointed at) any repo:
benzi-headless . "what does this repo do?"

This also installs benzi-mcp — the same compiled index exposed as tools over MCP, for whatever agent you already run (Claude Code, Cursor, your own harness). Point your MCP client at it after the same benzi-login step; output quality then depends on that harness, since this mode has no agentic loop of its own.

. means "the repo I'm standing in" — pass a path instead if you're running it from somewhere else. Your key stays on your own machine and talks to your model provider directly; Benzi's servers never see it or proxy the call. Run benzi-login with no flags any time to see what's currently saved, or benzi-headless --help for every option.

Benzi is also available as a live web demo (no install, no key needed) and a VS Code extension.

FAQ & comparisons

Do I need an API key? For the CLI, MCP, and the VS Code extension, yes — bring your own Anthropic or OpenAI-compatible key. Only the browser demo runs without one.

How is this different from Cursor, Copilot, or Claude Code? They find code by searching text — grep, or embedding similarity. Benzi resolves it first: a tree-sitter compiler builds a real index of symbols, call edges, inheritance and data flow, and the agent queries that index instead of guessing which files to read.

Full FAQ & comparisons (privacy, pricing, limits, and how Benzi compares to Claude Code, LSP servers, CodeQL and CodeGraph): GitHub.

_{Full README on GitHub — benchmarks, demos, and more.}