Dynamic Workflows : How Anthropic Industrialized Token Consumption

There are two ways to read the announcement of dynamic workflows in Claude Code, published on May 28. The first, the one everyone will repeat, fits in the tagline: work you used to plan in quarters now wraps up in a matter of days. The second hides in a quiet note, repeated twice in the same post: the feature consumes “substantially more” of your quota than a normal session, and Anthropic recommends starting on a small, scoped task “to get a feel for usage.”

It is the second reading that interests me. Because the real news here is not the capability. It is the bill.

What it actually does, in two paragraphs

The principle: instead of launching a single agent that advances step by step, Claude Code dynamically writes an orchestration script that splits the task across tens to hundreds of subagents running in parallel within a single session. Some attack the problem from independent angles, others play the adversary and try to refute what the first ones found, and the loop iterates until it converges. Progress is saved as it goes, so an interrupted run picks up where it left off, and coordination happens outside the conversation so the plan does not drift as the task grows.

On the usage side, there are two ways in: explicitly asking Claude to create a workflow, or switching on a new in-house setting, ultracode, which pushes effort to the xhigh level and lets Claude decide on its own when to trigger the orchestration. The feature is in research preview, available on the Max, Team, and Enterprise plans as well as through the API, Bedrock, Vertex, and Foundry. So much for the mechanics. They are elegant. They are not the point.

The point is the meter

Back in March, I argued that the promise of unlimited AI was a mirage, and that the real business model of an LLM vendor depends less on whether you succeed at a task than on how much you consume in succeeding at it (The Mirage of Unlimited AI, for anyone who wants the full reasoning). Dynamic workflows do not contradict that thesis. They instantiate it.

Consider what is being optimized. A single agent that resolves a bug consumes a certain number of tokens. A hundred agents going after the same bug, half of them working to tear down the work of the other half, consume an order of magnitude more, all for a result the announcement itself admits “converges” rather than deduces. Elegant deduction has been replaced by algorithmic brute force, and every round of refutation, every re-run against the test suite, is paid for in compute. The technical value is real on certain massive tasks. The commercial value, on the other hand, is mechanical: more compute billed for the same unit of problem solved.

This is the exact inverse of the logic I documented in Prompt Caching, where the whole game was paying ten times less for the same tokens. Here you pay ten times more for the same deliverable, and it gets called progress.

The double lock, or the admission that speaks volumes

Here is the detail I would not have dared invent. On the Max and Team plans, dynamic workflows are on by default. On Enterprise, they are off by default at launch, leaving it to the administrator to switch them on.

Read it slowly. The two plans where the “burn tokens” mode turns itself on are the most expensive consumer plans, the ones sold on the promise of comfort and abundance. The Enterprise plan, by contrast, is protected by default, because on the other side there is a procurement team watching the tab and an administrator who can say no. In other words: Anthropic spontaneously steers toward the most expensive mode precisely the customers who will not see the spending itemized line by line, and puts a safety catch where someone is keeping an eye on things.

The admission does not stop there. The first time a workflow fires, Claude Code shows what is about to run and asks you to confirm. This is presented as transparency. What it really proves is that Anthropic knows the bill can come as a surprise, to the point of having to warn you before it charges. An abundance that asks for your consent before it spends is not abundance: it is a metered plan that kept the word “unlimited” on the brochure.

The Bun case: a demo of speed, not a proof of reliability

The announcement leans on one spectacular example: the rewrite of Bun, ported from Zig to Rust with, reportedly, around 750,000 lines of Rust, 99.8% of the existing test suite passing, and eleven days from first commit to merge. Agents by the hundreds, two reviewers per file, a fix loop driving build and tests until everything ran clean.

The number is engineered to make you bow. Let us put it on trial instead, using the lens I already applied to the models themselves in LLMs Are Swiss Cheese, where I showed that an LLM’s impressive surface hides structural holes.

Three questions, then. First, what is 0.2% of failing tests worth on a systems runtime? On most software it is trivial. On a JavaScript runtime, whose entire job is to handle correctly the edge cases everyone else gets wrong, those 0.2% may be exactly the hard part, the very reason the project was worth writing in the first place. The reassuring percentage measures the easy and conceals the costly.

