💻 computer science

On the Uncertainty of Large Language Model-Based Multi-Agent Systems

This paper investigates the uncertainty dynamics of large language model-based multi-agent systems through entropy analysis, revealing that single agents often outperform multi-agent setups and that reducing uncertainty early in interactions is critical, leading to the development of an "Entropy Judger" algorithm that consistently improves solution accuracy across various tasks.

Original authors: Yuxuan Zhao, Sijia Chen, Ningxin Su

Published 2026-04-09

📖 5 min read🧠 Deep dive

CC BY 4.0

Original authors: Yuxuan Zhao, Sijia Chen, Ningxin Su

Original paper licensed under CC BY 4.0 (http://creativecommons.org/licenses/by/4.0/). ✨ This is an AI-generated explanation of the paper below. It is not written or endorsed by the authors. For technical accuracy, refer to the original paper. Read full disclaimer

Imagine you have a team of brilliant but slightly nervous experts (Large Language Models) trying to solve a complex puzzle together. You might think, "More brains working together must be better than just one brain!" This is the promise of Multi-Agent Systems (MAS).

However, this paper asks a very important question: Does adding more people to the team actually help, or does it just create more noise and confusion?

To find out, the researchers didn't just look at who got the right answer. Instead, they looked at the team's "Uncertainty"—a concept they measure using something called Entropy.

Here is the breakdown of their findings using simple analogies:

1. The "Confusion Meter" (Entropy)

Think of Entropy as a "Confusion Meter" or a "Nervousness Gauge."

High Entropy: The agent is guessing, wavering, or unsure. It's like a student raising their hand and saying, "I think it's A, but maybe B? Or maybe C?"
Low Entropy: The agent is confident and decisive. It's like a student saying, "It's definitely A," with total certainty.

The researchers tracked this meter for every word the AI generated, every time the agents talked to each other, and every round of the discussion.

2. The Big Surprise: One Person is Often Better Than a Crowd

The most shocking finding is that a single agent (one person working alone) actually beats the whole team about 43% of the time.

The Analogy: Imagine a committee trying to decide on a restaurant.

The Team (MAS): Everyone talks over each other. One person suggests Italian, another says "No, we need pizza," a third says "Wait, I saw a review..." They get confused, change their minds, and end up ordering something mediocre because they couldn't agree.
The Solo Agent (SAS): One person thinks it through, makes a decision, and sticks with it.
The Result: Sometimes, the "committee" just creates too much noise, and the solo thinker gets the job done faster and better.

3. The "First Round" Rule

The paper discovered that the first round of conversation is the most important.

The Analogy: Think of a group project. If the team starts off arguing and confused in the first 5 minutes, they will likely fail the project, no matter how long they work on it later.

If the agents start with high confusion (high entropy) in the first round, the system usually fails.
If they start with low confusion (low entropy) and get on the same page quickly, they are much more likely to succeed.
Key Takeaway: You can't fix a bad start by just talking longer. If the first round is messy, the rest of the conversation is just digging a deeper hole.

4. The "Goldilocks" Zone of Uncertainty

The paper found that uncertainty isn't just "bad." It depends on the task:

Easy Tasks (like simple math): You want low uncertainty. The team should agree quickly and stop talking.
Hard Tasks (like Olympiad math): You need some uncertainty. The team needs to explore different ideas and debate a bit. But if the uncertainty gets too high (everyone is panicking), it fails.
The Sweet Spot: The best teams are the ones that explore a little bit but then calm down and agree on a solid answer.

5. The "Calm Down" Algorithm (Entropy Judger)

Since the researchers figured out that "calmness" (low uncertainty) usually leads to the right answer, they built a simple tool called the Entropy Judger.

The Analogy: Imagine you ask the team for 5 different answers to a question. The Entropy Judger looks at the "Confusion Meter" for all 5 answers. It ignores the ones where the team sounded panicked or unsure, and picks the one where the team sounded the most confident and consistent.

Result: This simple trick improved the accuracy of the AI teams across the board, without needing to know the correct answer beforehand.

6. The "Base Model" Matters

The researchers also found that the "personality" of the AI matters.

Some AIs (like Qwen) are naturally good at checking their own work. Even if they seem unsure (high entropy), they are actually exploring different paths to find the truth.
Other AIs (like LLaMA) might seem confident (low entropy) but are actually just guessing wrong and sticking to it.
Lesson: A team built on a "self-checking" AI works better than a team built on an "overconfident" AI.

Summary

This paper teaches us that more agents don't always mean better results. In fact, adding more people can sometimes make things worse if they don't get on the same page immediately.

The secret to a successful AI team isn't just adding more brains; it's about managing the confusion. You want the team to start with a clear head, explore just enough to be creative, and then settle down into a confident, unified answer. If they start out confused, they probably won't finish strong.

1. Problem Statement

Multi-Agent Systems (MAS) built on Large Language Models (LLMs) are increasingly used to solve complex tasks, yet the underlying mechanisms governing their success or failure remain poorly understood. While existing literature often relies on aggregate metrics (accuracy, latency, cost) or proprietary models, it fails to explain why MAS sometimes underperform single-agent systems (SAS). Specifically, there is a lack of insight into how uncertainty (measured via entropy) evolves within and across agents during reasoning, and how these dynamics interact with different system topologies and task difficulties.

2. Methodology

The authors conducted a systematic, large-scale empirical study to analyze uncertainty dynamics in LLM-based MAS.

Datasets & Models:
- Models: Five open-source LLMs (LLaMA-3.1-8B, LLaMA-3.2-3B, Qwen3-0.6B, Qwen3-4B, Qwen3-8B). Open-source models were chosen to access full token-level probability distributions for accurate entropy calculation.
- Benchmarks: Six diverse tasks including mathematical reasoning (GSM8K, MATH500, AIME2024/2025), code generation (HumanEval), and knowledge Q&A (MMLU).
- Topologies: Four distinct MAS architectures were evaluated: Sequential (pipeline), Centralized (orchestrator + workers), Debate (majority voting), and Hybrid (orchestrator + peer feedback), compared against a Single-Agent System (SAS).
Uncertainty Metrics:
- The study defined a hierarchical set of 245 features derived from Shannon entropy at multiple granularities:
  - Token-level: Entropy of individual token predictions.
  - Agent-level: Statistics (mean, variance, max, min) of an agent's trajectory.
  - Round-level: Aggregated entropy per interaction round.
  - Sample/System-level: Cross-agent divergence and global uncertainty measures.
Analysis Framework:
- Supervised Learning: An ensemble classifier (XGBoost + LightGBM), termed the Entropy Judger, was trained to predict the correctness of a MAS output based solely on entropy traces.
- Interpretability: SHAP (SHapley Additive exPlanations) analysis was used to identify which entropy features most strongly correlate with success or failure.
- Causal Investigation: Controlled experiments compared SAS, MAS Round 1 (pre-interaction), and MAS Round 2 (post-interaction) to isolate the effects of role assignment vs. inter-agent communication.

3. Key Contributions

Counterintuitive Performance Finding: The study reveals that SAS outperforms MAS in approximately 43.3% of cases, particularly on mathematical tasks and with smaller models. This challenges the assumption that "more agents always equals better performance."
Three Core Principles of Entropy Dynamics:
- Certainty Preference: Reducing uncertainty at any stage for any agent strongly correlates with correct solutions. High peak uncertainty is universally harmful.
- Base Uncertainty: The inherent entropy of the base model ( $M_{base}$ ) directly limits MAS performance. Models with lower initial entropy during problem-solving yield better MAS results.
- Task Awareness: Optimal entropy profiles vary by task. Simple tasks require rapid convergence to low entropy; medium tasks benefit from moderate exploration; hard tasks require structured deliberation but suffer from uncontrolled divergence.
The Entropy Judger: A novel, label-free algorithm that selects the best solution from a set of $k$ MAS candidates (pass@k) based on predicted correctness derived from entropy features. This consistently improves accuracy across all configurations without ground-truth labels.
Round-1 Dominance: The effectiveness of MAS is largely determined during the first round of interaction. Subsequent rounds often fail to recover from initial misalignment, and extending deliberation (e.g., from 2 to 5 rounds) frequently degrades performance due to error propagation.

4. Key Results & Findings

Failure Modes:
- Inter-Agent Misalignment: The primary cause of MAS failure is high variance in entropy across agents (disagreement) in the first round.
- Model-Specific Behaviors:
  - Qwen: Tends to use self-correction and verification, leading to higher entropy but better error suppression. Failure is driven by inter-agent entropy variance.
  - LLaMA: Tends to reuse answers without verification, leading to lower entropy but uncontrolled error propagation. Failure is driven by verbose, uncertain final answers.
Architecture Sensitivity:
- Centralized/Debate: Highly sensitive to early-round peak entropy; noisy inputs corrupt the shared context.
- Sequential: Most fragile; errors propagate through the chain without cross-checking.
- Hybrid: Most robust, as dual feedback (orchestrator + peers) allows for recovery.
Impact of RL Training: When using an RL-trained base model (Qwen2.5-7B-SimpleRL-Zoo), the relationship between entropy and accuracy inverts. Moderate entropy in later rounds becomes beneficial (productive exploration), whereas in standard models, it signals noise.
Scalability: Even with larger models (up to 14B), SAS remains competitive or superior in ~50% of cases, indicating the trade-off is task-dependent rather than purely scale-dependent.

5. Significance

Theoretical Insight: This work shifts the paradigm of MAS evaluation from aggregate metrics to uncertainty dynamics, providing a mechanistic explanation for why MAS fails (misalignment, peak entropy) and succeeds (stable, low uncertainty).
Practical Utility:
- Resource Efficiency: The finding that SAS often outperforms MAS suggests that practitioners should not default to multi-agent setups, potentially saving significant computational costs.
- Deployment Strategy: The Entropy Judger offers a practical tool for real-world deployment, enabling the selection of high-quality outputs from multiple agent runs without requiring expensive human verification or ground-truth labels.
- Design Guidelines: The paper provides concrete guidelines for designing MAS: prioritize early consensus, avoid architectures that amplify initial divergence, and match the architecture to the task difficulty (e.g., avoiding complex debate for simple tasks).

In summary, the paper establishes that uncertainty management, rather than mere agent count, is the critical factor in LLM-based Multi-Agent Systems. It demonstrates that controlling entropy—specifically ensuring low, stable uncertainty in the early stages of interaction—is essential for achieving reliable reasoning.