September 10, 2026 ·

openaiagentspricingverificationresearchapi

OpenAI published the first itemized bill for a 10,000-agent swarm — and the $22.5M everyone quoted counts output tokens only

TL;DR: On 8 September 2026 OpenAI said roughly 10,000 agents running an internal model more capable than GPT-6 Astra produced a finite-time singularity result for 3D Navier-Stokes in 88 hours, plus 17 hours of Lean formalization, and released a 166-page manuscript with formal proof files. The week-long sprint burned 300 billion output tokens; Navier-Stokes alone took 130 billion across 2.7 million messages. The widely-quoted $22.5M is not an invoice — it is exactly 300B × $75/M, Astra’s above-272K output rate, counting output tokens only. Add input and cache writes and the list-price figure is plausibly $30–40M. The useful numbers are the derived ones: ~$11 per agent-hour, 41 output tokens/second sustained per agent for four days, and — critically — the earlier 100-agent Euler run cost the same per agent-hour as the 10,000-agent run. Swarms do not get cheaper at scale; they get faster. Meanwhile the 17 hours of Lean checking that made the result auditable cost roughly one hundred-thousandth of the generation. For buyers: you can finally price an agent fleet with arithmetic instead of vendor anecdote — and the cheapest line item is the verifier.

The disclosure nobody treated as a disclosure

Two stories ran on 8 September. One was mathematical: a claimed finite-time singularity in the three-dimensional Navier-Stokes equations, one of the seven Clay Millennium Prize problems. The other was a bitter priority dispute between OpenAI and two mathematicians who say they got there first.

Underneath both sat something no lab had published before: a complete set of unit counts for a production-scale agent swarm.

Unit	Navier-Stokes run	Full week sprint
Agents (peak, concurrent)	~10,000	—
Wall-clock	88 hours (1–5 Sept)	~1 week
Messages	2.7 million	—
Output tokens	~130 billion	~300 billion
Lean formalization + verification	17 hours	—
Manuscript	166 pages	—

Vendors sell agent fleets constantly. Cursor bills always-on cloud agents by subscription, Warp sells model-agnostic agent orchestration, and OpenAI itself has an agent swarm that wrote ~18,000 wiki posts over six weeks. None of them ever published agents × hours × tokens for a single run. This one did. That makes it the first swarm you can actually do arithmetic on.

Where $22.5 million comes from

The figure repeated across coverage has a precise and checkable origin:

300,000 million output tokens × $75 per million = $22,500,000

That $75 is not a generic estimate. It is GPT-6 Astra’s published output rate above the 272K input-token threshold — the premium tier that kicks in when a request crosses the cliff and re-bills the entire request at $20/$75 instead of $10/$50.

Two things follow, and both matter.

First, the figure embeds an assumption. Using $75 rather than $50 asserts that the swarm ran above the 272K threshold essentially throughout. For agents that accumulate a long reasoning scratchpad over 88 hours, that is plausible — but it is inference, not disclosure. At the standard $50 rate the same 300 billion tokens cost $15M.

Second, and more significantly, it counts output only. There is no input line. There are no cache writes. For agent workloads input volume routinely runs two to three times output, because every step re-reads a growing context. At a conservative 2.5:1 ratio, 300 billion output tokens implies roughly 750 billion input tokens — about $15M more at the above-threshold input rate of $20/M, or $7.5M at the standard $10.

Then add cache writes, which is where a long agent session genuinely spends. Astra bills cache writes at $12.50/M below the threshold and $25.00/M above it, and as we noted when OpenAI shipped the configuration_update item, a rebuilt prefix costs 12.5x a preserved one. Ten thousand agents establishing and re-establishing prefixes is not a rounding error.

The honest summary: $22.5M is a floor on the token bill, and it has been reported as though it were the cost of the project.

What a swarm costs per agent-hour

Strip out the headline and take the transferable numbers.

The Navier-Stokes slice consumed ~130 billion output tokens with ~10,000 agents over 88 hours:

