Builders are naming a new kind of failure this week, and it doesn't look like a failure at all. Chain a few models together — a scraper, an extractor, two or three LLMs, a synthesizer at the end — and when one link goes bad, nothing throws. No exception, no red text, no stack trace. The answer just comes out the other side, fluent and confident and wrong.
That's the part that should worry you. A crash you can catch. A pipeline that degrades quietly and then hands you a clean paragraph gives you nothing to catch.
The reflex fix is the obvious one: add another model to check the first. If one AI can be wrong, put a second behind it, and a third behind that. More eyes, fewer misses. It feels like basic redundancy.
The research already ran that experiment. It doesn't work the way you'd hope — and the reason is worth a whole post, because it changes what you should build instead.
Adding models doesn't catch a wrong answer
Stacking models doesn't reliably catch a wrong answer, because the models' mistakes are correlated. They were trained on overlapping data, they share the same blind spots, and they tend to be wrong on the same questions at the same time. A recent study across 67 frontier models put a hard ceiling on this: the gain from any voting or routing scheme is capped by the rate at which every model is wrong at once — and that rate is higher than the field usually assumes. Gains come from models failing on different questions, not from adding more of them. When they fail together, a hundred of them fail together.
It gets worse when you let them talk. Passing raw work back and forth doesn't average out the error — it launders it. One model's wrong step gets adopted by the next, repeated, agreed to, and by the end you have a unanimous answer that everyone signed off on and nobody checked. One recent study of multi-agent discussion put it exactly: the agents agree more while knowing less.
So here is the uncomfortable turn. A confident, unanimous answer is not the reassuring outcome. It's the tell. When every model in the room says the same thing in the same calm voice, that's the case you should distrust most, because it's the one where correlated error and social agreement are hardest to tell apart.
A confident answer is not a verified one.
Three findings, one direction
The evidence points the same way from three different angles.
More models don't verify each other for free. The co-failure work is the ceiling. A separate audit of ensemble "diversity" found that naive voting beats the single best model only a small fraction of the time — the combination gain is real, but it usually goes uncollected. And a study of AI-generated code, where you can actually run the output and grade it, found that three- and five-model ensembles capture under half the reliability improvement you'd get if the models failed independently. They don't fail independently. Even different-looking bugs turned out to share root causes.
Talking amplifies the mistake instead of catching it. The interaction-heavy setups — everyone deliberates, everyone revises — are exactly where the confident-but-wrong consensus is born. The more the models chat, the more they converge on each other and the less each one actually knows. The failure mode isn't disagreement. It's premature agreement.
What clears the bar is a judge, not a crowd. The one peer-reviewed result in this space worth pointing at didn't win by adding models. It won by putting a judge over the debate — a layer whose only job was to verify the claim before it shipped. On checkable fact-checking, that structure beat the strongest single fine-tuned model. Not because it had more voices. Because it had a step that was paid to say no.
That's the whole distinction. A pile of models is a crowd, and a crowd ratifies. What you want is something that verifies — and verification is a different job than answering, done by a different part of the system, with different incentives.
Verify, don't ratify.
Structure that refuses to nod things through
This is why the useful version of a council isn't "run the question past more models." It's structure whose entire point is to refuse to rubber-stamp.
A Red Team vs. Blue Team run doesn't ask the models to agree — it assigns one to attack the confident answer, to go looking for the broken link on purpose, precisely because a fluent answer won't surrender its flaw unless something is built to hunt for it. Round Robin and Collaborative Editing keep each step's reasoning legible, so a bad link sits in the open instead of buried inside a smooth final paragraph. And Chairperson Synthesis is the judge, not the averager — it reads the disagreement and decides what to do with it, instead of blending five answers into one clean-looking consensus that hides which parts were actually contested.
None of that is about headcount. It's about putting a verifier where the crowd used to be.
The builders complaining about silent failures in their chains and the researchers quietly publishing co-failure ceilings are describing the same thing from two ends. More models don't check each other. A fluent, unanimous answer is the one to distrust. And the fix was never a bigger crowd or more trust in the room.
It's a council with a judge — a structure that treats the confident answer as a claim to be tested, not a conclusion to be shipped.
Try it free — no signup. shingik.ai