Multi-Agent Development with Claude Code Subagents, Team Orchestration, and Long-Running Systems for Autonomous AI Development (Makino, Makoto)（Z-Library）

# Multi-Agent Development with Claude Code ## 【One-Line Pitch】 A practical engineering guide to building multi-agent AI systems with Claude Code—covering subagents, orchestration patterns, and long-running autonomous workflows—for developers who want to move beyond single-session AI assistance to production-grade agent architectures. ## 【Book Arc】 - **Opening (~0%–10%)**: Establishes the case for multi-agent systems—why single agents hit context window ceilings, lose information, and struggle with complex tasks—and introduces the five canonical workflow patterns (prompt chaining, routing, parallelization, orchestrator-workers, evaluator-optimizer) that form the vocabulary for the rest of the book. - **Early (~10%–32%)**: Covers subagent fundamentals—how Claude Code's Agent tool works, built-in subagent types, custom subagent definitions in `.claude/agents/`, and MCP server integration for connecting agents to external tools. Includes real-world evidence from Anthropic's research system and the C compiler project, plus a decision framework for when multi-agent architecture is (and isn't) worth the complexity. - **Middle (~32%–52%)**: Delves into design and orchestration principles—orchestrator design patterns, task decomposition strategies, context passing, and the Agent-Computer Interface (ACI) for designing tools that agents can use effectively. Introduces eight prompt engineering principles that shift thinking from prompt engineering to context engineering. - **Late (~52%–75%)**: Addresses long-running agent systems—harness architecture, checkpoint design, memory management, and context compression for agents that span multiple sessions. Covers error recovery and failure modes, including retry strategy design and human-in-the-loop timing. - **Ending (~75%–100%)**: Moves to agent teams—multiple Claude Code instances working in parallel on shared codebases with direct inter-agent communication—and concludes with evaluation methodology and production reliability considerations for deploying multi-agent systems. ## 【Key Takeaways】 - **Context isolation is the core value of multi-agent architecture** (Early): Each subagent gets its own context window, acting as an "intelligent filter" that compresses large volumes of raw data into only the most relevant findings before returning them to the orchestrator. This solves the context window ceiling problem that plagues single-agent sessions. - **Parallelization delivers dramatic speedups when subtasks are independent** (Early): Anthropic's research system achieved up to 90% reduction in research time by spawning 3–5 subagents in parallel, each using multiple tools concurrently. This maps directly to development scenarios like running security, performance, and style reviews simultaneously. - **Multi-agent systems are not a default—they're a specific tool** (Early): The book emphasizes "find the simplest solution possible, and only increase complexity when needed." Single-file changes, sequential dependencies, quick tasks, and shared-context work all favor single agents. Token costs scale significantly with parallel agents, so the investment only pays off for valuable, parallelizable, context-heavy tasks. - **Five workflow patterns form a complexity staircase** (Middle): Prompt chaining, routing, parallelization, orchestrator-workers, and evaluator-optimizer progress from simple to complex. Each adds flexibility at the cost of coordination overhead, and the right choice depends on whether subtasks are predictable and whether accuracy or speed matters more. - **Gates between chained steps prevent cascading errors** (Middle): In prompt chaining, programmatic checks (like type checking or test runs) between LLM calls catch failures at each boundary. Without gates, errors compound silently—each step builds on the previous step's mistakes, producing output that's confidently wrong. - **Orchestrator-workers handle unpredictable task decomposition** (Middle): Unlike parallelization where subtasks are predefined, the orchestrator decides at runtime what subtasks are needed. Claude Code itself is an orchestrator-worker system—when you request a migration, it dynamically determines which files need changes and delegates independent work to subagents. - **Tests can serve as the orchestrator** (Early): The C compiler project deliberately avoided a central orchestrator, using high-quality test suites as ground truth. Each agent independently assessed what needed fixing and verified its own work. This works for tasks with clear, measurable success criteria but not for ambiguous goals. - **Long-running agents require harness architecture** (Late): Agents that span multiple sessions need checkpoint design, progress file management, and context compression strategies. The book covers building a harness with five scripts and lessons from a C compiler project that ran 16 parallel agents. ## 【Reading Tips】 - **Skim the WHY blocks** (Early): The book marks design rationale explanations as indented "WHY" quotes. You can skip them without losing the main thread, but they answer the "why not just do it the simpler way?" questions that naturally arise. - **Deep-read the decision framework** (Early, ~32%): The flow chart for deciding whether a task benefits from multi-agent execution is the most practically useful single element. Memorize this before diving into implementation details. - **Clone the companion repository** (Opening): All sample code is available on GitHub (`driftnode986/claude-multiagent-guide-en-samples`). Run examples as you read—each chapter's samples are in a directory matching the chapter number. - **Watch for version volatility** (Early): Claude Code is under active development, and agent teams are experimental. The book marks volatile details with "At time of writing (Claude Code vX.Y)" callouts—grep for this phrase to find sections that may need updating. - **Pay attention to the failure patterns** (Throughout): Each chapter includes "Common Failure Patterns" sections. These are gold for avoiding real-world pitfalls that the author observed across production systems. ## 【Coverage Limits】 Excerpts cover roughly the first half of the book in detail (foundations, subagents, workflow patterns, orchestration principles). Later sections on long-running agents, agent teams, and production evaluation are summarized from the table of contents and may lack the depth of earlier chapters. ##