Derived metric	At $75/M (premium)	At $50/M (standard)
Cost of the Navier-Stokes run	$9.75M	$6.50M
Per agent	$975	$650
Per agent-hour	$11.08	$7.39

And the throughput, which is the sanity check:

130B ÷ 10,000 agents = 13 million output tokens per agent
13M ÷ 88 hours = ~147,700 output tokens per agent-hour
That is ~41 output tokens per second, sustained, per agent, for nearly four days

Forty-one tokens per second is a realistic sustained generation rate. Which means these agents were not idling between tasks or waiting on tool calls — they were saturated, generating continuously, for 88 hours. That is what “10,000 agents” actually purchased.

The message count adds one more texture: 2.7 million messages across 10,000 agents is 270 messages per agent, roughly one every 19.5 minutes, at an average of ~48,000 output tokens per message. These are not chat turns. Each “message” is a substantial reasoning episode — closer to a research memo than a reply.

The finding that should change a budget: no bulk discount

OpenAI ran two swarms, and the pair is more informative than either alone.

Before Navier-Stokes, the system resolved the unforced Euler regularity problem using roughly 100 agents in about 50 hours. Then Navier-Stokes: 10,000 agents, 88 hours.

That is 100x the agents for 1.76x the duration — about 176x the agent-hours. Applying the same per-agent throughput derived above, the Euler run consumed on the order of 0.74 billion output tokens against Navier-Stokes’ 130 billion: a ratio of about 177.

176x the agent-hours, 177x the tokens. The cost scaled linearly, to within rounding.

This is worth stating plainly because a great deal of agent-fleet marketing implies otherwise. A swarm is not a machine that gets more efficient as it grows. A swarm is tokens, tokens are billed linearly, and there is no volume tier hiding inside the parallelism. What 100x the fleet bought was wall-clock time and search breadth on a harder problem — a real thing to buy, and the right thing to buy when the deadline matters more than the invoice. But it is a latency purchase, not an efficiency purchase.

We made a version of this point when OpenAI disclosed that its median researcher spends about $600/day on inference. Set the two against each other: the $9.75M Navier-Stokes slice equals about 16,250 researcher-days of inference at that rate — roughly 62 researcher-years. That is the actual trade OpenAI made, and it is a legitimate one for a problem that has been open since 1934. It is almost certainly not the trade your roadmap is making.

The cheapest step is the one that made it real

Now the ratio that deserves to outlive the news cycle.

Generation: 88 hours, ~130 billion output tokens, ~$9.75M. Formalization and machine verification in Lean: 17 hours, no token cost — Lean checking is ordinary CPU work.

The step that converted a claim into something any stranger can audit cost on the order of one hundred-thousandth of the step that produced it.

This is the same structure we saw when Anthropic’s Claude formalized a Fermat’s Last Theorem component in Lean over 11 days, and when OpenAI shipped ten math proofs with Lean certificates in August. The pattern holds across labs and across problems: generation is expensive and verification is nearly free, and the asymmetry is getting wider, not narrower.

For anyone running agents in production, that is a design instruction, not a curiosity. If your fleet produces output no cheap checker can validate, you are paying the expensive half of this equation and skipping the cheap half. Machine-checkable output — tests that run, schemas that validate, types that compile, proofs that check — is not a nice-to-have bolted on afterward. It is the line item that makes every other line item worth paying. Build the verifier first; it is the cheapest thing in the system.

What Lean did not check

Here the story turns, and buyers should notice exactly where.

Lean certifies that an argument follows from its premises. It says nothing about whether the premises are the right ones. And on that question there is a real caveat that most coverage buried: OpenAI targeted Clay options C and D — the forced variants, where a smooth external force is applied to the fluid. The unforced options A and B remain open, and many mathematicians consider those the substantive question, since they ask whether the equations break down on their own rather than under an imposed term.

OpenAI has said it does not intend to claim the $1M prize. Independent peer review has not happened. The manuscript and Lean files are public, which is the right thing to have done, and checking them is now someone else’s 17 hours.

