When Does Multi-Agent Collaboration Help? An Entropy Perspective

AI summary

Overview

Research area: Multi-agent systems (MAS) built on large language models, analyzed through the lens of information-theoretic entropy.

Technical level: Advanced. The paper combines token-level entropy measurement, supervised learning over engineered features, SHAP attribution, and causal discovery (PC/FCI with DoWhy effect estimation).

Scope: A systematic empirical and causal study of how entropy dynamics within and between LLM agents predict when multi-agent collaboration succeeds or fails, across open-source model families, multiple benchmarks, coordination topologies, and interaction rounds.

What This Paper Is About

Multi-agent systems built from LLMs are widely used for complex tasks, but it is largely unexplored whether they actually beat a single agent, and why they succeed or fail when built on open-source models. Existing evaluations rely on aggregate metrics such as accuracy, latency, and cost, which do not reveal the internal mechanisms driving outcomes. This paper asks whether entropy — the uncertainty in an LLM's token probability distribution — can explain, and even causally drive, MAS effectiveness.

Key Contributions

1. A systematic entropy study. The authors analyze entropy dynamics across six reasoning benchmarks (GSM8K, MATH500, AIME2024, AIME2025, HumanEval, MMLU) and two agentic benchmarks (GAIA, FinanceAgent), under multiple MAS topologies, using 245 trainable features at the token, agent, and interaction-round levels.

2. A counterintuitive baseline result. Single-agent systems outperform MAS in approximately 43.3% of cases, highlighting a trade-off between system complexity and performance.

3. Three named entropy principles. Certainty Preference (peak entropy directly harms and stable entropy directly benefits MAS correctness), Base Entropy (base models with lower entropy during problem-solving causally drive MAS performance), and Task Awareness (entropy dynamics play varying roles across different tasks). The findings extend to agentic settings, where tool-call entropy and first-round inter-agent dispersion jointly constrain MAS correctness.

4. The Entropy Judger. A simple ensemble algorithm (averaging XGBoost and LightGBM predicted probabilities) that selects solutions from MAS pass@k results, yielding consistent accuracy improvements across all MAS configurations and tasks without ground-truth labels.

Main Findings

• Single agents often match or beat multi-agent systems. SAS matches or exceeds at least one MAS topology in 26/30 cases across 5 models and 6 datasets. SAS achieves the highest accuracy in 13 cases (43.3%), surpassing average MAS accuracy by 6.28%, particularly on math tasks and with smaller models.

• Entropy is largely decided in round one. Across all topologies and tasks, round-1 entropy features dominate the top predictors, and additional deliberation cannot reliably recover from initial misalignment.

• Round-1 dominance is causal, not just correlational. Both PC and FCI causal discovery identify three consensus direct causes of MAS correctness: base-model average per-token entropy (ATE_PS = −0.12, p < 10⁻²¹), round-1 total entropy (p < 10⁻¹⁹), and maximum answer-token entropy (ATE_PS = −0.31, p < 10⁻²⁸), with all refutation tests passing. No treatment variable shows a robustly positive effect.

• Base-model entropy limits what MAS can achieve. On the base-entropy feature group, top predictors are base-model total token-level entropy and answer length. For LLaMA: total token count (ρ ≈ −0.47, Ī = 1.0) and entropy (ρ ≈ −0.73, Ī ≈ 0.72). For Qwen3: answer token count (ρ ≈ −0.18, Ī ≈ 0.58) and entropy (ρ ≈ −0.64, Ī ≈ 0.36). MAS accuracy drops sharply when entropy exceeds 100.

• Model families differ in how they use entropy. LLaMA operates in low-entropy ranges (0–100) but achieves lower accuracy, while Qwen uses higher entropy (100–1,000) yet performs better, because Qwen verifies and refines answers before finalizing while LLaMA tends to reuse others' answers without verification.

