What if coding agents didn't have to read code?

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

SWE-bench Verified · 500 instances · one attempt each

swebench.harness.run_evaluation

The full SWE-bench Verified set — 500 real GitHub issues from twelve Python repositories — run end to end through Benzi on DeepSeek v4-flash, graded by the official SWE-bench harness inside its own per-instance Docker images. Network access to GitHub and PyPI was blocked inside every container, so nothing could look up an answer.

Try Benzi Two capabilities, side by side. On the left, Benzi taking apart a 30-year-old engine. On the right, a whole app it built from a single chat.

No summaries from memory — the actual source, resolved and explained.

Everyone says DOOM’s engine was ahead of its time. Almost nobody has opened z_zone.c

to see why. So Benzi did. A few things were worth writing down.

malloc() during gameplay.id wrote their own memory allocator — one big arena grabbed once at startup, sliced into blocks tagged by how precious they are (PU_STATIC

, PU_LEVEL

, PU_CACHE

…). The genius part: allocating new memory can silently evict old “cache” blocks it walks past along the way — no one calls free()

, the allocator just decides your cached texture is cheap to regenerate and reclaims the space on the spot. That’s cache-eviction policy baked directly into the allocation path itself. malloc

/free

still can’t do that today.

tables.c

is a 2,000+ line file that is almost entirely one thing: every sine, tangent and arctangent value the engine will ever need, precomputed at compile time into lookup tables. Movement, angles, rendering — all fixed-point integer math against these tables. Not every ’93 machine had an FPU, and even where it did, table lookups beat live trig every time.

screens[0] is a flat 320×200 buffer, one byte per pixel. The 3D world gets drawn into it column by column. Then the HUD gets stamped on top using the exact same pixel-blitting function used to draw monster sprites and gun sprites. There is no UI toolkit, no widget tree, because there was nothing to build one on top of: the game owns the entire display, full stop. A health digit and a demon sprite are the same kind of draw call.

p_maputl.c

splits the map into a grid (the “blockmap”) so hit detection only checks nearby geometry instead of scanning every wall in the level — a spatial hash, built from scratch, years before that was a common technique people talked about.

None of this was over-engineering. Every one of these systems exists because the standard answer (malloc, floats, a GUI library, brute-force collision) either didn’t exist on the target hardware or would have been too slow — and Benzi surfaced each one by resolving the actual code, not guessing from what it remembered about DOOM.

A dating app for horses, greenfielded in one chat session.

Procedural SVG portraits (no image is a file — every horse is drawn in code), a swipe deck, and live AI chat where every match flirts back through a real model. Frontend, backend, and the prompts — all written by Benzi.

24-bug cross-harness benchmark · each point is one bug

Lines read counts only what came back from file-read calls — grep and shell output are search, not reading. It is the one figure that means the same thing in every harness, which is why it is the one compared here.

From the 24-bug cross-harness benchmark: every harness opens more source as bugs get harder — the question is the slope. Each point is one bug, laid out easiest to hardest, left to right. Hover any point for the bug and its count. Difficulty is Claude Code's turn count on that bug — a third-party yardstick, so no harness sets its own position on the axis. Lines read counts only what came back from file-read calls; grep and shell output are search, not reading. The figure beside each line is its slope: how many extra lines that harness opens per step of difficulty.

The same 24 bugs in the same order, with wall clock in place of lines read.

Wall clock is raw — Benzi's per-repo index build is not subtracted. Each point is that harness's most recent solved run for that bug; unsolved and unfinished runs are left out rather than plotted as fast. Benzi on Sonnet never solved http-parser and the DeepSeek harness never ran nats-server, so those two points are absent and neither enters its fit.

And the same again with dollars on the vertical axis.

Priced at the published per-token rates, same run selection as the chart above. The two DeepSeek series run an order of magnitude cheaper than the two Sonnet ones, so at this scale they sit close to the baseline. What the axis does show is the slope: Claude Code's cost climbs with difficulty faster than any other series here. Full tables behind every point live on the

benchmark page. The architecture · one compiler, one agent loop

Everything that falls out of actually resolving the code — from the index itself to the gates on every write.

Every file parsed, imports resolved, class ancestry built, every identifier traced to its definition — before a single question is answered. 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; Benzi resolves — and answers in O(1).

Every write passes syntax and semantic gates against the real language parser — a broken parse auto-reverts. Every write that lands reports its blast radius: the changed symbol, its callers, its holders — and the same analysis pulls in the selectively relevant existing tests.

Proven edges carry evidence. Ambiguous calls keep their candidate lists instead of a guess. Runtime traces settle what static analysis can't.

Every unresolved call is classified: a library call, an in-repo call with recorded candidates, or an honest unknown with the ID the compiler supposed.

Follows actual execution through the compiler's map — real arguments, real returns, real dispatch — overlaid back onto the static index.

A focused, model-generated repro against the exact change, run under the tracer to fast-track testing. No mock harness.

The map that drives the tools drives the live call graph beside the chat. When Benzi names a function, that node lights up.

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

Durable per-repo facts survive restarts — conventions learned once aren't re-derived every session, and wrong memories get deleted, not hoarded.

Anthropic, OpenAI, or any compatible API — and when a task outgrows the model running it, Benzi escalates itself to a bigger one mid-task.

Links · everywhere Benzi lives