Design Advanced Multi-Agent Architectures

Provides guidance for designing multi-agent LLM architectures that distribute work across multiple context windows for context isolation - covering supervisor/orchestrator, peer-to-peer/swarm, and hierarchical patterns, plus coordination protocols and failure mitigation.

Use this skill when single-agent context limits constrain task complexity, a task decomposes naturally into parallel subtasks, different subtasks require different tool sets or system prompts, or you're designing a production agent system with multiple specialized components. Not a fit for simple queries or tool-using tasks a single agent handles well - multi-agent systems consume roughly 15x the tokens of a single-agent baseline versus ~4x for a single agent with tools, so the added token cost must be justified by genuine parallelization or specialization needs.

Frames the core rationale via the context bottleneck (lost-in-middle effect, attention scarcity, context poisoning as context windows fill), token economics (production data showing single-agent chat at 1x baseline, single agent with tools at ~4x, multi-agent systems at ~15x), the BrowseComp finding that token usage explains 80% of performance variance, and the observation that upgrading models often outperforms doubling token budgets.

Describes three architectural patterns: Supervisor/Orchestrator (a central agent delegates to specialists and synthesizes results - strong for clear decomposition and human oversight, but prone to context bottleneck and the "telephone game" problem where supervisors paraphrase sub-agent responses incorrectly, fixable via a forward_message tool letting sub-agents respond directly to users); Peer-to-Peer/Swarm (agents hand off control directly via functions like transfer_to_agent_b, good for flexible exploration and emergent requirements, but risks divergence without a central state keeper); and Hierarchical (strategy, planning, and execution layers, suited to large enterprise workflows but adding cross-layer coordination overhead).

Covers three context isolation mechanisms - full context delegation, instruction passing, and file system memory - each trading capability against isolation and latency. Covers consensus and coordination: the voting problem (simple majority treats hallucinations as equal to sound reasoning), weighted voting by confidence/expertise, debate protocols with adversarial critique, and trigger-based intervention for stalls or sycophancy. Notes framework differences: LangGraph (graph-based state machines), AutoGen (conversational/GroupChat), and CrewAI (role-based hierarchical crews).

Provides failure modes and mitigations for supervisor bottlenecks (output schema constraints, checkpointing), coordination overhead (clear handoff protocols, batching, async communication), divergence (objective boundaries, convergence checks, time-to-live limits), and error propagation (output validation, retry with circuit breakers, idempotent operations). Includes a research-team supervisor example and a customer-request handoff routing example.

Builds on context-fundamentals and context-degradation skills; connects to memory-systems (shared state), tool-design (per-agent tool specialization), and context-optimization (partitioning strategies). References LangGraph, AutoGen, and CrewAI as implementation frameworks.

Engineers designing production multi-agent LLM systems who need to choose the right coordination pattern, isolation mechanism, and consensus protocol for their task's actual parallelization and specialization needs, rather than anthropomorphizing role division.

def forward_message(message: str, to_user: bool = True):
    if to_user:
        return {"type": "direct_response", "content": message}