OpenAI Navier-Stokes, a Reported $40M Lesson in Verification

The OpenAI Navier-Stokes run is the most expensive public evidence yet that AI generation has outrun our capacity to check what it generates. OpenAI's own announcement cites roughly 10,000 agents and about 130 billion tokens consumed; the roughly 88-hour runtime comes from unconfirmed secondary reporting rather than from the company. The compute bill is the least settled figure of all: secondary reports put it at $40M+, while the one available account of OpenAI's own press briefing describes it as "millions of dollars." What came out the other end is a candidate proof that now sits in a human-paced verification queue, exactly where the Clay Mathematics Institute's rules say it must sit.

That gap is the whole story for anyone who builds or evaluates agents. Generation now scales with your compute budget. Verification still scales with reviewer hours, and reviewer hours do not double when your cluster does. Three things follow: the per-candidate cost ledger built from the headline numbers, the queue math that makes checking rather than thinking the binding constraint on agentic AI, and Tao's warning about open problems read as an eval-supply problem you already face at smaller scale.

What the OpenAI Navier-Stokes Run Actually Claimed

On September 8, OpenAI's announcement stated that its agents had produced a proof that the full Navier-Stokes equations, the equations that describe how fluids such as water and air flow, can break down, admitting solutions that develop singularities rather than staying smooth. That attacks one of the seven Clay Millennium Prize problems, each carrying a $1 million prize, of which only one has ever been resolved. The internal model behind the work, per press-briefing accounts, dramatically outperforms Astra, the model OpenAI shipped the week before the announcement. That detail enters the record through the briefing coverage rather than the announcement page.

So, did OpenAI solve Navier-Stokes? The precise answer is narrower than the headlines: its agents produced an argument that would resolve the Navier-Stokes Millennium Prize problem if it survives expert checking. No such check has happened. The company has said it will not claim the prize money, and Simon Willison's analysis weighs how much an unreviewed, agent-produced proof can be called a solution.

The reported run card, with calibration:

The week also produced an attribution fight. MIT Technology Review's reporting covered accusations that OpenAI used AI-assisted work by NYU's Tristan Buckmaster and Anthropic's Levent Alpöge as a jumping-off point without credit; OpenAI denies this, while acknowledging the team was inspired by a rumor of their efforts. The builder-relevant detail is not the drama but the shape of the dependency: both efforts reportedly built on an approach pioneered by Diego Córdoba and Luis Martínez-Zoroa. In other words, the swarm's direction was aimed by human research taste. Ten thousand agents supplied volume. Humans supplied the pointer.

What the Run Cost per Candidate

How much did OpenAI spend on Navier-Stokes? Enough that the agent swarm compute cost deserves unit economics rather than headlines. Sort the evidence into two tiers before touching a calculator, because the tiers carry different weight. Tier one, stated by OpenAI itself: roughly 10,000 agents and about 130 billion tokens. Tier two, resting on unconfirmed secondary reporting: the $40M+ bill and the roughly 88-hour runtime, with the one account of OpenAI's own press briefing saying only "millions of dollars."¹ Every calculation below that leans on tier two is a conditional scenario, labeled before the arithmetic runs rather than after. Do the math out loud, because you can run this same audit on any large agent deployment from its press numbers.

Headline arithmetic

Blended cost per token. Conditional on the $40M figure: $40M across roughly 130 billion tokens is about $0.31 per thousand tokens. That is far above raw inference pricing, and it tells you where swarm money actually goes: orchestration, long-context re-priming, retries, and dead branches. Swarms do not pay per useful thought. They pay per attempt.

Cost per agent-hour. This block leans on both unconfirmed figures, the bill and the runtime, so treat it as a scenario. If 88 hours holds, 10,000 agents across that span is 880,000 agent-hours, or roughly $45 each at the reported $40M. Token throughput is its own line: each agent sustained on the order of 150,000 tokens per hour, about 40 tokens per second, every second, for three and a half days. The two announcement-page figures give a runtime-independent cross-check: 130 billion tokens across 10,000 agents is 13 million tokens per agent, however long the run took.

