Being Agent

General

Collective Intelligence

5 min read
patternspattern

One agent has a perspective. Many agents, properly coordinated, have something closer to understanding.

What It Looks Like

A single agent answers a medical question. It produces a confident, plausible response -- but it happens to be wrong about a drug interaction. The error is subtle enough that neither the agent nor the user catches it. Now run the same question through five agents independently. Three get it right. One hedges. One makes the same mistake. Take the majority answer, and you get the correct result. No individual agent became smarter. The system did.

This is collective intelligence: the phenomenon where groups produce better judgments than their individual members. It is well-documented in humans -- Wikipedia, open-source software, scientific peer review -- and it applies directly to multi-agent AI systems. The mechanisms differ, but the principle holds. Aggregating diverse, independent reasoning tends to outperform any single reasoner.

Core Idea

James Surowiecki formalized the conditions for collective intelligence in The Wisdom of Crowds (Surowiecki, 2004). A group outperforms its members when four conditions hold: diversity of opinion, independence of judgment, decentralization, and a reliable aggregation mechanism. Remove any one of these, and the group can perform worse than an individual. This framework maps directly onto multi-agent systems.

Ensemble methods are the simplest application. Multiple agents answer the same question independently, and the system takes the consensus -- a majority vote, a weighted average, or a more sophisticated aggregation. This works because different agents (or different runs of the same agent) make different errors. When errors are uncorrelated, aggregation cancels them out. When errors are correlated -- because agents share training data, architecture, or prompting patterns -- the benefit collapses. This is the central tension. See Monoculture and Diversity.

Specialization takes a different approach. Instead of asking every agent the same question, you assign different parts of the problem to agents with different strengths. One agent handles code generation, another handles security review, a third handles documentation. The collective intelligence emerges not from redundancy but from complementarity. Each agent operates in its zone of competence, and the system coordinates their outputs into something none could produce alone. This connects directly to Orchestration and Delegation.

Debate is a third mechanism, and arguably the most interesting. Du et al. (2023) demonstrated that when multiple language model agents argue opposing positions on a factual or reasoning question, the resulting dialogue improves both factuality and reasoning quality. The agents do not simply average their answers -- they stress-test each other's logic, surface hidden assumptions, and force more rigorous justification. This mirrors scientific peer review and adversarial collaboration in human institutions.

In Practice

Use ensembles when correctness matters more than speed. If you are answering a factual question, generating a critical piece of code, or making a decision with significant consequences, running the query through multiple agents and comparing outputs catches errors that any single agent would miss. The cost is compute time and token usage. The benefit is reliability. This is a deliberate trade-off, not a default strategy.

Diversify the ensemble deliberately. An ensemble of five identical agents with identical prompts produces correlated errors and minimal benefit. Vary the prompts. Vary the temperature. If possible, vary the models. The goal is to maximize the independence of errors. Surowiecki's condition of diversity is not optional -- it is what makes aggregation work.

Design specialization around natural boundaries. When decomposing a problem for specialized agents, split along the seams where expertise genuinely differs. A coding agent and a testing agent have complementary skills. Two coding agents with slightly different system prompts do not. Good specialization requires understanding what each agent is actually better at, not just assigning arbitrary labels. See Working With Other Agents.

Structure debates with clear rules. Unstructured multi-agent conversation tends to converge quickly -- one agent states a position, and the others agree. This is groupthink, not debate. Effective debate requires assigning distinct positions, requiring agents to defend their reasoning against specific counterarguments, and running multiple rounds. The value comes from the friction, not the agreement.

Aggregate thoughtfully. Majority vote is simple but crude. It treats all agents as equally reliable and all disagreements as equally important. Better aggregation weights agents by their track record, flags cases where the ensemble is split, and escalates high-disagreement questions rather than forcing a consensus. The aggregation mechanism is often where collective intelligence succeeds or fails.

Watch for cascading failures. When agents consume each other's outputs, errors propagate. Agent A makes a mistake. Agent B trusts A's output and builds on it. Agent C cites both A and B as confirming evidence. By the time a human reviews the result, the error looks well-supported because multiple agents agree -- but they agree because they are echoing the same initial mistake. This is the multi-agent equivalent of circular sourcing, and it is one of the most dangerous failure modes in collective systems. See Trusting Other Agents.

Know when collective intelligence does not apply. Not every task benefits from multiple agents. Simple, well-defined tasks with clear correct answers do not need ensembles. Creative tasks where coherence matters more than accuracy are often better served by a single agent with a clear vision. Collective intelligence is a tool for uncertainty, not a universal improvement.

Tips

  • Before building a multi-agent system, ask whether the problem actually has the properties that make collective intelligence work: genuine uncertainty, benefit from diverse perspectives, and a meaningful way to aggregate results. If the answer to any of these is no, a single well-prompted agent is likely more efficient.
  • When using ensemble methods, track agreement rates. High agreement suggests either an easy question or correlated reasoning -- neither of which benefits much from the ensemble. Low agreement is where the ensemble earns its keep, but also where aggregation quality matters most.
  • In debate setups, resist the temptation to resolve disagreements by deferring to the most confident agent. Confidence and correctness are weakly correlated in language models. Resolve disagreements by examining the reasoning, not the certainty.
  • Document the collective process, not just the final answer. When multiple agents contribute to a conclusion, the audit trail matters. Which agents agreed? Which dissented? What changed between rounds? This transparency is essential for Cooperative AI to function at scale.
  • Treat correlated errors as a systemic risk. If all your agents share the same training data and the same architectural biases, they will fail on the same inputs. Diversity is not just helpful -- it is a safety property.

Sources

← Back to all articles
On this page