Everything else in the story has no certificate whatsoever. Buckmaster and Alpöge claim priority on related forced-Euler work from August. Buckmaster alleges Bubeck proposed dropping Alpöge’s name because of his Anthropic affiliation, and responded to his objection with “Why would you ruin your career?” Bubeck says “We did not use their prompts or proofs to prompt our models or direct our agents.” OpenAI has since acknowledged the pair’s Euler priority. Altman explained the sprint’s origin as “We were curious if ours could do it too.”

Notice the sorting. The part with a machine-checkable artifact is the part nobody is arguing about. The parts without one — provenance, priority, intent, what was said in a DM — are the entire dispute. That generalizes uncomfortably well to enterprise agent deployments, where the model’s output is increasingly verifiable and the questions that actually cause trouble are about what the system saw, when, and on whose authority. It is the same gap we flagged when OpenAI’s chief scientist warned that chain-of-thought monitorability is degrading.

What to do with this

Reprice your fleet from real units. Use $7–11 per agent-hour as an order-of-magnitude anchor for a saturated frontier-model agent, then adjust for your model tier. If your estimate is far below that, your agents are thinking far less than these were.
Stop budgeting for a scale discount. Agent-hours are linear. Buy parallelism to compress wall-clock, and say so in the business case, because that is the thing you are actually buying.
Watch the 272K cliff, not the sticker. The gap between $50 and $75 output — and $10 versus $20 input — is a 50% swing that triggers on context length, and long-horizon agents cross it by design. Measure where your requests actually land.
Fund the verifier first. It is the cheapest component and the only one that makes the expensive component trustworthy.
Do not read a benchmark headline as a capability you can buy. The model here is internal and unreleased. Nothing about this run is currently purchasable, and the Intelligence Index reshuffle is a reminder that even published scores move under you.

Update, 11 September 2026: the per-agent-hour figure derived above now has a product to be applied to. On 10 September OpenAI opened the Agents API in public beta, selling the managed Codex harness with no fee of its own — you pay tokens, tools, and container time. Two connections to the arithmetic on this page. First, the $7–11 per agent-hour anchor is a token figure, and OpenAI-hosted sandboxes add a wall-clock meter on top at $0.09–$5.76 per hour by memory tier: negligible against a saturated agent, and the entire bill for one that waits. Second, the compaction policy that decides whether your requests land above or below the 272K cliff is now set by OpenAI’s harness rather than your code, which makes the 50% output-price swing discussed above a vendor decision rather than yours.

If you are choosing a platform to run fleets on, our best AI agent tools rundown covers the orchestration layer, and the ChatGPT review tracks OpenAI’s shipping model tiers and what they cost.

Frequently asked questions

Where exactly does the $22.5 million figure come from?

It is 300 billion output tokens multiplied by $75 per million, which is $22,500,000 to the dollar. That $75 is not an arbitrary rate — it is GPT-6 Astra's published output price for requests above the 272K input-token threshold. Astra's standard output rate below that threshold is $50 per million, which would give $15M instead. So the circulating figure carries an embedded assumption: that the swarm ran deep in long-context territory for essentially the whole sprint. That assumption is probably right for a long-horizon reasoning agent, but it is an assumption rather than a disclosure. More importantly, the calculation counts output tokens only. It does not include input tokens, and for agent workloads input volume typically exceeds output by a factor of two or more. It does not include cache writes, which Astra bills at $12.50 per million below the threshold and $25.00 above it. Treat $22.5M as a floor on the token bill, not as the cost of the sprint.

What would the full bill plausibly look like once input is counted?

Nobody outside OpenAI can compute it exactly, because only output tokens were disclosed. But the shape is estimable. If the sprint ran at a conservative 2.5:1 input-to-output ratio — normal for reasoning agents that re-read a growing scratchpad — 300 billion output tokens implies roughly 750 billion input tokens. At Astra's above-threshold input rate of $20 per million that is about $15M in input alone; at the standard $10 rate it is about $7.5M. Add cache writes for 10,000 agents repeatedly establishing and rebuilding prefixes and the all-in list-price figure lands somewhere in the $30M to $40M range rather than $22.5M. None of this is a criticism of OpenAI, which disclosed more unit-level detail than any lab has before. It is a caution about a number that has been repeated as though it were an invoice.