Cost per surviving candidate

This is the number nobody reported, and it inherits the top tier's uncertainty, so treat the scenarios below as arithmetic, not claims:

Even the generous case prices one surviving idea at $40K, and every surviving idea then needs a qualified expert to actually read it. The asymmetry in one line: the generation side ran 10,000 agents in parallel, while the verification side is a small set of experts who work serially for months, and their cost appears nowhere in the ledger. When you audit your own runs, that missing line item is usually where the truth about throughput lives.

Why Verification Is the Bottleneck

The stall at the checking step is deliberate: per Clay's official problem page, the prize process prices claims in expert attention, requiring a solution to be published and then withstand a period of community acceptance, roughly two years, before any prize is paid. That two-year window is a queue written into institutional rules. It was sized for a world in which serious claims arrive at the pace human authors produce them, and a machine-generated candidate changes nothing on the service side: it enters the same line a human's would, with nothing about its origin speeding the wait.

What the run moved is the arrival rate. Ten thousand agents can emit candidate arguments at machine speed, while the service rate on the other side of the counter is fixed, serial, and human. Once arrivals outrun service, backlog and latency both grow without bound, and no fall in the price of generation relieves either. Halving the cost per candidate just doubles how many candidates stand in the line. The gap between generating an argument and knowing whether it is right is set entirely by the slow side of the queue, and that side stayed put.

Formal verification, the one demonstrated lever

Generation already has its scaling lever, which is compute. Checking has exactly one demonstrated lever that raises service rate toward machine speed: the Lean proof assistant, which turns a proof into an object a program can check in minutes. The Liquid Tensor Experiment is the existence proof at research scale: a distributed team, working in public over about half a year, machine-checked a deep theorem of Clausen and Scholze, one its own author had found grueling to verify by hand. Formal verification for AI-generated proofs works by the same move. The candidate arrives as machine-checkable code, the checker becomes a compiler, and the service rate stops depending on scarce human attention.

As of the announcement, no machine-checkable artifact of the OpenAI proof has been reported. The candidate sits in the slowest queue in mathematics. If your agent's output format cannot be checked automatically, so does yours.

Terence Tao's Non-Renewable Warning

Put the two searches side by side. When a human mathematician spends five years failing on a famous problem, the field inherits the failure: the partial results, the dead ends, the techniques that miss here but land elsewhere. When a swarm burns 880,000 private agent-hours and publishes only the winner, all of that evaporates on the cluster. Days before the announcement, Terence Tao named the stakes in remarks relayed through Simon Willison's notes, on why mathematics poses its problems at all:

"...not because we desperately want the solution..."

The problem is the filter, not the trophy. The fuller argument, as Willison relays it: hard problems are valuable because "human-directed efforts" against them drag the rest of the field forward, and a problem cracked instead "by purely AI-powered methods" can contaminate that filtering process until it turns "net negative" for mathematics as a whole.

Read that as resource economics and the warning sharpens. Open problems are a commons whose value is not the answer but the effort they attract, and that value regenerates slowly or never, because a solved problem attracts no one. Mass automated exploration is consumption without replenishment, and each run permanently draws the stock down.

Your own holdout runs the same clock. A private benchmark set survives its first training run largely intact; by the third pass, scores climb on familiarity alone, the signal is spent, and nothing grows it back. Tao's warning is what that ledger looks like when nobody keeps one.

Prestige Problems Are the Frontier's Eval Set

Swap "famous open problem" for "benchmark test set" and every mechanism survives the translation. Benchmark contamination is the same depletion at a faster clock speed: once a public test set has been mined by enough training runs, it stops measuring capability and starts measuring memorization. The field's response was institutional, not algorithmic. Evaluation moved toward held-out, privately verified designs like Epoch AI's FrontierMath, where problems are withheld from the public so they cannot be mined, and answers are verified by the benchmark's maintainers rather than scraped. That is the institutional form of a leakage-proof holdout.

