Claude Code Dynamic Workflows Guide 2026: 6 Orchestration Patterns Explained

Claude Code v2.1.154 quietly redrew the boundaries of AI-assisted development at scale. What previously required developers to hand-craft orchestration logic for parallel workloads now lets Claude auto-generate a JavaScript script that runs independently outside your context window, coordinating up to 1,000 subagents working in parallel.

But "can do" and "worth doing" are different questions. This guide isn't here to hype what Dynamic Workflows can achieve. It's here to help you figure out: when to use it, how to control costs, which of the six orchestration patterns fits your task, and which approaches will burn 50x more tokens with nothing to show for it.

Based on Anthropic's official documentation and community testing, all technical details have been cross-verified.

TL;DR

• Dynamic Workflows is an event-driven orchestration architecture, not just "parallel task execution"
• Best for: 10+ independent subtasks that can run in parallel and need quality cross-verification
• Not for: exploratory tasks, step-by-step confirmation needs, tight token budgets
• Token cost is 10-50x higher, but four strategies can keep it manageable
• Fastest entry point: /deep-research <question> — experience it in 5 minutes

What Is Dynamic Workflows? 3-Minute Concept Clarification

Most people's first reaction to "Dynamic Workflows" is: "So Claude runs multiple tasks at once." That's half right, but it misses the most important part.

The cognitive flip: You might think Dynamic Workflows is just "letting Claude run multiple tasks simultaneously," but it's actually an event-driven orchestration architecture. Claude doesn't generate more conversation — it generates a JavaScript script. An independent runtime executes that script outside Claude's context.

The architecture works like this:

Your prompt → Claude analyzes the task → Generates JS orchestration script
→ Runtime executes script independently → Calls subagents sequentially
→ Results stored in script variables → Returns to you when complete

This means: intermediate results from 1,000 subagents don't fill your context window. Workflow state lives in script variables, not Claude's memory. Once you understand this distinction, the decision framework becomes clear.

Core specs (source: Anthropic official docs):

• Up to 1,000 subagents per run
• Up to 16 running in parallel
• Requires Claude Code v2.1.154+ (verify with claude --version)
• Available on: Pro (manual activation required) / Max / Team / Enterprise (enabled by default)

Dynamic Workflows vs. Manual Parallel Worktrees: A Decision Framework

Developers already using Claude Code parallel worktrees often ask: should I switch? The answer is: they're not replacements — they serve different scales.

Dimension	Manual Parallel Worktrees	Dynamic Workflows
Who writes orchestration logic	Developer, manually	Claude auto-generates JS script
Where results are stored	Each agent's context window	Script variables (doesn't consume Claude context)
Resumability after interruption	Must restart from the beginning	Resumable within the same session
Scale	Limited by context	Up to 1,000 agents per run
Re-runnable	Requires manual reconfiguration	Save as /<command> and retrigger

The two aren't mutually exclusive: Dynamic Workflows can run agents inside worktrees, using the worktree option to isolate file modifications.

Three-Dimensional Decision Matrix

Use Dynamic Workflows when:

• The task can be broken into 10+ independently parallel subtasks
• You need adversarial verification to ensure quality
• The task can absorb higher token costs
• You'll run the same type of task repeatedly (save and retrigger)

Stick with manual worktrees or conversation when:

• Fewer than 5-10 subtasks
• You need step-by-step human sign-off
• Tight token budget constraints on daily development
• Exploratory, creative, or early design-phase work

A simple heuristic: if you're thinking "how do I split this into parallel subtasks," Dynamic Workflows is worth considering. If you're thinking "what should I do next," keep using conversation.

Three Activation Methods: From workflow to /deep-research

Dynamic Workflows has three entry points, in increasing order of complexity.

Method 1: workflow Keyword (Single-Task Trigger)

Add workflow: to the start of your prompt to trigger a Dynamic Workflow:

workflow: audit every API endpoint under src/routes/ for missing auth checks

Version note:

• v2.1.154 - v2.1.159: The exact keyword trigger is workflow: — natural language also works in this version range
• v2.1.160+: More flexible triggering options, including natural language (e.g., "use a workflow to audit...")

Natural language triggering works in both version ranges. The difference is only the exact keyword itself (workflow: pre-v2.1.160, more options in v2.1.160+).

