Multi-Agent Debate: Building Consensus Through Discussion

Multi-agent debate is an architectural pattern in which several LLM agents independently propose solutions, critique each other's proposals and, over multiple rounds, converge on a shared, higher-quality answer. A moderator or critic agent steers the discussion and makes the final decision. The pattern improves reasoning quality and factual accuracy at the price of significantly higher costs and latency. It is therefore a tool for high-value, error-sensitive tasks, not for routine volume.

• What it delivers: Several agents productively contradict one another, expose errors and blind spots and revise their answers instead of cementing a first draft.
• What it costs: An estimated 3-6x more tokens than a single agent, more for larger setups, plus high latency because rounds run sequentially.
• When it is worthwhile: For demanding reasoning and high factual-accuracy requirements (law, science, regulatory affairs, claim review); not for routine high volume.

Classification: debate as an Evaluator-Optimizer pattern

Anthropic's taxonomy in Building Effective Agents (December 2024, Schluntz & Zhang) does not mention multi-agent debate. The pattern can, however, be mapped to the Evaluator-Optimizer workflow, often also called critic-generator. The basic form is simple: a generator agent proposes a solution, and a critic or judge agent evaluates it and demands a revision. In the extended form, which Anthropic does not describe, several equally ranked agents debate adversarially, and a moderator decides at the end.

The decisive mechanism is explicit, iterative critique. Unlike a single agent that delivers its first plausible answer, here every answer is exposed to a counterpart that actively searches for weaknesses. The underlying multi-agent debate research from MIT and Google Brain (Du et al., 2023, ICML 2024) substantiates this approach: a structured exchange can reduce reasoning errors and hallucinations, because what one agent overlooks, another catches.

Important for classification in the DACH B2B context: Evaluator-Optimizer is one of seven patterns in this taxonomy, and multi-agent debate can be read as its extended form. In 2026, most productive "agents" are still either a single LLM with tools (augmented LLM) or a single agent in a tool loop (autonomous agent). Debate is a deliberate escalation, not a default.

How a debate unfolds

A typical multi-agent debate run follows this scheme:

1. Proposal round: Two or more agents answer the same question independently, ideally with different prompts or models, in order to generate diversity.
2. Critique round: Each agent receives the others' proposals and names concrete weaknesses, factual errors or logical gaps.
3. Revision round: Each agent reworks its answer in light of the critique. This can run over several iterations.
4. Consensus/decision: The agents converge on a shared answer, or a moderator/judge agent selects or synthesizes the final solution.

The value arises in rounds two and three. A debate in which no one genuinely disagrees is merely expensive self-consistency.

Relationship to self-consistency, ensembling and mixture-of-agents

Multi-agent debate is often confused with related methods. The differences are architecturally significant and cost-relevant.

Self-consistency generates several independent answer paths from the same model and takes the most frequent answer by majority. The runs know nothing of one another, so there is no discussion, only aggregation through voting.

Mixture-of-Agents (MoA) is a parallel ensemble across several LLMs with an aggregator that synthesizes the answers. The reference work from Together AI (Wang et al., arXiv:2406.04692, ICLR 2025 Spotlight) shows that a layered MoA configuration of open-source models outperformed GPT-4 Omni on AlpacaEval 2.0 (65.1% vs. 57.5%). However, MoA only aggregates. The models do not critique one another iteratively.

Multi-agent debate goes beyond both: the agents see each other's proposals, critique them explicitly and revise over multiple rounds. It is discursive and iterative, not merely voting or aggregating.

The cost factors for MoA (4-8×) and debate (3-6×) are rough estimates for small setups (as of 2026) and rise with the number of models, agents and rounds; the ~N× factor for self-consistency follows directly from the number of sampled paths. For a decision: self-consistency is the cheapest quality improvement, MoA brings model diversity, and debate is the only method with genuine mutual correction, but also the one with the highest latency, because the rounds have to build on one another.

When debate genuinely improves quality

Multi-agent debate is a quality-bound pattern, not a latency-bound one. Suitable fields of application are above all:

• Highly sensitive reasoning tasks where quality matters more than cost
• Drafting legal memos
• Scientific writing and regulatory submissions
• Reviewing marketing claims for accuracy and compliance

The common denominator: a wrong answer is expensive, and the task benefits from a second viewpoint challenging the first. Factual accuracy improves because a critic agent can flag unsubstantiated assertions before they make their way into the final answer.

When to forgo it: For routine high-volume workflows. If each request incurs three to six times as many tokens and the response time multiplies, this is not justifiable for standard support, simple classification or mass generation.

Failure modes and their countermeasures

Three risks are decisive in practice:

• Mode collapse: The critic reflexively agrees instead of naming genuine weaknesses. The debate degenerates into expensive echoing.
• Echo chamber: The agents mutually reinforce a false premise, for instance from a flawed lead prompt. Countermeasure: diversify sub-agents with different models or prompts (MoA style) and introduce an explicit critic role.
• Reward hacking / cost explosion: If the critic is simultaneously a training source, it can reward itself; and without a round limit, token costs escalate.

Alongside this, the general multi-agent failure mode of cascading failures applies: if one agent hallucinates a fact, the moderator may carry it into the final answer. An effective countermeasure is a dedicated verifier/judge agent with grounded retrieval and mandatory citations.

Example setup: claim review with three agents

A concrete, realistic setup for an agency that wants to check whether a marketing claim is factually defensible:

```
Question: "Is the claim 'leading solution in the DACH region' substantiable?"

Round 1: Proposal:
Agent A (Model 1, prompt "optimistic"): Draft assessment A
Agent B (Model 2, prompt "skeptical"): Draft assessment B

Round 2: Critique:
Agent A critiques B (missing sources?)
Agent B critiques A (unsubstantiated superlatives?)

Round 3: Revision:
Agent A and Agent B rework on the basis of the critique

Conclusion: Verifier/Moderator (Model 3):

• checks each assertion against retrieval (mandatory citation)
• synthesizes final, substantiated assessment
  ```

A back-of-the-envelope calculation for scale: If a single agent consumes roughly 4,000 tokens for this task, even the minimal form (one generator, one critic, one revision) costs roughly 3-6x as much. The setup shown needs at least seven LLM calls, and from round 2 onward every agent also processes the other side's texts. It therefore lands closer to 7-10x, roughly 28,000 to 40,000 tokens (our own estimate, as of 2026). For a single, high-value claim this is justifiable; for 10,000 claims per day it is not. This exact threshold, "is the extra effort per case worth it?", is the real architectural decision.

The pattern can be implemented without building from scratch: LangGraph maps Evaluator-Optimizer loops as a stateful graph, AutoGen supports group chat with turn-taking, and both are under the MIT license. AutoGen, however, is in maintenance mode and receives no new features. Microsoft names the Microsoft Agent Framework as its successor.

For agencies and B2B

For marketing agencies and DACH B2B decision-makers, the message is pragmatic: multi-agent debate is a targeted instrument for high-value, error-sensitive outputs, not a standard lever for every workflow. Typical cases are claim and compliance review, well-founded specialist texts and regulatory drafts. Anyone deploying it should deliberately weigh the token overhead, depending on the setup 3 to 10 times that of a single agent, and the higher latency against the error risk, and always work with diverse models plus a verifier to avoid echo chamber and mode collapse. Blck Alpaca designs such agent topologies so that the depth of discussion is incurred only where it pays off, with clear cost limits per case and traceable sources for every statement. How we build such systems is described on the AI agent integration page.