OpenAI Navier-Stokes Solution: What GPT-6 Astra Actually Did

On 8 September 2026 OpenAI published On the Navier-Stokes Millennium Prize Problem. The headline claim is a finite-time singularity for three-dimensional incompressible Navier-Stokes: an initially smooth fluid at rest, with a smooth external force and finite energy, can blow up.

The model that found that proof is not GPT-6 Astra, and it is not for sale. OpenAI says an internal system "significantly more capable than GPT-6 Astra" produced the analysis. Astra's documented job was the Lean formalization, about 17 hours. OpenAI is not claiming the Clay Millennium Prize. The Clay Institute page still lists the problem Unsolved.

The public model is Astra. It is live on RouterPlex as gpt-6-astra at $10 / $50 per 1M at or below 272K input tokens.

Did OpenAI solve Navier-Stokes? #

Search is asking a yes/no question. The accurate answer is narrower than the headlines.

Clay's write-up splits the problem into smoothness statements (A and B) and blow-up statements (C and D). OpenAI assigned A/B to some agent groups and C/D to others. The published result is a disproof of "solutions always stay smooth" under a smooth force, not a proof that every smooth initial condition stays regular with no force.

The picture they give is a vortex that spirals inward and stretches, "like spaghetti," with the Navier-Stokes terms getting large yet cancelling so the external force stays smooth while velocity unbounded.

That is a serious claim. Independent mathematicians still have to read the write-up and the Lean. Until Clay moves the listing, "solved" is OpenAI's word, not the Institute's.

Did GPT-6 Astra solve Navier-Stokes? #

No.

OpenAI is explicit: the search was run on an internal model whose training started around 28 August 2026 and is still improving. GPT-6 Astra entered after the agents had a resolution, to formalize and verify the proof in Lean.

Internal model  →  analytical proof (not a public API)
GPT-6 Astra     →  Lean formalization + verification (~17 hours)

If a pricing table, Reddit thread, or model card says "Astra solved Navier-Stokes," it collapsed two models into one. Astra is the public flagship. The solver is not on any catalog, including ours.

How OpenAI found the Navier-Stokes solution #

OpenAI says it launched the effort on Tuesday 1 September 2026 after rumors that two Millennium problems had been resolved. Agents could read a cached internet and run code. Groups could talk inside the group. The Navier-Stokes group was on the order of 10,000 concurrent agents.

A warmup problem came first: blow-up for the Euler equations (Navier-Stokes with viscosity removed). Agents produced an unforced Euler regularity disproof — no external force — with nearly 100 agents over about 50 hours. OpenAI then moved capacity onto Navier-Stokes and fed those groups the Euler result. Codex was used to consolidate insights across groups.

Ten thousand concurrent agents is not a ChatGPT session. It is a swarm with a budget. If you try to copy the shape of that work on a public model, the failure mode is a drained key, not a Clay prize.

What 130 billion output tokens cost at GPT-6 Astra rates #

You cannot buy the solver, so you cannot reproduce this bill. You can translate OpenAI's token counts onto the public list rate, which is the number developers actually search.

Astra list output is $50 per 1M tokens at or below 272K input.

130,000,000,000 output tokens × $50 / 1,000,000  =  $6,500,000

That is output only, at Astra's public rate, for the Navier-Stokes subset. It ignores input tokens, reasoning tokens billed as output, the unpublished solver's real cost, and the other Millennium attempts (another ~170 billion output tokens). New Scientist reported the effort at $15 million. The $6.5 million figure is the floor you get if you pretend the 130 billion output tokens were Astra.

On RouterPlex a 40,000-in / 2,000-out Astra turn is about $0.50. The 272K cliff still applies: cross 272,000 input tokens and the whole request bills $20 / $75, not $10 / $50. A research agent that quietly grows its context will double the request before you notice, then keep going.

That is the practical lesson of this announcement. The interesting model is private. The public model is expensive. If you run a swarm, put it on a prepaid key with a hard budget so the run stops at $0 instead of going negative.

Live numbers: GPT-6 Astra, GPT-5.6 Sol, the rest of the OpenAI catalog.

Concurrent Euler work #

OpenAI says the 1 September rumor later turned out to be Levent Alpöge (Anthropic) and Tristan Buckmaster (NYU). After Lean verification on 6 September, OpenAI reached out expecting a Navier-Stokes result and found they had forced Euler. OpenAI recognizes their priority on forced Euler, says the researchers and the agents did not see that work before it was public, and notes the Euler statements differ: forced versus unforced.

This page is not a courtroom. Two groups published nearby results in the same week. The Lean and the write-ups are the artifacts to read, not the rumor timeline.

GPT-6 Astra is available on RouterPlex #

The solver from the OpenAI Navier-Stokes solution is not an API. GPT-6 Astra is. Model ID gpt-6-astra, OpenAI list rates, no per-token markup, same prepaid key as Sol, Terra, Luna, and the rest of the catalog.

Create a key, set a hard budget, and send a standard chat-completions request:

curl https://api.routerplex.com/v1/chat/completions \
  -H "Authorization: Bearer $ROUTERPLEX_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "gpt-6-astra",
    "messages": [
      {"role": "user", "content": "Formalize the riskiest assumption in this proof sketch."}
    ]
  }'

The Python client is the regular OpenAI SDK. Only the base URL, key, and model ID change:

import os
from openai import OpenAI
 
client = OpenAI(
    api_key=os.environ["ROUTERPLEX_API_KEY"],
    base_url="https://api.routerplex.com/v1",
)
 
response = client.chat.completions.create(
    model="gpt-6-astra",
    messages=[{"role": "user", "content": "Check this lemma for a hidden unbounded term."}],
)
 
print(response.choices[0].message.content)

Claude Code and the Anthropic SDK reach the same model at https://api.routerplex.com with gpt-6-astra as the model string. Setup is in the Claude Code guide. Cursor users can override the OpenAI base URL to https://api.routerplex.com/v1.

Astra is the current public OpenAI flagship, not a discount SKU. Use it when the task needs the newest model and you can stay under 272K. Use GPT-5.6 Sol at $5 / $30 when evaluation does not pay for doubling input. Do not point a 10,000-agent swarm at Astra without a cap.

Start a $5 RouterPlex test, put gpt-6-astra on its own budgeted key, and run one live request. That is the model you can actually call.