51  Multi-Agent Systems

TipTL;DR

Multi-agent systems decompose a task across a network of specialized agents that communicate, delegate, and check each other’s work. Individual agents may use any backbone; the architectural question is how they coordinate, message passing, shared memory, or hierarchical orchestration.

Depends on: Tool Use & Function Calling

51.1 Why this matters

A single agent running the perceive-reason-act loop (Agent Architectures Overview) has one context window, one persona, and one thread of reasoning. Some tasks are naturally decomposable into roles that benefit from being kept separate: a planner should not also be the code reviewer catching its own mistakes, and a long, complex task can exceed what any single context window can hold coherently. Multi-agent systems address this by running multiple agent instances, possibly with different prompts, tools, or even different backbone models, that communicate with each other rather than one agent doing everything.

51.2 The mechanism

51.2.1 Orchestrator and subagent patterns

The most common structure is hierarchical: an orchestrator agent breaks a task into subtasks and delegates each to a specialized subagent, then collects and integrates the results.

This mirrors Tool Use directly: an orchestrator treats a subagent as just another callable tool, except the “tool” is itself a full reasoning loop rather than a single function.

51.2.2 Agent communication

Agents exchange information in one of two ways.

• Shared context: all agents read and write to the same conversation or memory store, seeing each other’s outputs directly.
• Structured messages: agents exchange explicit, typed messages (a request, a result, a critique), keeping each agent’s own context focused on only what is relevant to its role.

AutoGen (Wu et al., 2023) formalizes multi-agent conversation this way, defining agents as conversable entities that pass structured messages and can be configured with different tools, memory, and human-in-the-loop checkpoints per agent.

51.2.3 Debate, self-consistency, and emergent behavior

Two further patterns use multiple agents for reliability or realism rather than task decomposition.

• Debate and self-consistency: rather than dividing labor, run multiple independent attempts at the same task and use disagreement as a signal. Several agent instances answer the same question independently, and either vote (self-consistency) or critique each other’s reasoning directly (debate) before a final answer is produced, trading extra inference compute for a form of error-checking a single generation pass cannot provide.
• Emergent social behavior: Generative Agents (Park et al., 2023) demonstrated that giving each agent its own persistent memory, persona, and ability to observe and message other agents in a shared simulated environment produces emergent, human-like coordination (planning a party, spreading information) without any of that coordination being explicitly programmed.

51.2.4 What to observe

• Hierarchical orchestration is architecturally identical to Tool Use: a subagent is a tool call that happens to contain another full reasoning loop.
• Debate and self-consistency spend compute on redundancy (multiple attempts) rather than decomposition (dividing the task); both are valid ways to use more inference-time compute to improve reliability.
• Emergent coordination (Generative Agents) is a result of giving agents memory and the ability to communicate, not of any explicit coordination algorithm.

WarningPitfall: more agents is not always better

Every additional agent adds coordination overhead (messages to route, context to keep synchronized) and inference cost (each agent runs its own reasoning loop). Multi-agent decomposition helps when subtasks genuinely benefit from separate context or specialized prompting; it is not a free way to improve reliability on a task a single well-prompted agent already handles well.

51.3 Application & impact

Concept here	What it became	Where you see it today
Orchestrator/subagent hierarchy	The dominant multi-agent pattern	Coding assistants delegating to specialized subagents
Structured agent messaging	A framework-level abstraction	AutoGen and similar multi-agent frameworks
Debate / self-consistency	Compute-for-reliability tradeoff	Ensemble-style answer verification
Generative Agents’ persistent memory + persona	Emergent multi-agent social simulation	Research into agent societies and simulated environments

NoteKey takeaway

Multi-agent systems are single agents (Agent Architectures Overview) composed together, coordinating through the same tool-call mechanism (Tool Use) recursively applied. The architectural choice is not the backbone model but the communication and delegation structure wrapped around it.

← Back to: Agent Architectures Overview

Park, J. S., O’Brien, J., Cai, C. J., Morris, M. R., Liang, P., & Bernstein, M. S. (2023). Generative agents: Interactive simulacra of human behavior. arXiv Preprint arXiv:2304.03442.

Wu, Q., Bansal, G., Zhang, J., Wu, Y., Li, B., Zhu, E., Jiang, L., Zhang, X., Zhang, S., Liu, J., et al. (2023). AutoGen: Enabling next-gen LLM applications via multi-agent conversation. arXiv Preprint arXiv:2308.08155.