On 9 October 2026, Anthropic quietly changed the maths of AI agents. The company put Claude dynamic workflows into public beta on its Claude Managed Agents platform, and the headline number is genuinely startling: a single lead agent can now write its own orchestration program and fan a single job out to up to 1,000 AI agents. Not 10. Not 100. One thousand.
The announcement came via a launch thread from Anthropic’s @ClaudeDevs account, and it has already picked up a nickname in developer circles: “Claude Flows” — as in, hand it a goal and it runs the flow. Whether you call them Claude Flows or by the official name, dynamic workflows, the idea is the same: instead of you hand-configuring a coordinator and an agent roster, the lead agent writes the program that organises the swarm, executes it in the background on Anthropic’s servers, and hands you the combined result. (For a developer-oriented technical walkthrough of Claude Flows, including the exact configuration and the community’s cost reports, that dev.to guide is the best starting point we found.)
This guide explains what Claude dynamic workflows actually are, how they work under the hood, what they cost (the part most launch coverage glosses over), how to enable them, and whether you should use them at all. Everything here is based on Anthropic’s documentation and real-world reports from developers who have already run them — with the company’s own marketing claims clearly flagged as such.

One lead agent, up to 1,000 subagents: Anthropic’s Claude dynamic workflows turn a single prompt into a coordinated agent fleet running in the background.
Table of Contents
- What Are Claude Dynamic Workflows?
- How Claude Dynamic Workflows Actually Work
- Anthropic’s Own Test: 66 of 70 Bugs Found
- What Claude Dynamic Workflows Cost
- How to Enable Dynamic Workflows: Step by Step
- When to Use Dynamic Workflows — and When to Skip Them
- The Honest Criticism: Cost, Control, and the Token-Burn Debate
- Dynamic Workflows vs the Rest of the Agent Wave
- Verdict: Should You Try Claude Dynamic Workflows?
- Claude Dynamic Workflows FAQ
What Are Claude Dynamic Workflows?
For the past two years, an “AI agent” has mostly meant one model working through a task step by step. It reads a file, runs a command, looks at the result, and decides what to do next — as this independent explainer of dynamic workflows puts it, that model works well for small jobs but gets slow and patchy when the job is wide: reviewing hundreds of documents, auditing a large codebase, or checking many sources against each other. A single agent runs out of room, forgets earlier findings, or simply misses things.
Claude dynamic workflows are Anthropic’s answer to that problem. Instead of the developer hand-configuring every step of a complex process, you describe the task and let Claude determine how to divide the work, coordinate agents, and combine their results. The lead agent writes a small program — a workflow — that splits the job into phases, hands the pieces to many other agents, and stitches the answers back together at the end.
Anthropic’s own one-line summary puts it cleanly: “A workflow is a program that runs many agents in phases and combines their results.” The key numbers for the new public beta:
- Up to 1,000 agents can be started over the life of a single run.
- Up to 64 agents can work concurrently (the docs note the API does not guarantee this number).
- 24 hours is the default maximum run lifetime.
- Background execution on Anthropic’s servers — your main Claude session stays free to talk to you while the swarm works.
This is not the same as ordinary subagent delegation, and the distinction matters. With subagents, the agent delegates tasks itself, turn by turn, and every result lands in its context window. With a dynamic workflow, the script sets the order, intermediate results sit in script variables, and only the final combined answer comes back. The coordination lives in the program the agent wrote — not in a long conversation.
How Claude Dynamic Workflows Actually Work
The two runtimes: Claude Code and Claude Managed Agents
Dynamic workflows exist in two places, and they are not identical. The older form shipped inside Claude Code — Anthropic’s developer CLI tool — as a research preview on 28 May 2026, and it is now generally available. There, Opus 4.8 writes a local JavaScript harness, and you trigger it by using the word “workflow” in a prompt, switching to ultracode mode, or asking for a “quick workflow”. Local runs support up to 16 concurrent subagents and up to 1,000 per run.
The new public beta brings the concept to Claude Managed Agents — Anthropic’s hosted developer platform — where it matters most for production systems. Here is how the two compare:
| Claude Code (local) | Claude Managed Agents (API, new beta) | |
|---|---|---|
| Status | Generally available (preview since May 2026) | Public beta since 9 October 2026 |
| Concurrent agents | Up to 16 | Up to 64 |
| Total agents per run | Up to 1,000 | Up to 1,000 |
| How it starts | The word “workflow”, ultracode, /effort ultracode |
Agent decides from your message or system prompt |
| Where it runs | Local JavaScript execution | Anthropic’s servers, in the background |
| Cost | Counts against plan usage limits | Token rates + $0.08 per session-hour |
The API version is the one that matters for production systems — and it is the one this guide focuses on. If you build agent-powered products and want an efficient tool-use backbone to pair with orchestration, it is also worth reading our guide to Liquid AI’s LFM2.5, the open-weight model that currently leads tool-use benchmarks.

