Multi Agent Patterns

1---
2name: multi-agent-patterns
3description: This skill should be used when the user asks to "design multi-agent system", "implement supervisor pattern", "create swarm architecture", "coordinate multiple agents", or mentions multi-agent patterns, context isolation, agent handoffs, sub-agents, or parallel agent execution.
4---
5 
6# Multi-Agent Architecture Patterns
7 
8Multi-agent architectures distribute work across multiple language model instances, each with its own context window. When designed well, this distribution enables capabilities beyond single-agent limits. When designed poorly, it introduces coordination overhead that negates benefits. The critical insight is that sub-agents exist primarily to isolate context, not to anthropomorphize role division.
9 
10## When to Activate
11 
12Activate this skill when:
13- Single-agent context limits constrain task complexity
14- Tasks decompose naturally into parallel subtasks
15- Different subtasks require different tool sets or system prompts
16- Building systems that must handle multiple domains simultaneously
17- Scaling agent capabilities beyond single-context limits
18- Designing production agent systems with multiple specialized components
19 
20## Core Concepts
21 
22Multi-agent systems address single-agent context limitations through distribution. Three dominant patterns exist: supervisor/orchestrator for centralized control, peer-to-peer/swarm for flexible handoffs, and hierarchical for layered abstraction. The critical design principle is context isolation—sub-agents exist primarily to partition context rather than to simulate organizational roles.
23 
24Effective multi-agent systems require explicit coordination protocols, consensus mechanisms that avoid sycophancy, and careful attention to failure modes including bottlenecks, divergence, and error propagation.
25 
26## Detailed Topics
27 
28### Why Multi-Agent Architectures
29 
30**The Context Bottleneck**
31Single agents face inherent ceilings in reasoning capability, context management, and tool coordination. As tasks grow more complex, context windows fill with accumulated history, retrieved documents, and tool outputs. Performance degrades according to predictable patterns: the lost-in-middle effect, attention scarcity, and context poisoning.
32 
33Multi-agent architectures address these limitations by partitioning work across multiple context windows. Each agent operates in a clean context focused on its subtask. Results aggregate at a coordination layer without any single context bearing the full burden.
34 
35**The Token Economics Reality**
36Multi-agent systems consume significantly more tokens than single-agent approaches. Production data shows:
37 
38| Architecture | Token Multiplier | Use Case |
39|--------------|------------------|----------|
40| Single agent chat | 1× baseline | Simple queries |
41| Single agent with tools | ~4× baseline | Tool-using tasks |
42| Multi-agent system | ~15× baseline | Complex research/coordination |
43 
44Research on the BrowseComp evaluation found that three factors explain 95% of performance variance: token usage (80% of variance), number of tool calls, and model choice. This validates the multi-agent approach of distributing work across agents with separate context windows to add capacity for parallel reasoning.
45 
46Critically, upgrading to better models often provides larger performance gains than doubling token budgets. Claude Sonnet 4.5 showed larger gains than doubling tokens on earlier Sonnet versions. GPT-5.2's thinking mode similarly outperforms raw token increases. This suggests model selection and multi-agent architecture are complementary strategies.
47 
48**The Parallelization Argument**
49Many tasks contain parallelizable subtasks that a single agent must execute sequentially. A research task might require searching multiple independent sources, analyzing different documents, or comparing competing approaches. A single agent processes these sequentially, accumulating context with each step.
50 
51Multi-agent architectures assign each subtask to a dedicated agent with a fresh context. All agents work simultaneously, then return results to a coordinator. The total real-world time approaches the duration of the longest subtask rather than the sum of all subtasks.
52 
53**The Specialization Argument**
54Different tasks benefit from different agent configurations: different system prompts, different tool sets, different context structures. A general-purpose agent must carry all possible configurations in context. Specialized agents carry only what they need.
55 
56Multi-agent architectures enable specialization without combinatorial explosion. The coordinator routes to specialized agents; each agent operates with lean context optimized for its domain.
57 
58### Architectural Patterns
59 
60**Pattern 1: Supervisor/Orchestrator**
61The supervisor pattern places a central agent in control, delegating to specialists and synthesizing results. The supervisor maintains global state and trajectory, decomposes user objectives into subtasks, and routes to appropriate workers.
62 
63```
64User Query -> Supervisor -> [Specialist, Specialist, Specialist] -> Aggregation -> Final Output
65```
66 
67When to use: Complex tasks with clear decomposition, tasks requiring coordination across domains, tasks where human oversight is important.
68 
69Advantages: Strict control over workflow, easier to implement human-in-the-loop interventions, ensures adherence to predefined plans.
70 
71Disadvantages: Supervisor context becomes bottleneck, supervisor failures cascade to all workers, "telephone game" problem where supervisors paraphrase sub-agent responses incorrectly.
72 
73**The Telephone Game Problem and Solution**
74LangGraph benchmarks found supervisor architectures initially performed 50% worse than optimized versions due to the "telephone game" problem where supervisors paraphrase sub-agent responses incorrectly, losing fidelity.
75 
76The fix: implement a `forward_message` tool allowing sub-agents to pass responses directly to users:
77 
78```python
79def forward_message(message: str, to_user: bool = True):
80    """
81    Forward sub-agent response directly to user without supervisor synthesis.
82    
83    Use when:
84    - Sub-agent response is final and complete
85    - Supervisor synthesis would lose important details
86    - Response format must be preserved exactly
87    """
88    if to_user:
89        return {"type": "direct_response", "content": message}
90    return {"type": "supervisor_input", "content": message}
91```
92 
93With this pattern, swarm architectures slightly outperform supervisors because sub-agents respond directly to users, eliminating translation errors.
94 
95Implementation note: Implement direct pass-through mechanisms allowing sub-agents to pass responses directly to users rather than through supervisor synthesis when appropriate.
96 
97**Pattern 2: Peer-to-Peer/Swarm**
98The peer-to-peer pattern removes central control, allowing agents to communicate directly based on predefined protocols. Any agent can transfer control to any other through explicit handoff mechanisms.
99 
100```python
101def transfer_to_agent_b():
102    return agent_b  # Handoff via function return
103 
104agent_a = Agent(
105    name="Agent A",
106    functions=[transfer_to_agent_b]
107)
108```
109 
110When to use: Tasks requiring flexible exploration, tasks where rigid planning is counterproductive, tasks with emergent requirements that defy upfront decomposition.
111 
112Advantages: No single point of failure, scales effectively for breadth-first exploration, enables emergent problem-solving behaviors.
113 
114Disadvantages: Coordination complexity increases with agent count, risk of divergence without central state keeper, requires robust convergence constraints.
115 
116Implementation note: Define explicit handoff protocols with state passing. Ensure agents can communicate their context needs to receiving agents.
117 
118**Pattern 3: Hierarchical**
119Hierarchical structures organize agents into layers of abstraction: strategic, planning, and execution layers. Strategy layer agents define goals and constraints; planning layer agents break goals into actionable plans; execution layer agents perform atomic tasks.
120 
121```
122Strategy Layer (Goal Definition) -> Planning Layer (Task Decomposition) -> Execution Layer (Atomic Tasks)
123```
124 
125When to use: Large-scale projects with clear hierarchical structure, enterprise workflows with management layers, tasks requiring both high-level planning and detailed execution.
126 
127Advantages: Mirrors organizational structures, clear separation of concerns, enables different context structures at different levels.
128 
129Disadvantages: Coordination overhead between layers, potential for misalignment between strategy and execution, complex error propagation.
130 
131### Context Isolation as Design Principle
132 
133The primary purpose of multi-agent architectures is context isolation. Each sub-agent operates in a clean context window focused on its subtask without carrying accumulated context from other subtasks.
134 
135**Isolation Mechanisms**
136Full context delegation: For complex tasks where the sub-agent needs complete understanding, the planner shares its entire context. The sub-agent has its own tools and instructions but receives full context for its decisions.
137 
138Instruction passing: For simple, well-defined subtasks, the planner creates instructions via function call. The sub-agent receives only the instructions needed for its specific task.
139 
140File system memory: For complex tasks requiring shared state, agents read and write to persistent storage. The file system serves as the coordination mechanism, avoiding context bloat from shared state passing.
141 
142**Isolation Trade-offs**
143Full context delegation provides maximum capability but defeats the purpose of sub-agents. Instruction passing maintains isolation but limits sub-agent flexibility. File system memory enables shared state without context passing but introduces latency and consistency challenges.
144 
145The right choice depends on task complexity, coordination needs, and acceptable latency.
146 
147### Consensus and Coordination
148 
149**The Voting Problem**
150Simple majority voting treats hallucinations from weak models as equal to reasoning from strong models. Without intervention, multi-agent discussions devolve into consensus on false premises due to inherent bias toward agreement.
151 
152**Weighted Voting**
153Weight agent votes by confidence or expertise. Agents with higher confidence or domain expertise carry more weight in final decisions.
154 
155**Debate Protocols**
156Debate protocols require agents to critique each other's outputs over multiple rounds. Adversarial critique often yields higher accuracy on complex reasoning than collaborative consensus.
157 
158**Trigger-Based Intervention**
159Monitor multi-agent interactions for specific behavioral markers. Stall triggers activate when discussions make no progress. Sycophancy triggers detect when agents mimic each other's answers without unique reasoning.
160 
161### Framework Considerations
162 
163Different frameworks implement these patterns with different philosophies. LangGraph uses graph-based state machines with explicit nodes and edges. AutoGen uses conversational/event-driven patterns with GroupChat. CrewAI uses role-based process flows with hierarchical crew structures.
164 
165## Practical Guidance
166 
167### Failure Modes and Mitigations
168 
169**Failure: Supervisor Bottleneck**
170The supervisor accumulates context from all workers, becoming susceptible to saturation and degradation.
171 
172Mitigation: Implement output schema constraints so workers return only distilled summaries. Use checkpointing to persist supervisor state without carrying full history.
173 
174**Failure: Coordination Overhead**
175Agent communication consumes tokens and introduces latency. Complex coordination can negate parallelization benefits.
176 
177Mitigation: Minimize communication through clear handoff protocols. Batch results where possible. Use asynchronous communication patterns.
178 
179**Failure: Divergence**
180Agents pursuing different goals without central coordination can drift from intended objectives.
181 
182Mitigation: Define clear objective boundaries for each agent. Implement convergence checks that verify progress toward shared goals. Use time-to-live limits on agent execution.
183 
184**Failure: Error Propagation**
185Errors in one agent's output propagate to downstream agents that consume that output.
186 
187Mitigation: Validate agent outputs before passing to consumers. Implement retry logic with circuit breakers. Use idempotent operations where possible.
188 
189## Examples
190 
191**Example 1: Research Team Architecture**
192```text
193Supervisor
194├── Researcher (web search, document retrieval)
195├── Analyzer (data analysis, statistics)
196├── Fact-checker (verification, validation)
197└── Writer (report generation, formatting)
198```
199 
200**Example 2: Handoff Protocol**
201```python
202def handle_customer_request(request):
203    if request.type == "billing":
204        return transfer_to(billing_agent)
205    elif request.type == "technical":
206        return transfer_to(technical_agent)
207    elif request.type == "sales":
208        return transfer_to(sales_agent)
209    else:
210        return handle_general(request)
211```
212 
213## Guidelines
214 
2151. Design for context isolation as the primary benefit of multi-agent systems
2162. Choose architecture pattern based on coordination needs, not organizational metaphor
2173. Implement explicit handoff protocols with state passing
2184. Use weighted voting or debate protocols for consensus
2195. Monitor for supervisor bottlenecks and implement checkpointing
2206. Validate outputs before passing between agents
2217. Set time-to-live limits to prevent infinite loops
2228. Test failure scenarios explicitly
223 
224## Integration
225 
226This skill builds on context-fundamentals and context-degradation. It connects to:
227 
228- memory-systems - Shared state management across agents
229- tool-design - Tool specialization per agent
230- context-optimization - Context partitioning strategies
231 
232## References
233 
234Internal reference:
235- [Frameworks Reference](./references/frameworks.md) - Detailed framework implementation patterns
236 
237Related skills in this collection:
238- context-fundamentals - Context basics
239- memory-systems - Cross-agent memory
240- context-optimization - Partitioning strategies
241 
242External resources:
243- [LangGraph Documentation](https://langchain-ai.github.io/langgraph/) - Multi-agent patterns and state management
244- [AutoGen Framework](https://microsoft.github.io/autogen/) - GroupChat and conversational patterns
245- [CrewAI Documentation](https://docs.crewai.com/) - Hierarchical agent processes
246- [Research on Multi-Agent Coordination](https://arxiv.org/abs/2308.00352) - Survey of multi-agent systems
247 
248---
249 
250## Skill Metadata
251 
252**Created**: 2025-12-20
253**Last Updated**: 2025-12-20
254**Author**: Agent Skills for Context Engineering Contributors
255**Version**: 1.0.0
256