Conflict Resolution Between Agents

Most multi-agent guides say that when agents disagree, they should "discuss until they reach consensus." That advice is often wrong, and following it produces worse answers than picking one agent. Consensus among agents frequently means averaging away the correct answer - the one agent that was right gets talked out of it by two that were confidently wrong. Multi agent conflict resolution done well is not about reaching agreement; it's about structured arbitration that surfaces the best answer, which is sometimes a minority view.

Let me tear down the naive consensus pattern, show precisely why it degrades quality, and rebuild it into arbitration that actually resolves conflicts toward correctness rather than toward the middle.

Before: The Weak Consensus Pattern

Here's the pattern that sounds reasonable and underperforms. When agents disagree, they debate until they converge.

[object Object], ,[object Object],(,[object Object],):
    answers = [a.answer(question) ,[object Object], a ,[object Object], agents]
    ,[object Object], ,[object Object], all_agree(answers):
        ,[object Object],
        answers = [a.revise(question, answers) ,[object Object], a ,[object Object], agents]
    ,[object Object], answers[,[object Object],]   ,[object Object],

What this does: It has agents repeatedly see each other's answers and revise until they all agree, then returns the converged answer. It sounds collaborative and produces a clean single result - and it systematically pulls answers toward whatever's most confidently stated or most common, regardless of which is actually correct.

Why It Fails

Consensus optimizes for agreement, not correctness, and those are different targets. When one agent is right and two are wrong, the revision loop pressures the right agent to conform - it sees two confident disagreeing answers and, being agreeable, moves toward them. You've built a machine that converts a correct minority into an incorrect majority. This is groupthink, and agents are unusually susceptible to it because they're trained to be accommodating.

There's a second failure. Consensus loops can run indefinitely or converge on a compromise that no single agent would have chosen and that's worse than any individual answer - an average of "the value is 10" and "the value is 20" becomes "15," which may be wrong in a way neither original answer was. Averaging works for estimates and fails for facts, and the loop doesn't know which it's dealing with.

⚠️ Common mistake: Treating agent disagreement as a problem to be smoothed away rather than as information. When two well-designed agents disagree, that disagreement is a signal - it flags exactly the cases that are genuinely hard or where evidence is thin. Forcing consensus discards that signal. The disagreement itself is telling you "look here, this one is uncertain," and averaging it away throws out the most useful thing the conflict produced.

⚡ Pro tip: Disagreement between agents is a feature for detecting hard cases, not a bug to eliminate. Route the cases where agents disagree to extra scrutiny - a stronger model, a human, more evidence-gathering - instead of forcing convergence. The conflict is a free difficulty detector; use it to triage rather than suppress it.

After: Structured Arbitration

The fix replaces "revise until agreement" with arbitration: agents state answers with evidence, and a separate mechanism decides based on the strength of that evidence, not on popularity. Nobody is pressured to conform; the best-supported answer wins.

[object Object], ,[object Object],(,[object Object],):
    positions = []
    ,[object Object], a ,[object Object], agents:
        ans = a.answer_with_evidence(question)   ,[object Object],
        positions.append(ans)
    ,[object Object],
    ,[object Object], arbiter.decide(question, positions)

What this does: It has each agent produce an answer plus its supporting evidence and reasoning, then hands all positions to an arbiter that decides based on which position is best supported. A well-reasoned minority answer can win over a poorly-supported majority, because the arbiter weighs evidence rather than counting votes.

Breaking Down Each Element

The evidence requirement is the crucial change, and it maps directly to the groupthink failure. By forcing each agent to state why it holds its answer, you give the arbiter something to evaluate other than confidence and consensus. An answer backed by a cited source and clear reasoning beats a confidently-stated bare assertion, regardless of how many agents made the bare assertion. Evidence breaks the popularity contest.

The separate arbiter removes the conformity pressure. Because agents state their positions independently and don't revise toward each other, the correct minority answer survives to be judged on its merits. The arbiter can be a stronger model, a rule-based judge for structured domains, or a human for high stakes - but the key property is that it's separate from the agents, so it isn't subject to the same pressure to agree.

The explicit tie-breaking handles genuine ambiguity. Sometimes evidence really is balanced, and rather than forcing a false resolution, the arbiter can escalate, gather more evidence, or return the conflict with both positions flagged. Honest "these two answers are both defensible, here's the tradeoff" is more useful than a fabricated consensus.

[object Object], ,[object Object],(,[object Object],):
    scored = [(p, score_evidence(p)) ,[object Object], p ,[object Object], positions]
    best, second = ,[object Object],(scored, key=,[object Object], x: -x[,[object Object],])[:,[object Object],]
    ,[object Object], best[,[object Object],] - second[,[object Object],] < MARGIN:      ,[object Object],
        ,[object Object], escalate(question, [best[,[object Object],], second[,[object Object],]])
    ,[object Object], best[,[object Object],]

