multi-agent-patterns

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

Updated Feb 20, 2026
One-click install
npx skills add https://github.com/gtbauke/bj-utils --skill multi-agent-patterns-gtbauke
Or copy as Structured Prompt for Agent▼
Please help me install this Agent Skill.
Skill: multi-agent-patterns
Source: https://github.com/gtbauke/bj-utils/tree/main/.agent/skills/multi-agent-patterns
Command: npx skills add https://github.com/gtbauke/bj-utils --skill multi-agent-patterns-gtbauke

SYSTEM DOCUMENTATION & REQUIREMENTS

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

What problem does it solve? Single-agent systems hit context window limits, suffer from context degradation, and cannot parallelize work across independent subtasks. This Skill provides architectural patterns and reusable coordination code for distributing work across multiple LLM agents without introducing coordination overhead that negates the benefits. ## Core Features & Use Cases - Three Architecture Patterns: Guidance for choosing between supervisor/orchestrator, peer-to-peer swarm, and hierarchical patterns based on coordination needs rather than organizational metaphor. - Coordination Utilities: A Python module providing message passing, supervisor task delegation, handoff protocols, weighted consensus voting, and circuit-breaker failure handling. - Framework References: Implementation examples for LangGraph, AutoGen, and CrewAI covering supervisors, swarms, context isolation, and checkpoint recovery. - 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 handoffs. ## 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, fact-checker, and 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 the supervisor context from becoming a bottleneck, and cap workers at 3-5 per supervisor.

What is the difference between supervisor and swarm multi-agent patterns?▼

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 directly to each other, eliminating translation errors but requiring explicit handoff protocols and convergence constraints.

How much more expensive are multi-agent systems compared to 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 the 15x multiplier including coordination overhead, retries, and consensus rounds.

Does LangGraph support multi-agent supervisor workflows?▼

Yes, LangGraph implements supervisors as graph-based state machines with explicit nodes and edges. The references include code for supervisor nodes that route to researcher and writer workers using StateGraph with typed state.

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

LLMs have an inherent bias toward agreement, causing sycophantic consensus where agents mimic each other rather than reason independently. Counter this with weighted voting by confidence, explicit adversarial roles, and requiring stated disagreements before convergence.

When should I avoid using a multi-agent architecture?▼

Avoid multi-agent designs when a single agent's context window can hold all task-relevant information, when subtasks cannot run in parallel, or when coordination overhead exceeds the work itself. Over-decomposition into many agents spends more tokens on handoffs than on actual work.