Every experiment in the paper is one model (Claude Sonnet 4.5) at one reasoning level, run through six pipelines: zero-shot, self-refine, single reviewer, two reviewers, a five-agent baseline, and Adversarial Review. AR is three agents — a coder, a reviewer working on a frozen artifact, and a critic whose job is to audit the review. It scores 87% on LiveCodeBench (versus 82% for the five-agent baseline) and 75.2% on SWE-bench Verified (versus 71.6% zero-shot), and its first attempt on SWE-PRBench underperformed until the authors traced the failure to reviewer and critic collapsing into agreement.
The chart the paper is arguing against is "more agents, more capability". Add a reviewer, add a second reviewer, add a meta-reviewer on top; each step is presented as new evidence and each step costs more tokens. Held to one model at one reasoning setting, that story stops working around three agents, and the three-agent version that wins is not the one with the most reviewers — it is the one whose third agent has been given a job that requires it to disagree well.
Zero-shot, self-refine and one-reviewer land at 77%. Adding a second reviewer buys nothing. The five-agent baseline picks up five points; Adversarial Review picks up ten and does it with fewer agents. That is what the rest of the paper is naming a mechanism for.
The main agent writes the code and does not touch it again until review has finished. The reviewer inspects the frozen artifact and issues flags, each with a citation to the line it is complaining about. The critic reads the review — not the code first, the review — and its whole job is to answer one question: is this review accurate and complete? Step through the three agents.
Two things about this that are not decorative. First: the artifact is frozen while the review is in flight, so no agent gets to trim its own output before the review runs. Second: the critic reads the review before the code, so its default view is of the review as the object under examination — an audit, not a second opinion.
The paper does something rare and worth reading for its own sake: it reports the losing first attempt, in detail. AR without the text constraint scored an F1 of 0.457 on SWE-PRBench — the lowest of every method tested. The authors traced it back to two patterns that surface when you ask two agents to reach a review together.
Both patterns are the same underlying push. When the protocol tells two agents to reach a review together, they reach a review together. That is fine when the code is fine and disastrous when it is not; the fix is to make the reaching cost something.
The critic's response is constrained to one of three tokens, and two of them oblige it to say what it is disagreeing with. Flip the schema on and watch every headline result move — the mechanism is entirely in the constraint on the response, not in a bigger model or another agent.
The reviewer's protocol closes the loop: on DISAGREE_EVIDENCE it must revise the flag against the cited line; on DISAGREE_CONCERN it must either cite code confirming the bug or cite code refuting it — capitulating to a bare "are you sure?" is explicitly disallowed. That is the whole change.
The common shape in production is a coder-plus-reviewer loop, with the reviewer running the same model as the coder. Set your daily task volume and how often the coder ships a defect on its own, then flip the third agent between an unconstrained critic and a cite-required one. The improvement is the paper's, held per pipeline; the volume is yours.
The zero-shot / self-refine / single-reviewer / two-reviewer arms all catch defects at about the same rate on LiveCodeBench because they let the reviewer agree with the coder cheaply. Cite-required disagreement is the lever that turns the extra call into evidence rather than agreement — and it is the one thing you can add to a coding-agent loop tonight without touching the model.