What are dynamic workflows in Claude Code?

Dynamic workflows are a feature in Claude Code, launched in research preview on May 28, 2026 alongside Claude Opus 4.8. They let Claude write orchestration scripts that spawn tens to hundreds of parallel subagents in a single session. Each subagent gets a focused task, runs independently, and reports results back to the orchestrating Claude. The orchestrator iterates: verify, retry, merge. Use cases include full codebase migrations, large refactors, and multi-file investigations.

What are the limits on Claude dynamic workflows?

Two hard caps. (1) 16 concurrent subagents at any given moment — the orchestrator can launch new subagents but only 16 run in parallel at once. (2) 1,000 total subagents per run — the entire dynamic workflow session is capped at 1,000 lifetime subagents. Combined, these caps create a soft ceiling on how big a single workflow can be: roughly 1,000 atomic units of work, processed in 16-wide parallel waves.

Why did Anthropic cap dynamic workflows at 1,000 subagents?

Three reasons. (1) Cost protection — each subagent burns API tokens, and uncapped workflows could rack up six-figure bills in hours. The 1,000 cap creates a ceiling. (2) Quality control — beyond ~1,000 subagents, orchestration coherence breaks down; the orchestrator loses track of what's been done. (3) Safety review — dynamic workflows are research preview, and Anthropic wants empirical data on how 1,000-agent runs behave before lifting caps. Expect higher caps in subsequent releases as Anthropic builds confidence.

How do dynamic workflows compare to LangGraph and CrewAI?

LangGraph and CrewAI are general-purpose multi-agent orchestration frameworks — you bring your own model, you wire your own graph or crew, you handle persistence and verification yourself. Claude dynamic workflows are built-in to Claude Code, opinionated about Anthropic models, and ship with iterative verification and resumable state out of the box. Dynamic workflows are easier to use for codebase-scoped tasks; LangGraph/CrewAI are more flexible for arbitrary multi-agent systems but require more wiring.

Quick Answer

Why Are Claude Dynamic Workflows Capped at 1,000 Subagents? (June 2026)

Published: June 1, 2026

Why Are Claude Dynamic Workflows Capped at 1,000 Subagents? (June 2026)

Anthropic launched dynamic workflows in research preview on May 28, 2026, alongside Claude Opus 4.8. The pitch: Claude writes its own orchestration script and runs hundreds of parallel subagents in a single Claude Code session. Use cases include full codebase migrations and large refactors.

But there are caps: 16 concurrent subagents, 1,000 total per run. Why those numbers? And what do they mean for what you can actually build? Here’s the deeper look.

Last verified: June 1, 2026.

TL;DR

	Dynamic Workflows
Released	May 28, 2026 (research preview)
Where	Claude Code (Opus 4.8 + dynamic workflow primitives)
Concurrent cap	16 subagents at once
Total cap	1,000 subagents per run
Verification	Iterative — orchestrator checks results, retries failures
State	Resumable mid-run
Best for	Codebase-scale work that doesn’t fit one session

What dynamic workflows actually do

The mental model from Anthropic’s launch announcement and TechCrunch’s reporting:

You give Claude Code a task that’s too big for one session (e.g., “Migrate this 800-file Express codebase to Fastify”)
Opus 4.8 in orchestrator mode plans the work — breaks the task into atomic subagent units
Orchestrator writes an orchestration script that defines:
- What each subagent does
- How results are verified
- When to retry
- How partial results merge
Claude Code executes the script — up to 16 subagents in parallel, capped at 1,000 total
Orchestrator iterates: verify each subagent’s output, retry on failure, accumulate progress
State is persisted — you can pause and resume mid-run

The killer feature is iterative verification. Each subagent’s output gets checked by the orchestrator before it’s accepted. Failures retry with refined prompts. This is the difference between “naive fan-out” (run 1,000 agents in parallel, hope for the best) and “structured fan-out” (run 16 at a time, verify each, retry as needed).

Why 16 concurrent?

Three factors converge on 16:

1. API rate limits. Anthropic’s Tier 4 enterprise rate limits in 2026 comfortably support 16 concurrent Opus 4.8 calls per organization. Going higher would trip rate limits for most paying customers.

2. Cognitive coherence for the orchestrator. The orchestrator Claude has to track what each running subagent is doing, integrate completions, and decide next moves. Tracking 16 things at once is hard. Tracking 50 things at once is currently beyond what Opus 4.8 can reliably do without losing context.

3. Diminishing returns. Empirically, 16-wide parallel waves saturate the orchestration overhead well. Beyond that, orchestrator latency starts dominating subagent latency, and total wall-clock speedup flattens.

Expect this cap to rise as orchestrator models get better. By Opus 5 or GPT-6, 64-wide concurrency might be normal.

