Peter Steinberger's $1.3M One-Month Token Bill

$1,305,088.81, and a screenshot

Most of us screenshot our API bill when it crosses three figures and we want sympathy. Peter Steinberger screenshotted his when it crossed $1,305,088.81. One month. One open-source project. A team of three. He posted the usage dashboard on X, and the internet did what the internet does — some marvelling, some doing the "you could have hired engineers for that" math out loud, a lot of people quietly recalculating their own agent spend. The number itself is almost the least interesting thing about it. What makes this a case study rather than a flex is that the whole bill is itemised, the protagonist explained exactly how it happened, and one disclosure he made afterwards tells you precisely where the money went — and where most of it didn't have to.

What 603 billion tokens buys

Steinberger is the creator of OpenClaw, a project that grew into one of the most-starred repos on GitHub, and he joined OpenAI in February 2026. His three-person team runs roughly 100 Codex instances in the cloud, continuously, against the codebase. They are not just generating code. The agents review pull requests, scan commits for security holes, deduplicate GitHub issues, write fixes, open new PRs, and flag benchmark regressions to a Discord channel. It is, in effect, a large engineering org's worth of busywork running on three humans and a fleet of agents. The receipt for that, over 30 days: $1.3 million, 603 billion tokens across 7.6 million requests, with GPT-5.5 as the top model. OpenAI, his employer, picks up the tab — the spend is treated as research into a question Steinberger keeps coming back to: "How would we build software in the future if tokens don't matter?" It is a wonderful question to ask when someone else holds the credit card. For everyone reading who holds their own, the honest version is: tokens matter, and this bill is the clearest public lesson in which tokens matter.

The one sentence that gives the game away

After the post went viral, Steinberger added a clarification that, to me, is the entire case study in a single line. The $1.3 million figure reflects Codex's "Fast Mode" pricing, which burns credits at a much higher rate than standard execution — and turning Fast Mode off alone would cut the bill by about 70%, to roughly $300,000 a month. Read that again. Seventy percent of a seven-figure bill was a speed setting. Not more work done, not more code shipped — the same 603 billion tokens, run on a faster, pricier execution tier. The work was identical; the wrapper around it was the expensive part. That is the recurring shape of every exploded agent bill I have looked at. The headline number is rarely "we did a million dollars of useful thinking." It is "we did some useful thinking, wrapped in layers — execution tiers, re-sent context, verbose tool output — that each took their cut."

Where the tokens actually went

Strip away Fast Mode and you still have 603 billion tokens to explain. Here is the mechanism, from someone who builds token tooling for a living. A hundred agents running continuously against a large codebase is the most token-hungry workload there is, because of how agentic coding works under the hood. Every turn of an agent loop — read a file, run a command, check the output, decide the next step — re-sends the entire context window to the model. The API is stateless; each call starts cold. An agent doing 20 iterations on one task can push 200,000+ input tokens without producing more than a few hundred lines of code. Now run that pattern 100 ways at once, 24 hours a day, and stack the usual amplifiers on top:

• The same files re-ingested every turn — a 500-line module read fresh on iteration after iteration
• Full-directory orientation scans at the start of each session
• Verbose tool output folded wholesale into the next prompt — raw diffs, complete stack traces, entire test logs
• No pruning between steps, so the window grows instead of shrinking as a task drags on

This is why agentic workloads are so lopsided toward input tokens. On a fleet like this, the model spends most of its bill re-reading things it was already told. I have written about why this happens and how to cut it — the short version is that the expensive token is almost never the one that produces your code.

What the bill says about price

The pricing makes the lopsidedness sting. GPT-5.5 lists at $5 per million input tokens and $30 per million output tokens, and our own LLM API token pricing breakdown tracks the same shape across vendors: output costs more per token, but on agent fleets the volume is overwhelmingly input — context re-sent every turn — so input is where the dollars pile up. There is a detail in OpenAI's own pricing that matters enormously here: cached input on GPT-5.5 is discounted by 90%. When the same prefix — system prompt, file contents, prior context — is sent again, the cached portion costs a tenth as much. That is prompt caching, and on a workload defined by re-sending the same context 7.6 million times, it is not a nice-to-have. It is the single biggest lever on the board. For the scale of what teams are now spending per engineer, see our AI coding agent token cost data.

What a real efficiency layer would have changed (an estimate)

Let me be careful here, because the rules I write to apply to me too: the figures below are a labelled estimate, not a claim that we audited Steinberger's account. He pays nothing — OpenAI covers it — so for him this is academic. But for the thousands of teams reading his receipt and seeing their own future in it, the math is very real. Take the honest baseline, not the headline. Drop Fast Mode, as Steinberger says, and you are at roughly $300,000/month for the same 603 billion tokens. On a continuous agent fleet, input typically dominates — call it ≈85% of token volume on this kind of workload (a conservative figure given how much context is re-sent each turn). Two levers act on that input:

• Prompt caching, which OpenAI itself prices at 90% off cached input. On a workload re-sending the same prefixes millions of times, a large share of input is cacheable.
• Context reduction — sending skeletons instead of whole files, filtering tool output, pruning the window — which cuts the input that has to be sent at all, before caching even applies.

If a token-efficiency layer trims re-sent input by a conservative 40–60% across that ≈85%, the post-Fast-Mode bill falls by roughly $100,000–$150,000 a month, with no change to what the agents actually accomplish. That is an estimate, tied to one real lever — the input side that this bill is built from — using OpenAI's own published prices. It is deliberately well short of the 70% that Fast Mode alone accounted for, because I would rather under-promise than match a number I can't audit. The point is not the exact figure. It is the direction: the biggest line item on a runaway agent bill is almost always re-sent context, and re-sent context is the most reducible thing in the whole system.

The lesson isn't "run fewer agents"

Steinberger's experiment is genuinely useful — running software development as if tokens were free tells us something about where the tooling is going. But the lesson for the rest of us is the inverse of his question. Tokens do matter, and the bill that proves it is itemised: a 70% speed-tier premium on top of a workload whose dominant cost is the same files, read again and again. You don't fix that by vibe-coding less or by being scared of agents. You fix it by putting an efficiency layer between your agents and the API — cache the repeated prefixes, send skeletons instead of whole files, filter the verbose tool output before it becomes next turn's input. The work stays the same. The token volume doesn't. That is exactly what Tokenade does: it sits in front of your coding agents and cuts the re-sent context and noisy tool output that make bills like this one balloon — typically a large reduction on the input side, which, as Steinberger's receipt shows, is where the money is. Before you decide what your agents are "worth," it is worth knowing what they actually cost: try the LLM token cost calculator on your own numbers. You probably won't ever see a $1.3M screenshot. But the mechanism that built it is running, quietly, in every agent loop you fire. Start free and find out how much of your bill is just context you already sent.