One AI Isn't Enough: Why I Use Multiple Models That Disagree
Four design principles that prevent AI groupthink and surface genuine disagreement in multi-model systems.
One day I had a thought: instead of asking Gemini about a coding problem, then opening Claude to get a second opinion, then checking what Codex thinks — what if I could ask them all at once, from the same place?
Better yet, what if they could see each other’s responses?
Better yet, what if they could debate each other?
And then reach consensus — or not, and tell me why they disagree?
That’s how the roundtable was born. A system where multiple AI models deliberate together on the same problem, challenging each other’s reasoning, building on each other’s ideas, and surfacing disagreements instead of hiding them.
I now use it for everything. Architecture decisions, code reviews, research questions, strategic planning. It’s become indispensable.
But building it taught me something I didn’t expect: putting multiple AI models in conversation is harder than it sounds. Left to their defaults, they don’t debate. They agree with each other.
Not because they’ve reasoned their way to consensus. Because they’re doing what language models do — pattern matching on discourse norms, avoiding conflict, deferring to whoever spoke first. The result looks like collaboration but functions like groupthink.
This is a design problem, not a model problem. And it has a solution. This article is about the principles I learned along the way — the rules that make multi-model deliberation actually work.
Why Multiple Models Converge (When They Shouldn’t)
The failure modes are well-documented in human group dynamics. AI models exhibit the same patterns:
Anchoring bias: The first response frames the entire discussion. Other models unconsciously orbit around that initial position, even when they’d have reached different conclusions independently.
Bandwagon effect: “Two models already agree, so I should too.” The appearance of consensus creates actual consensus — not through persuasion, but through conformity.
Authority deference: Models treat certain other models as more authoritative (often based on nothing more than response order or perceived reputation) and defer rather than challenge.
Politeness spiraling: “I agree with my colleague’s excellent point, and would like to add…” Nobody wants to be the dissenter. Disagreement gets softened into agreement-with-minor-additions until the original conflict disappears.
These aren’t bugs in the models. They’re features of how language models learn discourse — from human text where these patterns are everywhere. The solution isn’t better models. It’s better system design.
Principle 1: Independent First Response
The rule: In the first round, models respond to the user’s query in complete isolation. They cannot see each other’s responses until everyone has answered.
Implementation: First-round responses generate in parallel, revealed simultaneously only after all models have committed to their positions.
What this prevents:
- No anchor to drift toward
- No majority to join
- No authority to defer to
- No bandwagon to jump on
What you get: Genuinely independent perspectives. If three models reach the same conclusion independently, that’s meaningful signal. If they reach different conclusions, that’s valuable diversity — diversity that would have been erased if they’d seen each other’s responses first.
The key insight: independence must be enforced structurally, not requested behaviorally. Telling a model “please respond independently” while showing it other responses doesn’t work. The architecture must make dependence impossible.
Principle 2: Informed Deliberation
The rule: After the first round, models can see all responses and engage in genuine deliberation.
This might seem to contradict the first principle. It doesn’t. Independence in round one creates the raw material — diverse, uncontaminated perspectives. Deliberation in subsequent rounds refines that material through discourse.
What’s permitted in deliberation:
- Agreeing with specific points (with reasoning)
- Disagreeing with specific points (with reasoning)
- Building on others’ ideas
- Challenging others’ reasoning
- Synthesizing across perspectives
- Changing position based on new arguments
What’s different from round one: Models now have information. They’re not guessing what others think — they know. This enables substantive engagement rather than parallel monologues.
The two-phase structure: Independence first, deliberation second. You get the benefits of diverse initial perspectives AND the benefits of models engaging with each other’s reasoning. Neither phase alone is sufficient.
Principle 3: Transparent Attribution
The rule: Every response is clearly labeled with its source model. Users always know who said what.
This seems obvious but matters more than it appears:
Pattern recognition: Users start noticing tendencies. “Claude is consistently cautious about security claims.” “GPT tends toward optimistic timelines.” These patterns inform how users weight different perspectives.
Accountability: Anonymous positions enable different behavior than attributed positions. When a model knows its response is labeled, it can’t hide behind the group.
Get Alexander Zanfir’s stories in your inbox
Join Medium for free to get updates from this writer.
No mob dynamics: Anonymous criticism hits different than attributed criticism. Attribution keeps discourse civil and substantive.
User agency: Users can decide which models’ opinions they weight more heavily for which types of questions. This requires knowing which model said what.
Principle 4: User-Controlled Termination
The rule: The user decides when deliberation ends. Consensus is not required.
This is the principle that prevents the most insidious failure mode: fake agreement.
When models know they must reach consensus to conclude, they’re incentivized to paper over genuine disagreement. The result is a synthesized position that doesn’t actually represent anyone’s view — a diplomatic compromise that obscures the real tradeoffs.
The concept of impasse: Deliberation can end without consensus. An impasse isn’t failure — it’s information. Knowing that three sophisticated models genuinely disagree after deliberation is valuable. It tells the user this is a legitimately hard call with real tradeoffs, not a question with an obvious answer they just hadn’t seen.
Partial consensus matters: Two out of three models agreeing is still signal. The user knows the majority position and the dissenting view. Both inform the decision.
Diminishing returns: Extended deliberation rarely changes positions. After two or three rounds, models have typically said what they’re going to say. Further rounds produce politeness, not insight. Users have limited time and should control when to stop.
Final authority: The user makes the decision, not the models. The roundtable informs; it doesn’t decide. This keeps the human in the loop as the ultimate arbiter.
The Anti-Patterns These Principles Prevent
- First response anchors discussion → Independent First Response
- Models pile onto majority view → Independent First Response
- Polite non-engagement → Informed Deliberation (challenge is expected)
- Anonymous criticism → Transparent Attribution
- Endless deliberation → User-Controlled Termination
- Forced consensus → User-Controlled Termination
- Fake agreement → User-Controlled Termination
How It Works in Practice
Question: “Should we build a monolith or start with microservices?”
Round 1 (Independent, parallel):
- Claude: “Monolith first. Premature decomposition is expensive. Most startups fail before scaling matters.”
- GPT: “Microservices from day one. Migration debt compounds. Boundaries are easier to establish early.”
- Gemini: “Depends on team size and experience. What’s your current team composition?”
Three genuinely different responses. No anchoring, no convergence, no deference.
Round 2 (Deliberation):
- GPT challenges Claude: “Migration debt is real. I’ve seen monoliths become unmaintainable faster than teams expect.”
- Claude responds: “That’s a valid risk, but premature optimization kills more startups than technical debt. Ship first, scale second.”
- Gemini: “You’re both right for different contexts. A 3-person team should absolutely monolith. A 20-person team might benefit from boundaries.”
Real disagreement. Real engagement. No fake consensus.
Round 3 (User decides to stop):
The user has heard the tradeoffs. Two models lean monolith-first, one prefers early microservices, one emphasizes context-dependence. The user makes their choice with full awareness of the considerations.
No forced synthesis. No diplomatic mush. Real information for a real decision.
The Broader Pattern
These principles aren’t specific to AI roundtables. They’re instantiations of well-established group dynamics research:
Jury deliberation: Courts require independent initial votes before discussion for exactly these reasons — to prevent anchoring and conformity.
Brainstorming best practices: The “no criticism during ideation” rule exists to preserve independence. Evaluation comes after generation.
Delphi method: The forecasting technique explicitly prevents panelists from seeing each other’s estimates in early rounds.
Democratic theory: The value of minority positions depends on their being genuinely independent, not suppressed by majority pressure.
The roundtable system applies these established principles to multi-model AI interaction. The technology is new. The human dynamics are ancient.
Designing for Disagreement
The default assumption in system design is that agreement is good and disagreement is friction to be minimized. For many systems, this is correct.
For systems meant to inform human decisions on hard problems, it’s backwards.
Disagreement — genuine, substantive, well-reasoned disagreement — is signal. It tells you the problem is hard, the tradeoffs are real, and reasonable perspectives differ. Erasing that disagreement through premature consensus doesn’t make the problem easier. It just hides the difficulty.
The roundtable principles are designed to surface disagreement, not suppress it. Independence prevents false consensus from forming. Deliberation ensures disagreements are substantive, not arbitrary. Attribution keeps discourse accountable. User control ensures the human remains the decision-maker.
The goal isn’t AI models that agree. It’s AI models that inform — even when, especially when, they disagree.
This article represents the original ideas and writing of Alexander Zanfir, edited and refined through an agentic editorial process.
