Did OpenAI actually solve Navier-Stokes?

The Claim: A Machine-Checked Proof Nobody Fully Understands

On September 8, 2026, OpenAI announced something extraordinary: an internal multi-agent system had produced a 166-page proof resolving the Navier–Stokes existence and smoothness problem, one of the Clay Mathematics Institute's seven Millennium Prize Problems. The proof's Lean formalization compiled successfully, and per mathematicians interviewed by NPR, community consensus leans toward the formalization being correct.

The scale of the effort was staggering. The successful agent group ran roughly 10,000 concurrent agents, exchanging 2.7 million messages and generating about 130 billion output tokens over 88 hours, followed by 17 more hours to formalize the proof in Lean, according to OpenAI's own account. Different agent groups were prompted with different variants of the problem — some implying proof, others disproof — while Codex shuttled insights between them, and a stepping-stone result on the unforced Euler equations (solved by ~100 agents in ~50 hours) guided the approach.

Yet the honest answer to "did they solve it?" is probably, not certainly. Three caveats stand out:

• The Clay Mathematics Institute has not acknowledged any correct solution, and OpenAI itself says its model merely "proposes" a solution.
• A Cambridge team found a "mistranslation" between the natural-language proof and the Lean code — the PDF requires a value below m + 4, while the Lean proof uses the weaker m + 5 — and it took them about two weeks to find even that one discrepancy.
• Mathematicians report the proof has yielded almost no human understanding; as Oxford's James Maynard put it, "It's been very difficult to really extract any human understanding from this new AI proof."

Kevin Buzzard of Imperial College captured the paradox bluntly: he is confident the problem was correctly resolved, but "far less confident" the human-readable PDF is correct. Even OpenAI doesn't fully understand its own model's reasoning, and the Clay Institute's silence means the $1M prize remains unclaimed — OpenAI has said it doesn't intend to claim it.

This is the trust gap every AI output now carries: results that are impressive, machine-checkable in one form, and yet hard for any human to independently verify. It's the same problem anyone faces when an agent produces code, analysis, or a workflow — the output looks finished, but verification is a separate, costly step. That's precisely why independent verification matters, whether the subject is a Millennium Prize proof or the agent skills that power everyday automation. SkillzBench is being built on that principle: pinning every skill to a commit SHA, security-scanning it, and benchmarking it in a sandbox so you never have to take an agent's word for anything. Skills, proven — join the waitlist at skillzbench.com to see what's coming.

Inside the Agent Swarm: How AI Actually Attacked Frontier Math

If you want to know how AI actually attacked a Millennium Prize Problem, forget the image of a single genius model pondering fluid dynamics. The real story is a swarm: roughly 10,000 coordinating agents, each armed with tools and a slightly different version of the problem, grinding through one of mathematics' hardest open questions.

The architecture, described in OpenAI's own announcement, reads like a case study in brute-force orchestration. Different agent groups received different framings of the Navier–Stokes problem statement — variants A and B implied a proof of smoothness, while C and D implied a disproof — so the swarm covered the entire problem space rather than betting on one interpretation. The agents had access to cached internet browsing and code execution, and Codex was used to cross-pollinate insights between groups, feeding what one cluster learned into another's context.

The effort was quantified in staggering terms. Resolution took about 88 hours from the launch of the first agents, with an additional 17 hours to formalize the argument in Lean, the machine-checkable proof language. Along the way the agents exchanged 2.7 million messages and produced roughly 130 billion output tokens. NPR's reporting put the estimated cost at $6–10 million for the Navier–Stokes attempt alone, based on OpenAI's public pricing — electricity alone ran "in the order of millions," per researcher Noam Brown.

Notably, OpenAI didn't jump straight at the prize. The team first pointed a much smaller swarm — about 100 agents over roughly 50 hours — at the unforced Euler equations regularity problem, a stepping-stone result that guided the decision to focus on Navier–Stokes. It's a classic agent-builder pattern: validate the pipeline on a tractable variant before committing full compute.

• Variant prompting beats single framing. Covering proof and disproof variants (A/B vs. C/D) let the swarm explore the whole problem space instead of anchoring on one guess.
• Cross-pollination is a first-class tool. Using Codex to move insights between agent groups meant no cluster's discovery stayed siloed.
• Stepping stones de-risk big runs. The ~100-agent, ~50-hour Euler result proved the pipeline worked before 10,000 agents were committed.
• Verification still needs a separate layer. Agents coded arguments into Lean so logical steps could be machine-checked — and even then, Cambridge reviewers spent about two weeks finding one true discrepancy between the Lean proof and the natural-language paper.

The takeaway for anyone building agents: this was scale and orchestration, not a eureka moment. No single model "understood" the proof — more than a month later, no one fully does, and experts say the paper "is not written for humans." The winning ingredients were mundane: many concurrent agents, diverse problem framings, shared tools, and a machine-checkable verification target.

That same lesson applies at ordinary scale. Agent output is only as trustworthy as the skills and tools behind it, which is exactly the problem SkillzBench is building for — independently verifying, security-scanning, and benchmarking agent skills so you can see the lift each one actually delivers. Browse the free directory and join the waitlist at SkillzBench — skills, proven.

Where It Fell Apart: Verification Gaps, Contamination, and a Priority Fight

The cracks appeared almost immediately — and they came from the very people best qualified to spot them. A Cambridge team spent roughly two weeks auditing the proof and found a mistranslation between the natural-language paper and its Lean formalization: the prose proof required a value below m + 4, while the Lean version demanded only below m + 5 — a weaker statement. The machine-checked proof and the human-readable proof were not, in fact, proving the same thing.

