How to Orchestrate 100+ Agents With Claude Code

Towards Data Science (Eivind Kjosbakken): a practitioner account of running 100+ Claude Code agents in parallel, a concrete large-scale instance of orchestrator → fan-out. The distinctive mechanism is headless mode — many independent claude -p "<prompt>" sessions rather than nested in-process subagent loops. T3: hands-on but no throughput/cost/concurrency data (the article omits git-worktrees, queues, concurrency caps, and failure recovery).

The approach

• Hierarchical, one orchestrator: “you talk to one agent which can itself orchestrate several other agents” — a master orchestrator decomposes work and spawns child agents, so the human isn’t managing 100 agents directly (agent-orchestration).
• Headless mode as the fan-out primitive: each claude -p invocation is an independent, autonomous session that does scoped work and reports a final result — process-level parallelism over nested subagent loops. (Headless claude -p is the same surface the SDK-billing change targeted.)
• No centralized state; high-level prompting + task isolation: the orchestrator hands each agent a scoped, self-contained task and expects it to decide independently — isolation to prevent interference, not a shared state store. That isolation is a rot-avoidance move by another name (each session starts clean; cf. governed-context-claude-code‘s “isolate debugging to separate sessions”).
• Self-verification in the prompt: agents must “verify their own work” — the orchestrator bakes the verification mechanism into the task prompt rather than validating centrally (loop-engineering).
• Full autonomy per agent: autonomous permissions (no per-step approval) + MCP access + “give the agent all the tools it needs.”
• Scoped to well-defined work: recommended for refactoring-style tasks with clear success criteria, not ambiguous work needing iterative human input. A worked loop: Fable detects improvements → orchestrator converts findings into parallel tasks → many Opus headless sessions execute → results aggregate back.

Where it sits

It’s the spoke’s largest-scale fan-out instance and adds a flavor: process-level parallelism via stateless one-shot headless sessions with strong task isolation, distinct from the nested-subagent-loop instances (orchestration-mode, agentsys) and the durable job-queue one (gbrain). Its “no shared state, isolate to avoid interference” bet is where orchestration meets context-rot (isolation as rot control) and agent-guardrails (fully-autonomous agents scoped to reversible, well-defined tasks — the safety comes from task choice, not human checkpoints). The honest limit — it works for well-scoped work, not ambiguous tasks — is the same “match the pattern to the task” discipline.

Related

agent-orchestration · eivind-kjosbakken · context-rot · loop-engineering · building-effective-agents · agent-guardrails · anthropic-agent-sdk-billing-pause · claude-fable-5 · model-context-protocol