The scenario Anthropic tested: a 116,000-line codebase with 70 deliberately planted bugs. A single agent found 14 to 27; the dynamic workflow found 66 — in every run.
How Claude dynamic workflows differ from subagents
The workflow runs on a one-level-deep delegation rule: the lead agent’s subagents cannot create their own subagents. A workflow can draw on up to 20 predefined agents the developer lists, or the workflow can define agents inline. Runs last up to 24 hours by default (the agent can set a custom lifetime), and a session can hold up to 10 open runs at once — idle runs count toward that limit.
A few more constraints from Anthropic’s docs are worth knowing before you build on this:
- The workflow script itself has no direct filesystem or shell access — the agents do the I/O.
- Progress streams as
workflow_run.*events on the session event stream, so you can watch phases complete. - Once a run ends, the agent cannot send follow-up messages to its threads — the program is committed.
- Anthropic notes the server has “other limits on workflows, and rules for them, that aren’t listed here.”
To enable the beta on the API, you pass the beta header anthropic-beta: managed-agents-2026-04-01 and configure the agent with the multiagent_20261001 type:
{
"multiagent": {
"type": "multiagent_20261001",
"workflows": {
"type": "enabled",
"inline_agents": { "type": "enabled" }
}
}
}
You do not make a separate API call to start a workflow. You describe the work — for example, “analyse this repository for security vulnerabilities; divide the codebase into independent components, investigate them in parallel, verify findings, and produce a consolidated report with file references” — and the agent decides whether and when to start a run, guided by its system prompt.
Anthropic’s Own Test: 66 of 70 Bugs Found
To justify the obvious question — is a swarm of agents actually better than one good agent? — Anthropic ran a deliberately unfair-looking test. The team hid 70 bugs in a 116,000-line codebase, then compared a lone agent against a dynamic workflow across three runs each.
| Approach | Bugs found (out of 70) |
|---|---|
| Single agent | 14, 15, and 27 across three runs |
| Dynamic workflow | 66 in each of three runs |
The consistency is the striking part: the workflow hit 66 out of 70 every single time, while the single agent’s results swung wildly. That matches the intuition that wide, parallel investigation — dozens of agents each owning a slice of the codebase — is more reliable than one agent paging through everything sequentially.
But read the fine print like a sceptic. These are Anthropic’s internal results, not an independently reproduced benchmark. They demonstrate the potential of parallel investigation; they do not establish that multi-agent workflows outperform single agents across every workload. A bug hunt is also close to the ideal case for swarms: the work splits cleanly, each file can be checked independently, and results are easy to verify. Fuzzy, judgement-heavy tasks will not look this clean.

The workflow is a program, not a conversation: phases, agents, and result-combining are written in JavaScript by the lead agent before the run begins.
What Claude Dynamic Workflows Cost
The price formula on the API
Here is the part launch coverage tends to bury: a workflow run has no price of its own. Every agent in the run bills at its model’s standard token rates, plus Claude Managed Agents session runtime at $0.08 per session-hour. You can set a session budget to cap the spend — and you should.
On Claude Code, the accounting is simpler but harsher: usage counts against your plan limits. Each agent in a workflow uses the model active in the current session, so a 500-agent audit on Opus 4.8 shifts the session bill by an order of magnitude compared with a normal session. That is why Anthropic’s own docs say to start on a scoped slice first — and why the confirmation dialog showing planned phases and agent counts before execution is a safety valve, not a formality.
What real users are reporting
Early testers have flagged the burn rate explicitly, and the numbers are sobering:
- One developer reported that spawning 62 Opus sub-agents exhausted a Max plan’s five-hour usage limit in about 18 minutes.
- Another hit their Max plan limit for the first time after roughly 90 agents ran a code review of a small package.
- A third described a session where Claude attempted to launch 47 concurrent agents, successfully launched 25, and made errors over a five-hour run that required human review to catch.
The takeaway is not that the feature is broken — it is that large-scale parallel orchestration at public-beta maturity still demands active supervision and a deliberate budget. A senior OpenAI engineer recently dismissed agent swarms as a massive waste of tokens, and even Anthropic advises teams to start small rather than throw 1,000 agents at a problem out of the gate. When the vendor itself tells you to ease in, listen.