That gap matters because Lean compilation is being treated as a replacement for peer review. Cambridge mathematician Fabian Circelli argued that AI auto-formalization "can't serve the same purpose" as traditional review, and his colleague Anders Hansen warned that LLM-generated proofs still "have to be read by humans, creating an enormous extra burden on mathematicians." Kevin Buzzard of Imperial College distilled the situation perfectly: "I am confident that the Navier-Stokes problem has been correctly resolved. I am far less confident that the proof described in the PDF is correct."

The timing raised its own questions. Mathematicians Tristan Buckmaster and Levent Alpöge announced related results about 12 hours before OpenAI's announcement, and Buckmaster alleged his Codex session data had been leaked and used in training. OpenAI admitted using "de-identified" and "derived" data from those sessions, while denying the prompts influenced the system. The dispute may never resolve — as Camillo De Lellis of the Institute for Advanced Study put it, it's "not anymore a matter of clearly verifiable mathematical facts."

The mathematical community's response was swift. Between 25 and 28 Fields Medalists (accounts differ) signed a September 11 declaration warning against treating unsolved problems as AI benchmarks without enhancing human understanding. OpenAI's reply — forming an advisory group that explicitly would not advise on pacing — did little to calm concerns.

For anyone building with agents, the lessons are concrete:

• Agent output always needs independent verification — even a 166-page proof backed by machine checking contained a silent translation error.
• Formal verification can drift from intent; the Lean proof held while the underlying claim weakened.
• Agent conversations can end up in training data, as the Codex controversy shows.
• Scale isn't understanding — 10,000 agents and ~130 billion tokens produced results humans still can't fully interpret.

This is exactly the trust problem SkillzBench is being built to address: independently verifying agent skills through security scanning and sandboxed benchmarking, so you know what a skill actually does before your agent runs it. If you're assembling agent tooling, you can join the waitlist to browse and test free, verified skills when it launches. Skills, proven — not just claimed.

What This Means for Anyone Running Agents at Work

The most uncomfortable lesson from the Navier–Stokes saga isn't that agents solved a Millennium Prize problem — it's that nobody, including OpenAI, fully understands how they did it. More than a month after the announcement, experts report that no one fully understands the proof, and the 166-page paper "is not written for humans," as Brown University's Javier Gómez-Serrano put it. It doesn't explain what's important, what's routine, or how ideas connect.

For anyone running agents at work, that's the reality check. Agent swarms can produce genuinely valuable output — the successful run involved roughly 10,000 concurrent agents, 2.7 million messages, and an estimated $6–10 million in compute. But the output arrives as a black box, and verification doesn't automate away. The Lean formalization compiled cleanly, yet a Cambridge team needed about two weeks to find a silent "mistranslation" between the natural-language proof and the machine-checked version — the Lean proof demanded a weaker condition than the paper claimed. The formalization drift was invisible until humans dug in.

Three practices follow directly from this:

• Demand machine-checkable outputs where possible. Lean caught the logical structure — but only because it existed. Ask your agents for verifiable artifacts: tests, schemas, executable checks, not just prose.
• Verify independently. Don't trust the same system that produced the work to grade it. The Cambridge reviewers found the discrepancy precisely because they checked the formalization against the paper themselves.
• Treat agent tooling with the same skepticism as agent output. Published research found roughly 26% of agent skills carry at least one vulnerability — and skills shape what your agents do before you ever see the result.

There's also a quieter operational risk: data contamination. OpenAI admitted using "de-identified" and "derived" data from users' Codex sessions in training, a dispute that fueled the priority controversy with mathematicians Tristan Buckmaster and Levent Alpöge. Assume anything your agents touch may circulate further than you intended.

This is the trust problem SkillzBench is being built to solve: pinning every skill version to a commit SHA, security-scanning, and benchmarking each skill in a sandbox with the same model, with and without it, publishing the Lift in percentage points. Agent skills can automate the rest of your workflow — browse and test free, verified ones on SkillzBench, where every claim has to prove itself.

Your Next Step: Verified, Benchmarked Agent Skills

Here's the uncomfortable takeaway from the Navier-Stokes saga: a system of roughly 10,000 concurrent agents produced a 166-page proof, and even OpenAI didn't fully understand what its own model had written. Raw agent capability, at any scale, means nothing without independent verification.

The verification gap was real. A Cambridge team spent about two weeks and found a "mistranslation" between the natural-language proof and its Lean formalization — the Lean version required a value below m + 5, where the paper claimed m + 4, a weaker statement. Kevin Buzzard of Imperial College put it plainly: he was confident the problem was resolved, but far less confident the proof described in the PDF was correct. The Clay Mathematics Institute has not acknowledged any solution.

That's a math problem at a cost estimated at $6–10 million. Now scale the trust problem down to something you actually use: agent skills. Research has found that roughly 26% of published skills carry at least one vulnerability, and almost none come with evidence they improve your agent's work at all. You're in the same position as the mathematicians — handed output, told it works, given no way to check.

Independent verification is the fix, and it's what SkillzBench is building around agent skills:

• Every skill pinned to a specific commit SHA, so you know exactly which version you're running
• Security scanning, license checks, and quality review on each listing
• Sandboxed benchmarks that run the same model with and without a skill, publishing the measured Lift in percentage points
• A free MCP connector so your agent only sees the vetted tools you've chosen

The Fields Medalists who signed the September 11 statement warned against treating unsolved problems as benchmarks without enhancing human understanding. The same principle applies to your stack: a skill that claims to help means little without a benchmark showing how much. That's why Lift is always shown separately from ratings, and money never touches scores.

SkillzBench is pre-launch and actively being built — the directory, the benchmarks, and the MCP connector will all be free when it ships, funded by blog advertising rather than user fees. Join the waitlist now to browse and test free, verified skills at launch.

Skills, proven.