Cost of Running 10,000 AI Agents: The OpenAI Run, Modelled
Quick answer: OpenAI published no dollar figure for the run it described, so there is no official cost of running 10,000 AI agents. What is published is the workload shape: on the order of 10,000 concurrent agents, about 88 hours to the resolution, 2.7 million messages and approximately 130 billion output tokens — the Navier–Stokes problem only. That shape is 880,000 agent-hours, roughly 147.7K output tokens and 3.07 messages per agent-hour. Model the bill at an assumed inferred $5M–$15M all-in band and it works out to $38.46–$115.38 per 1M output tokens, $5.68–$17.05 per agent-hour and $1.85–$5.56 per message. Every dollar figure on this page is either third-party reported or an inferred assumption — none of them is OpenAI's. Run the per-agent side of this maths on your own numbers →
The workload, in one table
Start with the workload, not the money. Money claims about this run are all secondary; the workload numbers are the only part OpenAI published, and they are the anchor everything else here is built on.
| Figure | Published value | Label | Source |
|---|---|---|---|
| Concurrent agents | on the order of 10,000 — final stage only, not an exact headcount | published | OpenAI's post |
| Wall-clock to resolution | about 88 hours after the first agents launched (resolution Sept 5, 2026) | published | OpenAI's post |
| Messages exchanged | 2,700,000 | published | OpenAI's post |
| Output tokens | approximately 130 billion | published | OpenAI's post |
| Lean formalization + verification | +17 hours on GPT-6 Astra — a different model from the agent fleet | published | OpenAI's post |
| Model the agents ran on | internal, unreleased — "significantly more capable than GPT-6 Astra", training ongoing since Aug 28 | published | OpenAI's post |
| Dollar figure from OpenAI | none published anywhere (zero cost language in the post) | published | OpenAI's post, negative check |
Scope guard: all four workload numbers above are the Navier–Stokes run only. Across all the problems the system attempted, the published totals are 4.9 million messages and about 300 billion output tokens. Never mix the two pairs: 2.7M messages pairs with ~130B tokens, and 4.9M pairs with ~300B. Some write-ups conflate them.
Two things this page will not say. The result itself is disputed and has not been independently verified: NYU's Tristan Buckmaster and Anthropic's Levent Alpöge dispute credit and say they are unsure whether their work was used, and the Clay Mathematics Institute has accepted nothing — its eligibility bar is peer-reviewed publication plus two years of community acceptance. And the run used an unreleased internal model, so it is not reproducible on any public endpoint. Nothing below is a claim that a proof is accepted; this is the economics of a claimed workload. For when to fan out at all, see our decision guide: agent fleets are a budget line, not a feature flag.
Where the money language comes from. Not from OpenAI's post, which contains no cost language at all. OpenAI's chief research officer Mark Chen told reporters costs ran "emphatically in the millions of dollars" (AFP). The phrase "millions of dollars in computing power" is AFP's framing, not an OpenAI quote. And a third-party estimate reported by Business Insider — from LisanBench, an LLM benchmark evaluator — put the 130B output tokens alone at about $6.5 million at "OpenAI's average consumer price", with the total reaching $10M–$40M once the far larger, unpublished input-token volume is included. third-party That estimate is not OpenAI data either. It also implies a rate of $50.00 per 1M output tokens ($6.5M ÷ 130B), which happens to be close to our published GPT-6 Astra output rate of $50/M — coincidence, not evidence: it is the estimator's price assumption, not a rate for this run.
Per agent-hour and per message: what the run's rates actually were
The raw totals are hard to hold in your head. Normalise them by agent-hours and the workload becomes a set of rates you can compare against any other agent deployment. This is arithmetic on OpenAI's published totals derived — not OpenAI-provided unit costs.
| Quantity | Formula | Value | Label |
|---|---|---|---|
| Agent-hours | 10,000 × 88 h | 880,000 agent-hours | derived |
| Output tokens per agent-hour | 130B ÷ 880,000 | 147,727 (≈147.7K) | derived |
| Messages per agent-hour | 2.7M ÷ 880,000 | 3.07 | derived |
| Output tokens per agent | 130B ÷ 10,000 | 13,000,000 (13M) | derived |
| Messages per agent | 2.7M ÷ 10,000 | 270 | derived |
| Output tokens per message | 130B ÷ 2.7M | 48,148 (≈48.1K) | derived |
| Fleet output rate, wall-clock | 130B ÷ 88 h | ≈1.48B tokens/hour | derived |
| End-to-end elapsed | 88 h + 17 h Lean pass | 105 hours (4.4 days) | derived |
Ratio caveat on 48.1K: messages and output tokens are different measurements — messages are inter-agent traffic, tokens are model output. So 48,148 is the ratio of two published totals, not the size of an observed message. Use it as a derived ratio, not an observed message size. The same applies to the 17-hour Lean pass: it ran on GPT-6 Astra, not on the 10,000 agents, so it is calendar time, not agent-hours. Do not fold it into 880,000.
Two of these rates are the ones a fleet model actually needs: 147,727 output tokens per agent-hour and 3.07 messages per agent-hour. The first is what an agent emits. The second is what makes fleets behave differently from single agents — see the super-linear section below.
How much did the OpenAI math run cost? Three readings of one unpublished bill
To price the workload you need a total, and OpenAI published none. So we assume one, and we label the assumption every single time it produces a dollar figure: inferred $5M–$15M all-in, mid $10M. That band is our modelling choice. Its $5M low end sits below the third-party output-only estimate ($6.5M) and its $10M mid equals the low end of the third-party all-in range ($10M–$40M); every dollar figure it produces is labelled inferred.
| Assumed all-in total inferred | $ / 1M output tokens | $ / agent-hour | $ / message | vs $10–$15/M frontier output band | vs our published Astra output rate ($50/M) |
|---|---|---|---|---|---|
| $5M (band low) | $38.46 | $5.68 | $1.85 | 2.6x | 0.77x |
| $10M (band mid) | $76.92 | $11.36 | $3.70 | 5.1x | 1.54x |
| $15M (band high) | $115.38 | $17.05 | $5.56 | 11.5x | 2.31x |
Formulas: $ / 1M output tokens = assumed total ÷ 130,000 (the number of millions in 130B) · $ / agent-hour = assumed total ÷ 880,000 · $ / message = assumed total ÷ 2,700,000. Every dollar value in this table is inferred from the assumed band above.
The premium is real, and it is not a price
Read at 2.6x–11.5x the typical frontier output band, the fleet's effective rate looks like a premium — and there are two honest reasons for it. First, it is a loaded rate, not a list price inferred: we divided a whole-fleet bill (which contains input tokens, retries and infrastructure) by one component of that bill (output tokens). A list price and a loaded rate are different objects. Second, most of the bill is probably not output tokens at all. Input volume is unpublished and expected to be "far larger" than the 130B output tokens, which is exactly why a loaded rate sits above list.
For readers who already use the calculator, the useful comparison set is our own published rate card: at band mid the loaded rate is 1.54x our published GPT-6 Astra output rate of $50 per 1M output tokens and 6.41x GPT-5.6 Terra's $12 per 1M (rates live on the GPT-Live-1 cost calculator). Those multiples are arithmetic on our published rates plus the assumed band — both legs labelled, neither of them OpenAI's.
Cost of running 100, 1,000 and 10,000 AI agents
Here is the scaling table most people want. It holds two things constant and says so inferred: the 88-hour horizon at every fleet size, and the per-agent output rate (147,727 tokens/agent-hour). That means this table prices a proportionally larger workload — more agents, same duration, more total output — not the same job finished faster. A bigger fleet that finishes one job sooner would not cost agents × more.
| Agents | Agent-hours | Output tokens | Messages | Cost @ $5M basis | Cost @ $10M basis | Cost @ $15M basis | $ / agent-hour (mid) |
|---|---|---|---|---|---|---|---|
| 100 | 8,800 | 1.3B | 27,000 | $50,000 | $100,000 | $150,000 | $11.36 |
| 1,000 | 88,000 | 13B | 270,000 | $500,000 | $1,000,000 | $1,500,000 | $11.36 |
| 10,000 | 880,000 | 130B | 2,700,000 | $5,000,000 | $10,000,000 | $15,000,000 | $11.36 |
Formula: cost(A) = assumed total × A ÷ 10,000. Worked row (1,000 agents, mid basis): 1,000 × 88 = 88,000 agent-hours; 1,000 × 13M = 13B output tokens; $10M × 1,000 ÷ 10,000 = $1,000,000 inferred. Every dollar cell is inferred — it inherits the assumed band — and every non-dollar cell is derived from published totals.
Cost per agent-hour is flat at $11.36 inferred by construction, because every cell is the same per-agent figure multiplied by agent count. This is the optimistic floor, and it is the number a budget built from a small pilot will land on. It is also wrong, because it assumes agents do not talk to each other. They sent 2.7 million messages.
Why agent swarms cost more than agents × hours: message volume × context re-reads
Agent-hours scale linearly with agents × hours. Token cost does not, because of the messages. Two effects compound, and both are modelled here with a single exponent inferred e = 0.30:
- Message volume grows faster than agent count. Each agent's per-hour rate is held at the observed 3.07 messages/agent-hour relative to a 10,000-agent fleet, so a 10x larger fleet sends about 2x the messages per agent — roughly 20x the total message volume. More peers to coordinate with means more traffic per agent, not the same traffic.
- Every message is re-read as context. Input tokens per message are held at 192,592.59 inferred — 4x the derived output tokens per message. The only published statement about input volume is that it is expected to be "far larger" than the 130B output tokens; 4x is our mid choice, and it is the unpublished half of the bill.
The price is calibrated, not observed: it is set so the 10,000-agent row equals the assumed total (that is $10M ÷ (5 × 130B) = $15.3846 per 1M tokens). The two tables therefore agree exactly at 10,000 agents and disagree everywhere else — and the direction of the disagreement is the whole point.
| Agents | Fan-out factor | Messages | Input tokens (context re-reads) | Output tokens | Cost @ $10M basis | Cost per agent | vs the linear table |
|---|---|---|---|---|---|---|---|
| 100 | 0.251 | 6,782 | 1.31B | 1.3B | $40,095 | $401 | 0.40x |
| 1,000 | 0.501 | 135,321 | 26.06B | 13B | $600,950 | $601 | 0.60x |
| 10,000 | 1.000 | 2,700,000 | 520B | 130B | $10,000,000 | $1,000 | 1.00x |
| 100,000 | 1.995 | 53,872,083 | 10.38T | 1.3T | $179,620,985 | $1,796 | 1.80x |
Every dollar cell in this table is inferred: it depends on the assumed band, on e = 0.30 and on the 4x input ratio. The marginal cost of the next agent is the number that actually rises, and it is visible even though the 10,000-agent point is pinned to the same total. Every dollar figure in the table below is inferred, from the same assumed $10M mid-band.
| Fleet step | Agents added | Cost added (mid basis) | Cost per added agent |
|---|---|---|---|
| 100 → 1,000 | 900 | $560,855 | $623 |
| 1,000 → 10,000 | 9,000 | $9,399,050 | $1,044 |
| 10,000 → 100,000 | 90,000 | $169,620,985 | $1,885 |
Marginal cost per added agent runs $623 → $1,885 (inferred, like every dollar case above) — a 3.0x rise — while the 100-agent average sits at $401. That rising slope, not the total, is the planning number for an agent-fleet budget.
The extrapolation trap
A 100-agent pilot priced with this model runs about $40,095, or $401 per agent inferred. Extrapolate that straight line to 10,000 agents and you get about $4.01M against a modelled $10M — a 2.5x undercount (both figures inferred, from the assumed band). The reverse also holds — reading the 10,000-agent total down to a 100-agent pilot overstates that pilot by 2.5x. Either direction, the straight line is wrong. Super-linearity is a statement about the slope, and one published data point cannot pin a slope.
Sensitivity of the shape, for completeness: at 100,000 agents the modelled cost is $100M if the exponent is zero (no fan-out at all), $179.62M at e = 0.30 and $272.98M at e = 0.50 — all three inferred, from the assumed band plus the assumed exponent. The exponent changes the curve's steepness; the assumed total sets its height.
The unmodelled half: verification cost, and the public dispute as the object lesson
Everything above is generation-side: output tokens plus the context re-reads they trigger. The run's own resolution did not end there, and neither should the budget — and this is the part almost every fleet cost estimate quietly leaves out.
The bounded half: machine re-checking is cheap
The 17-hour Lean formalization and verification pass is published; its token count and cost are not. Because GPT-6 Astra's rates are published on our own calculator ($10/M in, $50/M out), the bill can at least be bounded inferred:
| Assumed verification volume inferred | Tokens over 17 h (output only) | Cost at Astra's published $50/M | Share of a $10M generation bill |
|---|---|---|---|
| 0.5M tokens/hour | 8.5M | $425 | <0.01% |
| 5.0M tokens/hour | 85M | $4,250 | 0.04% |
| 50.0M tokens/hour | 850M | $42,500 | 0.43% |
Even the top rung — 50M tokens/hour for 17 hours — is about 3% of the run's own fleet-wide emission rate of 1.48B output tokens per wall-clock hour, and it stays under 1% of the generation bill. So the unmodelled half is not the Lean bill. Machine re-checking is cheap.
The unbounded half: the epistemic tail — and the dispute is the evidence
- The result is not accepted. The MathOverflow discussion thread on the claim states it "hasn't been independently verified as of this writing"; Lean machine-checks steps against stated assumptions, which is not peer review.
- Clay's bar is explicit and long: peer-reviewed publication plus two years of community acceptance. Two years of expert attention is the real tail, and nobody has priced it.
- The dispute is a cost line, not just drama. Buckmaster and Alpöge dispute credit and say they cannot tell whether their work was used; OpenAI does not rule out that de-identified product-usage data helped train the model. Verification effort here is adversarial, and adversarial verification is the most expensive kind.
- Wasted tokens are unpublished. OpenAI published no retry or failed-attempt rate. If a share of the 130B output tokens was discarded work, the cost per useful result divides by (1 − waste):
| Assumed wasted-token share inferred | Cost per verified result (mid basis) | Multiplier on the $10M generation bill |
|---|---|---|
| 0% | $10,000,000 | 1.0x |
| 25% | $13,333,333 | 1.33x |
| 50% | $20,000,000 | 2.0x |
| 70% | $33,333,333 | 3.33x |
The defensible sentence is this: the published 130B output tokens and the $10M mid-band figure cover generation; the verification path — 17 published hours of machine-checking plus an open-ended peer-review and priority dispute — is the part nobody has priced, and the public fight over the result is the evidence that this cost is real. A fleet budget that stops at tokens is budgeting the half of the bill that is measurable and missing the half that decides whether the run was worth anything.
Every assumption, stated inline
No footnotes. Six modelling choices carry every dollar figure on this page, and each one appears next to the numbers it produces:
| # | Assumption | Value | Why it is what it is |
|---|---|---|---|
| A1 | All-in total for the run | $5M–$15M (mid $10M) inferred | OpenAI published no figure. The band deliberately straddles the third-party reference points: it spans from below their output-only estimate ($6.5M) to inside their all-in range ($10M–$40M). |
| A2 | Cost allocated per output token | flat $/1M output tokens inferred | A convenience denominator that makes the implied rate loaded — it carries input, retries and infra, so it is not comparable to a list price. |
| A3 | Hours held constant across fleet sizes | 88 h at every agent count inferred | Prices a proportionally larger workload, not the same job finished faster. A faster fleet would not cost agents × more. |
| A4 | Message rate grows with fleet size | e = 0.30 (fleet messages ~ A^1.3) inferred | The most important assumption on the page: e = 0 is the naive linear case, e > 0 models fan-out and re-reads. Tested at 0.0 / 0.3 / 0.5. |
| A5 | Input tokens per message | 4x output tokens (192,592.59) inferred | The only published statement is that input volume is "far larger" than output. The ratio changes the curve's shape, not the calibrated total. |
| A6 | Our band vs the third-party range | different measurements inferred | Ours models an all-in bill; theirs is a back-of-envelope price. Do not blend them into one "estimated cost". |
Count the provenance on this page: 4 published workload inputs (agents, hours, messages, output tokens), 8 derived quantities (the rates table), and 6 inferred assumptions (A1–A6). Nothing inferred is presented as published, and no dollar figure is attributed to OpenAI.
Price your own many-agents, long-horizon workload
This page is the anchor we lacked. Until now the calculator could price a single agent or a workflow, but it had no reference for what many agents over a long horizon costs — no published workload with an agent count, a duration and a token total attached. This run is that anchor.
The agent API cost estimator runs the per-agent side of the maths on your numbers: agents × calls/agent/day × working days, a complexity multiplier for retries and fan-out, tokens per call in and out, cache-hit rate and overhead, and it reports loaded cost per agent and per resolution. What it does not carry is the fleet-scale term — a per-agent message rate that itself rises as the fleet grows. Use the table above for that: take your pilot's cost per agent, find the nearest fleet size, and move it along the curve instead of multiplying by agent count. For single-model rates, start from the GPT-Live-1 cost calculator.
Frequently asked questions
How much did the OpenAI math run cost?
OpenAI published no dollar figure — its post contains no cost language at all. The money language is other people's: OpenAI's chief research officer Mark Chen told reporters costs ran "emphatically in the millions of dollars", and a third-party estimate reported by Business Insider put the 130 billion output tokens alone at about $6.5 million and the all-in total including the far larger, unpublished input-token volume at $10M to $40M. Model the run at an assumed $5M-$15M all-in band and the implied loaded rate is $38.46-$115.38 per 1M output tokens — 2.6x to 11.5x a $10-$15/M frontier output band. That band is our assumption, not a published figure.
What does it cost to run 10,000 AI agents?
At the published shape — on the order of 10,000 concurrent agents for about 88 hours — the run is 880,000 agent-hours carrying 2.7 million messages and approximately 130 billion output tokens. Under an assumed $5M-$15M all-in bill that is $5.68-$17.05 per agent-hour ($11.36 at the $10M mid) and $1.85-$5.56 per message ($3.70 at mid). Both the bill and every dollar figure derived from it are labelled inferred: OpenAI published no cost for the run.
Why do AI agent fleets cost more than agents times hours suggests?
Because inter-agent traffic in a swarm is the part that does not scale linearly. Two effects compound: per-agent message volume rises as the fleet grows (more peers to talk to, more re-reads), and every message is re-read as context on the way into the model. Holding the 10,000-agent run as the calibration point and assuming message rate grows with fleet size to the 0.30 power — our assumption, labelled inferred — the marginal cost of the next agent runs $623 at 100 agents, $1,044 at 1,000 and $1,885 at 10,000: a 3.0x rise in slope while the average cost per agent still looks flat.
Was the result verified, and did verification cost anything?
The result is disputed and has not been independently verified; the run also used an internal, unreleased model, so it is not reproducible on any public endpoint. OpenAI published a 17-hour Lean formalization and verification pass on GPT-6 Astra — a different model from the agent fleet. Machine re-checking is cheap against the generation bill (our inferred bound is $425-$42,500, under 1% of a $10M generation bill at every rung); the expensive half is epistemic — an open peer-review and priority dispute, and Clay's bar of peer-reviewed publication plus two years of community acceptance.
How do I estimate my own agent-fleet cost?
Three steps: (1) count agent-hours, not agents — agents x hours x horizon, because that is the unit that carries the per-agent rates; (2) price the tokens the fleet actually bills, which is output tokens plus the input tokens every message re-reads as context; (3) do not extrapolate from a small pilot. A 100-agent pilot at $40,095 extrapolated straight to 10,000 agents gives about $4.01M against a modelled $10M — a 2.5x undercount (both dollar figures inferred, from an assumed $5M-$15M band), because the slope rises. The estimator on this site runs the per-agent side of that maths on your own numbers; this page supplies the fleet-scale term it does not carry.
Sources
- OpenAI, the primary post — agent count, 88 hours, 2.7M messages, ~130B output tokens, the 17-hour Lean pass on GPT-6 Astra, the unreleased agent model, and the absence of any cost language: openai.com/index/navier-stokes-solution/. The live host returns 403 to scripted fetches; the copy read for this page was the Internet Archive snapshot timestamped 2026-09-08 17:15:18 UTC, which is byte-identical in all workload numbers to the 2026-09-09 snapshot.
- CNBC, Sept 9, 2026 — quotes the release verbatim on the 10,000 "coordinating agents" and the 88-hour sentence; Buckmaster's pushback; Clay "has not yet commented": cnbc.com/2026/09/09/openai-navier-stokes-math-problem-solved.html
- phys.org (AFP), Sept 9, 2026 — origin of the money language: Mark Chen's "emphatically in the millions of dollars", Bubeck's ~1,000x comparison, Clay president Martin Bridson on the deliberately unhurried process: phys.org/news/2026-09-openai-ai-agents-math-hardest.html
- TechSpot, Sept 2026 — "unreleased AI model", the hedged "likely required millions of dollars" framing, Noam Brown's "a very expensive process", and the explanation that Lean checks steps against stated assumptions rather than judge importance: techspot.com/news/113785-openai-claims-10000-ai-agents-solved-one-mathematics.html
- Interesting Engineering, Sept 8, 2026 — the 2.7M messages and ~130B output tokens restated with the 17-hour Lean pass and the Euler side quest (~100 agents, ~50 hours): interestingengineering.com/ai-robotics/openai-navier-stokes-mystery-solved
- Science Times, Sept 9, 2026 — Clay's eligibility rules (peer-reviewed publication plus two years of community acceptance) and the statement that the problem "is not officially considered solved": sciencetimes.com — the "million dollar Navier-Stokes problem" report
- Business Insider, Sept 2026 — the third-party cost estimate (LisanBench on X: ~$6.5M output-only at an assumed average consumer price; $10M–$40M including the far larger input volume), the note that input volume is expected to be "far larger", and Sam Altman's reply on X: businessinsider.com/openai-math-problem-solved-tokens-cost-altman-2026-9
- MathOverflow question 515056 — the community discussion stating the claim "hasn't been independently verified as of this writing", and the (C)/(D) vs (A)/(B) scope boundary: mathoverflow.net/questions/515056
- Wikipedia, "Navier–Stokes priority controversy" — used only for the credit-dispute timeline. It contains a known conflation (it pairs 4.9M messages with 130B tokens); this page uses the primary source's pairing (2.7M with ~130B, Navier–Stokes only): en.wikipedia.org/wiki/Navier–Stokes_priority_controversy
- Our own published rates, used as the comparison set — GPT-6 Astra $10/$50 per 1M and GPT-5.6 Terra $12/M output: aiagencycalculator.com/gpt-live-1-cost-calculator and aiagencycalculator.com/openai-gpt-6-astra-pricing
Accuracy note: the agent count ("on the order of 10,000 concurrent agents", final stage), the 88-hour window, the 2.7 million messages, the ~130 billion output tokens, the 17-hour Lean pass on GPT-6 Astra and the unreleased status of the agent model are OpenAI's own published statements. The all-in band ($5M–$15M mid $10M), the e = 0.30 fan-out exponent, the 4x input-token ratio, the 192,592.59 input tokens per message, the verification volume rungs and the wasted-token shares are our assumptions, labelled inferred wherever they produce a number. The derived rates (880,000 agent-hours, 147,727 output tokens and 3.07 messages per agent-hour, 48,148 output tokens per message as a ratio of two totals, 1.48B fleet tokens/hour) are arithmetic on the published totals, not OpenAI-provided unit costs. The dispute, the unverified status of the result, the unreleased model and the non-reproducibility of the run on public endpoints are stated above and are not qualifications to be dropped: nothing on this page asserts that a proof is accepted, and no dollar figure is attributed to OpenAI.