One model sounds certain. Five models show you the risk.
engineering8 min read
Builder · Applied AI

One model sounds certain. Five models show you the risk.

A single model answers in one confident voice whether it is right or wrong, and the prose has no seam where the guessing starts. So I built a council: five cross-lineage models answer in parallel, and a sixth reconciles them. V3 makes the machine legible: a narrated film of one run, a replayable council with three scenarios (the outlier, the split, clean consensus), the spread charted, and the four verdict shapes, including the one the council cannot catch.

A single model has one property that should unsettle you more than it does. It sounds exactly as sure when it is wrong as when it is right. The sentences come out smooth either way, and there is no seam in the prose where the confident part ends and the guessing begins. So for the questions where being wrong is expensive, I stopped asking one model and built a room of them. Five models answer the same question at once, none of them seeing the others, and a sixth model reads every answer and tells me where they agree, where they split, and which one is probably making it up. It lives at /council, and this post carries a working replica: you can convene a canned run a few scrolls down and watch the outlier get caught.

One run, twenty-six seconds, now with sound: the question fans out, five models stream blind to each other, the outlier gets flagged, Sonnet writes the report. The narrator is a synthesized voice on purpose; turn the sound on with the player controls.

The smooth answer hides the risk

The failure mode of a good model is not that it stalls or refuses. It is that it hands you a fluent, well-structured, completely wrong answer in the same register it uses for a correct one. You cannot read uncertainty off the surface, because the surface is always calm. The obvious fix, blend several models into one polished consensus voice, makes it worse: averaging smooths the exact split you needed to see back over into another confident paragraph. So the council does not blend. It keeps every answer separate and puts the seams on display. This is the mixture-of-agents shape, many proposers and one aggregator, tuned so the output is a comparison instead of a blend.

One model gives you an answer. Five models give you a distribution, and the distribution is where the risk shows.

Convene one yourself

Here is the whole mechanism, live, and one run only teaches one shape, so the replica below carries three. The outlier: a cross-region latency question with a physically correct answer near 80 ms, where one proposer confidently reports a same-region number an order of magnitude too low. The split: a Postgres migration question where the room divides three against two and both camps are internally consistent, because the real fork is a hidden version assumption. And consensus: a question about webhooks and absent deploys (readers of the deploy radar post already know this one) where five models agree for the same reason stated five ways. Pick a scenario, press the button, and watch what the console shows me.

Q: Roughly how much p99 latency does a cross-region read add (us-east to eu-west)?
Claude Opus 4.8
Anthropic
waiting to be convened
Llama 3.3 70B
Meta
waiting to be convened
Qwen2.5 72B
Alibaba
waiting to be convened
DeepSeek V3
DeepSeek
waiting to be convened
DeepSeek R1
DeepSeek
waiting to be convened
Sonnet reconciles · not a proposer
the report writes itself here once the panel has answered
A replayable run with canned answers, mirroring the real console at /council. Three scenarios, three shapes of disagreement. The staggering is real too: proposers finish at different speeds, and the report only starts once the room has gone quiet.

The spread is the signal

Plot that run and the argument makes itself. Four answers cluster between 70 and 85 ms, right where the physics of transatlantic fiber puts them. DeepSeek V3 sits alone at 8 ms, a cross-AZ number that would read as perfectly plausible in isolation. On a single-model day, one time in five, that 8 ms is the answer I would have gotten, delivered in prose exactly as confident as the correct one. The spread is what makes the error visible before it ships.

consensus band · 70–85 ms0255075100added p99 latency (ms)the confident outlierDeepSeek V3 · 8 msLlama 3.3 · 70 msQwen2.5 · 75 msOpus 4.8 · 80 msDeepSeek R1 · 85 ms
The five answers from the run above, on one axis. The cluster carries the consensus; the lone dot is the answer you might have shipped.

Five models, chosen to disagree

The panel is cross-lineage on purpose, because two models trained on the same data tend to be wrong in the same places. Claude Opus 4.8 sits next to Llama 3.3 70B from Meta, Qwen2.5 72B from Alibaba, and two from DeepSeek: V3 and the R1 reasoning model, which streams its visible thinking so I can watch it reason before it commits. Five makers, five sets of blind spots. They answer in parallel and never read each other, so nobody anchors on the loudest voice in the room.

The fixed panel. Five makers, three lineages, one seat that never proposes.
ModelMakerLineageRoleWhat it adds
Claude Opus 4.8AnthropicClaudeproposerthe frontier baseline the others get compared against
Llama 3.3 70BMetaLlamaproposerthe open-weights workhorse, trained on a different corpus
Qwen2.5 72BAlibabaQwenproposera non-Western training lineage; disagrees in useful places
DeepSeek V3DeepSeekDeepSeekproposera second independent open lab; cheap, fast, occasionally wrong out loud
DeepSeek R1DeepSeekDeepSeek (reasoning)proposervisible chain-of-thought; you watch it reason before it commits
Sonnet 5AnthropicClaudereconcilerreads all five, writes the report; never one of the proposers
The roster is content-as-code: one file, one entry per seat. Swapping a model is a one-line edit.
js
// panel.mjs: five proposers, one reconciler. Diverse on purpose.
export const COUNCIL_PROPOSERS = [
  { id: 'opus',        label: 'Claude Opus 4.8', maker: 'Anthropic' },
  { id: 'llama',       label: 'Llama 3.3 70B',   maker: 'Meta' },
  { id: 'qwen',        label: 'Qwen2.5 72B',     maker: 'Alibaba' },
  { id: 'deepseek',    label: 'DeepSeek V3',     maker: 'DeepSeek' },
  { id: 'deepseek-r1', label: 'DeepSeek R1',     maker: 'DeepSeek', thinking: true },
];
// Sonnet is the reconciler, and NOT in this list, so it never
// grades its own homework. Change the roster? Edit this one file.

