Per-Token Prices Fell. Everyone’s AI Bill Exploded Anyway. Welcome to the Reckoning

This image was generated with help from an AI program

All week I wrote about the AI gold rush, the chips, the agents, the billions, the tollbooths. This is the morning after, when the invoice lands on the desk of everyone actually building on this stuff. And the invoice is the most honest story of them all.

I’ve spent eight days now tracing the AI boom from the top down: the superchip, the always-on assistant, the security breach, the record raise, the cartoon app, Apple’s tollbooth, and a billion-dollar-a-month scramble for GPUs. Grand, sweeping, civilization-scale stuff.

Then on Friday, a quieter story landed that I suspect matters more to people like me than any of them, because it’s about the part where the bill arrives. TechCrunch reported on the industry’s growing panic over runaway AI costs, and reading it felt less like news and more like a mirror. If you build anything on top of AI, this is your story. It’s certainly mine.

And it opens with a paradox worth staring at.

The paradox: prices dropped, bills detonated

Here’s the thing that should reorganize how you think about AI economics. Per-token prices have actually fallen. The cost of a unit of AI has been dropping. And yet companies are blowing through their budgets at a pace that’s triggering genuine crisis.

This story was written with assistance from an AI program.

How? Because the agents eat more. The push toward autonomous, agentic AI, he exact capability everyone spent this week celebrating, means the machines now consume tokens at a volume no human prompt-typer ever could. An agent doesn’t ask one question; it loops, it reasons, it calls tools, it retries, it churns through context windows the size of novels. Cheaper units, astronomically more units. The bill goes up even as the price goes down.

This is Jevons’ paradox arriving in AI: make a resource more efficient, and total consumption doesn’t fall, it explodes. The cheaper the token got, the more recklessly we burned them.

The receipts in the reporting are brutal. Uber reportedly torched its entire 2026 AI coding budget by April. Microsoft pulled Claude Code licenses from developers just months after handing them out. Priceline saw a routine tool renewal come back four to five times more expensive. One company, per the reporting, ran up a $500 million Claude bill after simply forgetting to set usage limits for employees. A CTO told one vendor that a single engineer spent $40,000 on tokens in a month, and admitted he genuinely didn’t know whether to stop the guy or order everyone else to copy him.

That last anecdote is the whole era in one sentence.

“Tokenmaxxing” is over. The guardrails era has begun.

The cultural shift in the reporting is unmistakable, and it maps onto a theme I keep hitting all week. The FinOps Foundation’s J.R. Storment described companies coming to him in April and May in something close to existential panic, months into the year and already multiples over their entire annual token budget. The conversation across the industry, he said, flipped from “go fast, use the best model, costs be damned” to “we need guardrails, how do we control this?”

OpenAI’s head of enterprise, Alexander Embiricos, described the same inversion: six months ago, customer conversations were about whether the AI was good enough. Now they’re about spend, visibility, auditability, and token controls. Nobody’s asking “can it do the job” anymore. They’re asking “can I afford to let it.”

Notice what’s happening here, because it’s the same move I wrote about with Microsoft’s Scout and Apple’s agent approval. The industry is racing to build an accountability layer, except this time it’s not for agent behavior, it’s for agent spend. The Linux Foundation just unveiled a Tokenomics Foundation to do for AI tokens what FinOps did for cloud bills: impose a shared language, real metrics, actual discipline. New yardsticks are being proposed: cost-per-intelligence, tokens-per-watt. A whole market of spend-tracking tools is erupting overnight: pure-plays like Pay-i and Paid, monitoring from Jellyfish and Faros AI, and the incumbents, Ramp, Datadog, New Relic, AWS, all bolting on token observability. Provability is becoming the product, again. First we needed to prove what the agent did. Now we need to prove what it cost, and whether it was worth it.

The uncomfortable question hiding under the bills: was it worth it?

Here’s where the reporting gets genuinely bracing, and where I’d push every builder to sit in the discomfort.