Why 1,000 total?

The total cap is more about practical guardrails than fundamental limits:

1. Cost protection. An Opus 4.8 subagent burns 5,000–20,000 tokens average. At $5 input / $25 output, 1,000 subagents = $20,000–$80,000 worst case. Anthropic doesn’t want surprise enterprise invoices — the 1,000 cap forces you to think about scope.

2. Quality control. Past a certain run length, orchestration coherence degrades. The orchestrator forgets early decisions, retries become redundant, the workflow drifts. 1,000 is around where Anthropic’s internal evals show coherence holds.

3. Research preview prudence. Dynamic workflows are research preview, not GA. Anthropic wants empirical data on how 1,000-agent runs behave in the wild before lifting caps. The 1,000 number says: “this is the scale we’ve validated, push us if you want more.”

What 1,000 subagents can actually do

A useful unit calibration: each subagent typically does one atomic unit of work. Examples:

One file edit
One test written
One symbol renamed
One PR diff reviewed
One module migrated

So 1,000 subagents = ~1,000 atomic units. That’s:

A full-codebase migration of a medium-sized project (500–1,500 files)
A complete test suite generation for a new module (500–1,000 tests)
A symbol rename across an enterprise codebase
An exhaustive PR review on a feature branch with 500+ files changed
A complete dependency upgrade audit across a polyrepo

Things 1,000 subagents can’t do in one workflow:

Migrate a 50K-file monorepo end-to-end (you’d need to break it into multiple workflows)
Generate test coverage for an entire 5M-LoC codebase
Rebuild a service from scratch with thousands of files

For those, you’d run multiple dynamic workflow sessions and merge results manually.

Dynamic workflows vs LangGraph vs CrewAI

	Dynamic Workflows	LangGraph	CrewAI
Style	Opinionated, Claude-native	DAG-based graphs, BYO model	Role-based crews, BYO model
Verification	Built-in iterative	You write it	You write it
State persistence	Resumable, built-in	You configure	You configure
Best fit	Codebase tasks in Claude Code	Custom multi-agent apps	Multi-role agent teams
Setup time	Minutes	Hours	Hours
Lock-in	Anthropic + Claude Code	None (any model)	None (any model)

If your task is codebase-shaped and you’re already in the Anthropic ecosystem, dynamic workflows are dramatically faster to deploy than LangGraph or CrewAI. If your task is something else — arbitrary agent topologies, multi-vendor models, custom verification — you still want LangGraph or CrewAI.

Practical patterns that work

From early-preview reports on Reddit r/ClaudeCode and Anthropic’s own examples:

1. Codebase migration

Task: "Migrate React class components to hooks across all .jsx files"
Plan: orchestrator identifies ~600 components → 600 subagents
Wave size: 16
Verification: TypeScript compile + test suite per subagent
Cap usage: 600 of 1000

2. Test backfill

Task: "Generate Jest tests for all uncovered files in src/"
Plan: orchestrator finds 250 uncovered files → 250 subagents
Wave size: 16
Verification: coverage delta per subagent
Cap usage: 250 of 1000

3. Symbol rename + caller update

Task: "Rename OrderService.process to OrderService.execute everywhere"
Plan: orchestrator finds 1 definition + 180 callers → 181 subagents
Wave size: 16
Verification: compile + targeted test per subagent
Cap usage: 181 of 1000

When NOT to use dynamic workflows

Small tasks (<10 atomic units). Just run them inline in Claude Code. The orchestration overhead isn’t worth it.

Tasks with strict ordering requirements. Dynamic workflows are best at parallel-friendly work. If subagent N depends on subagent N-1’s exact output, sequential is faster.

Production-critical changes. Research preview. Use Claude Code traditional flow with human approval per file for high-stakes production changes.

Cost-sensitive workloads. 1,000 Opus 4.8 subagents can rack up real bills. Use Sonnet for the bulk and Opus only for orchestration if cost matters.

What’s next

Anthropic hasn’t committed to a GA date for dynamic workflows. Reading the tea leaves:

Cap increases in subsequent releases as Anthropic gathers data (likely 32 concurrent / 2,500 total by end of 2026)
Multi-model support — currently Anthropic-only; Claude Code may add other providers as subagent models
Resumable across days — current resumability is within a session; multi-day resume is plausible
Cost guardrails built into the workflow primitive itself (set a max dollar budget per run)

Sources

Bottom line

The 16 concurrent / 1,000 total cap on Claude dynamic workflows isn’t an arbitrary limit — it’s where API rate limits, orchestrator coherence, and research-preview prudence converge. Most codebase-shaped tasks fit inside 1,000 atomic units. Bigger work needs multi-workflow runs. Expect caps to rise as Anthropic gathers production data.