Every agent in a workflow bills at standard token rates plus session runtime. Scale is a budget decision, not just a technical one.
Five ways to keep the bill under control
- Check your model before a large run. As of mid-2026 pricing, Claude Opus 4.8 runs $5/$25 per million input/output tokens while Claude Fable 5 runs $10/$50. In a 40-agent workflow, routing 30 analytical calls to Opus 4.8 and 10 synthesis calls to Fable 5 can roughly halve the token cost versus running everything on Fable 5. Use the per-agent
modeloption deliberately. - Set explicit budgets. On the API, set a session budget cap. In Claude Code, the Large workflow warning — triggered when a run schedules more than 25 agents or projects past about 1.5 million tokens — is advisory only, so do not treat it as a guardrail.
- Start on a scoped slice. Calibrate consumption on one directory, one document set, or one service before pointing the machinery at the entire codebase. Anthropic’s docs say this explicitly.
- Use the size guidelines. The
/configsettings (small/medium/large/unrestricted) tell Claude how many agents to aim for when it writes the script. The default ismedium— orsmallon Pro with recent builds. - Consider efficient models for routine extraction. Not every agent in a swarm needs frontier reasoning. For the mechanical extraction and categorisation phases, cheaper or open-weight models can slash costs — our guides to Liquid AI’s LFM2.5 and Reflection AI’s Beam cover two of the strongest efficiency-first options for exactly this kind of work.
How to Enable Dynamic Workflows: Step by Step
Step 1: Enable the Claude dynamic workflows beta on the API
First, make sure your API requests include the beta header:
anthropic-beta: managed-agents-2026-04-01
Then add the multiagent configuration shown above to your Managed Agent definition, with workflows enabled. There is no separate “start workflow” endpoint — you describe the workflow in your prompt, and Claude decides whether to start one based on the task and its system instructions. If you run Claude Code, Anthropic also ships a quick setup command, /claude-api managed-agents-onboard, that walks through the onboarding.
Step 2: Turn it on in Claude Code
Inside Claude Code, you have three ways to trigger a dynamic workflow:
- Use the word “workflow” in your prompt (“run a workflow to audit this repo”).
- Switch to
ultracodemode, or run/effort ultracodeto have Claude plan a workflow for every substantive task in the session. - Ask for a “quick workflow” directly.
On the plans side: dynamic workflows are on by default for Max and Team plans and for API, Amazon Bedrock, Vertex AI, and Microsoft Foundry users. Enterprise plans default to off — administrators enable them through managed settings — and Pro users turn them on manually from the Dynamic Workflows row in /config. You need Claude Code version 2.1.154 or later on all platforms.
Before execution begins, a confirmation dialog shows the planned phases and agent counts — review it. That dialog is your last cheap chance to catch a run that is about to go big.
Step 3: Monitor, and know how to turn it off
Follow execution through the workflow_run.* events on the session event stream, or the /workflows progress view in Claude Code, which shows each agent’s token usage while the run is live. If you stop a run in Claude Code, you can resume it inside the same session: completed agents return from cache up to the first agent that did not finish, and everything after that runs again.
To disable workflows entirely, you have three options: the toggle in /config, setting "disableWorkflows": true in ~/.claude/settings.json, or the environment variable CLAUDE_CODE_DISABLE_WORKFLOWS=1. Organisation-wide control goes through managed settings.