A survey of 20,000 developers found that yes, output went up with heavy AI use, but so did bugs and rewrites. Another analysis found the heaviest token users were roughly twice as productive as light users, but burned around ten times the tokens to get there. Per-developer token consumption reportedly rose something like 18-fold in nine months. And the punchline, from Jellyfish’s head of research: whether all that spend pays off comes down to the business value of what actually ships, revenue, real outcomes, which most companies still can’t measure.

Read that again. We are spending fortunes on a productivity gain we mostly cannot quantify. The entire hype cycle deferred this question, what is the ROI, really?, and the token bill is the thing finally forcing it onto the table. The diminishing returns are real: ten times the cost for two times the output is not a slam dunk, it’s a spreadsheet problem. The smartest take in the whole piece came from that same researcher, who argued the best returns come not from pushing power users to burn even more, but from moving the broad, cautious middle from low to moderate use. The optimum isn’t maximal. It never was.

What I’m actually doing about it (and what you should consider)

I run on the token meter. My margins are inference costs, I watch that line the way a restaurant owner watches food costs, because it’s the difference between a business and a hobby. So this isn’t abstract for me, and here’s the playbook this reckoning has hardened for me:

Measure spend against outcomes, or you’re flying blind. If you can’t connect a token to a result that matters, a shipped feature, a closed ticket, actual revenue, you can’t tell investment from waste. Instrument this before you scale usage, not after the $500K surprise. The companies in crisis are the ones who scaled first and asked questions later.

Route ruthlessly; stop defaulting to the biggest model. The single clearest cost lever in the reporting is model routing, automatically sending each task to the cheapest model that can actually handle it. Frontier labs are already doing this quietly on enterprise bills, fulfilling some of your “premium model” calls with smaller, cheaper models when those suffice. A startup like Factory just shipped a router that picks the right model per task. Build or buy this. Most of your spend is probably premium horsepower aimed at jobs a compact model would nail.

Set hard limits before you need them. The half-billion-dollar bill happened because nobody capped usage. Guardrails, per-user, per-team, per-task budgets, are not bureaucracy. They’re the seatbelt. Put them in on day one.

Audit the bill itself. One finance leader in the reporting noted discrepancies between what a vendor reported and what his own data showed, and drew the parallel to the early, messy days of telecom and cloud billing. This is a brand-new, immature metering layer, assume it’s “ripe for errors” and reconcile it yourself.

Keep the on-device option on the table. I opened this whole series skeptical-but-curious about NVIDIA’s pitch for running models on hardware you own. A week of cost-crisis stories later, local inference looks less like a novelty and more like a structural hedge: the one model whose meter doesn’t tick is the one running on a machine you already paid for.

The week, paid in full

So here’s where the eight days land. NVIDIA showed what agents can do. Microsoft showed how we’ll govern them. Meta showed how they break. Alphabet showed who’s funding them. Dreambeans showed how we’ll be made comfortable with them. Apple showed who controls the door. Google and SpaceX showed the compute underneath: billions a month, even for the biggest player. And now the token-cost reckoning shows the invoice, that same scarcity and spend, finally landing on the customer’s desk.

The supply side and the demand side of this story are the same story. Upstream, the giants pay a billion a month for GPUs. Downstream, an enterprise torches its annual budget by April and a single developer spends forty grand in thirty days. The pipe is finite and the meter never sleeps, and we are all, giants and solo builders alike, learning the same lesson at the same time: capability was the easy, fun, expensive part. Control is the hard part, and the bill is how we found out.

One source compared where we are to having built a steam engine without yet figuring out the assembly line. That’s exactly right. The power is real and astonishing. The discipline to use it without bankrupting ourselves is the thing we’re frantically inventing right now, in real time, one runaway invoice at a time.

I’d get your meter in order before the next one arrives.

If you build on AI: do you actually know what your tokens buy you in business terms, or are you, like most of us, still guessing? And how are you controlling spend: routing, hard limits, going local, something else? I’d genuinely like to compare playbooks, because none of us has fully solved this yet.