Your Copilot and Cursor seats are approved. Adoption is climbing, engineers are shipping, the dashboards look healthy. Then the invoice changes shape. What used to be a flat seat fee is now metered by the token, and it moves with every prompt your team sends. Your first instinct is to cap usage and switch on spend alerts. That instinct may be a mistake.
This is not hypothetical. Uber's CTO told The Information his organization burned through its entire planned 2026 AI coding budget in four months, with individual engineers spending 500 to 2,000 dollars a month on tokens. Microsoft answered the same math by pulling most Claude Code licenses from its Experiences and Devices division. Two of the most sophisticated engineering organizations on the planet, and their first public responses to metered AI were a blown budget and a retreat.
So the decision in front of you is not "how do we cut the AI bill." It is "are we treating tokens as a cost to suppress, or as capital to compound?" Get it wrong and you either starve your best people or fund theater. Get it right and every token buys both an outcome today and an asset tomorrow.
Building the AI-DLC harness at Betsson, I saw the same type of tasks task run in two different ways: one setup burned ten times the tokens of the other and produced similar to worse results, purely because of how context was fed, which model was chosen, and constraints provided.
Cost is a design outcome, not a usage number. That is why engineering the system around the model is the right answer.
Why the bill went variable
For a while, AI in the IDE felt free; flat subscriptions hid the cost of inference and vendors absorbed the difference. That era is over. Cursor now prices agent requests by the token, against API rates, GitHub paused new Copilot sign-ups when agentic workloads outran plan prices, and from June 2026 every Copilot plan is billed in metered AI Credits computed from token consumption. The reason is architectural, not commercial. Autocomplete used a narrow context at predictable cost; agentic tools ingest whole directory trees and run plan, edit, test, retry loops, and because the models are stateless the full transcript is re-sent each turn. A quick question and a multi-hour autonomous run can no longer rationally cost the same. For scale: Anthropic's own enterprise figures put Claude Code at around 13 dollars per active developer-day, a figure it recently doubled as usage deepened.
Cap or not to cap ?
Faced with a variable bill, most organizations pick one of two reactions, and both repeat the mistake I described in The Velocity Trap: they manage the number that is easy to count, tokens, instead of the value those tokens produce.
When you cap the limits blindly it generates a "token anxiety".
Engineers start thinking in cost-per-prompt, hesitate to hand the agent a hard problem, and write boilerplate by hand to save credits. You bought leverage, then taught people to be afraid to use it.
The way out is to change what you count. The right model is not the cheapest per token; it is the cheapest per successful outcome. Report spend in dollars against something that shipped: cost per merged PR, with at least two guardrail metrics - PR size and revert rate - so nobody splits work or merges junk to move the number.
But do not mistake the gauge for the engine. The numbers will tell you whether things are improving or not, but what improves them is the system around the model.
Tokens that compound
Once the unit is an outcome, the goal stops being fewer tokens used and becomes fewer tokens wasted.
And don;t take me wrong you need to have caps and governance, but those should be bounded by the value it genereates.
Then comes the part the cost conversation misses. Satya Nadella calls it token capital: the AI-embodied knowledge a firm owns and compounds, a factor of production beside human capital. The test he sets is sharp:
can you say what, from last night's work, became knowledge your firm now owns?
The tokens you spend need not evaporate into a vendor invoice. The traces they leave, how specs become working software, which prompts and checks pass your gate, can be captured, owned, and used to make the next cycle cheaper.
Rent the intelligence, own the memory and the harness.
Six moves that raise return on every token
1. Instrument telemetry, so every token has an owner. The invoice tells you nothing about where the tokens went. Use the telemetry your IDEs and agent tools already emit, route requests through a gateway that attributes each one to a user, session, model and task, and read transcripts, not just dashboards. Feed it into one honest number: cost per merged PR in dollars. Pitfall: publishing raw consumption with no outcome beside it. Signal: every dollar maps to a user, a task and a shipped change.
2. Fix defaults and routing before you touch caps. Do not use frontier models for non-frontier problems. Default your gateway to a strong mid-tier model and let engineers escalate by choice; route by step, a frontier model for planning, cheaper models for execution. In practice that is as simple as running sweeps on a Sonnet-class model and reaching for the top model only at the hard junctures. Honor the floor: if a task needs real intelligence, a larger model at low effort usually beats a small model straining at high effort. Pitfall: forcing model choice onto people; better defaults beat mandates. Signal: most calls served by non-frontier models with quality holding on your evals.
3. Treat caching as a first-class discipline. Cache the stable prefix so repeated context is read back cheaply; cached reads cost around 90 percent less than base input tokens. Put durable content at the front, rules files, system context, tool definitions, long examples, and keep it immutable and append-only. The classic cache-breaker is a datetime variable in the system prompt that ticks every turn and silently invalidates everything behind it. Measure your hit rate, which the APIs return, and climb it. Pitfall: dynamic values inside the cached prefix. Signal: hit rate at 80 percent and above.
4. Keep context lean, and bound the worst case. Every token in context is one you pay to re-read, and the dominant waste event is the runaway loop: a blind agent re-submitting the same failing fix with the full transcript each turn. Open fresh sessions per task, scope file context narrowly, and disconnect tools you are not using. Then add circuit breakers in the gateway that trip on repeated identical errors, on iterations without a repository change, or on a spend spike against the session median, plus hard-stop wallets that refuse calls at budget zero. Pitfall: compacting context endlessly instead of resetting. Signal: no session able to exceed its wallet.
5. Compound what you spend into token capital. Persist the artifacts of each cycle, the machine-ready specs, the prompts and checks that passed your gate, the traces of how work got done, into owned memory and your knowledge base, the compounding argument of Continuous Fluid Flow. Over time you can tune a smaller model on your own traces until it beats a prompted frontier model on repeatable workflows. Pitfall: letting hard-won knowledge leak into vendor logs you do not control. Signal: repeat tasks getting cheaper cycle over cycle.
6. Make all of it legible to engineers. None of this survives a team that does not understand it, and metered pricing turns cost intuition into a skill. Teach it directly: prompting that reduces ambiguity, context management, decomposing work into small testable steps. Invest hours, not just licenses, and promote power users as AI Champions, chosen by delivery impact rather than consumption. Pitfall: mistaking the loudest token-burner for the best practitioner. Signal: the median engineer working fluently inside the guardrails.
What to fund: the harness, not the caps
The thing worth funding is not a tighter set of limits. It is the harness, everything around the model: the gateway and router, the workflows that break work into small checkable steps, the skills that carry your conventions, and underneath it all a structured knowledge base. That last piece is where most waste hides. If agents retrieve loosely, they pull in tokens they do not need and reason over noise, the cost side of the case I made in Your Coding Agents Are Drowning in Context: knowledge modeled once and retrieved precisely is both more accurate and far cheaper than re-reading everything on every call.
Sequence the build. Fund first the three cheapest, highest-return moves: telemetry, caching discipline, and default routing; they pay back inside a quarter. Fund next the knowledge base and the skills that scope context precisely. Fund later the heavier bets, local-first inference and distilling your own models on your traces. The gauge that proves or kills the program within a quarter is cost per merged PR: falling while revert rate stays flat and usage grows means the harness is earning its keep. If the only lever you pull is a cap, you are choosing Uber's surprise or Microsoft's retreat, just slower.
Start, Stop, Continue
For executives. Start measuring cost per merged PR in dollars, and ask in every review what the last cycle added to your token capital. Stop the consumption leaderboards and blanket caps; both cost more than they save. Continue funding the harness and the knowledge base as infrastructure, not a one-off project.
For engineers. Start writing append-only prompts, opening fresh sessions per task, and reading your own transcripts. Stop hand-writing boilerplate out of token anxiety, and stop leaving datetime variables in cached prefixes. Continue delegating hard problems to the agent and feeding what works back into shared context.
The strategic takeaway
Suppression plateaus fast. What compounds is the infrastructure: routing that keeps getting smarter, caches that keep getting warmer, and a knowledge base that turns each cycle into a cheaper next one. That gap widens every month, because usage is rising either way. The only real question is whether your spend is buying assets or just buying invoices.
So borrow Nadella's question and make it your own. What is your token capital, and what did last week's work add to it? If you cannot answer, you are renting the intelligence and letting the memory leak. Are you managing tokens as a cost to suppress, or as capital to compound? I would rather be argued with than applauded, so push back, and repost this to the leader whose AI bill just went variable.
Top comments (0)