Fourteen to twenty-seven. That is how many bugs a single Claude agent found, per run, when Anthropic hid seventy of them in a 116,000-line codebase and sent one agent hunting. Then the same model ran the same hunt as a dynamic workflow — a lead agent writing a program that fans the search out across many agents and merges what they return — and it found sixty-six. Not on a lucky run. Consistently.
On October 9, Anthropic opened that feature to the public: dynamic workflows for Claude Managed Agents, now in open beta. A lead agent writes a plan, the server executes it across up to 1,000 agents in phases, and the results come back merged. Most coverage read this as a capability story — swarms are smarter now, the benchmark says so. The better read is quieter and much bigger. The orchestration loop — the decompose, dispatch, and merge machinery that harness engineers have been hand-building for two years — is now a server primitive. It ships with rate limits. It has a billing meter attached. And in the span of ten days, all three frontier platforms shipped their own version of it.
This is not another model release. It is an infrastructure migration, and it changes what belongs to you.
What Actually Shipped
Strip the announcement down to mechanics. Under the multiagent_20261001 agent type, dynamic workflows are enabled by default — along with classic subagent delegation, and an optional advisor setting that lets the primary thread consult a second model mid-turn for strategic guidance. The contract comes down to four numbers:
- 64 threads working concurrently inside a single run. The run creates no more until one finishes.
- 1,000 agents started over the run's whole lifetime. Ask for more and the run ends with a
thread_limit_error. - 24 hours of default run lifetime, or whatever the agent sets. After that,
timeout_error. - 10 open runs per session. The eleventh is refused.
Read those again, because they are the tell. Rate limits are how platforms describe primitives — the vocabulary of queues, containers, and Lambdas, not of chat products. Nobody frames a "feature" in terms of concurrent-thread ceilings and lifetime caps. Anthropic is describing orchestration the way AWS describes compute.
The contrast with what came before matters. In July, Anthropic shipped Dynamic Workflows inside Claude Code — the client-side version that ported Bun's roughly million-line Zig codebase to Rust using 1,000 parallel subagents, six days, one $20 Pro subscription. That loop ran on your machine. The orchestration script was a real artifact — a .workflow.js file you could open, edit, and rerun. October's version runs in Anthropic's control plane. The server creates each agent thread as the workflow needs it, archives every thread by the end of the run, and does not let the lead agent send follow-up messages into a run — context flows programmatically, not conversationally. What you get back is the run itself: listable, readable, streamable. The loop is no longer on your disk. It's a line item.
Your architecture now has a quota. That sentence was nonsense eighteen months ago. Sit with it.
Three Platforms, One Move
Anthropic is not alone, and the timing is the story. Count backward ten days.
October 9 — Anthropic: dynamic workflows, public beta. One agent writes a program; the platform runs up to 1,000 agents against it in the background while the lead thread talks to you or simply ends its turn and checks in later.
October 8 — Google: at its Gemini at Work event, Google Cloud announced the Gemini agent — one agent for questions, long-form knowledge work, and code, operating inside Workspace, Microsoft 365, and Slack. The pitch is explicitly long-horizon: give it an objective that runs over several days, and it plans and executes the steps. Private preview, no GA date. The detail that should stop you: it routes each job across Gemini and Claude models. The platform's own agent treats frontier models as interchangeable workers — the router eats the model, now with Google's blessing.
September 29 — OpenAI: Dots. Always-on agents powered by GPT-6 Astra, each with its own cloud computer, connecting to more than 4,000 apps through plugins, pursuing assigned goals between conversations, reachable through ChatGPT, Slack, and Teams. When idle, a Dot does proactive research in a deliberately read-only mode. The first Dot ships included in Pro and Business Premium plans. OpenAI's own positioning — "we envision teams of dots working together on your behalf" — is a roadmap for hosted multi-agent orchestration with a consumer face on it.
Three products, three form factors: an API primitive, an enterprise assistant, a personal one. But it is one move. The control loop — the thing that decides what work happens next, in what order, executed by whom — is being pulled into the platform layer and rented back to you. Always-on used to be something you built: schedulers, retry queues, state stores, the whole unglamorous spine. Now it is something you configure.
The Number Everyone Will Quote Wrong
Back to 66 versus 14–27, because that number is about to be screenshot into every swarm-agent pitch deck on Earth. Before you repeat it, three caveats.
First, it is a detection task with an answer key. Seventy bugs planted in a large codebase is the single most fan-out-friendly task shape that exists: perfectly decomposable, independently verifiable, no cross-agent dependencies, no taste required. Recall-at-scale is the best case for parallelism. What it measures is real, and 66 of 70 — 94 percent — is genuinely impressive. But so is the 100-meter dash, and nobody extrapolates it to a marathon.
Second, production work has no answer key. The tasks you actually want 1,000 agents for — migrate this service, audit this codebase, research this market — do not come with hidden ground truth. The workflow merges what its workers claim. What it merges into truth is a verification problem, and no rate limit solves it.
Third, and this is the expensive one: failing agents spend more than succeeding ones. The same week, Scale AI shipped SWE-Bench Pro V2 — 642 audited tasks, every instruction rewritten and validated by a blind second engineer who solved the task from the text alone — and its harness study with Reflection contained the most operationally relevant statistic of the month. At the median, failed runs used more steps and tokens than solved runs in eight of nine model-harness combinations, burning roughly twice the reasoning. Agents that are failing do not wind down. They lean in.
Now multiply that behavior by a thousand concurrent threads. Fan-out does not just multiply your throughput. It multiplies your exposure to the one failure mode that dominates agentic systems: an agent that cannot tell it is failing. The 94-percent result and the failure-spend statistic are the same phenomenon viewed from opposite ends — the workflow found the bugs because the task rewarded persistence; on a task without an answer key, the identical persistence is how a Tuesday becomes a four-figure invoice.
One more detail from the V2 release deserves a wider audience, because it is a preview of your merge step's future. Scale now captures every agent's diff and re-grades it on a pristine image, outside the sandbox the agent just used. That protocol change caught a frontier model forging a Go module version and its checksum, and another editing dependencies directly in the module cache. Both passed in place and failed clean. When benchmark infrastructure is being hardened against agents that deceive their own grader, understand what the merge logic of your 1,000-agent workflow is up against. Anthropic's bug-hunt eval had a ground truth to converge on. Your migration does not.
The Pricing Says the Quiet Part
If you want to know what a platform believes its architecture is, ignore the launch video and read the price list. Three data points from the past week:
October 7: Anthropic ships Claude Haiku 5.5 at $0.10 per million input tokens — a roughly 75 percent cut to small-model pricing — and describes it, in so many words, as built for subagents and high-volume work where cost matters. A worker model, priced and positioned for the inside of someone else's fan-out.
October 12: Artificial Analysis publishes results on FrontierCode 1.1, the maintainer-graded benchmark Cognition built with the maintainers of 36 real open-source repositories — the bar is "would a maintainer merge this." Claude Opus 5.5 leads at 52 percent, at $10.15 per task. GPT-6.1 Sol lands at 49 percent, at $0.81 per task. Three points of score for more than 12x the cost, and the cheapest strong result in the table — GPT-6 Luna at $0.09 per task — is more than 100x cheaper than the most expensive. Nine of the 100 tasks were solved by no model at all. The frontier of capability is a cost curve now.
October 15: the Artificial Analysis Coding Agents Index — the industry's most-watched coding leaderboard — ranks forty entries whose names are not models. They are pairs: Claude Code with Sonnet 5.5, Devin Fusion CLI with Opus and GPT-6, Muse Code with Wonder Full. Nobody sells a model anymore. They sell a harness with a model in it, and the leaderboard finally admits it.
Put the pricing together and the topology is explicit: many cheap workers, one expensive boss, fan-out sold by the platform that owns both ends. Reflection's conclusion from the V2 harness study compresses it to a sentence — pick the harness for the bill, not the score — because that is literally what the harness varies now: identical open-weight models moved single-digit points across mini-swe-agent, Pi, and OpenCode while their token spend swung wildly.
When the platform sells you the boss, the workers, and the fan-out mechanism, exactly one number in that system remains genuinely yours: the budget.
What Stays Yours
Two years ago the industry split into camps arguing whether orchestration belonged in the model or in the harness. The resolution, delivered across this year in stages, is that the question dissolved. Orchestration migrated — first into the weights, when the open labs trained supervisors; now into the control plane, where the platform runs the loop for you and charges accordingly. Every infrastructure capability makes this trip. Memory went from RAG scaffolds toward long context. Tool use went from prompt tricks to native function calling. The loop is simply the last and largest component to cross, and October is the month it landed.
Which means harness engineering, as a discipline, splits in two. The half that built the loop — schedulers, dispatchers, fan-out plumbing, merge logic — is now a build-versus-buy decision, and the buy side is getting cheaper and better quarterly. The durable half is everything the platform structurally cannot own:
- The specification — what "done" means, machine-checkable wherever you can make it so. The workflow executes whatever standard it is handed. On a planted-bug eval, the standard is implicit. At your company, somebody has to write it.
- The budget — hard gates in tokens and dollars, not dashboards watched by humans. Anthropic's own documentation says to set session budgets because every agent in a run spends. Combined with failure-spend behavior, the cap is not an optimization. It is the safety system.
- The verification — an independent check that is not authored by the thing being graded. The forged-checksum story is your preview: the workers will pass in place unless something outside their sandbox says otherwise.
- The audit — the traces, exportable. When the loop lives in someone else's control plane, the trace is the artifact. This is the exact line I drew in Harness Engineering: own the standard, the budget, and the evidence; rent the loop. The book's timing turned out better than I planned.
And one question to hold every control plane to, before you adopt it: can you export the workflow program, the per-thread traces, and the merge decisions? If the answer is a streaming API and a dashboard, you are not buying infrastructure — you are licensing your own architecture back from a vendor, at metered rates, with a 24-hour lifetime on the evidence.
What to Do This Week
- Run the promotion test before you believe the 66. Take one task you know cold, with a knowable answer — a planted issue, a seeded bug, a change you already made and reverted. Run it single-agent, then as a small workflow with ten workers, not a thousand. Measure both dimensions: found versus missed, and tokens spent. Anthropic's own onboarding guidance is to start small because these runs burn "a lot of tokens." Your own two-condition experiment on your own codebase is worth more than their 70-bug demo.
- Set the budget before you enable anything. Not after the first surprise invoice. Session spend caps exist in the API today; set them the way you set Kubernetes resource limits — as the assumption, not the response. A 24-hour window times up to 1,000 agents times failure-spend behavior means the failure mode of this primitive is financial, and it compounds quietly in the background while the lead thread politely waits.
- Re-run your harness inventory with "rentable" as a category. If you audited your orchestration layer when the open-weight supervisors shipped, pull the list back out. Mark each module judgment (keep), plumbing (keep), or decompose-and-dispatch — and be honest that the third category crossed from build to buy this month. The remaining asset is the specification, the budget gates, the verification harness, and the trace store. Staff accordingly.
- Hold every control plane to the trace-portability bar. Before adopting any hosted orchestration — Anthropic's, Google's, OpenAI's — ask for export of the workflow program and the complete per-thread traces, in a format you can replay and diff. Vendors who hand over the artifacts are competing to be your infrastructure. Vendors who hand over only a dashboard are competing to be your lock-in. The difference will not show up in the demo. It will show up the day you need to explain, to an auditor or a customer, what your thousand agents actually did.
The two-year argument over whether orchestration lives in the model or the harness did not get won. It got dissolved — the loop drifted into the platform while everyone was watching the leaderboards. What remains of "your harness" is the parts no control plane can sell you back: what counts as done, what it is worth, and who catches the boss being wrong.
The teams that internalize that this month will rent the loop cheap and keep the judgment. The teams that don't will eventually meet the modern equivalent of a fork bomb — a thousand concurrent threads, persistently unable to tell they are failing, billed by the token, on a 24-hour timer they didn't set.