You already know which job I’m talking about. The review bot that fires on every push. The 2 a.m. cron. The claude -p helper you run without thinking. Until June 15 all of it rode free on your subscription. As of this week it’s on a meter, and the meter doesn’t warn you when it empties. It just stops.

What everyone’s getting wrong

The loudest take is that Anthropic jacked up the price 25×. So people are doing one of two things: throttling their agents to save money, or threatening to walk. Both reactions are aimed at the wrong target.

June 15 wasn’t a price change. It was a routing change. The same task now costs you nothing or costs you real money, and the only thing that decides is how you call the model, not what you ask it to do. Ration the wrong half and you slow yourself down for no reason. Cancel and you’ve burned the easiest tool you have over a problem you could have measured in an afternoon.

What actually changed: two meters

Your subscription has two lanes now.

  • Interactive. You, at the keyboard, in a Claude Code session, Cowork, or the apps. Same limits as always. Free, unchanged.

  • Programmatic. The Agent SDK, claude -p, Claude Code GitHub Actions, anything headless. It now pulls from a separate monthly Agent SDK credit: Pro $20, Max 5× $100, Max 20× $200, billed at full API rates. Hit zero and it hard-stops unless you switched on extra usage.

The credit is per person. It doesn’t roll over. And the line between the two lanes comes down to one thing: authentication.

OAuth on your subscription, real agent loop → interactive, free.
An ANTHROPIC_API_KEY, the Agent SDK, claude -p, or Actions → the metered credit.
A third-party key like OpenRouter → already pay-as-you-go, untouched.

The danger was never the price. It’s that you can’t see which of your own jobs walks through which door.

And it’s not just Claude

Here’s what makes the real bill so slippery. Your spend is scattered. Some Claude on the subscription. Some Codex or ChatGPT. An OpenRouter router. A local Ollama model doing the cheap work. Four bills, four meters, and only one of them, Anthropic run programmatically on your subscription, actually touches the $200 credit.

Mix those up in your head and your estimate is fiction. The fix is to sort every call into a billing bucket and count only the one that counts:

  • Anthropic interactive → unchanged, free.

  • Anthropic programmatic → this is the credit.

  • External pay-as-you-go (Codex, OpenRouter, Anthropic on your own key, Gemini) → a separate bill, never the credit.

  • Local (Ollama) → free models.

Running Hermes, Paperclip, OpenClaw, ClaudeClaw, a custom swarm? Each one gets bucketed by how it authenticates. Your whole agent fleet, one honest view.

The replacement move

So if rationing and canceling are both wrong, what’s right? Smaller and stranger: find out which door each call walks through, then move the cheap, unattended traffic off the meter and leave the rest alone. Two levers do most of the work.

Route. Heavy headless jobs don’t need to run on the subscription credit. Push them through a local-first router with a spend cap, or onto a dedicated API key, and the $200 stays for the work that actually needs it.

Cache. A cache read costs about one-tenth of a fresh input token. After June 15 that’s no longer a latency trick. It’s a discount on real money. Credit where it’s due here: the idea of a token-burn dashboard, turning an opaque monthly number into “which workflow burned which tokens,” is Nate B. Jones’ (June 2026). The piece I added is the caching breakout: counting what caching already saved you, and what’s still recoverable, per system and per bucket. On the metered pool that recoverable number is money sitting on the ground.

You can’t cache what you can’t see

Caching only pays if you watch it like a meter. Per system, per provider, three numbers: your hit rate, what caching has already saved you, and what’s still recoverable if you cached the stable prefix. That last number is the one nobody tracks, and it’s the one that turns straight into dollars off the credit. Make it a reading you check, not a setting you forget.

And the meter is wider than your models. Your token burn is driven by your whole stack, and almost none of it shows up on Anthropic’s bill:

  • Every model. Claude, Codex/ChatGPT, Gemini, local Ollama. Different prices, different caches, one combined cost you currently can’t see in a single place.

  • Every agentic orchestrator. Claude Code, Codex, Hermes + Paperclip, OpenClaw, ClaudeClaw, your own swarm. Each one is a token firehose, and each authenticates differently, which is exactly what decides whether it hits the $200 credit or a separate bill.

  • Your knowledge layer. The second brain. An open-brain or 2nd-brain, a vector store like Pinecone, a notes system like QMD. This is the silent driver: every retrieval becomes input tokens, and the same source gets re-read run after run. Compile it into a stable packet and it becomes a cacheable prefix at one-tenth the price. Leave it raw and you pay full freight every single time.

  • Intelligent routing. A local-first router (Ollama, then a cheap cloud model, then Claude only when the task earns it) with a daily spend cap. The cheapest token is the one you never send to a frontier model on the meter.

Put all of it on one dashboard and the guessing stops. You see which system drained the credit, and you see where caching your second brain pays you back.

The tool

I packaged all of it into a free Claude Code skill on GitHub: Burn-Safe Token Ledger (MIT). Point it at your own usage and it does five things: splits your burn into interactive vs programmatic vs external vs local by system; projects only the Anthropic-programmatic slice against your credit as a range tied to your real cache hit rate; breaks out caching dollars saved and recoverable; shows your whole stack in one dashboard (every model, the agentic orchestrators, and the knowledge layer driving your retrieval burn); and hands you the fixes, then offers to wire them in.

It runs on sample data in one command, so you see the shape before you commit. Your real paths and usage stay local and gitignored. Nothing personal ships.

For most people the honest answer is that the bill barely moves, if you keep hands-on work interactive, route heavy unattended jobs off the subscription, and cache the prefixes your agents reuse. The tool’s job is to prove which of the three you actually need, from your numbers, not mine.

Go look

The worst outcome here isn’t a big bill. It’s a silent one: a job that dies at 2 a.m. because the credit ran dry and nobody decided, in advance, hard-stop or overage.

You already know which job I mean. Right now you can’t see what it costs. Go look. And then send this to the one person on your team who owns the pipeline you’re not sure about, before it goes dark at 2 a.m. and takes their morning with it.

That’s not my problem to fix. It’s yours, and it’s an afternoon’s work.

Sources

Every figure in this piece is from a primary source below. Anthropic’s policy and prices change; verify before acting.

Further reading

Independent coverage of the June 15 change (secondary sources; quality varies, and none replaces Anthropic’s own docs above):

Burn-Safe Token Ledger is open source (MIT) at github.com/emergentcap/Burn-Safe-Token-Ledger. Token-burn dashboard concept credited to Nate B. Jones (June 2026): see his Token Burn Dashboard post and his newsletter, Nate’s Newsletter. Not affiliated with Anthropic. Verify current pricing and policy against Anthropic’s official documentation before making billing decisions.