One prompt. N agents. Done in parallel.

Stop running tasks one by one. Spawn a swarm of agents, each tackling a piece of the problem simultaneously. Orchestrate, fan out, collect results. This is how you scale intelligence without scaling effort.

The Problem They Solve

Single-agent Claude Code is sequential by default: one task finishes before the next begins. That's fine for a 3-step pipeline, but catastrophic when you have 50 files to migrate, 12 client reports to write, or 8 competitors to research. The wall-clock time scales linearly with the number of tasks.

Agent swarms break that constraint. An orchestrator fans work out to N independent worker agents that run in parallel. Token cost stays the same (you pay per task either way), but wall-clock time collapses from items × duration to max(duration).

The 6 Swarm Patterns

Click each pattern to expand. Every pattern includes a description, flow, example, and runnable bash code.

The /batch Skill

A custom Claude Code skill for swarm orchestration. One command decomposes, plans, spawns, and manages parallel agents for you. No bash scripting required. (This is an AY-authored skill, not a native Claude Code built-in.)

# What /batch does under the hood:

# 1. Scan and decompose
files=$(find src/ -name "*.tsx" -exec grep -l "extends React.Component" {} \;)

# 2. Present plan (you approve)
# "Found 20 class components. Migrate each to functional + hooks."
# [approve / modify / cancel]

# 3. Spawn agents in isolated worktrees
for f in $files; do
  # Each agent gets its own git worktree
  git worktree add "/tmp/batch-$(basename $f)" -b "batch/migrate-$(basename $f)"

  claude --worktree "/tmp/batch-$(basename $f)" \
    "Convert $f from class component to functional.
    Replace lifecycle methods with hooks.
    Run tests. Open PR when done." &
done

wait
# Result: 20 PRs ready for review

Handoff Patterns & Locks

A multi-agent pipeline needs a coordination layer; otherwise agents stomp on each other's work. In Claude Code's 6-mode pipeline (PLAN → BUILD → REVIEW → QA → SHIP → RETRO), each mode hands off to the next via a shared tracking file and an exclusive lock.

Concrete Example: 12 Client Reports in 2 Minutes

You manage 12 active clients. Every Friday you need a status report per client: blockers, wins, next actions, and a health score. Sequentially that's 12 × ~2 min = 24 minutes of waiting. With a fan-out swarm it takes 2 minutes regardless of how many clients you have.

#!/bin/bash
# Weekly client reports - fan-out swarm

clients=$(ls 01_Projects/Clients/Active/)
count=0

for client in $clients; do
  claude -p "Read all files in 01_Projects/Clients/Active/$client/.
  Generate a Friday status report:
    - Health score (1-10)
    - Top 3 blockers
    - Wins this week
    - Next 3 actions
  Return as JSON: {client, health, blockers:[], wins:[], actions:[]}" > "reports/${client}.json" &

  count=$((count + 1))
done

wait  # all 12 agents finish in parallel
echo "Generated $count client reports"

# Reduce: executive summary
claude "Read all reports/*.json.
Create an executive summary:
- Flag any client with health < 7
- List all blockers that need my attention
- Suggest my top 3 priorities for next week
Save to WEEKLY-SUMMARY.md"

Real Use Cases

Patterns deployed in production. Real numbers, real workflows.

Common Pitfalls

When NOT to Use a Swarm

Swarms add orchestration overhead and complexity. They are the right tool only when tasks are genuinely parallelisable and numerous enough to justify the setup. Skip swarms when:

• ×Tasks that depend on each other's output (use Pipeline instead)
• ×Fewer than 3 items; sequential is simpler and easier to debug
• ×Tasks that require real-time peer communication between agents
• ×When you need deterministic, reproducible output on every run
• ×Tightly rate-limited APIs where parallel calls will be throttled anyway

Want to build production agent swarms for your team? See our AI agent development service or read the best multi-agent frameworks guide for a wider comparison. For how hooks coordinate agent handoffs, see Advanced Hooks.