About fifty medium coding tasks a month. That's what AI credits and usage-based billing would buy a Claude Pro subscriber under the $20 credit pool Anthropic floated for programmatic work — fifty tasks, at roughly Sonnet rates, before the meter runs dry. If you run Claude Code as your main tool, fifty is a morning.
I spent years on the research side of this industry, and I want to be careful about what kind of event this is. It isn't a price hike wearing a costume. It's the moment a subsidy stopped being invisible, and a lot of us finally got to see what a day of autonomous agent work actually costs to produce. The mechanism is more interesting than the outrage, so let me walk through it.
What changed in mid-2026
Two pricing moves landed weeks apart, and they point the same direction.
GitHub Copilot went first. On June 1, Copilot shifted onto "AI Credits". Pro at $10 a month, which had meant unlimited agent use, became a 1,500-credit monthly allowance. A new $100 Max tier appeared for people running agents all day. The flat rate, gone.
Anthropic's move was more surgical. On May 14, the company announced that, starting June 15, Claude Agent SDK and claude -p headless usage would no longer count toward your plan's limits. Programmatic work would instead draw from a separate dollar-denominated pool — $20 on Pro, $100 on Max 5x, $200 on Max 20x — billed at standard API list prices, with no rollover. Interactive Claude Code in your terminal stayed on the subscription. The line was drawn between you typing and your scripts running.
The reaction was sharp. The effective cost increase ran 5 to 10x for heavy Agent SDK users. Before the effective date arrived, Anthropic paused the change — "it is not taking effect," in the company's words — and said it would rework the structure. Note the word. Paused, not reversed.
The subsidy you didn't know you were getting
Here's the figure that matters more than any sticker price. By Anthropic's own accounting, the Agent SDK had been running at a 15 to 30x subsidy relative to direct API pricing. When you pointed the SDK at your subscription, you were paying somewhere between a fifteenth and a thirtieth of what those same tokens cost through the metered API. That's the whole story, compressed into one number.
Subscriptions are priced on averages. The provider assumes most people use a little and a few use a lot, and the light users quietly fund the heavy ones. That arrangement holds as long as a human sits in the loop, because a person has a ceiling. You can only read so many diffs, approve so many changes, type so many prompts before you need lunch. Your own attention caps your spend.
Agents removed the cap. An autonomous loop has no attention budget to exhaust. Some of these systems run for hours unattended, and the leaderboards now track 397-billion-parameter open models with 262k-token context windows doing serious agentic work. When the thing consuming tokens is software rather than a person, the assumption that "most users sip" simply fails. So a flat plan paired with an agent became an arbitrage: the provider priced for human appetite, and the customer fed a machine instead. "Unlimited" was never a claim about infinity. It was a bet on human limits, and agents made that bet unwinnable.
Why the token is becoming the unit of pricing
What we're watching is the unit of pricing migrate from the seat to the token. A seat is a proxy. It stands in for one human of bounded throughput and roughly predictable cost. A token is the thing itself. The move to AI credits and usage-based billing is providers pricing the real unit, because the proxy stopped predicting anything the moment the human stopped being the bottleneck.
That's uncomfortable, but it has one genuine virtue: your agent's cost becomes legible. Every loop carries a meter now, and that should change how you build. A retry that fires three extra times isn't free anymore. An agent that re-reads the entire repository on every step because you never gave it a memory becomes a line item you can see. Verbose system prompts, redundant tool calls, an LLM-judge step you wired in and forgot about — under the flat rate, all of it dissolved into a fixed monthly number. Metered, it shows up. Token efficiency turns into an engineering discipline, much the way query optimization became one once cloud databases started charging per scan.
There's a structural current under all this, too. Stateless MCP is moving into the standard, so a remote server that once needed sticky sessions and a shared session store can run behind a plain round-robin load balancer. Cheaper, more elastic plumbing for agents produces more agent calls, not fewer. The infrastructure is getting ready for high-volume, metered traffic, and the pricing is catching up to the infrastructure.
What I'd actually do about it
So you're running Claude Code or Cursor as your primary tool. The pause gives you a window. What's the move?
First, stop treating "unlimited" as something you can design around. It was a temporary subsidy, and it's being repriced while we watch. Adoption is the reason it can't hold — when an entire cohort of engineers comes to depend on Claude Code for daily work, the cost of subsidizing them climbs faster than any flat plan can absorb. Dependence and subsidy can't both keep growing.
Second, measure your token burn per task now, while learning it is still cheap. Instrument your loops before the meter forces the lesson. And keep a cheaper model in rotation for the mechanical work — the leaderboards already list capable open-weight alternatives at a fraction of flagship cost. You don't need the top model on the board to rename variables.
Will the next version of this pricing be gentler? Maybe. But it won't get paused twice. Measure now, while the meter's still off.