The seven days would have produced a winner. They would not have produced a fact, and knowing the difference is the entire skill.
We almost ran a seven-day cage match between two language models. We designed it, we were a day from launching it, and then the design review killed it, and the reason it died is the most useful thing we learned, more useful than any transcript of two chatbots bickering about REST for a week would have been.
Here was the plan, and it is probably close to the one forming in your head right now, because it is the obvious experiment. Take two instances of a capable model. Hand them opposing sides of ten questions that developers have fought about for twenty years: monorepos versus polyrepos, static versus dynamic typing, REST versus GraphQL, tabs versus spaces if we were feeling cruel. Let them argue in alternating rounds until one concedes or twenty rounds elapse. Then measure three things: how many turns until they converge, whether the winner was actually right or just more confident, and whether adding a neutral third model as a judge cleans up the result. It is cheap, it is a clean loop, and it feels like it would settle something.
It would settle nothing, and walking through why is the whole essay. Because the moment you try to score the middle measurement, whether the winner was right or merely confident, the experiment falls apart in your hands, and it falls apart in a way that turns out to be the single most important fact about using language models to adjudicate anything.
Look again at the questions. Monorepos versus polyrepos. Static versus dynamic typing. REST versus GraphQL. Why have developers argued about these for two decades without resolution? Not because everyone is stubborn. It is because none of them has a context-free right answer. The correct choice depends on your team size, your deploy cadence, your domain, your tolerance for build complexity, a dozen situational variables. A monorepo is right for one org and wrong for the next. These questions are perennial precisely because they are tradeoffs, not facts.
Which means there is no "correct" to measure the winner against. When your questions have no ground truth, the axis "was the winner right or just confident" does not merely become hard to score. It collapses. The only thing a debate on a genuine tradeoff can measure is which model argued more persuasively, which is to say, which one was more confident and more fluent. We had set out to build a machine that measures who is right. What we had actually designed was a machine that measures who is more persuasive, with a label on the front that said truth. That mislabeling is not a footnote. It is the exact error people are making right now, in production, when they wire up LLM debates or LLM juries to decide things, and it is worth the price of the experiment we did not run to see it clearly.
Here is the tell that should have stopped us sooner: if you want to measure whether a debater is right or merely confident, you need at least some questions where "right" exists, a factual or logical question with a verifiable answer. Then you can catch the beautiful failure mode, a model that argues its way to victory while being wrong. Our ten tradeoff questions had no such answer key. So we could never have caught it. We would have crowned winners for a week and learned only which instance talks better, then published a number that looked like insight and was noise.
The genuinely good news, and the reason this is a report rather than a shrug, is that the experiment we could not interpret has already been run, carefully, by people who fixed the flaw first. The multi-agent debate literature of 2025 and 2026 measured nearly every axis our brief wanted, and the results are sharper than anything our tradeoff questions could have produced.
Start with the measurement we most wanted and least could have gotten: does a confident argument beat a true one? In "When Persuasion Overrides Truth in Multi-Agent LLM Debates," Mahak Agarwal and Divyam Khanna built exactly the honest version of our experiment, and they built it on the thing our design lacked: questions with ground truth, drawn from TruthfulQA. One agent states the factual answer, another vigorously defends a falsehood, and a model of the same architecture judges which won. Their metric, the confidence-weighted persuasion override rate, captures not just how often the judge is fooled into picking the falsehood but how strongly it believes the wrong choice. Their finding across five open-source models from three to fourteen billion parameters, with argument length varied deliberately from thirty to three hundred words: even the small models could craft arguments persuasive enough to override the truthful answer, often with high confidence. That is the finding our design could never have surfaced, because it requires a known-correct answer to catch the confident lie beating it. Persuasion overrides truth, and it has a measured rate.
Next, our convergence metric, turns-to-concession. We would have reported it as if a fast convergence meant the debate resolved something. It means the opposite of what it looks like. In "When Two LLMs Debate, Both Think They'll Win," Pradyumna Shyama Prasad and Minh Nhat Nguyen ran sixty structured debates among ten advanced models and found a spectacular calibration failure: in 61.7 percent of debates, both sides simultaneously claimed at least a 75 percent chance of winning, which is a logical impossibility, since the two probabilities cannot both be right. Models started at an average 72.9 percent confidence against a rational baseline of 50, and climbed to 83 percent by the final round rather than converging toward reality as evidence accumulated. My favorite number in the whole literature is this one: when the researchers explicitly told a model its win probability was exactly 50 percent, its stated confidence still rose to 57.1 percent. The models cannot update their beliefs downward under pressure. So when one finally concedes, the concession is not the sound of a mind changed by a better argument. Neither mind was tracking the argument's merit. The concession is social capitulation, one model deferring to a more assertive peer, and our turns-to-convergence metric would have been measuring the speed of that capitulation, dressed up as the speed of resolution.
That reframing has teeth, because a correct model caves too. Work on answer instability, including a 2026 study pointedly titled "Who Flips?", shows that a model holding the right answer will abandon it under a forceful counterargument. So "turns to convergence" measures how fast someone folds, and the someone who folds is as likely to be the one who was right. Fast agreement is not the debate working. It is often the debate destroying a correct answer that happened to be held quietly.
And debate does not reliably rescue truth by aggregation, either. Research revisiting multi-agent debate as a way to scale test-time compute found the gains are conditional, and that majority voting across agents fails in exactly the cases you cannot detect from inside: when the agents share a bias, which they always do when they are copies of the same base model, and when the correct answer is the minority view, in which case the lone correct agent gets outvoted by a confident consensus. This is the debate-shaped face of a pattern we have written about from two other directions this month, that stacking more agents onto a problem tends to cost more than it returns, whether the mechanism is coordination overhead, the voting math of correlated jurors, or, here, the sycophancy of a crowd talking itself into agreement. Three mechanisms, one conclusion: more voices is not more truth.
Which leaves the third thing our brief wanted to measure, the intuitive fix. Surely if two debaters are unreliable, a neutral third model as judge restores order. This is the part that should genuinely unsettle you, because the referee imports the exact bias it was hired to remove.
A model acting as judge carries documented, measured biases: it favors the answer in a particular position, it favors the longer and more verbose answer as a lazy proxy for quality, and it scores outputs in its own style more highly. Every one of those biases points the same direction, toward the fluent, assertive, verbose debater, which is to say the confident one, which is to say precisely the debater whose confidence we were trying to see past. The judge does not neutralize the confidence advantage. It certifies it.
It gets worse inside a debate specifically. A 2025 study with the apt title "Judging with Many Minds" found that a debate framework amplifies these biases sharply after the first round, and that the amplified bias sustains through subsequent rounds rather than washing out. Position, verbosity, and bandwagon effects all grow once the models start reacting to each other. The only structure that showed real resistance was a meta-judge, a judge evaluating judgments rather than raw outputs, which is a more elaborate machine than anyone reaching for a quick "add a judge agent" is picturing. So the third agent does not fix the confidence-over-correctness dynamic. It launders it into an authoritative-looking verdict. We have written separately about why an evaluator that is entangled with what it evaluates cannot be trusted to referee, the way an auditor cannot audit a client it depends on; the LLM judge is that conflict of interest rebuilt in miniature, an evaluator that shares the debaters' training, style, and blind spots and calls itself impartial.
So here is the practical residue, and it is worth more than the transcript we did not generate.
First, if you are using LLM debate or an LLM jury to decide anything real, be clear about what you are measuring. On any question that is a genuine tradeoff, with no verifiable answer, a debate measures persuasion and nothing else. It will hand you a winner, and the winner will be the more confident, more verbose instance, and you will have learned the model's rhetorical temperature, not the truth of the matter. That is fine if rhetoric is what you want. It is a quiet disaster if you mistook it for correctness.
Second, if you actually want to measure correctness, engineer ground truth into the design, the way the CW-POR researchers did. Salt your question set with items that have known answers, factual and logical questions where a wrong winner is detectable, and watch how often the confident model wins while wrong. That number, the rate at which persuasion beats truth on the questions where truth is knowable, is the only honest read on whether your debaters track reality or just volume. If you cannot build an answer key, you cannot measure correctness, full stop, and you should stop calling the output a measurement of it.
Third, treat convergence speed as a caving metric, not a resolution metric, and do not expect a judge agent to save you. Convergence tells you how fast one model deferred socially; a fast, confident consensus among copies of one model is the danger sign, not the success signal, especially when the right answer might have been the lonely one. And the neutral referee is the confident liar's best audience, so if you add a judge, assume it is measuring fluency and design around that, rather than trusting it to have measured truth.
We were going to spend a week watching two language models argue about GraphQL and crown a champion. What the design review handed us instead is the thing worth keeping: a debate between two confident systems, over a question with no answer, judged by a third system that rewards confidence, is not an experiment that finds the truth. It is an elaborate and very persuasive way to launder the loudest voice into a verdict. The seven days would have produced a winner. They would not have produced a fact, and knowing the difference is the entire skill.
A debate measures persuasion. To measure truth, you need ground truth the evaluator cannot argue its way around.
Every failure here traces to one missing thing: an answer key the judge is not entangled with. An LLM refereeing LLMs shares their training, their style, and their blind spots, so it certifies confidence and calls it correctness. The agent trust stack is the alternative built as installable pieces: verification against ground truth rather than a peer's opinion, a provenance record of what each agent actually did so the check reads the work and not the rhetoric, and ratings that price an output by its track record instead of its fluency. If you are wiring up an LLM jury to decide something real, wire in the part that does not share the debaters' blind spots.
Read the Theory of Agent Trust
pip install agent-trust-stack · npm install agent-trust-stack
Or the provenance record on its own: pip install chain-of-consciousness / npm install chain-of-consciousness.