Agent Debate

Agent debate is a multi-agent technique where two or more LLM instances independently answer a question, critique each other’s reasoning across multiple rounds, and converge on a final response.

What It Is

A confident wrong answer from a single LLM is one of the most expensive failure modes for teams using AI assistants. Agent debate addresses this by forcing the model to argue with itself — or with other models — before producing a final answer. The system runs the same question through multiple agents, lets them read each other’s answers, and gives them rounds to disagree, correct, and refine. Confident errors drop when reasoning has to survive cross-examination.

The basic loop has three pieces. First, the propose step — each agent produces an independent answer, ideally with its reasoning shown. Second, the critique step — each agent reads the others’ answers and points out errors, gaps, or alternative paths. Third, the revision step — agents update their answers based on the critique. This repeats for a fixed number of rounds or until answers stabilize. According to Du et al. (arXiv), the original 2023 paper introducing this approach showed measurable gains on mathematical reasoning and factual accuracy compared to single-agent baselines.

Three design choices matter. The judge — a verifier agent, a majority vote, or negotiated consensus picks the final answer. The diversity — clones of the same model with the same prompt produce less benefit than mixing models or roles (skeptic vs. optimist, generalist vs. specialist). The stop condition — fixed rounds waste tokens, while stability detection is cheaper but needs logic to distinguish real convergence from polite agreement.

In multi-agent systems where each agent calls tools or writes to databases, debate becomes a verification layer: a planner proposes an action, a checker argues against it, and a judge resolves the dispute before anything runs. That accountability framing is why the technique shows up in reviews of consequential AI decisions.

How It’s Used in Practice

In multi-agent systems making real decisions, debate shows up where stakes are high enough to justify the extra cost. Customer support routing, contract review, medical triage prototypes, fraud screening, and code review are common venues. The pattern is usually a primary agent that drafts a response, a critic agent that evaluates it, and a judge agent that issues the final verdict. In frameworks like LangGraph, CrewAI, and AG2, this is built as a node graph where messages flow between roles until a stop condition fires.

For everyday workflows, debate is overkill. Generating a summary or rephrasing an email rarely needs three agents arguing — cost balloons, latency triples, and the error you avoid was probably not going to happen. The sweet spot is decisions where a confident wrong answer is costly to detect later, and where you want an audit trail of dissent.

Pro Tip: Before wiring up debate, log your single agent’s reasoning on real tasks and see where it actually fails. If errors cluster around one specific reasoning step, a targeted check there is cheaper than a full debate loop. Debate works when failures are diverse and unpredictable; for narrow, repeatable failure modes, simpler verification often beats it.

When to Use / When Not

Common Misconception

Myth: If multiple agents agree, the answer must be correct. Reality: Debate reduces some error types but can amplify shared blind spots. When agents share the same training data and prompt style, they often agree on the same mistake — confidently. Diversity across models, roles, or temperatures matters more than just adding more voices.

One Sentence to Remember

Use agent debate when a single confident wrong answer would be expensive to catch later — and pair it with logging so you can audit the reasoning path, not just the final verdict.

FAQ

Q: Does agent debate always produce better answers than a single agent? A: No. Debate helps most on reasoning tasks where errors are diverse. On simple lookups or tasks where models share blind spots, debate can converge on the same wrong answer with higher confidence.

Q: How many agents and rounds should I use? A: Most implementations use two to four agents and two to four rounds. More agents and rounds increase cost and latency without proportionate gains. Tune based on your specific failure modes and token budget.

Q: Is agent debate the same as ensemble learning? A: They share the spirit of combining multiple models, but ensembles aggregate predictions statically. Debate runs an iterative critique loop where agents see each other’s reasoning and revise, which can correct errors statistical voting would miss.

Sources

• Du et al. (arXiv): Improving Factuality and Reasoning in Language Models through Multiagent Debate - Original 2023 paper introducing the multi-agent debate technique, later published at ICML 2024.
• composable-models GitHub: llm_multiagent_debate - Reference implementation accompanying the ICML 2024 paper.