Why Microsoft Dropped Claude Code and Uber Ran Out of AI Budget

On May 15, 2026, Microsoft sent an internal note to its engineering organisation: every Claude Code license would be cancelled by June 30, and developers would be migrated to GitHub Copilot CLI. Six weeks earlier, on the other side of the country, Uber's CTO Praveen Neppalli Naga had quietly informed leadership that the company had exhausted its full-year 2026 AI budget in four months. The two events are not coincidental. They are the first publicly legible signs that agentic AI tool cost management has overtaken model capability as the binding constraint on enterprise adoption.

The pattern is consistent across both incidents. A coding tool gains rapid internal traction. Per-engineer spend rises from low triple digits to four figures monthly. Finance discovers the existing software-procurement framework cannot price the consumption. A reversal follows. Understanding why this pattern is now structural — and not a quirk of two outlier companies — requires unpacking the cost mechanics underneath the agentic-loop workflow.

The shift from seat economics to token economics

Enterprise software procurement has, for two decades, assumed a roughly linear relationship between headcount and software cost. A SaaS seat costs a fixed amount per user per month. Spend grows when hiring grows. Finance teams plan against this assumption, and the variance is small enough that quarterly true-ups absorb it.

Agentic coding tools violate this assumption at the unit level. The cost driver is not the engineer; it is the engineer's token consumption pattern, and that pattern varies by one to three orders of magnitude between users on the same nominal license. One engineer running short, well-scoped prompts may consume 10,000 tokens a day. A second engineer running agentic loop workflows — where the model plans, calls tools, observes results, and re-plans — can consume 10 million tokens in the same day. Gartner's March 2026 analysis pegged agentic workflows at five to thirty times the token cost of a single-turn chat exchange, with longer-horizon planning tasks at the upper end.

This is the gap that Uber walked into. Claude Code was introduced internally in December 2025, when 32% of engineers were already using it. By February, that had grown to 63%. By March, 84% were classified as agentic users, meaning the dominant workload had shifted from one-shot completions to multi-step task execution. Per-engineer monthly API costs settled in the $500-to-$2,000 range, with no FinOps playbook in place to allocate, attribute, or cap the variance.

Why finance cannot back-fit the old model

The natural reaction is to impose per-user spending caps and call the problem solved. This works only if the work being done is also capped, which agentic workflows are not. A senior engineer using Cursor or Windsurf to refactor a service across forty files will, by design, consume more tokens than a junior writing a single function. Capping the senior penalises the higher-leverage work. Capping by team aggregates the same problem one level up. The cost is genuinely variable, and the variance correlates with output value, which makes flat caps a strictly worse instrument than usage-aware budgeting.

Tool-call amplification and the agentic loop

The mechanism underneath the cost explosion has a name in the literature: tool-call amplification. A standard chat completion is one prompt and one response. An agentic loop is a different shape — the model emits a tool call, receives the tool's output, incorporates that output into its working context, and emits the next call. A non-trivial task — say, "fix the failing test in module X and update the docs" — routinely triggers ten to twenty such round trips. Each round trip pays for both the input context (now growing as outputs accumulate) and the output tokens.

Two compounding effects make this worse than a naive ten-to-twenty multiplier. First, context-window economics: each iteration includes the full prior conversation, so token cost grows roughly quadratically with loop depth rather than linearly. Second, modern coding agents inline file contents, test output, type signatures, and search results into the working context, meaning a single round trip can carry tens of thousands of tokens of grounding material that wasn't there in chat-mode workflows.

Where the amplification lands hardest

Three workload patterns drive disproportionate cost:

• Whole-repository reasoning — where the agent loads file trees and runs symbolic search across a large codebase before acting. Tools like Augment Code and Greptile are explicitly built around this pattern, which is genuinely useful but token-heavy.
• Test-driven iteration — where the agent writes code, runs tests, parses failures, and tries again. The failure output is itself token-expensive when it includes stack traces from a real codebase.
• Long-horizon planning — where an agent like Devin AI decomposes a feature request into a multi-hour plan, each step of which is itself an agentic sub-loop.

