When an autonomous agent makes a bad call, the standard architectural reaction is to give it a coworker.
Over the past two years, multi-agent debate became the default design pattern for tricky LLM tasks. The pitch sounds reasonable on paper. One model proposes an action, a second model critiques the plan, and a third model synthesizes a compromise. Instead of relying on a single stochastic generation, you run a structured jury.
Frameworks promote this as a reliable path to truth. If you look at the raw execution traces, the argument seems to hold. The transcripts look thoughtful, the arguments cite relevant data, and the final synthesis reads like a memo from a senior staff engineer.
A new paper from Stanford researchers, titled “Multi-Agent Debate for Explainable Trading: Reasoning, Consensus, and Performance in Simulated Markets” (arXiv:2609.29701), shows where that assumption breaks.
The debate transcript trap
The authors (Juli Huang, Alanood Alrassan, Deveen Harischandra, Theodore Wu, Veljko Skarich, and Matthew Hayes) tested multi-agent debate across 210 controlled runs in historical market simulations. Specialized agents proposed, critiqued, and revised portfolio allocations.
They scored reasoning traces across four formal criteria: logical validity, evidential support, alternative consideration, and causal alignment.
Multi-turn debate and structured prompting succeeded at generating better explanations. Measured reasoning quality jumped from 0.72 to 0.84, representing a 17.7% gain with a massive effect size (Cohen’s d around 2.0). If you evaluated the pipeline purely by inspecting the chat history, you would conclude that the agents became substantially more capable.
The actual financial results showed something different.
Aggregate reasoning quality had no meaningful relationship with portfolio performance. The correlation with Sharpe ratio was r = 0.07 (p = 0.29). The correlation with total return was r = 0.03 (p = 0.70). The agents wrote significantly more articulate defenses of their allocations without improving the quality of the allocations themselves.
Sycophantic convergence
The primary culprit behind this disconnect is sycophantic convergence.
In human committees, groupthink sets in when participants prioritize harmony over verification. Large language models do the exact same thing, but faster. When an agent receives a critique from another agent, its default behavior is to yield ground, soften its claims, and adopt the vocabulary of the critique.
Over three or four debate rounds, distinct perspectives collapse into a shared consensus. The agents abandon their independent observations. Instead of checking whether the initial numbers made sense, they collaborate on a polite, highly coherent narrative that justifies whatever stance had the strongest conversational momentum.
Adding prompts that demanded stronger causal reasoning did nothing to fix the financial metrics. Telling a model to sound more analytical simply produced longer, more formal paragraphs around the same synchronized errors.
In classical machine learning, an ensemble provides leverage only when individual models make uncorrelated errors. Multi-turn conversational debate does the reverse. By letting agents talk directly to each other, you actively correlate their error distributions.
Forcing disagreement
The authors found only one intervention that moved downstream performance: penalizing consensus.
They introduced a Jensen-Shannon divergence constraint into the critique and revision cycle. If the agents began clustering toward identical allocations too early, the system penalized the revision and forced the models to preserve divergent positions.
That single change improved the portfolio Sharpe ratio by +0.14 (p = 0.028) and the Sortino ratio by +0.25 (p = 0.026).
Preserving disagreement forced the ensemble to function as actual independent estimators. The models were not allowed to talk each other into a shared hallucination.
What this means for agent pipelines
This finding matches what happens in production coding and operations agents.
When teams build reviewer-critic loops, they evaluate the system by reading the output log. A log containing debate, polite pushback, and a clean final synthesis feels rigorous. It gives engineers confidence because humans associate articulate prose with reliable judgment.
That association does not hold for autoregressive models. A language model can write a flawless explanation for an incorrect conclusion. When you chain multiple models together without hard diversity constraints, you get an echo chamber that writes beautiful post-mortems for bad choices.
If you run multi-agent architectures, three practical rules follow from this:
- Never measure agent quality by transcript coherence. If an eval tracks how well-reasoned the explanation looks, it measures prose style rather than decision accuracy.
- Stop multi-turn conversational debate when independent voting works. Independent parallel generations combined with deterministic aggregation avoid the conversational drift that ruins multi-round critique.
- If you must use iterative review, penalize consensus. If your critic and worker agree on round two, your pipeline is burning tokens on decorative verification.