Parallel, Sequential, and the Workflow Tool
Parallel vs. Sequential
A major reason to use subagents is parallelization: multiple subagents can run concurrently, dramatically speeding up complex workflows. During a code review you might run a style-checker, a security-scanner, and a test-coverage agent simultaneously — reducing review time from minutes to seconds. The key requirement: the work must be independent.
Parallel subagents fit independent work (style + security + coverage at once); dependent steps must run in sequence — usually in the main thread.
When Parallel Works
Parallel subagents are ideal when investigations don't depend on each other. In Claude Code you can simply ask: 'Research the authentication, database, and API modules in parallel using separate subagents.' Each explores its area independently, and Claude synthesizes the findings. This connects directly back to the decision rule: independent work where the journey doesn't matter is exactly what delegates well.
Parallel results still cost context
There's a catch worth remembering: when subagents complete, their results return to your main conversation. Running many subagents that each return detailed results can itself consume significant context. Parallelism saves time, but be mindful of how much each agent brings back.
Chaining (Sequential) Subagents
For genuinely multi-step workflows, you can chain subagents: each completes its task and returns results to Claude, which passes relevant context to the next. In Claude Code: 'Use the code-reviewer subagent to find performance issues, then use the optimizer subagent to fix them.' But heed the anti-pattern lesson — chaining works when the handoff summary is enough; if each step needs the full prior context, keep it in the main thread instead.
Chaining is orchestrated from the main thread
Because subagents can't spawn subagents, any chain or fan-out is coordinated by the MAIN conversation. The main thread launches each subagent, collects its summary, and decides what to do next. This is the manual version of orchestration — the next lesson covers the systematic version.
Scaling Up: The Workflow Tool
Turn-by-turn subagent delegation works well for a few tasks per turn. But when you need to coordinate DOZENS to HUNDREDS of agents, that approach breaks down — the orchestration itself floods the conversation. For this scale, the SDK provides the Workflow tool, which moves orchestration into a script the runtime executes OUTSIDE the conversation context.
| Approach | Best for | Where orchestration lives |
|---|---|---|
| Turn-by-turn subagents | A few delegated tasks per turn | In the conversation (Claude decides each turn) |
| Workflow tool | Dozens–hundreds of agents, big migrations/audits | In a script the runtime runs outside the conversation |
Subagents for a handful of tasks; the Workflow tool when the job is too large for one conversation.
Next
You can run subagents in parallel, sequence, and at scale. The next lesson studies the real-world payoff: Anthropic's multi-agent research system and the orchestrator-worker pattern — with hard numbers.
Key Takeaways
- ✓Parallelization is a core subagent benefit: independent subagents run concurrently (e.g. style + security + coverage), cutting time from minutes to seconds.
- ✓Parallel works only for independent work; in Claude Code you can ask to research multiple modules 'in parallel using separate subagents'.
- ✓Caveat: each completed subagent returns results to the main conversation, so many detailed results can themselves consume significant context.
- ✓Chaining (sequential) subagents passes each summary to the next — fine when the summary suffices, but dependent steps belong in the main thread.
- ✓All chaining/fan-out is orchestrated by the MAIN thread, because subagents cannot spawn subagents.
- ✓For dozens–hundreds of agents, use the SDK's Workflow tool, which runs orchestration in a script outside the conversation context.
Check Your Understanding
Test what you learned in this lesson.
Q1.What is the key requirement for running subagents in parallel?
Q2.What is a caveat of running many parallel subagents?
Q3.Why must subagent chaining/fan-out be orchestrated by the main thread?
Q4.When should you reach for the SDK's Workflow tool instead of turn-by-turn subagents?
Practice This Lesson