Another example for codebase migration:

workflow: migrate all React class components under src/components/ to functional components with hooks, then run tests to verify

Method 2: /effort ultracode (Session Auto Mode)

Enter /effort ultracode at the start of a session. Claude combines xhigh reasoning with automatic judgment about which tasks warrant a workflow versus a normal conversation. This resets at the end of the session.

Best for: complex work sessions that mix exploratory and execution tasks, where you want Claude to decide which approach to use.

Method 3: /deep-research (Instant Entry, Zero Setup)

The fastest onboarding path:

/deep-research What are the key differences between Bun and Node.js module resolution?

This is a built-in workflow that automatically runs multi-angle web searches, cross-verifies information, and compiles a cited report. No setup required, no need to understand orchestration. You can feel the difference in five minutes.

Controls After Activation

Once a workflow starts, you'll see the /workflows view with these core controls:

Key	Function
/workflows	View all workflow execution progress
p	Pause / resume
x	Stop (completed work is preserved)
s	Save as /<command> for repeated triggering

Pro plan special step: Go to /config and manually enable the Dynamic Workflows toggle — otherwise the workflow: keyword won't trigger anything.

Enterprise plan: Admin must enable it in Claude Code admin settings before users see the option.

Six Orchestration Patterns with Real Examples

Anthropic's official documentation defines six core orchestration patterns. Key insight: these patterns are typically combined, not used in isolation.

1. Classify-and-Act

Logic: Route tasks by type, then route different types to the appropriate agents.

Best for:

• GitHub issue triage (categorize as bug/feature/question, trigger different flows)
• Support queue routing (technical vs. billing vs. feature requests)

workflow: triage all open GitHub issues in this repo, categorize by type (bug/feature/docs/question), assign priority (P0/P1/P2), and add appropriate labels

2. Fan-Out-and-Synthesize

Logic: Split a large task into parallel subtasks, execute each, then merge results.

Best for:

• Large codebase migrations (process multiple modules simultaneously)
• Unified audits across many files or API endpoints

Anthropic's official blog referenced the Bun example: a 750K-line codebase port used fan-out to split the codebase by module, ran agents in parallel, then merged results — dramatically reducing overall time.

3. Adversarial Verification

Logic: Multiple independent agents answer the same question, then another agent cross-compares and verifies discrepancies.

Best for:

• Security audits (two agents independently find vulnerabilities, a third cross-references)
• High-confidence research reports (avoids single-agent confirmation bias)
• Production-grade code review (harder to miss issues than a single-agent review)

This is the most effective pattern when the goal is "ensure nothing is missed."

4. Generate-and-Filter

Logic: Generate multiple candidate solutions, then filter by scoring criteria to find the best option.

Best for:

• Architecture selection (generate five designs, score and keep the best)
• API design evaluation (multiple designs in parallel, filter by constraints)
• Creative tasks like naming or UI options that need late-stage convergence

5. Tournament

Logic: Pairwise comparison (A vs. B, C vs. D, winners compete) until a final answer emerges.

Best for:

• Final selection from multiple implementations
• Performance comparison (five algorithms, tournament finds the fastest)
• Design evaluation (different UI patterns)

Tournament vs. Generate-and-Filter: Filter uses defined criteria to eliminate options; Tournament uses comparison to choose. Use Filter when you have clear scoring criteria, Tournament when you need subjective judgment.

6. Loop Until Done

Logic: Keep triggering until a specified condition is met.

Best for:

• Fix bugs until all tests pass
• Refactor code until linting score hits a threshold
• Security scanning until no critical or high severity findings remain

workflow: fix all failing tests in src/__tests__/, run the full test suite after each fix, loop until all tests pass or you've tried 10 iterations

Real-World Combination Example

A complete large-scale codebase migration typically looks like:

1. Fan-out: Split the 750K-line codebase by module, 16 agents process in parallel
2. Adversarial verification: Each module's output is verified by an independent agent to ensure no new bugs were introduced
3. Tournament: For modules with multiple valid implementations, tournament selects the final version

It's not about picking one pattern — it's about combining patterns to match each phase of the task.

Token Cost Estimation and Management

This is the most commonly underestimated aspect of Dynamic Workflows.

The cost reality: Dynamic Workflows can consume 10-50x more tokens than a regular conversation. A real community example: 113 agents ran through 1.95M tokens in 12.5 minutes.