What is the actual per-agent cost, and why does that matter more than the headline?

The Navier-Stokes problem alone consumed about 130 billion output tokens with roughly 10,000 agents over 88 hours. At $75 per million that slice is $9.75M, which is $975 per agent for the run, or about $11.08 per agent-hour. At the standard $50 rate it is $6.50M, $650 per agent, and $7.39 per agent-hour. That per-agent-hour figure is the transferable number. It is the first time anyone has published enough units to derive it from a real production swarm, and it gives you a sanity check for your own fleet: if your agents cost dramatically less per hour, they are doing dramatically less thinking, and you should know which. The token throughput confirms the agents were genuinely saturated — 13 million output tokens per agent over 88 hours works out to about 41 output tokens per second sustained, continuously, for nearly four days.

Did running 10,000 agents instead of 100 make the work cheaper per unit?

No, and this is the finding most likely to correct someone's budget. OpenAI ran two swarms. The Euler regularity problem was resolved first with roughly 100 agents in about 50 hours. Navier-Stokes then took roughly 10,000 agents over 88 hours. That is 100 times the agents for 1.76 times the duration, or about 176 times the agent-hours. Applying the same per-agent throughput, the Euler run consumed on the order of 0.74 billion output tokens against Navier-Stokes' 130 billion — a ratio of about 177. The cost scaled linearly with agent-hours, to within rounding. There is no volume discount hiding inside a swarm, because a swarm is just tokens, and tokens are priced linearly. What the 100x fleet bought was wall-clock time and search breadth on a harder problem, not efficiency. Anyone planning agent infrastructure on an assumption that scale brings unit-cost relief should plan differently.

What did the Lean verification actually establish, and what did it not?

OpenAI released a 166-page manuscript and a Lean formalization on 8 September, and formalization plus machine verification took 17 hours against 88 hours of generation. Lean checking is CPU work with no token cost, so the step that made the result auditable cost a rounding error against roughly $9.75M of generation — a ratio on the order of a hundred thousand to one. That is the structural lesson worth copying. But Lean establishes only that the argument is internally consistent given its stated premises. It does not establish that the premises capture the problem mathematicians care about, and here that gap is load-bearing: OpenAI targeted Clay options C and D, the forced variants where a smooth external force is applied. The unforced options A and B — which many mathematicians regard as the actual question, since they ask whether the equations break down on their own — remain open. OpenAI has said it does not intend to claim the $1M prize. Independent peer review has not happened.

Does the credit dispute affect how I should read any of this?

It affects how you read the claims, not the arithmetic. NYU's Tristan Buckmaster and Anthropic's Levent Alpöge say they held priority on related forced-Euler work completed in August, and Buckmaster alleges that OpenAI's Sébastien Bubeck proposed dropping Alpöge's name over his Anthropic affiliation, and told him 'Why would you ruin your career?' when he objected. Buckmaster has also questioned whether private Codex sessions informed OpenAI's direction. Bubeck says 'We did not use their prompts or proofs to prompt our models or direct our agents,' and OpenAI has since acknowledged the pair's Euler priority. Sam Altman said the sprint began after hearing a rival had solved a major math problem: 'We were curious if ours could do it too.' Note which claims are machine-checkable and which are not. The mathematics has a Lean certificate. Provenance, priority, and who said what in a DM have no certificate at all, and that is exactly where the fight is. Terence Tao's warning is the one to sit with: that 'the indiscriminate strip-mining of open problems for solutions may destroy the ecosystem' that produces the next generation of techniques and practitioners.

Sources

Related tool reviews

Questions or corrections? Email Pick Right. Want the full list? See all news.