Tokens Are the New Egress Bill

Uber, Walmart, Amazon, Meta and Nvidia just taught us the same lesson cloud computing did a decade ago: the surprise isn’t the unit price. It’s that nobody was watching the meter.

Token Usage — Anyone watching?

In April 2026, Uber’s CTO admitted the company had burned through its entire annual AI budget for coding tools in four months. The detail that stuck with me wasn’t the budget. It was a single demo: an executive reportedly torched around $1,200 in tokens during a two-hour internal session, and a colleague described learning the number as a “head-exploding moment.”

That is the whole story of AI cost in 2026, compressed into two hours. Not “AI is too expensive.” Not “AI is worth every penny.” Just: nobody saw it coming, because nobody was looking at the meter.

This post isn’t an argument for using more AI or less. Plenty of smart people are loudly making both cases, and I’ll get to them. It’s an argument for the boring thing in the middle that almost everyone skipped on the way to their first big bill: visibility. Know what you’re spending, know why, and stop being surprised.

The caps are arriving, all at once

Within a single week at the start of June 2026, three of the most AI-aggressive companies on earth quietly put up fences.

Uber set a $1,500 monthly cap per employee, per agentic coding tool — Claude Code, Cursor, and the like counted separately. Crucially, it’s not a blunt block. Every employee gets a dashboard that tracks usage across tools, and you can request to exceed the cap with approval. Uber framed it as a reasonable way to keep encouraging adoption without flying blind. This is the same company that, a few months earlier, told staff to use AI “as much as possible” and ran competitive internal leaderboards. The budget had been set in 2025, before anyone knew how hungry agentic coding tools would turn out to be.

Walmart ended unlimited access to Code Puppy, its in-house assistant for spreadsheets and presentations, and switched to a fixed token allocation per employee — after demand “far exceeded expectations.” Employees keep access to Claude and ChatGPT on the side. The stock dipped on the news, which tells you the market is now reading internal AI cost discipline as a signal.

Amazon went further and killed the incentive itself. Its internal KiroRank leaderboard ranked developers by token usage on the Kiro platform — until employees started pointing AI agents at pointless tasks just to climb it, running up cloud costs for nothing. A senior VP’s memo landed with a thud heard across the industry: “Please don’t use AI just for the sake of using AI.” Amazon retired the leaderboard and moved to a metric it calls “normalized deployments” — an attempt to measure useful AI work instead of raw volume.

If you’ve ever taken a stats class, you already know the name for what happened to Amazon: Goodhart’s Law. When a measure becomes a target, it stops being a good measure. Token counts make a terrible target and a useful gauge, and the difference between those two sentences is the entire ballgame.

And the burn stories keep coming

The caps are a reaction to genuine sticker shock, and the numbers are wild once you go looking.

At Uber, roughly 5,000 engineers were running monthly usage rates between 84% and 95%, with per-engineer bills ranging from $150 to $2,000. At Meta, an employee-built leaderboard called Claudeonomics — yes, named after Claude — ranked all ~85,000 employees by token consumption, complete with gamified titles like “Token Legend” and “Cache Wizard.” In a single 30-day window, Meta employees collectively consumed over 60 trillion tokens, with the top individual user reportedly on the order of 281 billion tokens for the month. One widely-cited back-of-envelope estimate put the list-price value of that month at around $9 billion. (Take that figure as an order-of-magnitude estimate, not an invoice — but even being generous, it’s a staggering number.)

The kicker: some employees left AI agents running idle for hours purely to pad their ranking. Meta took the dashboard down within about 48 hours of the data leaking externally. The Pragmatic Engineer’s Gergely Orosz gave the behavior its perfect name — tokenmaxxing — and the verdict that goes with it: great for AI vendors, bad for everyone else.

Meanwhile, the other camp wants you to spend more

Here’s where it gets genuinely interesting, because the loudest voices in tech are pulling in the opposite direction at the exact same moment.

At Nvidia’s GTC 2026, Jensen Huang laid out a thought experiment that’s been quoted everywhere since: take a software engineer or AI researcher you pay $500,000 a year. At year-end, Huang says, he’ll ask how much they spent in tokens — and if the answer is $5,000, in his words, he’ll “go ape something else.” His benchmark is that a $500K engineer should be consuming at least $250K in tokens annually. Asked whether Nvidia is trying to spend ~$2 billion a year on tokens for its engineering team, his answer was simply: they’re trying to. He compares an engineer who underuses AI to a chip designer insisting on paper and pencil instead of CAD tools.

Meta’s CTO Andrew Bosworth made a similar case earlier in the year: one of Meta’s top engineers spends roughly his entire salary on tokens and is, by Bosworth’s account, about 10x more productive for it. He called it a no-brainer with no upper limit. Meta has since tied “AI-driven impact” to performance reviews as a core expectation. And Sam Altman has floated the most expansive version of all — a future where AI compute is so foundational it becomes a kind of universal basic resource people could spend or sell.

So one set of leaders is installing fences and another is handing out bigger fuel tanks as a recruiting perk. Both can’t be wrong — and they aren’t. They’re answering different questions. “Should my best people have abundant compute?” is a strategy question. “Did we just spend $9 billion of compute and can we point to what it produced?” is an accounting question. The companies getting burned aren’t the ones who chose abundance or restraint. They’re the ones who never built the instrument that connects the two.

We have seen this exact movie before: the cloud bill

If all of this feels familiar, it should. We lived through it once already, with the cloud.

