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: According to the research, roughly 3-6x more tokens than a single agent, 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

In the established Anthropic taxonomy from Building Effective Agents (December 2024, Schluntz & Zhang), multi-agent debate belongs to the Evaluator-Optimizer building block, 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, 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 DeepMind and Meta from 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: debate is one of seven patterns in this taxonomy. 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 synthesises 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 - there is no discussion, only aggregation through voting.

Mixture-of-Agents (MoA) is a parallel ensemble across several LLMs with an aggregator that synthesises 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×) come from the underlying research (as of 2026); 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. The research explicitly names as suitable fields of application:

• 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 documented 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 according to the research: 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. The most effective countermeasure according to the research 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 a marketing claim for factual sustainability:

```
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 "sceptical"): 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)
• synthesises final, substantiated assessment
  ```

A back-of-the-envelope calculation for scale: If a single agent consumes roughly 4,000 tokens for this task, a three-round debate with three agents plausibly falls in the range of 3-6x, that is, roughly 12,000 to 24,000 tokens (as of 2026, an estimate based on the cost factor cited in the research). 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 with stateful state, AutoGen supports group chat with turn-taking, and both are under MIT licence (as of 2026).

For agencies and B2B

For marketing agencies and DACH B2B decision-makers, the message is pragmatic: multi-agent debate is not a standard lever for every workflow, but a targeted instrument for high-value, error-sensitive outputs - claim and compliance review, well-founded specialist texts, regulatory drafts. Anyone deploying it should deliberately weigh the 3-6x token overhead 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.