Approximate cost ranges:

• Narrow tasks (under 10 agents): ~10k - 50k tokens
• Medium tasks (20-50 agents): ~200k - 500k tokens
• Large migrations (100+ agents): 1M - 2M+ tokens

Four Control Strategies

Strategy 1: Start small

Don't run your entire repo on the first attempt. Test on one directory or module, verify the output matches expectations, then scale:

# Test one directory first
workflow: audit API endpoints under src/routes/auth/ for missing auth checks

# Then expand after verification
workflow: audit all API endpoints under src/routes/ for missing auth checks

Strategy 2: Use model tiering

Explicitly specify Haiku for lightweight tasks, reserving Sonnet or Opus for complex reasoning. Per Anthropic's pricing page, Haiku is approximately 15-25x cheaper than Opus (check the current official pricing page as rates vary by model version):

workflow: use haiku for classification and formatting tasks, use sonnet only for code generation and reasoning steps; audit all components under src/

Strategy 3: Structured handoff

Only pass necessary structured summaries between agents — not full context history. Specify the output format explicitly in your prompt:

workflow: for each module, output only: module name, issues found (list), recommended fixes (list). Do not include full code in the handoff.

Strategy 4: Set a token budget

Explicitly set a budget in your prompt so Claude works within constraints:

workflow: use approximately 10k tokens total; audit the most critical API endpoints first, stop when budget is reached

Real-time monitoring: The /workflows view shows live token usage per agent. Hit x to stop at any time — completed work is preserved.

Common Anti-Patterns

Based on official documentation and community testing, here are the five most common mistakes.

Anti-Pattern 1: Using Workflows for Exploratory Tasks

Problem: Exploratory tasks have unpredictable outputs, wasting tokens on useless output, and you can't redirect mid-execution.

What to do instead: Use regular conversation to clarify direction and approach first. Confirm the path forward, then use a workflow to execute. Dynamic Workflows fits the execution phase ("I know what needs doing"), not the exploration phase ("I'm still figuring out what to do").

Anti-Pattern 2: Not Breaking Long Workflows into Segments

Problem: Dynamic Workflows resumability is session-scoped. Close Claude Code and restart a new session — you're back to zero. One overly long workflow means a full restart after interruption.

What to do instead: Design multiple short workflows with clear input/output boundaries. Split a large migration into "analyze + plan," "execute modules A-E," and "execute modules F-K" as three independent workflows. Verify each before triggering the next.

Anti-Pattern 3: Running All Agents on Opus

Problem: 10-50x cost amplification. Most sub-tasks (classification, formatting, search) don't need Opus-level reasoning.

What to do instead: Reserve Opus or Sonnet for agents that genuinely need complex reasoning. Explicitly specify Haiku for classification, formatting, and data extraction.

Anti-Pattern 4: Using the Wrong Exact Keyword for Your Version

Problem: v2.1.154 - v2.1.159 uses workflow: as the exact trigger keyword, not other variants. If you use the wrong keyword, Claude responds normally without any indication that the trigger failed. Natural language works in both version ranges.

What to do instead: Check claude --version first. Before v2.1.160, use the exact workflow: prefix. v2.1.160+ offers more flexible trigger options. Natural language is supported in both.

Anti-Pattern 5: Treating Workflows Like a General Task Manager

Problem: Dynamic Workflows can't accept user instructions mid-execution. If your process needs "run step one, let me review it, then run step two," the architecture doesn't support this.

What to do instead: Break workflows with human approval gates into multiple independent workflows. Complete each, review the output manually, then trigger the next. Or use manual worktrees with step-by-step conversation instead.

Conclusion

Dynamic Workflows doesn't change what Claude can do — it changes who designs the workflow. Previously, developers had to manually assemble orchestration logic. Now Claude handles that, and you only need to know "what tasks I need to run" and "what token cost I can accept."

The lowest-barrier entry point: /deep-research <question> requires zero setup and gives you a feel for workflow execution in five minutes. Verify your version is v2.1.154+, try a research question you actually care about, and watch how agents collaborate in the workflow view.

Once you're comfortable, apply the decision framework from this guide to real migration or audit tasks in your projects. Start narrow, verify token costs are acceptable, then expand.