The Uber data — surfaced through the CTO's leadership memo and a subsequent Yahoo Finance report — places monthly per-engineer cost between $500 and $2,000. The bottom of that range describes light or single-shot users. The top describes engineers running long-horizon agentic workflows continuously through the working day. Both populations carry the same nominal license. The 4x cost spread within a single seat type is, structurally, what no per-seat budgeting framework was designed to absorb.

Microsoft's exit is a different story

The Microsoft case looks superficially similar but has different mechanics. Claude Code reached Microsoft's developer organisation in December 2025 and spread organically. Internal sentiment, according to coverage in Windows Central and The Information, ran strongly in favour of Claude Code over the in-house Copilot CLI. The June 30 deadline was framed publicly as a strategic alignment — Copilot CLI gives Microsoft a product surface it controls — but the timing aligns with the Microsoft fiscal year-end, which is the standard moment for cutting external software spend before the new budget cycle.

This is not a case of running out of money mid-cycle. It is a case of a hyperscaler with a competing first-party product deciding that the strategic and commercial cost of paying a rival ecosystem for the developer surface outweighs the productivity premium engineers reported. The Microsoft-Anthropic commercial relationship — including the November 2025 Foundry agreement and Claude availability inside Microsoft 365 Copilot — stays intact. Only the direct-license relationship for internal use is being severed.

The shared signal beneath two different decisions

What links the two cases is not the budgeting mechanism but the underlying observation: organic developer demand for the best available agentic coding tool will, absent active cost governance, produce a spend trajectory that exceeds what either finance or strategic procurement is prepared to absorb. Uber discovered this through a budget overrun. Microsoft discovered it through a strategic re-evaluation. Both ended in the same place — a forced migration off the tool engineers preferred.

A methodology for measuring agentic spend

Most enterprise cost-management frameworks are built around fixed inputs. Agentic AI requires the inverse: measurement-first governance, where the cost framework is rebuilt around the variance itself. The following five-step methodology is drawn from how FinOps teams who have weathered the first year of agentic adoption are approaching the problem.

1. Instrument at the request level, not the seat level. Every agent invocation should emit a trace with token-in, token-out, model identifier, tool calls, and the originating engineer or team. Without this, attribution is impossible and any subsequent governance reduces to flat caps.
2. Distinguish exploratory loops from production loops. An engineer iterating on a refactor is a different workload than a CI/CD pipeline running an agentic linter on every commit. The first has bounded human attention as a natural throttle; the second runs at the rate of merges and can run away invisibly.
3. Set budgets at the workflow level, not the user level. "This refactoring workflow gets X tokens per invocation, escalating to human approval beyond Y" is enforceable. "This engineer gets X tokens per month" punishes high-leverage work and creates incentives to hoard budget.
4. Route by task class. Not every step in an agentic loop needs the strongest model. Sub-steps that involve summarisation, classification, or rote reformatting can run on smaller or cheaper models. Routing alone reduces typical enterprise agentic spend by 30–50%, per CloudZero's 2026 inference-cost analysis.
5. Treat caching as a first-class architectural concern. Semantic and prefix caching, especially for repeated repository context, reclaims a meaningful fraction of spend in workflows that traverse the same codebase repeatedly. Tools like Continue and Cline expose cache controls that, used deliberately, change the cost curve materially.

None of these steps are exotic. What is novel is the requirement to implement them simultaneously and before the spend curve has run away — which is precisely what Uber's case shows is hard to do when adoption outpaces governance.

The empirical landscape of pricing models

Vendor pricing in the agentic coding space splits along three axes: per-seat, per-token, and outcome-based hybrids. Each carries a different risk profile for the buyer.