Second, what work is the phrase “while not yet in production” doing, slipped in almost casually at the end of the paragraph? An enormous amount. A port that passes the tests but does not run in production is, in this trade, a port that is not finished. The gap between those two states is precisely where the bugs the tests never catch make their home. Presenting the first state as an accomplishment and demoting the second to an aside is rhetoric, not engineering.

Third, and this is the figure nobody will put a number on: what did this demonstration cost, in tokens and above all in hours of human review? “Two reviewers per file” across hundreds of files are not just agents, they are decisions to be validated. The demo proves you can produce 750,000 lines very fast. It does not prove you can audit them. Conflating the two is the entire sales pitch.

Where the developer goes

That leaves the question of the craft, and I will raise it without any nostalgia for lost artisanship, because that register is as tiresome as it is misleading. The problem is not romantic. It is material.

When Claude deploys two hundred agents on a migration spanning thousands of files and you “come back to a single, coordinated answer,” the production work has indeed been delegated. But the verification work has gone nowhere. It has shifted, and it has changed in nature. You are no longer rereading a diff you thought through: you are signing off on a result you never watched take shape, produced by a swarm whose reasoning you cannot reconstruct, at a volume no human can audit line by line in the time allotted. This is the exact continuation of what I analyzed in The Great Dispossession, where the developer does not lose the job but loses command of what they put their name to.

The cognitive load does not evaporate. It concentrates on a single checkpoint, downstream, where it is least tenable. You are sold the elimination of production effort; you are handed a verification debt that scale makes impossible to pay. The cost has not disappeared, it has merely left your field of view, exactly the way the energy bill of vibe coding does not vanish just because you cannot see it running.

And this is where the quietest transfer of the whole operation takes place. If a workflow burns through $500 of tokens and produces code that passes the tests but crashes in production, Anthropic refunds nothing. You paid for the compute, you carry the defect, and it is your name on the commit. Responsibility, unlike the work, does not parallelize: not one of the two hundred agents will be summoned when the service goes down. The developer remains the single fuse in a system designed so that they can no longer inspect its wiring.

Anthropic ships the control tower it deemed unnecessary

I owe my own archives some honesty. On May 23, writing about Switchboard, I argued that Claude Code did not need an external control tower to orchestrate its sessions (Switchboard: The Control Tower Claude Code Didn’t Need?). Five days later, Anthropic ships one, native, integrated, and far more ambitious.

Two readings present themselves, and I refuse to hide the one that stings. First reading: the need for orchestration was real, and I was wrong to dismiss it when I judged a third-party tool to be excess baggage. Second reading: Anthropic confirms the other intuition, the one I laid out in March in Claude Code Is Fast. But Does It Go Far Enough?, where I doubted a single agent could see real work through to the end. By industrializing parallelism, the vendor admits in black and white that one agent is not enough for the tasks that matter.

Both readings are probably true at once. Switchboard answered a real gap on the wrong floor; Anthropic answers the same gap on the right one, while billing for the entire building.

From the product side, from the cash register side

The timing removes any doubt about the priority. On the very day Anthropic unveiled dynamic workflows, the company closed a $65 billion raise at a $965 billion valuation, overtaking OpenAI, on the strength of an annualized revenue run-rate said to have grown by roughly half in seven weeks. You do not value that kind of trajectory on the quality of the answers, you value it on the volume of compute billed. The feature that multiplies your consumption and the funding round that celebrates that consumption are not two pieces of news: they are the same one, seen from the product side, then from the cash register.

From flat rate to metered

The question, in the end, is not whether dynamic workflows work. On large, repetitive jobs, repository-wide security audits, framework migrations, dead-code hunts, they will probably work very well, and some of your projects will benefit. The question is who pays for the gap between the demo and production, between the reassuring 99.8% and the 0.2% that decide everything, between the line produced and the line verified.

Anthropic has turned “from quarters to days” into a sales argument. What you should really read in it is “from flat rate to metered.” The time savings are real. They are settled in tokens, the settlement is anything but unlimited, and there is no warranty: you pay for the compute up front, and if it gets things wrong, you alone answer for the result. That may be the most precise definition of progress as it is being sold to us in 2026: accelerate production, externalize the cost, and leave responsibility exactly where it has always been.