• MAS failure is mainly inter-agent misalignment. For Qwen, failure is driven by high entropy variance across agents (ρ ≈ −0.92, Ī ≈ 0.83) and strong agent disagreement in round 1 (ρ ≈ −0.87, Ī ≈ 0.47). Correclty solved MAS samples cluster at low sample-level and round-1 entropy variance, whereas SAS succeeds even at higher entropy variance — MAS imposes a stricter entropy constraint than SAS. For LLaMA, dominant predictors are answer-token count (ρ ≈ −0.63, Ī ≈ 0.78) and minimum answer-token entropy (ρ ≈ −0.78, Ī ≈ 0.56).

• Entropy effects are task-aware. On GSM8K, overall round-1 entropy (Ī ≈ 0.47, ρ ≈ −0.64) and the stability index (Ī ≈ 0.44, ρ ≈ −0.79) are strongly negatively correlated with success. On MATH500, high average per-agent reasoning entropy (Ī ≈ 0.77, ρ ≈ 0.63) and longer round-1 reasoning time (Ī ≈ 0.15, ρ ≈ 0.71) correlate positively, while maximal round-1 entropy (ρ ≈ −0.73) and verbose final answers (ρ ≈ −0.48) predict failure. On AIME24/25, round-1 total reasoning time is the top predictor (Ī = 1.0, ρ ≈ 0.73), with round-1 max entropy strongly negative (ρ ≤ −0.70) and moderate average output entropy positive (ρ ≥ 0.37). On HumanEval, moderate average entropy helps while overconfident or erratic profiles hurt. On MMLU, inter-agent agreement matters more than deliberation duration.

• Entropy demands track difficulty. As dataset accuracy declines from 82% on GSM8K to 25% on AIME25, both key entropy features increase in magnitude and dispersion, with round-1 max entropy showing the strongest sensitivity to task difficulty.

• Architecture shapes which entropy matters. Centralized systems fail when a peak-entropy agent contaminates the orchestrator's shared context; debate systems depend on early consensus; hybrid systems recover via dual feedback; sequential systems are most fragile due to unverified error propagation through role chaining; single agents prioritize brevity. Universally, peak entropy harms and cumulative entropy helps.

• More rounds are not better. Extending from R = 2 to R = 5 (Qwen3-0.6/4B on MATH500 and AIME2025, feature space expanding from 224 to 494 dimensions), performance rarely improves and often degrades, despite higher token consumption. Maximum, mean, and total entropy drop sharply from round 1 to round 2 but stay nearly flat through round 5. Only centralized systems show consistent gains.

• Mediation. Round-1 inter-agent entropy dispersion transmits 30–33% of its causal effect on correctness through round-2 entropy. Base-model entropy acts mainly through direct pathways.

• Entropy predictiveness. The Entropy Judger reaches 72.6% / 79.1% (LLaMA / Qwen) cross-validation accuracy on the MAS-only feature group, rising to 74.5% / 80.7% when base-model entropy is added, and 81.2% / 91.6% with base-model correctness included.

Methodology in Plain English

The authors restrict themselves to open-source small LLMs — LLaMA (3.1-8B-Instruct, 3.2-3B-Instruct) and Qwen3 (0.6B, 4B, 8B) — because full token-probability access is required to compute entropy; proprietary APIs return only top-k logprobs with k ≤ 20, which they note yields just 11 entropy-related features in prior work. They formalize a MAS as a tuple of agents, an interaction graph, and a number of rounds, and define four multi-agent topologies (sequential, centralized, debate, hybrid) plus a single-agent baseline — described in different places as four MAS topologies or five architectures. All systems use the same base model with R = 2 rounds by default.

During inference they log token-level entropy, latency, and token costs for every agent, then engineer hierarchical features: 254 features total (entropy, base-model entropy, and computational metrics), of which 245 remain trainable after excluding 9 experimental identifier columns. They define three nested feature groups — MAS only (d = 224), Base entropy (d = 241), and Base full (d = 245).

