multi-agent-patterns

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

Updated Apr 5, 2026
One-click install
npx skills add https://github.com/RobinMillford/GopherNotebook --skill multi-agent-patterns-robinmillford
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: multi-agent-patterns
Source: https://github.com/RobinMillford/GopherNotebook/tree/main/.claude/skills/multi-agent-patterns
Command: npx skills add https://github.com/RobinMillford/GopherNotebook --skill multi-agent-patterns-robinmillford

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve? Single agents hit context limits, sequential bottlenecks, and degraded reasoning on complex tasks. This Skill provides proven architectural patterns for distributing work across multiple LLM agents with isolated context windows, explicit handoffs, and reliable coordination. ## Core Features & Use Cases - Three Architecture Patterns: Supervisor/orchestrator for centralized control, peer-to-peer/swarm for flexible handoffs, and hierarchical layers for large-scale projects. - Context Isolation Strategies: Full context delegation, instruction passing, and file system memory to partition work without context bloat. - Consensus & Failure Mitigation: Weighted voting, debate protocols, and mitigations for supervisor bottlenecks, divergence, and error propagation. - Use Case: When building a research assistant that must search multiple sources, analyze data, and write reports, use this Skill to design a supervisor that routes subtasks to specialized researcher, analyzer, and writer agents with direct response forwarding. ## Quick Start Design a multi-agent system with a supervisor coordinating researcher, analyzer, and writer sub-agents for my research workflow.

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?

Place a central supervisor agent in control that decomposes user objectives into subtasks and routes them to specialist workers. Implement a forward_message tool so sub-agents can pass responses directly to users, avoiding the telephone game problem where supervisor paraphrasing loses fidelity.

Supervisor vs swarm architecture for multi-agent systems?

Supervisor patterns offer strict control and easier human oversight but risk bottlenecks and cascading failures. Swarm patterns allow direct agent-to-agent handoffs with no single point of failure, and benchmarks show swarms slightly outperform supervisors when sub-agents respond directly to users.

When should I use multi-agent architecture instead of a single agent?

Use multi-agent designs when tasks decompose into parallel subtasks, require different tool sets or system prompts per subtask, or exceed single-context limits. Note that multi-agent systems consume roughly 15x baseline tokens, so upgrading the model may be a cheaper first step.

How do agents share state without bloating context?

Use file system memory where agents read and write to persistent storage as the coordination mechanism. For simple subtasks, pass only instructions via function calls; reserve full context delegation for complex subtasks that genuinely need complete understanding.

Why do multi-agent discussions converge on wrong answers?

Simple majority voting treats hallucinations as equal to sound reasoning, and agents exhibit sycophancy bias toward agreement. Use weighted voting by confidence or expertise, debate protocols with adversarial critique, and trigger-based intervention to detect stalls and mimicry.

Which frameworks support multi-agent orchestration patterns?

LangGraph implements graph-based state machines with explicit nodes and edges, AutoGen uses conversational GroupChat patterns, and CrewAI provides role-based hierarchical crew processes. Each framework embodies different coordination philosophies suited to different workflow structures.