Per-seat pricing — the model used by Cursor AI at its individual tier, and by GitHub Copilot historically — caps the buyer's downside but caps the vendor's upside, which is why most vendors have introduced consumption add-ons for heavier workloads. Per-token pricing — the model that powers Claude Code's enterprise contract, and which is the proximate cause of Uber's overrun — aligns vendor revenue with usage but transfers all variance risk to the buyer. Outcome-based or hybrid pricing remains rare; the contracting complexity has so far kept it confined to bespoke enterprise deals.

The market is correcting in two directions at once. Buyers who experienced 2026's overruns are pushing for usage caps, monthly true-ups, and committed-spend discounts. Vendors are introducing prompt-cache discounts (typically 50-90% off cached input tokens) that materially reduce per-invocation cost for repetitive agentic workflows but do not change the underlying variance.

A taxonomy worth tracking

Three categories of tooling are emerging in response to the cost problem itself, not just the productivity opportunity:

• Gateways and routers — middleware that classifies a request and dispatches it to the cheapest viable model. Often paired with prompt caching and content filtering.
• Attribution layers — observability tooling that breaks down token spend by team, project, and workflow. The CFO-facing analogue of APM.
• Policy engines — components that intercept agent invocations and apply budget, escalation, or model-selection rules before the call reaches the model API.

None of these existed in mature form a year ago. The fact that they are now being procured separately from the underlying coding tool is itself evidence that the cost problem has crossed from "edge case" to "structural feature" of agentic adoption.

Limitations and edge cases

The framing above treats Uber and Microsoft as canonical, and there is some risk in generalising from two data points. Three counterweights deserve attention.

First, both companies are unusually large engineering organisations with unusually concentrated coding-tool spend. A 500-engineer firm running the same tools will not see the same absolute numbers, and may not trigger the same governance crisis. The qualitative pattern — variance exceeding the budgeting framework's tolerance — recurs at smaller scales, but the magnitude does not.

Second, the productivity premium is real and often goes uncounted on the same balance sheet as the API spend. Uber's CTO's memo, even while declaring the budget overrun, noted that 70% of committed code now originates from AI tooling. If that 70% is genuinely accelerating delivery, the appropriate counter-question is not "why is the AI bill so large" but "what is the marginal output of the next dollar of token spend versus the next dollar of engineering headcount." Neither company has published that calculation.

Third, model pricing is falling. Inference cost per equivalent benchmark has dropped by between 9x and 900x year-over-year, depending on capability tier. Some of this year's overruns will be next year's amortised line items. The structural challenge — variance management, attribution, governance — will persist even if the unit price stabilises.

Open questions for the next budget cycle

Two questions are worth carrying forward into the next twelve months of enterprise procurement discussions.

The first is whether per-engineer token budgets can be made to work without distorting work allocation. The simplest forms of budget — flat monthly caps — push engineers to under-use the tool, defeating the productivity premium that justified the spend. More sophisticated forms — workflow-level budgets, escalation-based approval — require infrastructure that most organisations have not built.

The second is whether the vendor side will absorb some of the variance risk. The early signals point in this direction: prompt-cache discounts, committed-spend tiers, and enterprise contracts with monthly spend ceilings have all appeared in 2026 vendor terms that did not exist in 2025. None of them yet match the predictability of a per-seat contract, and it is unclear whether they can without re-introducing the seat-pricing distortion the vendors are trying to escape.

A third question sits underneath both: whether the productivity gains attributed to agentic coding tools survive aggressive cost controls. If routing, caching, and workflow-level budgets clip 30-50% off spend without measurable degradation in shipped output, the governance overhead pays for itself. If they clip a similar fraction off the output, the optimisation is illusory. The honest answer is that the controlled studies do not yet exist, and the available evidence comes from organisations whose incentive is to justify the spend they already made.

For a team budgeting for agentic coding tools in the next quarter, the durable lesson is narrower than either Uber's or Microsoft's: instrument before you scale, and treat token attribution as a prerequisite for adoption rather than a fix applied after the spend has run away. The two organisations now most cited in this space arrived at that conclusion the expensive way. The teams writing their procurement documents this quarter have a brief, unrepeatable advantage in arriving at it cheaply.