What this does: It scores each position by evidence quality and picks the best - but if the top two are within a small margin, it escalates rather than pretending one clearly won. This prevents the arbiter from manufacturing false confidence on genuinely ambiguous cases, which is its own failure mode.

⚡ Pro tip: Make the arbiter score evidence, then check the margin between the top two positions. A wide margin means confident resolution; a narrow margin means the case is genuinely hard and deserves escalation, not a coin-flip dressed up as a decision. The margin is your signal for when to trust the arbitration and when to get help.

Isn't Arbitration Slower and More Expensive Than Consensus?

A fair objection: arbitration adds an extra step - the arbiter - and asks every agent for evidence, so it seems like it must cost more than just letting agents vote. In practice the accounting usually favors arbitration, and it's worth seeing why so you don't reject it on a false economy.

Consensus loops are the hidden expense. "Revise until agreement" can run many rounds, and each round is a full pass over every agent - so a consensus that takes four rounds to converge costs roughly four times a single-pass arbitration. Arbitration is one pass to collect positions plus one arbiter call; it's often cheaper than a consensus loop that thrashes, not more expensive. The intuition that arbitration costs more assumes consensus converges instantly, which is exactly what it fails to do on the hard cases.

[object Object],
,[object Object], ,[object Object],(,[object Object],):
    arbitration = n_agents + ,[object Object],          ,[object Object],
    consensus = n_agents * consensus_rounds  ,[object Object],
    ,[object Object], arbitration, consensus

What this does: It contrasts the bounded cost of arbitration - a fixed pass over the agents plus a single arbiter call - with the unbounded cost of a consensus loop that pays for every agent on every round. The more the agents genuinely disagree, the more rounds consensus burns, so arbitration's relative advantage grows exactly on the hard cases where you most need a good answer.

On latency the same logic holds: arbitration is a fixed two-stage pipeline, while consensus latency depends on how many rounds convergence takes, which is unpredictable and worst precisely when the question is hard. For anything user-facing, the bounded latency of arbitration is usually the better guarantee. Where arbitration genuinely does cost more is the simplest case where all agents already agree - but there, you don't need conflict resolution at all, so you can short-circuit: if the first-pass answers agree, return immediately and never invoke the arbiter.

⚡ Pro tip: Short-circuit when agents already agree. Run the arbiter only when there's an actual conflict; if the first-pass answers match, return immediately. This gives you arbitration's quality on the hard cases and consensus's speed on the easy ones, without the consensus loop's unbounded cost when things are hard. The cheap path and the correct path stop being a trade-off.

Variations for Different Contexts

For factual disputes (what's the value, what does the document say), arbitration on evidence works cleanly - the answer with the right citation wins. This is the easiest case and the one where forced consensus does the most damage, so it benefits most from switching.

For judgment calls (which strategy is better, how to phrase something), there may be no single correct answer, and here a different pattern helps: let the arbiter synthesize the strongest elements of multiple positions rather than picking one. The distinction is whether the question has a fact of the matter - use arbitration when it does, synthesis when it doesn't. Applying the wrong one (synthesizing facts, or arbitrating pure preferences) is a common misstep.

For high-stakes decisions, always route genuine conflicts to a human with both positions and their evidence laid out. The multi agent conflict resolution system's job there is not to decide but to frame the decision - surface the disagreement, gather the evidence, and present a clear choice - which is enormously valuable even when a human makes the final call.

Save and Reuse This

The reusable core of multi agent conflict resolution is: require evidence with every answer, arbitrate on evidence quality rather than popularity, check the margin to know when to escalate, and treat disagreement as a difficulty signal rather than a defect. That structure surfaces correct minority answers that consensus would have crushed.

Keep your arbiter prompt and evidence-scoring rubric versioned so you can reuse a resolution mechanism you trust. I store the arbiter prompt and the evidence rubric in PromptABCD, because a good arbiter - one that genuinely weighs evidence instead of drifting toward the confident majority - is hard to tune, and once you have one that resolves conflicts toward correctness, you want to reuse that exact prompt across every system rather than rebuilding arbitration and reintroducing the groupthink you already eliminated.

⚡ Pro tip: Log every conflict and its resolution, then review them periodically. The cases where your agents disagreed are a curated collection of your problem's genuinely hard instances, and studying how the arbiter resolved them shows you both where your agents are weak and where your arbiter is miscalibrated. That review loop is how the whole resolution system gets sharper over time, instead of quietly making the same wrong call on the same class of hard case forever.