Token spend reality check: when 1T tokens a month is rational, and when it's theater

AI token spend of a trillion tokens a month is rational when three things are true: the tokens are mostly cheap cache reads from long autonomous sessions, every token rolls up into work someone actually accepted, and the bill is smaller than the human labor that work would otherwise cost. Take away any one of those and you are looking at productivity theater with an invoice attached.

Lifters have a name for sets that add fatigue without adding stimulus: junk volume. You leave the gym exhausted, your training log looks heroic, and nothing grows. I kept thinking about that phrase all week while watching the AI world argue about token bills, because a token leaderboard is a training log that only counts sets.

Is spending 1 trillion tokens a month ever rational?

Yes, but only when the spend has a denominator. A trillion tokens is rational if it produces accepted work that would cost more in salaried time, at a blended rate dominated by cache reads. Without an outcome attached, the same number is just activity, and activity is the easiest thing in the world to inflate.

The case that started this round of the argument is a real one. In his video the hard truth about token spend, Theo Browne picks apart a viral calculation about a Cursor engineer whose public profile showed 1.5 trillion tokens in 30 days. Someone priced that at a flat $8 per million and got $132 million a year. Theo’s argument is that the flat rate is the whole mistake, and his verdict on the real cost is blunt: “Is it worth a mill or two a month? Without question.”

He is right about the arithmetic. What the arithmetic cannot tell you is whether the next trillion is worth it for your team.

What does a trillion tokens actually cost?

Somewhere between about $200,000 and $8 million a month, and the spread is almost entirely the blended rate. Agentic coding traffic is mostly cache reads, which cost a small fraction of fresh input or output. Price the whole bucket at output rates and you overstate the bill by an order of magnitude or more.

Theo’s own numbers make the point. He works almost entirely on Opus 5.5, nominally $5 per million input and $25 per million output tokens, yet his blended cost comes out to 41 cents per million because cache reads at 20 cents per million make up about half his spend. Jellyfish’s figures imply a different rate again: the median developer in its Q1 2026 data used about 51 million tokens a month for about $52.38, priced at published Claude API rates.

One trillion tokens at four rates

Here is what one trillion tokens a month looks like at each of those rates. The rates come from the sources above; the multiplication is mine.

Blended rate per million tokens	Where the rate comes from	Monthly cost of 1T tokens
$8.00	The flat rate in the viral calculation	$8,000,000
~$1.03	Jellyfish median ($52.38 for 51M tokens)	~$1,030,000
$0.41	Theo’s own blended Opus 5.5 rate	$410,000
$0.20	Cache-read price alone	$200,000

What a trillion-token bill has to buy

For scale, one widely shared breakdown of Meta’s internal spend used a loaded cost of $300,000 per engineer per year, which is $25,000 a month. Even at the cheapest row, a trillion tokens has to buy roughly eight engineers’ worth of accepted output every month to break even. That is the real bar. Whether the number looks scary on a slide is beside the point; the question a CFO should ask is whether the team shipped eight extra engineers of work last month.

Why does more token spend stop buying more output?

Because output per token falls off steeply at the top. Jellyfish’s Q1 2026 study of 12,000 developers across 200 companies found the top decile using roughly 10x the tokens of the median for about 2x the merged output. The marginal trillion buys far less than the first one did.

What the Jellyfish developer data shows

The detail is in Jellyfish’s own write-up and an interview with its head of research, Nicholas Arcolano. Throughput rose from about 0.77 merged PRs a week at the low end to 2.15 at the high end. But the median developer needed about 7 million tokens per PR, while the top decile needed about 69 million. Priced out, cost per merged PR ran from $0.28 in the lowest usage tier to $89.32 in the highest.

One limitation worth naming: merged PRs count shipped volume, not shipped value. A $89 PR that fixes a billing bug can be a bargain. The data shows the slope, not the worth of any single change.

The three regimes of AI token spend

Arcolano’s more useful framing is that spend clusters into regimes rather than sliding along a curve. At the bottom, people use agents as fancy autocomplete. In the middle, they run several agents in parallel but stay in the loop on each, and hit a hard ceiling: “You can only babysit so many robots.” At the top, about 2% of the engineers Jellyfish tracks run highly autonomous multi-agent workflows.

That middle regime is where most tokens get wasted. Parallel agents with one human reviewing them all produce output faster than anyone can check it.

What does tokenmaxxing productivity theater look like?

It looks like a leaderboard. Tokenmaxxing is treating token consumption as proof of productivity, and once a number becomes a target, people hit the number instead of the goal. The tell is spend that rises while nobody can name the accepted work it produced.

The clearest example is Meta’s internal “Claudeonomics” leaderboard, which ranked the top 250 token consumers. An internal memo reported by The Information put Meta’s employees at 73.7 trillion tokens in roughly 30 days, and the same report describes the response: parallel tasks, redundant queries, agents left running. Amazon shut down its own internal leaderboard in May after finding employees were tokenmaxxing to climb it.

Why leaderboards produce theater

Nate B Jones put the feel of it better than anyone in his video on the agent race: “It looks like work, it smells like work, it burns tokens like work, and it ends up on a board slide that nobody cares about.”

DORA’s June 2026 analysis names the mechanism. It is Goodhart’s Law, the same failure that killed lines of code as a metric decades ago. DORA cites reports of developers running agents on nonsense projects just to stay above the company average.

