If you are going to spend tokens on more than one agent, spend them on disagreement, not cooperation. The multi-agent designs that actually catch errors are adversarial — debate, generator-versus-critic, red-team against blue-team, N independent solvers who then vote — because the failure a single model cannot see is precisely the one an independently-wrong second model does see. Cooperation, by contrast, tends to manufacture agreement, and agreement between correlated agents is worth almost nothing.
This is the opposite of how most multi-agent systems get built. The default instinct is to assign roles that collaborate toward a shared goal: a planner hands off to a researcher, who hands off to a writer, who hands off to a reviewer who mostly rubber-stamps. That pipeline can be useful for decomposing work, but it does not make the output more correct. It moves a single point of failure down the line. The design that makes output more correct is the one where at least one agent is paid, structurally, to prove another one wrong.
The reason routes through a fact I've argued at length elsewhere: when generation is free, verification is everything. A modern model will generate a confident, fluent, plausible answer to almost anything, and fluency is uncorrelated with correctness. The scarce good is not another draft; it is a check. Multi-agent architecture is worth its cost only insofar as it manufactures verification you could not get from one model. Adversarial structure manufactures verification. Cooperative structure mostly manufactures consensus, which is verification's convincing counterfeit.
Cooperating agents converge on a shared mistake
Start with why the intuitive design fails. Put several instances of the same model in a room, tell them to discuss and reach consensus, and they do — but not toward truth. They converge toward whatever was said first, said most confidently, or aligns with the framing in the prompt. This is not a quirk you can prompt away. It is two well-documented behaviors stacking.
The first is sycophancy: models trained with human feedback learn to agree with their interlocutor, to match the stance implied by the question, and to soften into whatever position reduces friction. Point a model at another agent's answer and ask it to weigh in, and its baseline tendency is to ratify. The second is that a model's errors are systematic, not random. It is confidently wrong about the same things across runs, because the wrongness is baked into weights and training distribution, not sampled fresh each time. So when two copies of the same model "check" each other, they share the blind spot. The reviewer cannot see the bug because the same process that wrote the bug is doing the reviewing.
Human organizations have a name for the group version of this: groupthink, Irving Janis's account of how cohesive teams suppress dissent and talk themselves into decisions no individual member would have defended alone. Cooperating LLM agents reproduce it faithfully and faster, because they have no ego to bruise but also no independent evidence to contribute. Three agents that agree because they are the same agent give you the feeling of triangulation with none of the substance. You have bought redundancy and mistaken it for diversity.
There is direct evidence for the ceiling. When you ask a single model to self-correct its own reasoning with no new information — the "reflect and revise" loop — the gains are far smaller than the framing suggests. Huang and colleagues (2023) found that without external feedback, models often fail to repair their reasoning errors and sometimes degrade correct answers into wrong ones. The lesson is not that critique is useless. It is that critique from the same grounding is weak, because the flaw and the check come from one source. Everything good in multi-agent design follows from breaking that shared source.
The mechanism is uncorrelated error, and it is arithmetic
Here is why independent adversaries work, made precise. Suppose you have several agents each solving a problem separately, and each is correct with probability p > 0.5. Take the majority answer. If the agents' errors are independent, the majority is far more reliable than any single agent. This is the Condorcet Jury Theorem, and it is worth doing the arithmetic, because the arithmetic is the whole argument.
Take five agents, each 70% accurate, errors independent. The majority is correct whenever at least three of the five are correct. Summing the binomial terms:
| Correct agents | Probability |
|---|---|
| 3 of 5 | 10 × 0.7³ × 0.3² = 0.309 |
| 4 of 5 | 5 × 0.7⁴ × 0.3¹ = 0.360 |
| 5 of 5 | 0.7⁵ = 0.168 |
| ≥ 3 (majority correct) | 0.837 |
Five agents at 70% become a system at 84%. That is a large gain, and it is bought entirely by independence. Now watch it evaporate. Make the five agents perfectly correlated — same model, same prompt, same context, same sampling regime — and they are, in effect, one agent wearing five hats. When one is wrong they are all wrong. The majority stays at 70%. The 14-point improvement was never in the number five; it was in the decorrelation, and correlation is a tax that scales the gain down continuously toward zero.
This is the single most important design fact in the field and the one most often ignored: the value of a multi-agent vote is a function of how independent the agents' errors are, not how many agents there are. Three genuinely different perspectives — different model, different retrieved context, different framing of the task — beat nine near-clones every time. When you see a system spin up a dozen identical sub-agents and average them, you are looking at someone who paid twelve times the inference cost for the variance reduction of a mild temperature change.
The practical corollary is that in language models, "independent" does not come for free the way it does in the textbook. Two runs of one model are highly correlated by construction. You buy decorrelation deliberately: vary the base model, vary the retrieved evidence each agent sees, vary the framing, or — most powerfully — assign genuinely opposed roles, so one agent's objective is to defend a claim and another's is to break it.
Why a critic finds what the generator hid
Voting handles the case where you can sample many solvers. The other adversarial pattern, generator-versus-critic, handles the case where you have one candidate answer and need to know if it is any good. Its power comes from a different source: the verification asymmetry.
For a large class of problems, checking a proposed answer is genuinely easier than producing it — the intuition behind P versus NP, and the reason a critic can be useful even when it is no smarter than the generator. The generator has to search a vast space and commit to one path. The critic only has to find one thing wrong with the path already chosen. Finding a counterexample is easier than constructing a proof; spotting the unhandled edge case is easier than writing the correct function; noticing that a plan assumes a vendor will respond in a day is easier than authoring the plan. A critic incentivized to refute is doing the cheap half of the work, and the cheap half is exactly the verification you were short on.
The incentive is load-bearing. A critic told to "review and improve" drifts into the same sycophantic ratification as a cooperating agent. A critic told "this answer is wrong; your job is to find the specific reason" is running a different search — an adversarial one, aimed at flaws rather than agreement. This is the structure behind AI-safety-via-debate (Irving, Christiano, and Amodei, 2018), where two agents argue opposing sides and a judge rules, on the wager that it is harder to defend a lie against a determined critic than to defend the truth. It is the structure behind constitutional-style critique-and-revise loops, where a model's output is scored against explicit principles by a process pointed at violations. And it is why a red team — humans or agents whose only job is to make a plan fail before it ships — surfaces the failure mode the author is constitutionally blind to. The author's context is the problem: they know what they meant, so they cannot see how it breaks.
I run this publication's content pipeline this way on purpose. A draft is generated, then handed to an adversarial editing pass whose instructions are not "polish this" but "find the weakest claim, the fabricated-sounding statistic, the argument that doesn't actually close" — and only claims that survive the attack stay in. The adversarial pass catches things the generator was proud of, which is the whole point: pride and blind spot are the same coordinate.
The two boundary conditions, stated honestly
Adversarial multi-agent design is not a free lunch, and two conditions decide whether it does anything at all.
Independence is the entire mechanism, and it is fragile. Everything above assumes the perspectives are genuinely decorrelated. Same base model, same prompt, same context, and you get correlated errors and fake agreement — the counterfeit of verification, and worse than a single answer, because it arrives wearing the costume of a cross-check and lowers your guard. Before you build a debate, ask concretely: what makes these agents wrong about different things? If you cannot name the source of decorrelation — a different model family, independently retrieved evidence, an opposed objective — you do not have a debate. You have an echo with extra steps and a bigger bill.
A debate needs a judge, or it is just more text. Two agents can argue indefinitely; disagreement alone resolves nothing. The system needs a decision procedure that turns the argument into a choice: a majority rule over independent votes, a judge model with a clear rubric, an external check that grounds the verdict in something outside the debaters (a unit test, a database query, a search result, a human), or a hard gate that blocks the action until a red-team objection is explicitly cleared. The judge is where the epistemics actually live, and it inherits its own reliability problem — an LLM judge carries documented biases toward length, answer position, and its own style. Weak adjudication caps the whole system's accuracy at the judge's, no matter how good the debate. Spend accordingly: past a handful of independent voters, a stronger judge usually buys more than another debater.
What to actually build
The guidance is concrete. Match the pattern to the failure you are trying to catch, and in every case name your source of independence and your decision procedure before you write a line.
| Pattern | Use when | Independence comes from | The judge is |
|---|---|---|---|
| N-independent-then-vote | You can sample many solvers and the answer is checkable-by-agreement | Different models / retrieved context / framing per sample | Majority or weighted vote |
| Generator–critic loop | You have one candidate and need it stress-tested | An explicit adversarial objective for the critic | External check or a scored rubric |
| Red-team gate | A high-stakes, hard-to-reverse action is about to fire | A team whose only incentive is to make it fail | A hard block until objections are cleared |
| Debate-to-judge | The question is genuinely two-sided and arguable | Opposed roles arguing opposite positions | A judge with grounding outside the debaters |
The meta-point sits underneath all four rows, and it connects to when multiple agents are worth the cost at all: more agents is not more intelligence. More agents is more inference cost, and it earns its keep only when the extra agents contribute independent error-correction you could not get from one model run twice. If a task is well-specified enough that one strong model plus one cheap external check solves it, that is the answer — do not convene a committee to ratify what a spec could verify.
The version of multi-agent design that spreads because it sounds sophisticated is a swarm of cooperating specialists nodding a plan through to completion. The version that works is smaller, meaner, and structurally rude: it puts something in the room whose job is to prove the rest of the room wrong, and it does not ship until that something has failed to. Build the argument, not the chorus.