The pitch for cloud was simple and seductive: stop buying servers, pay only for what you use. And the number everyone anchored on was storage — pennies per gigabyte, cheap and legible. So that’s what people budgeted for.

Then the first real bill arrived, and there was a line item nobody had modeled: egress. Data transfer out. Ingress — data flowing into the cloud — is typically free. But moving data back out, between regions, across availability zones, or to the public internet, is metered, variable, and effectively unbounded. For analytics, media, and customer-facing workloads, egress routinely matches or exceeds the storage bill it was supposed to be a footnote to. Gartner has pegged egress at 10–15% of total cloud spend, climbing toward 40% in bad cases. Whole cloud bills overshoot forecasts by 30–40% — not because storage grew, but because data moved.

My favorite illustration: one company grew its user base 10x in six months. Compute and storage rose a sensible ~3x. Egress jumped more than 15x — from $400 a month to $6,200 — because each new user wasn’t just present, they were pulling more data, more often, from more places. The cost scaled with a dimension nobody was watching.

Tokens map onto this almost perfectly:

• Output tokens are your storage line — small, visible, the number you instinctively reach for.
• Input and context tokens are your egress — they scale with how much you feed the model, how long your sessions run, how many agents you fan out, and how often the whole context gets reloaded. At the scale of an agentic workflow, that’s where the bill actually lives.

And the fix is the same in both worlds. In the cloud, you tamed egress with caching, CDNs, and compression — keeping data close so you didn’t pay to move it repeatedly. In AI, the equivalent is prompt caching: don’t re-pay full price to re-read the same context on every turn. Which brings me to my own meter.

Input vs Output Tokens

What 100 million tokens a day actually looks like

I run a fairly serious homelab and a stack of agentic systems, and I track my token usage obsessively — partly by temperament, partly because the tooling now puts a live fuel gauge right in front of me. Here are few real sessions from my coding agent over two days this week:

2026-06-04 · gpt-5.5 · 39.2M in · 154K out
  total billable: 2,166,965  | uncached input: 2,012,800  | cached: 37,153,536  
  | output: 154,165

2026-06-04 · gpt-5.5 · 24.6M in · 101K out
  total billable: 1,393,686  | uncached input: 1,293,042  | cached: 23,338,240
  | output: 100,644

2026-06-05 · gpt-5.5 · 38.9M in · 121K out
  total billable: 2,009,139  | uncached input: 1,887,834  | cached: 36,984,320
  | output: 121,305

2026-06-05 · gpt-5.5 · 51.8M in · 140K out
  total billable: 2,252,471  | uncached input: 2,112,007  | cached: 49,682,816
  | output: 140,464

2026-06-05 · gpt-5.5 · 39.5M in · 90K out
  total billable: 1,703,324  | uncached input: 1,612,814  | cached: 37,858,944
  | output: 90,510

On June 5th, those 3 sessions alone moved ~130 million input tokens through the model. Compared to Input tokens, out tokens are a fraction but billed at much higher rate. But even with higher rate, output is the storage line. It’s a rounding error.

Now look at the split that matters. Of roughly 195 million input tokens across these five sessions, about 185 million — over 95% — were cache reads. Cached tokens are billed at a steep discount to fresh input (often on the order of a tenth of the price, depending on provider and cache window). So my effective billable input is a small fraction of that 195M headline.

Here’s the honest part: without caching, I could not afford to work this way. If every one of those 195 million cached tokens were billed at full input price, my input cost would be roughly an order of magnitude higher — and a personal homelab budget simply doesn’t survive that. Caching isn’t a nice-to-have optimization for me; it’s the only reason the whole thing is economically possible. It’s my CDN.

On a subscription plan, the real constraint often isn’t dollars-per-token at all — it’s rolling-window rate limits. The provider is already showing me a budget gauge for time, the way the AWS console eventually started screaming about data transfer. Even though I am using subscription plan, not paying by API, I still wanted to see how it would look like for a given session:

Session Token Cost

What to actually do about it

None of this is an argument against using AI heavily. I use it heavily. It’s an argument against being surprised — and the surprise is entirely optional.

A few things worth instrumenting before you scale, not after the bill:

1. Meter cached vs. uncached separately. A few hundred million-token day is terrifying or trivial depending on the cache-hit ratio, and a single headline number hides exactly the thing you need to manage.
2. Treat token volume as a gauge, not a target. The moment it becomes a leaderboard or a review metric, you’ve invented tokenmaxxing and idle-agent theater. Ask Amazon. Correlate spend with outcomes — shipped features, resolved tickets, throughput — or you’re measuring the activity of measuring.
3. Prefer soft alerts to hard walls. Uber’s model is the sane one: a default cap, a dashboard everyone can see, and a documented path to exceed it with a reason. Visibility plus a release valve beats a brick wall.
4. Budget for egress, not storage. Your forecast should be dominated by input and context growth — long sessions, fan-out agents, context reloads — not the tidy output number. Model the line item that actually scales.

Token Usage Visibility

The companies making headlines this spring didn’t fail because AI is too expensive or because their people used it too much. They failed because they bought a usage-based product on a fixed-budget assumption and didn’t build the meter until the meter built itself, in public, in the form of a budget exhausted in four months.

The cloud taught us this lesson with egress charges. We’re paying tuition for the same class again, in tokens. The good news is the syllabus hasn’t changed: watch the meter, separate the cheap line from the scary one, and tie what you spend to what you ship. Do that, and you get to decide whether to spend more or less — instead of finding out, two hours into a demo, that the decision already got made for you.

Thanks!