# Claude Dynamic Workflows Dynamic Workflows is a [[Claude Code]] feature that lets Claude orchestrate hundreds of parallel subagents inside a single session, plan the work itself, verify intermediate results, and resume after interruptions. Announced alongside [[Claude Opus 4.8]] on 2026-05-27. Framed by [[Anthropic]] as the on-ramp for tasks that "used to take quarters" landing in days. ## What it is A built-in orchestration layer that turns a single Claude Code request into a tree of subagents working in parallel toward a shared goal. The user gives one prompt; Claude decomposes, dispatches, verifies, and returns one coordinated answer. In other words, patterns the agentic community has been hand-rolling for the last year (multi-agent fan-out, verification loops, checkpointing) are now baked into the official harness. It is **not** a new model, plugin, or separate CLI — it's an architectural shift in *where the orchestration logic lives*. Claude writes a **JavaScript orchestration script on the fly** from the natural-language request, and a separate runtime executes that script in the background. The chat session stays responsive while agents work, intermediate results live inside script variables (so they don't saturate Claude's context window), and the user gets a consolidated report instead of a turn-by-turn transcript. ### Limits and controls - Up to **1,000 total agents per execution**, with a max of **16 running concurrently** — a ceiling tuned to an average local machine's resources. - Start one explicitly ("Create a workflow"), or enable the **`ultracode`** setting (effort menu → sets effort to `xhigh`) and let Claude decide automatically when to spin up a workflow. - Interrupted runs (manual stop, terminal exit) are **resumable** and continue from where they stopped. ## How it works 1. **Planning and distribution**: Claude reads the request, breaks it into subtasks, and assigns each subtask to a parallel subagent 2. **Verification before fold-in**: each subagent's output is checked before it merges into the shared answer. Adversarial subagents may try to refute findings 3. **Iterative refinement**: agents approach the problem from different angles; the workflow keeps iterating until results converge 4. **Continuous progress saving**: work is persisted as it happens. Interrupted runs resume from where they stopped rather than restarting from zero 5. **Single coordinated answer**: the user receives one synthesized result, not N parallel transcripts to reconcile manually ## Why Anthropic built it Dynamic Workflows targets the failure modes of single-context-window agents. When the default harness plans *and* executes inside one context window, long-running / highly-parallel / adversarial tasks degrade into: - **Agentic laziness** — stopping prematurely before fully completing multi-part tasks - **Self-preferential bias** — Claude preferring its own results when asked to verify them against a rubric - **Goal drift** — gradual loss of fidelity to the original objective across many turns, especially after compaction Offloading orchestration to a script (with state in variables, not the context window) and using fresh, independent subagents for verification is the structural fix for all three. ## Use cases Anthropic highlights - Codebase-wide bug hunts across an entire service - Security audits spanning the full repo - Large migrations touching thousands of files - Critical work where independent verification matters more than speed **Flagship example — the Bun rewrite:** Jarred Sumner used Dynamic Workflows to port Bun from Zig to Rust — ~750,000 lines of Rust, 99.8% of the existing test suite passing, ~11 days from first commit to merge. ## Community reception The Hacker News discussion is split. The recurring skeptical note: people want **control over speed** — more ways to inject corrections and nudges into long-running sessions mid-flight, not just a faster way to burn tokens without knowing whether results are correct. The status quo many already use is sequential quality control: multiple code-review passes by fresh agent sessions inspecting prior sessions' work. Dynamic Workflows automates that fan-out, but the "am I steering this?" anxiety remains. ## Cost profile - A lot more tokens than a standard Claude Code session: parallel subagents multiply both input prefix and output volume - Anthropic explicitly recommends starting with scoped tasks before letting it off the leash - Works well with Opus 4.8's new effort control: dial subagent effort down for cheap exploration, up for final verification ## Why it matters - **Harness beats weights**: the Hacker News consensus on the 4.8 launch is that orchestration improvements now move the needle more than base model gains. Dynamic Workflows is exactly that bet, shipped by the vendor - **The agent loop becomes a feature, not a project**: the plan-dispatch-verify-fold pattern is no longer something every team has to re-implement. The official harness does it for you - **Big tasks stop needing custom scaffolding**: codebase migrations and audits no longer require a custom multi-agent setup. The default Claude Code surface handles them - **Cost gravity shifts**: parallel subagent fan-out is the natural place enterprise API spend will land. This is the feature that justifies the "coding agents = product-market fit" thesis [[Simon Willison]] argues for ## Open questions - How does verification handle adversarial-prompt-injection attempts inside intermediate subagent outputs? ([[Prompt injection]] surface area scales with subagent count) - Cost predictability: token blast radius of a single "find every bug" prompt is hard to estimate up front - Failure modes when subagents disagree and never converge. What does the workflow do? - Interaction with [[Claude Code Auto Mode]] when each subagent triggers its own classifier checks ## Working with it - Start scoped. A repo-wide audit on day one is the wrong first move. Pick one service, one subsystem - Treat it as expensive by default. Use Opus 4.8's effort control to keep subagent effort modest until you know the convergence shape of your task - Lean on the checkpointing. Long runs are now interrupt-safe, so don't pre-optimize for one-shot completion - For knowledge work, the natural fit is repo-shaped knowledge bases (codebases, large wikis, document corpora) where the same audit-decompose-verify-synthesize pattern applies ## References - Official announcement: https://claude.com/blog/introducing-dynamic-workflows-in-claude-code - Opus 4.8 announcement (which references Dynamic Workflows): https://www.anthropic.com/news/claude-opus-4-8 - Hacker News discussion: https://news.ycombinator.com/item?id=48311647 - Hacker News discussion (announcement thread): https://news.ycombinator.com/item?id=48311705 - Blog (deep dive): https://claude.com/blog/a-harness-for-every-task-dynamic-workflows-in-claude-code - Simon Willison on the broader product-market fit context: https://simonwillison.net/2026/May/27/product-market-fit/ ## Related - [[Claude Code]] - [[Claude Opus 4.8]] - [[Claude Opus 4.7]] - [[Claude Code Auto Mode]] - [[Claude Code Agent Teams]] - [[Claude Managed Agents]] - [[Anthropic]]