Multi-agent systems succeed or fail based on their collaboration pattern, not their framework choice. In 2026 the handful of patterns that production shops use again and again are documented well enough to pick before you build. This article covers the five patterns worth knowing: sequential pipeline, hierarchical delegation, debate/critique, supervisor-worker, and swarm. For each: what the pattern looks like, when it fits, the LLM cost shape, and the specific pitfalls that break production runs.
Why collaboration patterns matter more than framework choice
CrewAI, LangGraph, AutoGen, and even raw OpenAI/Claude SDK can all implement any of the five patterns. The pattern determines:
- How many LLM calls per task (cost)
- How predictable the control flow is (debuggability)
- How well the system handles edge cases (reliability)
- Whether human-in-the-loop fits naturally (compliance)
- Whether the system scales horizontally (concurrency)
Pick the pattern first, then pick the framework that implements it cleanly.
Pattern 1: Sequential pipeline
Agent A does step 1, hands output to Agent B, which does step 2, hands to C, etc. Linear flow. Each agent sees only the prior output, not the full history.
Shape: Agent 1 to Agent 2 to Agent 3 to Output
When to use:
- Workflow has clear sequential dependencies (research then analyze then write then review)
- Each step has a specialized skill (no overlap of agent capabilities)
- You want predictable cost and latency
Cost profile: N agents = N LLM calls (plus tool-use overhead). Lowest total cost of all patterns because no coordination overhead.
Framework fit: CrewAI (default Process.sequential), LangGraph (linear edges), AutoGen (round-robin group chat with termination after N rounds).
Pitfalls:
- Error propagation: bad research kills the whole pipeline. Add validation at each step.
- Context stacking: each step receives prior output, which grows long. Add summarizer steps between heavy stages.
- No recovery: if step 3 fails, you cannot easily rerun just step 3. Checkpoint between steps.
Pattern 2: Hierarchical delegation
A manager agent receives the task, decides which specialist to delegate to, waits for the specialist’s result, decides what to do next (delegate again, synthesize, or finish). The manager has full visibility; specialists see only their assigned subtask.
Shape: Manager to Specialist 1 to Manager to Specialist 2 to Manager to Output
When to use:
- Tasks have variable structure (manager picks the right specialist per situation)
- Specialists are expensive and you want to call them only when needed
- You want a single accountable “agent” to the end user (manager is the face)
Cost profile: Higher than sequential. Each manager decision is an LLM call; each specialist call is additional. Typical: 2-3x the cost of a pure sequential equivalent.
Framework fit: CrewAI (Process.hierarchical), LangGraph (conditional edges from manager node), AutoGen (SelectorGroupChat with a manager).
Pitfalls:
- Manager over-delegates: picks a specialist for every tiny subtask, blowing up cost. Tune the manager’s system prompt to answer directly when the question is simple.
- Manager picks wrong specialist: ambiguous specialist roles. Make specialist descriptions crisp and non-overlapping.
- Infinite delegation loops: manager hands off to specialist, specialist hands back, manager hands off again. Cap turns.
Pattern 3: Debate / critique
Multiple agents independently produce candidate answers; a critic agent evaluates them and either picks a winner or sends them back for revision. Think editorial board.
Shape: Agents 1, 2, 3 (parallel) to Critic to Winner (or back to Agents for revision)
When to use:
- Quality matters more than cost (critical content, legal review, safety-sensitive outputs)
- Multiple perspectives genuinely add value (not just redundancy)
- You can design an objective critique rubric
Cost profile: Highest of all patterns. N candidate agents + 1 critic + optional revision rounds = 4-10x the single-agent baseline.
Framework fit: AutoGen (natural fit, the group chat metaphor matches multi-agent debate), LangGraph (parallel nodes + critic node + conditional loop back).
Pitfalls:
- Candidate agents converge to the same answer: not diversity, just redundant cost. Vary models, temperatures, or system prompts to encourage diverse candidates.
- Critic self-selects same style as its base model: use a different judge model than the candidates (Claude judging GPT-4o or vice versa).
- Revision loops that never terminate: cap at 2-3 revision rounds then force the critic to pick the best available.
Pattern 4: Supervisor-worker
A supervisor agent plans a sequence of subtasks and dispatches them to a pool of worker agents (potentially many instances of the same worker role). Workers execute in parallel; supervisor collects and sequences results.
Shape: Supervisor to Worker, Worker, Worker (parallel) to Supervisor to Output
When to use:
- Task has many parallel subtasks that can run concurrently
- Subtasks are the same shape (e.g., scrape 100 URLs, summarize each)
- Wall-clock time matters (parallel execution cuts total time dramatically)
Cost profile: Scales linearly with number of workers. Same total cost as sequential equivalent but much lower wall-clock time.
Framework fit: LangGraph (fan-out + fan-in on shared state), AutoGen 0.4+ (worker pool via custom team).
Pitfalls:
- Worker pool saturation: all N workers run concurrently; LLM API rate limits throttle. Add a semaphore limiting concurrent calls to your API tier’s safe max.
- Partial failure handling: if 1 of 50 workers fails, do you re-run that one or fail the whole batch? Design the supervisor to handle partial results gracefully.
- Supervisor becomes a bottleneck: if the supervisor must synthesize 50 worker outputs, synthesis itself takes a long prompt. Add intermediate aggregation workers.
Pattern 5: Swarm / peer-to-peer
Multiple agents operate as peers, passing work to each other based on handoff signals. No central manager; agents decide independently when to hand off.
Shape: Agent A to Agent B (handoff) to Agent C (handoff) to Agent A (handoff back) to Output
When to use:
- Agents genuinely need to pass control between each other based on content (e.g., customer support routing: billing agent passes to technical agent when the question changes topic)
- You want a single entry point for the user that invisibly routes
- OpenAI’s Swarm pattern is explicitly built for this
Cost profile: Similar to hierarchical. Each handoff decision is an LLM call; each specialist execution is additional.
Framework fit: OpenAI Swarm (built for this pattern), AutoGen (conversational handoffs), raw Claude tool-use with a “transfer_to_agent” tool.
Pitfalls:
- Ping-pong handoffs: Agent A passes to B, B passes back to A, loop. Cap total handoffs.
- Agent impersonation: without clear role boundaries, one agent answers questions meant for another. Make handoff conditions explicit in system prompts.
- Debugging is hard: the “why did we end up at Agent C” question requires reading every handoff decision. Observability matters more here than other patterns.
Decision matrix
| Pattern | Cost | Wall-clock | Debuggability | Best for |
|---|---|---|---|---|
| Sequential | Low | Medium | High | Linear workflows |
| Hierarchical | Medium | Medium | Medium | Variable workflows |
| Debate | High | Medium | Medium | Quality-critical outputs |
| Supervisor-worker | Medium | Low (fast) | Medium | Many parallel subtasks |
| Swarm | Medium | Medium | Low | Routing to specialists |
Combining patterns
Real production systems often combine patterns:
- Hierarchical over Sequential: manager routes to a sub-crew that runs its own sequential pipeline. Common in customer-support systems (manager routes to billing crew, billing crew runs its own 3-step pipeline).
- Supervisor-worker with Debate: supervisor dispatches to parallel workers; each worker is a debate pattern with critic. Use when the task is parallelizable AND each parallel subtask needs high-quality output.
- Sequential with Human Review: sequential pipeline but every step gates on human approval. Common in regulated industries.
Picking your first pattern
When unsure, start with Sequential. It is the simplest, cheapest, and easiest to debug. Upgrade only when a specific limitation forces you (e.g., need parallelism, need variable routing).
Beware prematurely jumping to Debate or Supervisor-worker because they sound sophisticated. The cost multiplier is real; use only when the quality or wall-clock improvement justifies it.
Frequently Asked Questions
Official documentation
Which pattern is OpenAI’s new Swarm built for?
Peer-to-peer / routing. Swarm is explicitly a lightweight framework for routing a conversation between specialist agents based on handoff signals. It is deliberately NOT designed for sequential pipelines or supervisor-worker patterns; use CrewAI or LangGraph for those.
Can I switch patterns mid-production?
Yes but costly. The pattern shapes your prompts, state design, and testing surface. Switching patterns is roughly a rewrite of the orchestration layer (not the agents themselves). Plan to pick carefully upfront.
Is there a pattern for agents that need to coordinate across machines?
Not in the common frameworks. For cross-machine coordination (one agent on each of 10 servers), you need a message bus (Redis streams, Kafka, cloud pub/sub) and build the orchestration layer yourself. Agent frameworks assume single-process execution for simplicity.
Does hierarchical always have a single manager?
Common but not required. Multi-level hierarchy (manager delegates to mid-managers who delegate to workers) works in CrewAI and LangGraph via nested crews / subgraphs. Watch cost: each level adds LLM calls.
How do I decide between Debate and Supervisor-worker for quality?
Debate improves quality on single answers (multiple candidates, pick best). Supervisor-worker improves throughput on parallel subtasks. If you need high quality on ONE answer, Debate. If you need to produce many answers in parallel, Supervisor-worker.
Can I use the same framework for all 5 patterns?
LangGraph covers all 5 cleanly because its graph primitive is pattern-agnostic. CrewAI covers Sequential and Hierarchical natively; the others require workarounds. AutoGen covers Debate and Swarm natively; the others require custom coordinator agents.
Mary Grace G. Patulada
Programmer & Technical Writer at PIES IT Solution
Mary Grace G. Patulada (pen name ‘Nym’) is a programmer and writer at PIES IT Solution with a BSIT background from Carlos Hilado Memorial State College, Binalbagan Campus. Authored 370+ UML diagram tutorials and capstone documentation guides at itsourcecode.com. Specializes in UML (class, use case, activity, sequence, component, deployment), DFD, and ER diagrams for BSIT capstone projects.
Expertise: UML Diagrams · DFD · ER Diagrams · Use Case Diagrams · Activity Diagrams · Capstone Documentation · PHP · View all posts by Mary Grace G. Patulada →