A judge that never competed

Then a sixth model reconciles. I use Sonnet for the job, and the load-bearing detail is that it is not one of the five. A judge that also answered would be grading its own homework. Sonnet reads every labeled answer and writes one report with fixed sections: what they agree on, where they diverge (attributed by name, so I can see the outlier was DeepSeek and not Opus), which claims look like outright errors, and a single consolidated recommendation. Handing an answer to a different model to grade is the LLM-as-a-judge pattern; the council just runs it across a whole panel at once.

one question
Opus 4.8
Anthropic
Llama 3.3
Meta
Qwen2.5
Alibaba
DeepSeek V3
DeepSeek
DeepSeek R1
reasoning
five proposers · in parallel · blind to each other
Sonnet reconcilesnot a proposer · never grades its own work
ConsensusDiscrepanciesOutliersRecommendation
one report · discrepancies attributed by model
The shape of an ask. One question fans out to five proposers running in parallel, blind to each other; every answer converges on Sonnet, which is not one of the five; out comes one report with the discrepancies attributed by model.

The adversarial round is what earns its seat

Asking five models a question is useful. Making them argue is where it gets sharp. The second mode, Review, takes an artifact instead of a question, a diff or an essay or a schema, and runs two rounds. In round one every model critiques it for defects only: find the passage, say what is wrong, rate the severity, propose no fixes. That produces a pile of findings, and some of them are lazy, and a few are hallucinated outright. Round two sorts the pile. Each model receives the other models' critiques with the names stripped to Reviewer A and Reviewer B, and its one instruction is to find the single weakest claim and knock it down. A real defect survives a peer trying to refute it. A style nitpick with no reproduction does not. The anonymizing is deliberate: a model that could see a critique came from Opus might defer to it, so the identities come off and every claim stands on its own legs. Then Sonnet reconciles both rounds into confirmed defects, contested defects, rebuttals that themselves look wrong, and a prioritized punch list.

critique
round 1 · defects only
race in the writerstyle nit, no reprounsigned webhook
rebuttal
round 2 · peers anonymized
race in the writer
style nit, no repro
unsigned webhook
verdict
Sonnet reconciles both
Confirmed: 2Contested: 0Bad rebuttal: 1
a defect that cannot survive a peer knocking it down gets burned off
Review mode in three stages. Every model flags defects, then rebuts the others' weakest claims with the names stripped off, then Sonnet reconciles. The style nit with no repro cannot survive a peer knocking it down, so it gets burned off before it reaches the punch list.

When one model is the right call

This is not free, and I want to be exact about the cost. Every ask fans out to five paid models plus the synthesis, and a review runs both rounds. So the council is owner-only and noindex, with no public cost surface, and it is the wrong tool for most questions. If an answer is cheap to verify or cheap to be wrong about, ask one model and move on. I reach for the council when being wrong is expensive and I cannot tell from the prose alone: a security review, an architectural call I will have to live inside for a year, a claim I am about to publish. Picking which single model to trust for a given job is what the benchmarks page is for. The council is for the times I would rather not pick.

5
proposers per question
all in parallel
+1
reconciler on top
Sonnet, never a proposer
2
rounds in Review mode
critique, then rebuttal
≈2.2×
the ask-mode cost
what a review runs
slowest + 1
the wall clock
slowest proposer, then the reconcile
The bill for a room instead of a voice. The fan-out is parallel, so the wall clock stays close to one slow model rather than five.

Four shapes you learn to read

After enough runs the verdict patterns start to rhyme, and there are only four of them. A tight cluster is consensus: boring, and usually trustworthy. Two camps is a split, and a clean split almost always traces to an assumption nobody stated, so the useful move is finding the fork, never picking a side by vote. Four and a loner is the outlier, the shape the latency run showed. And the fourth shape looks exactly like the first: five answers in one tight cluster, sitting together in the wrong place.

five answers, one place. Boring, and trustworthy.
two camps, both consistent. Find the hidden assumption.
four cluster, one is elsewhere. Check the loner first.
five agree, and all five are wrong. The council cannot catch this one.
The four verdict shapes on one abstract axis. Three of them the council reads for you. The fourth, the clean lie, it cannot see, which is what the next section is about.

Where it stops

That fourth shape is the honest limit, and it sits right at the center of the design: the council shows me where the risk is, not what is true. If all five models are confidently wrong in the same way, the report will call it consensus and hand me a clean, well-attributed lie. A diverse panel narrows that failure. It does not close it. Every stream still runs through the same red-lines guard as the rest of the site, and the final call stays mine. The council does not decide anything. It just makes sure I am deciding with the disagreement laid out in front of me, instead of buried under one smooth voice that sounded certain either way.

Experience it yourselfOpen the council
ShareXLinkedInHacker NewsEmail

Get the next one

An occasional note when something genuinely new ships here — essays, free tools, projects. No schedule, no filler, easy out.

Need something like this built?

I design and ship AI tools, full-stack apps, and data pipelines — end to end, to production. Tell me the problem in a sentence; I'll give you an honest read on fit within a day.

Work with me →