Before I built anything, I did this by hand. To pressure-test an idea I’d bounce it between models — have one generate, paste its answer into another and ask it to attack, carry the pushback back to the first. It was tab-switching drudgery, and the answers were reliably better for it. The tool I eventually built was an attempt to remove the friction, not to invent the behavior. The behavior already worked.

It worked because a single model has exactly one gear: forward. Every turn wants to answer, extend, help. That’s what it’s tuned for, and it’s genuinely useful — right up until you’re on the wrong road, at which point a model will help you drive down it faster, confidently, for as long as you let it. None of them has the gear that says wait — are we even going the right way?

And a model can’t grow that gear by itself, because the same context that produced the drift also produces the blindness to it. “Reflect on whether you might be wrong” is just the spiraling mind grading its own spiral. I’ve watched it happen — dozens of messages deepening a design before anyone noticed the whole architecture was wrong. You don’t need the model to reflect harder. You need a second one that doesn’t share the first one’s context.

Fanning out is not arguing

So I built a debate tool, and the first thing it taught me is that the obvious version isn’t a debate at all.

The obvious version is a council: fan the same question out to three or four models in parallel, then have a final model synthesize their answers. It looks like deliberation. It isn’t. You get three independent first drafts and a summary — nobody reacted to anybody. Each model answered the prompt in isolation, so there’s no rebuttal, no concession, no “actually that’s wrong, because.” A council reconciles monologues after the fact, and the interesting content of a real argument is precisely the part a council structurally cannot produce.

A debate is sequential and stateful. B’s turn is conditioned on A’s finished point. C answers both. The value is in the reaction — the counter, the correction, the grudging “fair, but.” To get that, the models have to be reading each other, in order, and responding to what was actually said.

What makes it an argument instead of a group chat

The mechanism turned out to be small. Before each turn, a separate, cheap model acts as an orchestrator and emits about fifty tokens of JSON: who speaks next, and what move they should make — counter, steelman, question, concede, ground the claim in evidence. That second half is the whole trick. Don’t just pick who talks; tell them how to talk. Left to themselves, models fall into a polite round-robin where each one restates the last in nicer words. Injecting the move type — your job this turn is to disagree, your job is to steelman the objection — is what stops the monologue.

The other non-negotiable is that round one has to become round two. Round one, everyone answers you. Round two, they answer each other — “I disagree with the financial angle because…”, “building on the risk point…”. Skip round two and you’re back to parallel opinions. I’d originally filed round two under “polish.” It’s the core.

None of this needed heavy infrastructure. The whole thing is fetch() in a loop with the transcript accumulating in an array — the transcript is the only state. Each model sees the full thread with every message tagged by its source, so it simply knows it’s reading a rival’s words and responds accordingly. The format carries the context; there’s nothing to orchestrate beyond the little JSON referee.

The moment it earned its keep

A six-model thread, arguing about server hardware. One model asserted, confidently, that a particular server took twenty-four drive bays. Another checked it against the spec and corrected it — twelve, not twenty-four. The wrong claim died on the spot, and no single model would have caught it, because the one that was wrong was confidently wrong and had no reason to doubt itself. It took a differently-wrong peer to notice.

That’s the shape that actually pays off: cheap models cross-examine each other and fact-check the specifics, and you only bring the expensive model back at the end, to synthesize. Cross-validation from disagreement, not consensus from a panel.

Where a debate turns into theater

Now for the part that didn’t work. Seeding a topic and letting the models argue autonomously, start to finish, mostly doesn’t work — not as a product. You end up reading a five-round transcript after the fact, which is harder than just reading each response as it comes and deciding yourself what to challenge. The elaborate autonomous version I first built collapsed into something much smaller and human-driven, and got better in the collapse, because the value was never the models debating on their own. It was making the disagreement visible so a person could steer it.

And there’s a specific failure to be afraid of, worse than a debate that won’t converge: one that hands you a final answer cleaner than the process that produced it. Synthesis laundering. The memo reads crisp and confident; the caveats have been compressed away, the dissent quietly dropped, and you’re left with a number whose argument you can no longer see. One live run of mine spent four separate turns demanding evidence for a claim, never got any, and synthesized a confident conclusion on the model’s priors anyway — and the transcript skipped a turn number while it did, a hole in a record that was supposed to be auditable. A synthesized wrong answer with its dissent stripped out is worse than no answer, because you’ll act on it. It’s the same rule I keep arriving at from every direction: never give the weight without the fight. The single most useful thing I added wasn’t a smarter debater — it was a line in the synthesis that had to answer “what would change this answer?”, because that’s the cheapest test of whether the deliberation did real work or just produced a confident paragraph.

I’ve parked the autonomous version. The thing that makes it good — sequential, grounded, reactive — is exactly the thing that makes it fragile: failures compound across rounds times models times web calls, and one dropped turn can derail the whole transcript. I’ll pick it up when grounded models are reliable enough to drop in as members and the debate chamber is a weekend’s wiring instead of an infrastructure project. Until then the useful residue is small and entirely human-driven: two models, one disagreement, made visible, and me deciding what to do about it — almost exactly the tab-switching I was doing by hand before I built anything, just with the friction gone and a fifty-token referee to pick who pushes back next. I spent months teaching models to argue on their own. What I kept was the oldest, dumbest version of the idea: two of them in a room, made to disagree where I can watch, and me still in the chair deciding what it means.