The Token Bill That Broke Two Tech Giants
In the same stretch of 2026, Uber's leadership discovered its annual AI tooling budget was gone by spring, and Microsoft decided its own engineers should stop using a coding tool it was paying for by the token. Different companies, different products, one shared cause: the meter.
Two companies arriving at the same decision in the same year raises the question this piece works through. Is this two finance teams tightening belts, or the first visible crack in the pay-per-token model underneath AI coding tools?
How Uber Burned a Year's AI Budget in Four Months
By the end of April, Uber had spent its full 2026 AI budget. Four months in, the money was gone.
The trigger was scale, and it arrived fast. According to the analysis, 95% of Uber's engineering team had adopted Claude Code and Cursor and started running heavy workloads through them. Rolling agentic tools out to nearly everyone at once multiplies token spend by headcount, and agentic workflows consume tokens at a rate the autocomplete era never prepared budgets for.
An agentic coding tool reasons through a task: it plans steps, reads files, writes code, checks its own output, and loops back to fix what it got wrong. Every one of those steps is a model call, and every model call bills on tokens in and tokens out. A single developer poking at a tricky refactor for an afternoon can rack up a bill that would once have covered a month of IDE tooling.
Frontier reasoning models price at up to $30 per million input tokens, and reasoning-heavy agentic workflows lean on exactly those models. Multiply that rate by an engineer running the agent loop dozens of times a day, across a near-universal rollout, and per-developer bills reaching as high as $2,000 a month become the predictable output of the pricing model.
What arrived instead of a predictable line item was constant, reasoning-heavy, agent-driven workload across nearly the whole engineering org. Per the report, Uber is now back at the drawing board on how it budgets for developer tools.
Microsoft's Claude Code Exit
Microsoft canceled the majority of internal Claude Code licenses inside its Experiences and Devices division, effective June 30, 2026. The stated reason wasn't a security review or a vendor dispute. It was the recurring bill, as coverage of the cutback put it plainly: the bill got too big.
The migration path is worth pausing on. Teams were pointed at GitHub Copilot CLI, which the company already owns. That isn't an escape from the token tax: it's a trillion-dollar company moving spend from one meter to a meter it controls end to end.
Read past the internal reshuffling and the signal reaches beyond one org chart. Microsoft can negotiate better token rates than almost anyone on the planet, and it still walked away from a third-party metered tool for its own developers. Every smaller engineering org running the same math on its Claude Code or Cursor spend now has that data point sitting in front of it.
Why Cloud AI Billing Keeps Getting More Expensive
Average enterprise monthly AI spend went from $63,000 in 2024 to $85,500 in 2025, an increase of over 35% in a single year. The 2026 projection puts that figure above $115,000 a month. The share of organizations spending over $100,000 a month doubled in 2025 and is on track to triple in 2026, so the high end of the distribution is filling up faster than the average is climbing.
Agentic tools generate far more calls per task than the chat-window tools most of those budgets were built around, and each call is metered in both directions. An agent might make a dozen calls to accomplish what a developer once did in a single edit. Spread that across a workforce rollout instead of a pilot group, and the monthly number stops looking like a tooling cost and starts looking like a payroll line.
The cost explosion tracks the billing structure underneath the models rather than the models themselves: a better, cheaper model on the same per-token scheme still meters every planning step and every self-correction. The era of unmonitored API calls is ending because usage-based billing scales with agent activity, and agent activity grows much faster than headcount.
Uber and Microsoft are early movers reacting to that structure, and every enterprise running agentic coding tools at real headcount is exposed to it. Whatever the next model release scores on a benchmark, the billing math that produced $85,500-a-month averages in 2025 stays the same.
OpenCode's Rapid Rise
While Uber's finance team was staring at April's bill and Microsoft was drafting cancellation memos, developers had already started voting with their terminals. OpenCode's monthly active users went from 650,000 to 6.5 million, a tenfold jump. The project's GitHub repository has crossed 124,000 stars, putting it in second place among agentic coding harnesses worldwide.
OpenCode has become the visible alternative for workforces deciding the metered version of the tool no longer justifies its bill.
The mechanism is simple: a hosted model meters every call, while OpenCode routes inference onto the developer's own machine. You pay upfront for capable hardware, and after that each generation costs electricity and depreciation instead of tokens. The pitch is fixed cost once versus a meter that runs every time the agent thinks, and Uber's engineers were living the metered side of that math at up to $2,000 a month per head.
Nothing here says a local model on developer hardware matches Claude Code or Cursor for output quality, and nothing measures how local inference latency stacks up against a cloud round-trip. What's on record is adoption: a tenfold jump in users and a top-two star count, arriving in the same stretch of 2026 that Uber and Microsoft spent pulling back from cloud billing. Developers aren't waiting for a benchmark study before they route around a bill they don't like.
The same request, two cost structures: cloud inference bills per token on every step, while local inference replaces the meter with a fixed hardware cost.
What Comes After the Token Tax
Uber and Microsoft both run balance sheets where a $2,000-a-month developer bill should be rounding error, and both hit the same wall anyway. The shared wall is the billing structure: meter every token, in and out, on every step, and the bill scales with how much the agent thinks rather than how much value it delivers.
The durable fix is architectural. Moving inference off the per-token meter and onto local or edge hardware changes what you're paying for: a fixed cost for silicon, then generations at the cost of electricity. That's the OpenCode bet, and it's why a tenfold jump in monthly active users happened in the same year one giant canceled licenses and the other tore up its budget plan over the same problem.
Until your team makes that call, four moves keep the meter honest this quarter:
- Set spend alerts and per-team caps now, before the quarter closes, so the April-surprise pattern can't happen to you.
- Ask your vendor about seat-based or committed-use pricing. Metered API rates are the most expensive way to buy heavy, predictable usage.
- Route mechanical work to cheaper models. Renames, boilerplate, and test scaffolds don't need a frontier reasoning model; save the expensive tokens for the problems that do.
- Track cost per developer monthly, with one line of arithmetic:
Monthly AI coding spend ÷ active engineers using the tool = cost per developer
Whether Microsoft's cancellation and Uber's budget rebuild mark the start of a permanent shift away from usage-based billing, or just a correction that vendors price back in, is still open. Your own spreadsheet answers a nearer question. If your per-developer number is trending toward Uber's, you're already in this story.
Top comments (0)