They reframe evaluation as supervised learning: predict per-sample correctness from entropy traces using an XGBoost/LightGBM ensemble. SHAP analysis gives each feature a mean importance Ī and a SHAP correlation ρ (positive means higher values increase predicted correctness). To move beyond correlation, they run PC and FCI causal discovery with temporal constraints plus DoWhy effect estimation and mediation analysis.

Why This Matters

Impact on research. The paper provides a mechanistic account, not just a benchmark scorecard, of when multi-agent LLM collaboration pays off. Its causal analysis (rather than correlation alone) and its finding that outcomes are fixed in the first round challenge the assumption that adding agents or rounds reliably improves results.

Real-world applications:

• Agent orchestration design: choosing between a single agent and a multi-agent topology based on observable early-round entropy signals.
• Inference cost control: avoiding extra interaction rounds and token spend when entropy dynamics indicate additional deliberation will not help.
• Model selection: preferring base models with lower problem-solving entropy for multi-agent pipelines.
• Output selection without labels: using the Entropy Judger to pick the best candidate from pass@k samples in deployment where ground truth is unavailable.

Industry relevance. Teams running LLM agent pipelines on open-weight models can apply a lightweight ensemble over logged entropy traces to predict correctness and filter outputs, with the caveat that the reported gains come from small open-source models (0.6B–8B parameters) and that many supporting details sit in appendices not included in the provided content.

Future Directions

• Testing whether the principles transfer to proprietary and larger models, since the study is deliberately limited to open-source small LLMs and the authors note that API access truncates token probabilities.
• Establishing calibration standards for entropy as an uncertainty measure. The authors explicitly treat entropy primarily as a predictive feature rather than a universal measure of uncertainty, and defer calibration analyses showing its dependence on model family and task difficulty to an appendix.
• Investigating reported latency and cost trade-offs of the Entropy Judger and of round-count choices — token costs are logged, but the provided content reports no latency or cost improvement figures for the Judger.
• Resolving open causal questions, such as the possible latent confounder (e.g., problem difficulty) suggested by round-1 maximum agent entropy dispersion being a direct cause under PC but not under FCI, and why round-1 total entropy shows near-zero propensity-based effects despite its causal role.

Target Audience

Researchers and engineers working on LLM-based multi-agent systems, agent orchestration, and evaluation methodology; practitioners selecting between single-agent and multi-agent designs for open-weight models; and anyone studying uncertainty quantification, entropy dynamics in reasoning, or causal analysis of machine learning systems. Readers seeking a purely applied deployment guide will find that most of the implementation detail (appendix sections B through L) is referenced but not contained in the provided paper content.

Authors’ abstract

Multi-agent systems (MAS) have emerged as a prominent paradigm for leveraging large language models (LLMs) to tackle complex tasks. However, the mechanisms governing the effectiveness of MAS built upon publicly available LLMs, specifically the underlying rationales for their success or failure, remain largely unexplored. In this paper, we revisit MAS through the perspective of \textit{entropy}, considering both intra- and inter-agent dynamics by investigating entropy transitions during problem-solving across various topologies, six reasoning benchmarks, and two agentic tasks. By analyzing 245 features spanning token-, agent-, and round-level entropy, we counterintuitively find that a single agent outperforms MAS in approximately 43.3\% of cases, and that entropy dynamics are largely determined during the first round of interaction. Furthermore, we provide three key observations: 1) \textit{Certainty Preference}: peak entropy directly harms and stable entropy directly benefits MAS correctness; 2) \textit{Base Entropy}: base models with lower entropy during problem-solving causally drive MAS performance; and 3) \textit{Task Awareness}: entropy dynamics of MAS play varying roles across different tasks. Building on these insights, we introduce a simple yet effective algorithm, the \textit{Entropy Judger}, to select solutions from MAS's pass@$k$ results, leading to consistent accuracy improvements across all MAS configurations and tasks. Our source code is available at \href{https://github.com/AgenticFinLab/multiagent-entropy}{this https URL}.