Variant TechnologiesBenzi 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.
github.com/oooscoos/BenziMost codebase questions reduce to three: where is it, what does it touch, and what actually happens when it runs? Benzi compiles the repository first, then gives the agent purpose-built tools to interrogate that same map—using runtime evidence when static analysis can’t settle the answer.
Turn entities into exact symbols and record their relationships, including provenance, before the LLM is loaded. The agent then cuts through the codebase with 30+ targeted tools, relying on compiler-derived structure and avoiding raw source reads where possible.
Trace callers, aliases, callbacks, registry references, and other indirect relationships—not just direct calls. Every edit is parse-checked immediately, and the finished change is statically checked for new errors.
Whatever can only be settled by execution is settled by execution. Dynamic relations start as CANDIDATE; when observed at runtime, they become OBSERVED, with actual arguments and return values recorded by the tracer.
A body tells you what it does. The edges tell you what it means. Switch lenses:
The skeleton. Every proven edge the compiler resolved, plus the candidate edges it couldn't — dynamic dispatch, tagged with the set of overrides it might land on. Walk it forward to see what a route reaches, reverse for the full blast radius.
reverse blast radius main └─ run_capture └─ Sensor.read ← you are here ├─ calibrate └─ db.insert (external) 3 proven callers · 1 possible via dispatch
Trace a parameter backward through the caller's assignments and up the call graph to the literal it originates in — and walk a return forward to where it finally lands.
backflow Sensor.read(sensor_id) sensor_id ← req.query.id @ api.py:41 sensor_id ← route.params @ main.py:12 sensor_id ← "T-42" origin: fixture 2 call sites · 1 defaulted arg
The tool that answers "when does this happen". One-level outline of a body: every branch header verbatim, every loop exit with its label, every early return, interleaved with the calls in source order — indented to real nesting.
def tick(self): if self.game_over or self.paused: return if self.pending: # queued turn self.direction = pending.pop(0) if self._off_board(head) or head in body: return self.end_game() # ← the guard ...
This approximates what Benzi does on a real repo: select a symbol, and its callers, callees and tier come back at once.
Nodes are symbols; edges are resolved calls. Green edges are proven; the tier line names any dispatch candidate.
Precision over recall — a coin-flip would undermine the whole map. So nothing is ever guessed silently; it's tagged.
The compiler resolved the call on hard evidence. This is fact — a caller you can rely on.
Dynamic dispatch and only that. Carries the bounded set of overrides it might land on. Running it is what resolves it.
Seen but not settled — and it says why: opaque receiver, untyped local, or a real name collision with candidates attached.
What actually ran under the tracer, with real argument and return values. The only truth for which dispatch target won.
The index is always in context; facts Benzi learns are saved as durable memories, so a future session opens already knowing them — the convention, the gotcha, the bug's real origin.
# a memory that pays for itself later type gotcha name "config-load-order" body "env.py must import before settings," "or SECRET_KEY reads empty. Load-bearing." # → every future session opens knowing this
Every lookup is O(1): the compiler has already resolved the answers into hashmaps, so the tools read them instead of searching. This list shows 16 of Benzi's 36 tools. Full tool list here.
One configuration, one attempt per instance, no ensembling, no test-time selection — graded by the official SWE-bench harness.
See every run, instance by instance, or read the technical report for the method and setup.
On a separate bug-fixing benchmark: 24 real bugs across 10 languages, each fixed once. The models stay the same — Sonnet and DeepSeek — so the only thing that changes is the harness: Benzi, Claude Code, or a plain DeepSeek harness. Below is how much source each one had to read, bug by bug, easiest to hardest. Hover any point for the bug and its count.
Source lines read (lower is better) across the same 24 bugs — 9,125 and 16,407 for the two Benzi series, against 20,704 for Claude Code and 43,598 for a plain harness. It's the one metric whose measurement is identical across harnesses, and the gap widens with difficulty.
On CodeGraph's own benchmark — their repos, their questions, their methodology — all four answers were scored blind by frontier models, from a fresh account:
Unmatched technical depth, architectural insights, edge-case coverage, and structural visualizations (flowcharts/tables).
Exceptionally precise, concise line-by-line tracing, high citation accuracy, and immediate zero-fluff code mechanics.
Strong overall structure, clear stage-by-stage breakdowns, and reliable coverage of core mechanisms.
Highly readable, great code snippets and summaries, but slightly less granular on deep runtime invariants.
Benzi ranked first with every reviewer. Full results →
Every horse portrait is drawn in code — procedural SVG, no image files — and matched horses flirt back through a live AI model. Frontend, backend and prompts were all written by Benzi.
Nine questions, straight answers — what runs where, what it costs, and how Benzi differs from the tools you already know.
Zero setup in a browser, the full product on your own machine, or the index handed to the agent you already use.
Paste a GitHub URL; Benzi compiles it into a map of calls, data flow and class hierarchy, then answers in a chat panel beside an interactive graph. Read-only — nothing is written to the repo, and there's no signup.
varianttech.net/demo →Benzi reads, explains, runs, edits and checks its own changes. Setup lives in a Benzi settings panel in the sidebar (model, API key, email login). Bring your own key; free during beta.
Get it on the Marketplace →Three commands, one login config shared with VS Code.
$ pip install benziPython 3.11–3.14 on Windows, macOS and Linux. Installs the benzi-login, benzi-mcp and benzi-headless commands.
Emails you a one-time code, then saves your key. The same login works in VS Code.
$ benzi-login --login you@example.com $ benzi-login --anthropic-key YOUR_KEY # or: benzi-login --nonanthropic-key YOUR_KEY
Serves the compiled index as tools to Claude Code, Cursor or any MCP client.
$ benzi-mcp
Point it at a repo from the terminal, for scripts and CI.
$ benzi-headless . "fix the failing test in parser.py"