Now look at prestige mathematics from the same angle. Famous unsolved problems are the closest thing frontier models have to an uncontaminated eval set: universally known, checkable in principle, and impossible to answer from memorization, only solvable. A lab that wants to demonstrate real research capability has a short list of targets, and every publicized run consumes one. The OpenAI Navier-Stokes run did more than answer a question. It removed one of the last untouched items from the only eval set the entire field shares.

Your eval suite is a smaller version of the same commons. Every model you train against it, every agent you let iterate on it, every example you paste into a prompt burns a little of the signal, and nothing regenerates it.

What Builders Should Change in Their Evals

The ledger changes the agenda. Generation is metered, verification is salaried, and the salaried side appeared nowhere in the run's accounting. At agent scale, eval design is capacity economics rather than test hygiene. Four line items, each priced:

1. Price the checking queue. Run the hypothetical micro-ledger first: 50 candidate solutions at 20 expert-hours each is 1,000 salaried reviewer-hours, set beside 1,000 metered agent-hours at roughly $45 each. The metered-versus-salaried ratio lands in one line, and only one side of it ever reaches an invoice. The run's imbalance was 880,000 metered generation-hours against an unbudgeted human queue; yours is the same imbalance at smaller scale, and it stays invisible until both sides carry a price.
2. Account for holdout burn like inventory. The unit that matters is problems consumed per training run, tracked across release cycles like warehouse stock. The prestige-problem commons was eaten because nothing carried the draw-down. A holdout with no burn-rate line is inventory waiting to be mined by accident.
3. Mint machine-checkable ground truth. Synthetic tasks with checkable answers, property-based tests, formal proofs. This is the Lean move from earlier, the one demonstrated lever that moves both curves, cutting the metered cost of generation and the salaried cost of checking in the same change.
4. Return negative results to the commons. One published dead branch returns its reviewer hours to every team that would have climbed the same tree. Tao's contamination worry peaks when only winners are visible, and a published failure is reviewer capacity handed back to the field at zero marginal cost.

The Dynabench paper argued years ago that static benchmarks rot and that data collection should be dynamic. What Dynabench never had to price is the asymmetry agents introduce: generation rents by the hour while checking draws a salary. Once checking is the expensive side of the ledger, rotation and minting stop being hygiene and become capacity planning.

Where This Leaves the Prize

This piece's framing makes predictions you can check, so hold it to a scoreboard. Within months: does OpenAI release a machine-checkable artifact of the proof, or does the candidate stay as prose only humans can read? Over the Clay window: does community verification finish inside the roughly two-year acceptance period, or does the queue swallow it? Next shot: when another lab targets a famous problem, does it answer the bottleneck with formal-methods output formats, or with another ten-thousand-agent swarm? Every outcome grades the thesis that verification, not generation, now binds.

Close the loops. Did OpenAI solve Navier-Stokes? It produced an unverified candidate argument whose checking will take the community months to years, and it declined the prize. What did the money buy? At reported figures, 880,000 agent-hours and, under generous yield assumptions, surviving candidate ideas at $40K to $4M apiece, none verified at announcement time. Why does that matter to you? Because the run is a public stress test of a constraint every agent team already feels: generation scales with compute, verification does not, and the scarce resource is checkable, trustworthy signal.

The $1 million prize against a reported $40M compute bill also tells you prizes were never the incentive. A Quanta panel from this year's International Congress of Mathematicians asked what mathematics is for in an age of AI; the honest answer from this episode is that at the frontier, math's remaining function is to be the last slow verifier standing.

Progress now has two independent fronts. Generation gets cheaper every quarter, and that side will take care of itself. Verification is where design work remains: formal methods adoption, machine-checkable output formats, and eval pipelines that treat problem supply as capital rather than air. The first team that scales checking the way this run scaled generation will not need 10,000 agents to make history. It will need the discipline to know, automatically, when one agent is right.