Building zerd · 2026
Published · 9 min read
Why choose zerd, and where it loses.
The case for choosing zerd over a general coding agent, argued from what the agent can't be trusted to do. Proof instead of assertion, the cost of a wrong claim against the cost of a check, model choice as a real lever, and the places where another agent is the better buy.
I built zerd, so I have a bias about it. This post is the argument I'd make to a team that asked me to pick one, and then the places where I wouldn't recommend it. The bench numbers I quote are from my own runs, and I say what they don't cover.
The problem is a claim you can't check
Every coding agent ends with a sentence. "Done." "Fixed." "Tests pass."
The sentence is free and the model wrote it. Sometimes it's wrong, and the cost of finding out is not the same for everyone. For a script that generates a report, a wrong "done" costs a minute. For a payment service, it costs an incident, and somebody has to roll it back at 2am.
So the question isn't which agent writes the nicer code. It's which agent makes the finished state checkable.
zerd's whole design is that a run has a status, decided in code, and the status is one of verified, unverified, verification_failed, failed or done_no_changes. There's no bare "done", because a bare "done" is a claim with no evidence attached.
If you've ever shipped a change that a test didn't cover, you already know this is the part that matters.
A check costs less than a wrong claim
This is the whole economics, and it's why verification survives the price of tokens.
A check on the changed files takes seconds. An independent review of the diff takes a couple of minutes and some tokens. A wrong claim in production takes hours of debugging and, if it's in the payments path, real money.
That ratio doesn't change with the size of your model. It's the same on a 500-line service and a 50,000-line one, because zerd only checks the files that changed.
Two things make it affordable:
Checks are scoped. zerd runs pytest for the tests that import the changed module, go vet, cargo check, eslint, or tsc --noEmit for the package a changed TypeScript file lives in. Never a whole build.
The context is cheap. A file read costs its size times the number of calls that follow it. zerd remembers which lines the model has already seen and sends only what's new, or a diff if the file changed. Big tool output is capped and archived, and the model pulls any range back with recall_result. Compaction asks the same model, on the exact prefix it just sent, so the provider serves the summary from cache.
In one live run on my own repo, 85% of input was cached, and 52% of that was earlier tool results travelling along again. Those are provider numbers from that run, not a guarantee for yours.
The model becomes a dial, not a decision
The most useful thing in zerd isn't a capability. It's that the model stops being the only thing you chose.
Routing is by role: default, fast, strong, summarize, review, advisor, challenge. Each role is a fallback chain across providers. A request is classified without a model call, so small work goes cheap and debugging goes strong. A failed repair or a detected loop escalates.
That's why the model-repair layer matters. A weak model makes mechanical mistakes: a wrong tool name, a stringified argument, a reply cut off mid-sentence. zerd fixes those in code, so they don't depend on how good the model is that day. Once they're handled, an open model on the hard 80% becomes a real option, and cost stops being a reason to use a bigger model everywhere.
If you're paying frontier prices for every edit because your harness can't survive a cheap model, that's a harness problem, and it's fixable.
The parts that are code, not prompts
This is the part I find hardest to argue against, because a prompt can say the same thing and doesn't enforce it.
One door. Every tool call, from the main agent, a sub-agent or a parallel worker, passes through one function. Guard rules, workspace confinement, approvals and the OS sandbox all hang off it. I built it that way after the first bug I hit, which was commands that needed confirmation being approved silently. Nobody was asked. If a different path can skip a rule, the rule is useless.
Read before edit. Editing a file the agent hasn't read this session is refused, and so is editing one that changed on disk since it was read. A small file comes back inside the refusal so the retry needs no extra round.
Per-edit diagnostics. An edit result comes back with the problems that edit introduced. Python syntax and ruff, JSON and TOML parsing, node --check, gofmt, and for TypeScript your project's own tsserver, kept running, so real type errors show up in the same turn. Anything already there is ignored, so the model doesn't go fix lint it didn't cause.
A citation check that isn't a model. Every path and path:line in the final answer is looked up in the real tree. A made-up file, or a line past the end of a real one, goes back for one correction, and whatever's still unverified shows as a warning. It's a few dozen lines of code, and a model would be worse at it, since a model can be confidently wrong about whether a file exists.
It won't edit what it hasn't read, and it says what it didn't do. A review states what was reviewed, whether that was the working tree, three commits or a PR, and every fallback it took. It says when passing checks don't exercise the change, and it labels guesses [guess].
Independent review, with a referee
A model reviewing its own work tends to agree with itself. So a second model on a different provider reads the real diff, through separate lenses: behaviour, approach, failure modes, project rules, git history, security, and a producer-to-consumer contracts pass.
Then a finding is treated as a claim. A verifier's job is to disprove it, six claims at a time, and it has to name the exact line it read. A confirmed high-severity finding goes to a repro agent that tries to make the defect happen in a sandboxed copy of the change. If it can't, the finding is capped at medium and shows what was tried. A finding that cites a file that doesn't exist is dropped before anyone reads it.
Refuted claims are remembered per repo for two weeks, so the same non-issue doesn't come back.
This costs more than a plain review. I get fewer findings and more of them are true. I'd rather read five of those than twenty.
What my own runs say, and what they don't
I ran zerd and Claude Code on the same job, separately, and gave both the same 15 failure scenarios for a payment-webhook service: 100 identical webhooks at once, two events for one payment, a worker killed mid-job, Redis down, Postgres down, retries running out, bad signatures, cross-tenant admin calls, out-of-order events, a crash between commit and ack.
| zerd (MiniMax M3) | Claude Code (Sonnet 5.5) | |
|---|---|---|
| Scenarios with an automated test | 15 / 15 | 14 / 15 (one kept as a known failure) |
| Database | real PostgreSQL, isolated database | in-memory repository |
| Queue | real Redis client, DB index 5 | enqueue made to throw |
| Worker crash | a real child process, SIGKILL | lease expiry simulated |
| Concurrency | 25 repeated races on one payment | Promise.all of 100 in memory |
| Real bugs found | 12, each reproduced or checked directly | 3, each reproduced |
The bugs it found were the ones that only exist in the real thing: unquoted camelCase SQL identifiers, so no webhook ever persisted. A lost update under concurrency that left a captured payment marked failed, fixed with row locking. Retries scheduled about 5.5 hours late on an IST machine, a timezone bug. Redis down made the outbox stall forever, fixed with a bounded timeout. Two dispatchers enqueuing the same event.
Claude Code's strength was service-level reasoning. It found a refund applying before its capture when events arrive out of order, which zerd missed, and it was upfront that it hadn't touched real Postgres, Redis, HTTP or process kills.
Read it for what it is. One project, one run each, and the two agents did not test at the same depth, so it measures how far each one verified as much as how well it engineered. Neither result is production ready. zerd's own report lists merchant-controlled tenant ids, one shared secret, one shared admin token and unauthenticated /metrics.
An earlier round on 11 small tasks ended 10/11 each, with different models. That's a sanity check, not a leaderboard. What it changed was the code: the miss became the signature guard, and the 31 of 113 model calls that only updated a todo list now ride along with the next real call.
Where another agent is the better buy
I'd rather lose a customer than oversell.
If you want the best code and money isn't a factor. zerd's review and verification layers add time on top of the model's writing. If your bottleneck is raw code quality from a frontier model and you're not shipping to production paths where a wrong claim costs, a good agent with a strong model may serve you better today.
If you need a mature ecosystem. zerd is young. It has MCP support, hooks, slash commands and project tools, and I use it on my own production repos every day. It isn't the place to go for a large plugin catalogue.
If you're on Linux or Windows and the kernel sandbox matters to you. The OS sandbox is macOS only. On Linux and Windows you get the confined file tools and the shell path scan, which is a real boundary but a thinner one than a kernel-level one.
If your repo has no tests. zerd picks checks for the changed files and runs the ones your project already has. No tests means the verification layer has less to work with. It asks the model to run something that proves the change instead, which is weaker. The tool that shows you the evidence is only as good as the checks that exist.
If you don't want to review the output. zerd hands you a diff to look at, and a review to read. It reduces how often you're wrong. It doesn't remove the reading.
The reason I'd choose it
If you can't afford to be wrong quietly, and your work reaches production where a broken assumption becomes someone else's incident, the agent you use should make its own claims checkable.
That's it. A finished change is one whose behaviour has been verified, not one whose code exists. zerd is built around that, and it tells you which parts it couldn't check.
It's one binary, and you can read the source: github.com/Adityaadpandey/zerd.si. www.zerd.si has the install command.
The source is not open. You can run it for anything, including commercial use, and redistribute unmodified official binaries. You can't copy, modify or reuse the source.
By Aditya Dutt Pandey, CTO of tunyt