Server-side execution is the real upgrade: the workflow runs on Anthropic’s infrastructure while your main session stays free for conversation.
When to Use Dynamic Workflows — and When to Skip Them
Dynamic workflows are a specialist tool, not a default. Here is the honest decision framework distilled from Anthropic’s docs and from developers who have burned real budget on them.
Use a workflow when:
- The task is bigger than one context window can coordinate cleanly — hundreds of files, documents, or data sources.
- You want the same orchestration again next week — the workflow script can be saved and reused.
- Wrong answers are expensive, so you want adversarial verification built in — independent agents cross-checking each other.
- You need dozens of independent file-level agents, not three chatty peers.
- The work fits the proven patterns: code audits, migrations, security analysis, architecture reviews, document review, and deep research.
Skip it when:
- A single subagent or an existing skill already covers the job — simpler is cheaper and faster.
- You are on a tight usage budget and the task is routine.
- You need to approve each step mid-run — workflows are not interactive playgrounds. There is no mid-run user input except permission prompts and usage-limit waits, and once the program starts, you cannot course-correct it.
- The one-level-deep delegation limit breaks your design — subagents cannot spawn their own subagents.
The Honest Criticism: Cost, Control, and the Token-Burn Debate
No guide to Claude dynamic workflows is complete without the pushback, because the developer community’s reaction has been genuinely split. The Hacker News thread on the launch ran to hundreds of comments, and three themes kept surfacing.
First, cost. The token economics of a 1,000-agent run are brutal on frontier models. As covered above, real users have burned through five-hour Max plan allowances in under 20 minutes. One commenter put the strategic worry sharply: spawning swarms is easy; knowing what each agent actually bought you is hard.
Second, control. The most-upvoted comment argued that correctness, not speed, is the bottleneck — and that dynamic workflows give you no way to steer a long session or inject corrections once the program is committed. For work where judgement calls compound, that is a real limitation, not a footnote.
Third, the premise itself. A senior OpenAI engineer recently dismissed agent swarms as a massive waste of tokens, and the argument has teeth: if one strong agent with good tools can do the job, 1,000 agents are theatre. Anthropic’s counter is its 66-of-70 benchmark — and its own advice to start small, which reads as a quiet admission that the theatre risk is real.
My take after weighing both sides: think of dynamic workflows like hiring a contractor team. For parallelisable, verifiable work — audit every file, check every claim, review every document — a coordinated fleet beats one heroic individual, and Anthropic’s bug-hunt numbers support that. For fuzzy, judgement-heavy creative work, a thousand agents will mostly produce a thousand opinions. Match the tool to the shape of the task.
Dynamic Workflows vs the Rest of the Agent Wave
Anthropic did not launch into a vacuum. The same week saw the agent-orchestration problem attacked from two other directions. On 15 October, Thenvoi AI launched BAND for Developers, a desktop app that coordinates multiple AI coding agents across tools, machines, and repositories at once — the same “supervising a team of agents” pain, solved with a local app rather than a server-side workflow. A day later, Tencent open-sourced Hy Memory 2.0, a memory framework giving agents a persistent record of what they tried, decided, and changed — the other half of the coordination problem.
The pattern is clear: the industry has moved from “one agent does a task” to “many agents do a project,” and every major lab is now selling its own coordination layer. Anthropic’s bet is that the agent itself should write the orchestration program; competitors are betting on apps, frameworks, and memory layers around it. For a wider view of where open models fit into this picture — including the 816-billion-parameter open release shaking up the same week — see our explainer on Meta’s Muse Spark Open.
There is also a delicious tension worth noting: while Anthropic is multiplying agents on its platform, major websites — Yelp, Delta, JPMorgan Chase, Charles Schwab — are actively blocking AI agents from theirs. The agent wave is accelerating and hitting walls at the same time. Expect that conflict to define the next year of agent development.
Verdict: Should You Try Claude Dynamic Workflows?
If you are a developer with access to Claude Code or the Claude API: yes — on a scoped task, with the budget meter in view. Pick something parallelisable and verifiable (a security pass over one service, a migration checklist across a module), review the confirmation dialog’s agent counts before you commit, and compare the result against what a single agent produced. That comparison is the only review that matters for your workflow.
If you are not a developer: this beta is not for you yet — it is API and CLI tooling, not a consumer product. But watch the concept, not the beta flag. The pattern — an agent that writes the program to organise other agents — will reach consumer tools within the year, and the cost lessons from this beta will shape how those products are priced.
The bottom line: Claude dynamic workflows are a genuinely new primitive for multi-agent work, backed by the strongest parallel-agent benchmark result published this year — and wrapped in the messiest token economics of any Anthropic feature to date. Powerful, expensive, and best aimed with care. That is the honest summary of the most ambitious agent feature of October 2026.
Claude Dynamic Workflows FAQ
What are Claude dynamic workflows?
They are a public-beta feature (launched 9 October 2026) of Claude Managed Agents that lets a lead agent write its own orchestration program — a workflow — which splits a job into phases, runs up to 1,000 AI agents against the pieces, and combines the results. Developers have nicknamed the feature “Claude Flows.”
How many agents can a dynamic workflow run?
Up to 1,000 agents can be started over the life of one run, with up to 64 working concurrently on the Managed Agents API. In Claude Code, the local version supports up to 16 concurrent subagents with the same 1,000-agent total. Delegation is one level deep: subagents cannot spawn their own subagents.
How much do Claude dynamic workflows cost?
There is no per-run fee. Each agent bills at its model’s standard token rates, plus $0.08 per session-hour of Managed Agents runtime. On Claude Code, usage counts against your plan limits — and large runs can burn through them fast, so set a session budget and start on a scoped task.
How do I enable dynamic workflows?
On the API, pass the anthropic-beta: managed-agents-2026-04-01 header and set the agent’s multiagent type to multiagent_20261001 with workflows enabled, then describe the task in your prompt. In Claude Code, use the word “workflow,” switch to ultracode mode, or run /effort ultracode (version 2.1.154 or later required).
Are dynamic workflows better than subagents?
They solve different problems. Subagents are conversational: the agent delegates turn by turn and reads every result into its context window. Dynamic workflows are programmatic: a script sets the phase order, intermediate results live in script variables, and only the final answer returns. Use workflows for wide, repeatable, verifiable jobs; use subagents for everything else.
When will dynamic workflows leave beta?
Anthropic has not announced a general-availability date. As of 20 October 2026 the Managed Agents version remains in public beta, while the Claude Code version is already generally available. Watch Anthropic’s release notes and the @ClaudeDevs account for the GA announcement.
