multi-agent-patterns

Design and implement multi-agent architectures using supervisor, swarm, and hierarchical coordination patterns.

1|Updated May 16, 2026
One-click install
npx skills add https://github.com/ludotype/game-adventurertown --skill multi-agent-patterns-ludotype
Or copy as Structured Prompt for Agent▼
Please help me install this Agent Skill.
Skill: multi-agent-patterns
Source: https://github.com/ludotype/game-adventurertown/tree/main/.agent/skills/multi-agent-patterns
Command: npx skills add https://github.com/ludotype/game-adventurertown --skill multi-agent-patterns-ludotype

SYSTEM DOCUMENTATION & REQUIREMENTS

💡 This Skill includes scripts (resource) and references (resource) components.

What problem does it solve? Single-agent systems hit context window limits, degrade under accumulated history, and cannot parallelize work across independent subtasks. This Skill provides the architectural patterns, coordination protocols, and failure-handling strategies needed to distribute work across multiple LLM agents without coordination overhead negating the benefits. ## Core Features & Use Cases - Architecture Pattern Selection: Guidance for choosing between supervisor/orchestrator, peer-to-peer swarm, and hierarchical patterns based on coordination needs rather than organizational metaphor. - Coordination Building Blocks: A Python module with message passing, supervisor task delegation, handoff protocols, weighted consensus voting, and circuit-breaker failure handling. - Framework Implementation References: Code examples for LangGraph, AutoGen, and CrewAI covering supervisor graphs, swarm handoffs, context isolation, and checkpointing. - Use Case: When building a research system where a single agent's context overflows, use this Skill to design a supervisor that routes subtasks to specialized researcher, analyzer, and writer agents with isolated contexts and validated result aggregation. ## Quick Start Ask the AI to design a multi-agent architecture for your task, for example: design a supervisor-based multi-agent system that coordinates a researcher, an analyzer, and a writer agent.

Frequently Asked Questions about multi-agent-patterns

High-intent search queries and answers about installing and using this skill.

FAQPage Schema
How do I design a multi-agent system with a supervisor pattern?▼

Create a central supervisor agent that decomposes tasks into subtasks, routes them to specialized workers based on capabilities, and aggregates results. Constrain worker output schemas to prevent supervisor context saturation, and cap workers at 3-5 per supervisor.

What is the difference between supervisor and swarm agent architectures?▼

Supervisor patterns use a central coordinator that delegates to workers and synthesizes results, giving strict control but creating a bottleneck. Swarm patterns let agents hand off control directly to each other, removing the single point of failure but requiring explicit handoff protocols and convergence checks.

LangGraph vs AutoGen vs CrewAI for multi-agent systems?▼

LangGraph uses graph-based state machines with explicit nodes and edges for deterministic routing. AutoGen uses conversational GroupChat patterns for event-driven coordination. CrewAI uses role-based hierarchical crews. Choose based on whether you need explicit state control, conversational flexibility, or role-based structure.

How much more expensive are multi-agent systems than single agents?▼

Production data shows multi-agent systems cost approximately 15x the tokens of a single-agent chat, while a single agent with tools runs about 4x baseline. Budget for coordination overhead, retries, and consensus rounds, not just per-agent costs.

Why do multi-agent debates converge on wrong answers?▼

LLMs have an inherent bias toward agreement, so agents converge on agreeable rather than correct answers, and simple majority voting weights hallucinations equally with sound reasoning. Counter this with confidence-weighted voting, explicit adversarial roles, and required statements of disagreement before convergence.

When should I not use a multi-agent architecture?▼

Avoid multi-agent designs when a single agent's context window can hold the task, when subtasks cannot run in parallel, or when decomposition creates more coordination overhead than the work itself. Over-decomposition past 3-5 agents shows diminishing returns and quadratic communication growth.