I made three AI models argue about my code, then judged the winner

I never fully trusted a single model's code review. Different models miss different things, and I wanted that difference working for me instead of betting everything on one. So I built a tool that runs the same review agent across several models and makes them cross-check each other. Here is how it works, and an honest note about what it is and is not yet.

One agent, many models

You already have a review agent defined for one coding CLI, a plain .claude/agents/*.md file. multi-agent runs that same agent on other model CLIs: grok, codex, claude. Each one executes it natively through its own runtime. No API keys, no re-implementation. If the CLI is installed and logged in, the agent runs there.

The point is diversity, not redundancy. When independent models converge on a finding, you get confidence. When they diverge, you get coverage you would not have had alone.

/arena: let the debate stop itself

The first command runs a deterministic tournament.

Round 1        each model audits independently
Round 2        cross-critique: KEEP / WITHDRAW / ADOPT / NEW, each citing code
Round 3, 4...  added ONLY while positions keep moving
Judge          opens the real code, confirms or rejects each disputed claim
Scoreboard     ranks the models, post-hoc

The rounds are convergence gated. My first version ran a fixed number of rounds, and half of them were theater: by round two nobody was changing position, they were just restating themselves with more tokens. Now a round is added only while someone is actually withdrawing a claim, adopting a rival's, or raising a new one. The moment the debate freezes, it ends.

Score the models, but never tell them

The arena ends with a scoreboard, and the design decision I care about most is that the models are never told they are being scored.

The moment a model knows it is in a competition, the incentives rot. It defends a weak finding because withdrawing looks like losing. It nitpicks rivals to farm points. The debate stops being about the code. So the scoring happens afterwards, from the judge's confirmed results: confirmed findings add points weighted by severity, false positives subtract, unique real catches and honest concessions count extra.

The models argue about truth. The ranking is computed behind their backs. Goodhart's law hits language models as hard as it hits people.

The honest part

I have to be straight about the current state, because it would be easy to oversell this.

It was built for and tested on Claude Code. The multi-round arena runs on top of Claude Code's Workflow system, the deterministic runtime you can watch live in /workflows. Claude is also the default judge, because it is the host model and always available.

The other CLIs, grok and codex, are supported as targets: the engine runs your agent on them and collects their findings. What is not shipped yet is native host wrappers for them, because I have not tested that path enough to trust it. The orchestration engine underneath is plain Python and host-agnostic, so those wrappers can be added later, but I would rather say "not yet" than pretend it is done.

There is also a real cost. A full adversarial run is heavy: many model turns, several rounds, minutes to tens of minutes, real token spend, and each round waits for the slowest model. For quick work you use fewer models, or the second command, a live single-model review you can talk to while it works.

Try it

It is open source under MIT. The write-up with the two commands, the exact scoring rules and the full list of limitations is on the project page: multi-agent on dogrubakar.com, and the code is on GitHub.

If you run multi-model review workflows, I would genuinely like to hear how you keep them honest.