The cost of this is not abstract. Uber, by its CTO’s own account, blew through its entire 2026 AI coding budget in four months, then capped spend at $1,500 per employee per month per agentic coding tool.

Four questions to ask before defending a token bill

Ask what the tokens bought, what rate you actually paid, which regime the spender works in, and whether you would notice half of it disappearing. If you cannot answer the first, the other three do not matter. These four are my own working test, not an industry standard.

1. What is the denominator? Cost per merged PR, per resolved ticket, per shipped feature. If the only number on the dashboard is tokens, the dashboard is measuring effort.
2. What is the blended rate? Pull the bill apart into cache reads, cache writes, input and output. A high cache-read share means long sessions with stable context, which is usually the efficient kind of heavy use.
3. Which regime is this person in? Heavy spend from someone babysitting six parallel agents is a review bottleneck with a meter running. Heavy spend from someone whose autonomous runs get merged with light rework is the good kind.
4. Would you notice if half of it vanished? If cutting the spend in half would not change what ships next month, the second half was junk volume.

Amazon’s October 2026 engineering memo lands on the same standard from the other direction. It calls token usage and adoption rates “deeply flawed” as standalone measures, and says: “If your work does not benefit from current AI tooling, that is a finding, not a failing.” I would frame that line and hang it next to every usage dashboard.

How I budget tokens in my own systems

I don’t run a trillion tokens a month, and I don’t think I should. Every system I build has a cost ceiling designed in before the first run, because when your budget is your own money, a runaway agent is not a line item, it is the month.

In practice that looks boring, which is the point. My headless content pipeline refuses to start if it is not running on a flat subscription login, and it reads the CLI’s own rate-limit signals and holds the next run instead of quietly falling through to metered API billing. My outreach messages go to a small, cheap model first, with a larger one only as a fallback. My scraping stack starts at the free engine and only escalates to paid tiers when a site actually blocks it.

When more tokens made the output worse

The most useful lesson was one where more tokens made the output worse. Batch-generating comment drafts through one fixed prompt produced a whole batch that converged on the same shape, twice. More calls bought more sameness. That is the small-scale version of the Jellyfish curve: past a point, volume stops buying quality and starts buying repetition.

And my AI-visibility sampler checks its remaining budget before it begins, and refuses to start a run it cannot finish. Half a measurement costs money and tells you nothing.

When should a team spend more on tokens, not less?

A team should spend more when the work is well-suited to autonomous runs, the output is getting accepted, and the bill is still a fraction of salaried time. Arcolano’s data says only about 0.5% of the developers Jellyfish tracks spend anything near their salary in tokens. For most teams, underspending on the right work is the more common mistake.

That is the part the anti-tokenmaxxing backlash tends to skip. DORA itself grants that a usage push can get skeptical developers experimenting, and its 2025 research found around 30% of developers trust AI output only “a little” or “not at all.” A team stuck in autocomplete mode is leaving real capacity on the table.

My call on capping AI token spend per person

So my call is this. Cap the spend per person, the way Uber did, but measure the cost per accepted unit of work, and raise the cap for whoever proves a low one. I’d be wrong about this if per-token prices keep collapsing as fast as Theo argues they are, because at some point the tokens get cheap enough that measuring them at all costs more than it saves. We are not there yet.

Why this pattern is older than AI tooling

Every time a new input becomes cheap and visible, organizations start counting the input because the output is hard to see. Lines of code, hours logged, sets in a training log. The teams that come out ahead are the ones that do the harder work of counting what got built.

If you run a team using coding agents, pull last month’s bill this week and divide it by something your customers would recognize. That one number will tell you more than any leaderboard. For a practical way to compare the models behind that bill on your own tasks, see my guide on how to test AI models, and for how task type changes which agent is worth paying for, my Codex vs Claude Code comparison.

Frequently asked questions

How much does 1 trillion AI tokens a month cost?

It depends almost entirely on the blended rate. Priced at a flat $8 per million, a trillion tokens is $8 million a month. At the roughly 20 cents per million that cache reads cost on a frontier model, it is about $200,000. Long agentic coding sessions are mostly cache reads, so real bills land far closer to the low end.

What is tokenmaxxing in AI?

Tokenmaxxing is treating AI token consumption as a proxy for productivity: the more tokens someone burns, the more productive they are assumed to be. It spread in early 2026 through internal leaderboards, including Meta’s “Claudeonomics” ranking, and drew pushback from DORA, Amazon and others as a gameable vanity metric.

Is tokenmaxxing worth it for engineering teams?

As a measurement strategy, no. Jellyfish found the top decile of developers using about 10x the tokens for about 2x the output. As a short adoption push, DORA grants it some value for getting hesitant developers to experiment. The spend is worth it only when it is tied to accepted work, not to a leaderboard.

What should I measure instead of token usage?

Measure cost per unit of accepted work: cost per merged PR, per resolved ticket, per shipped feature. Then compare that number against the human labor it replaces. Token count stays useful as a cost line and as a pulse check on adoption, never as a score.

When is high AI token spend a good sign?

When the person spending it runs long, autonomous sessions whose output gets accepted without heavy rework, and the bill is a fraction of what the same output would cost in salaried time. Jellyfish’s data suggests only a small share of engineers work this way today.