Why does adding more AI agents to a team sometimes make the group dumber, not smarter?
How do agent topology and error amplification constrain multi-agent scaling?
This explores how the wiring between agents (who talks to whom, and who checks whose work) and the way one agent's mistake spreads to others put limits on how much you gain by adding more agents.
This explores how the wiring between agents, and the way one agent's mistake spreads through that wiring, limits what you get from adding more agents. In short, the corpus says more agents does not automatically mean a smarter system. Coordination gets worse in predictable ways as networks grow, and the cause is more specific than "agents make mistakes." On the AgentsNet benchmark, agents fail in two ways. Some agree on a strategy too late. Others adopt a strategy without telling their neighbors. The key finding is that agents can spot a direct contradiction, but they accept information passed along by neighbors without checking it Why do multi-agent systems fail to coordinate at scale?. So errors don't spread because agents can't catch them. They spread because each connection works as a channel of trust.
The second surprise is how large groups break down. You might expect a bad agent to slowly corrupt the group's answer. Across hundreds of consensus simulations, though, LLM agent groups mostly failed by stalling: timeouts, endless back-and-forth, never settling. Agreement got worse as groups grew even when no adversarial agent was present Can LLM agent groups reliably reach consensus together?. Deliberation has its own versions of this. In "Degeneration-of-Thought" a discussion locks onto an early idea, and in "Silent Agreement" agents go along without pushing back What limits autonomous capability in large language models?. Size, then, works against you twice: more paths for unchecked errors to travel, and more participants who have to converge.
This raises the question of whether multi-agent gains were ever about coordination. One line of work finds that about 80% of the variation in multi-agent performance comes from how many tokens the system spends, not from how cleverly the agents work together How does test-time scaling work at the agent level?. Much of what looks like teamwork may simply be extra compute. The same note points to shared-memory approaches (LatentMAS, shared KV caches) that try to get the benefit without the token cost.
That doesn't make single agents the answer. Tasks that need different kinds of expertise, parallel work, or independent checking go beyond what one agent loop can organize Do single agents always hit organizational limits?. The corpus's position is that structure matters more than headcount. One experiment shows that making an agent "accountable" changes outcomes only if the workflow actually sends the deliverable through that agent. A role label does nothing unless the wiring enforces it Does accountability placement actually shape multi-agent outcomes?. Other designs make topology something you can deliberately change. IMACS separates team roles, coordination style, and how results get merged, so each can be swapped on its own Can multi-agent teams swap roles, coordination, and algorithms independently?. Capability vectors let agents find the right collaborator without hand-coded routing Can semantic capability vectors replace manual agent routing?.
The takeaway is that reliability at scale comes from what surrounds the agents, not from the agents themselves. Reliable systems move memory, skills, and interaction protocols out of the model and into a harness layer Where does agent reliability actually come from?. Broader agent infrastructure should also be able to trace which agent did what, which is how you find where an error entered the network What infrastructure must exist beyond training agents?. Making the team cheaper can help too. Small models can handle most routine subtasks at a fraction of the cost Can small language models handle most agent tasks?, which loosens the token-budget limit that drives so much of multi-agent performance.
Sources 11 notes
AgentsNet benchmark shows agents fail to coordinate strategies either by agreeing too late or adopting strategies without informing neighbors. Agents accept neighbor information without verification, enabling error propagation while remaining capable of detecting direct conflicts.
Across hundreds of simulations, LLM-agent groups frequently fail to reach valid agreement due to timeouts and stalled convergence rather than subtle value corruption. Agreement degrades with group size even without Byzantine agents present.
Multi-agent deliberation produces specific failure modes (Degeneration-of-Thought, Silent Agreement), alignment at scale includes problematic self-valuation, and self-improvement is formally bounded by the generation-verification gap. Measurement error and conditional compliance hide the true capability ceiling.
Research shows 80% of multi-agent performance variance comes from token budget, not coordination intelligence. LatentMAS and shared-KV-cache approaches offer ways to decouple performance gains from token costs.
Research shows that real-world tasks requiring heterogeneous expertise, parallel execution, and independent verification exceed what any single agent loop can organize. Graph-based system abstractions are needed to distribute intelligence across specialized agents.
Show all 11 sources
Ablation studies show RACI accountability tags change outcomes only when the collaboration protocol's control flow passes the deliverable through the accountable agent. The best placement varies by model family, requiring per-model validation rather than universal design.
IMACS demonstrates that team structure (Belbin roles), coordination mechanism (Mintzberg framework), and fusion algorithm can be architecturally separated into independent components. This decoupling lets teams and protocols swap without rewriting each other, unlike existing frameworks that fuse these concerns together.
Versioned Capability Vectors embedded in HNSW indices couple semantic matching with policy and budget constraints, making capability discovery a first-class operation that scales sub-linearly as agent heterogeneity increases.
Research shows reliable LLM agents externalize three cognitive burdens—memory (state persistence), skills (procedural components), and protocols (structured interaction)—into a harness layer rather than relying on model scale alone. The harness unifies these externalities and eliminates the need for the model to solve the same problems repeatedly.
Chan et al. argue that external technical systems modeled on internet protocols are essential beyond behavior training. These systems must handle three core functions: attributing actions to agents, shaping their interactions, and detecting and remedying harm.
SLMs handle the repetitive, well-defined language tasks that constitute most agent work at 10–30× lower cost than LLMs, making heterogeneous architectures (SLMs by default, LLMs selective) the economically rational design pattern.
Papers this line draws on 8
The research behind the notes this line reads — ranked by how closely each paper relates.
- Towards a Science of Scaling Agent Systems
- Drop the Hierarchy and Roles: How Self-Organizing LLM Agents Outperform Designed Structures
- Worse Together: How Performance Breaks Down in Multi-User Multi-Agent Teams
- Scaling Behavior of Single LLM-Driven Multi-Agent Systems
- Emergent Collusion in Long-Horizon LLM Agent Interaction
- Toward an Organizational Science of Multi-Agent LLM Systems: Decoupling Who, How, and Which Algorithm
- Single-Agent LLMs Outperform Multi-Agent Systems on Multi-Hop Reasoning Under Equal Thinking Token Budgets
- How we built our multi-agent research system