For nearly a century, the Navier–Stokes equations have stood as one of mathematics’ most formidable unresolved challenges. Now OpenAI says an internal artificial intelligence system has produced an analytical proof showing that the three-dimensional incompressible Navier–Stokes equations can develop a singularity in finite time, a result that would resolve one of the seven Millennium Prize Problems.
But for the supercomputing community, the most important part of the announcement may not be the mathematics itself. It is how the mathematics was discovered.
OpenAI says it attacked the problem with a coordinated system of about 10,000 concurrent AI agents, generating about 2.7 million inter-agent messages and about 130 billion output tokens during the Navier–Stokes effort. The agents reached their resolution approximately 88 hours after the project began, followed by another 17 hours of Lean formalization and verification using GPT-6 Astra.
The result represents something potentially more consequential for scientific computing than a single mathematical proof: a demonstration of what happens when reasoning itself becomes a massively parallel workload.
The problem is not writing down Navier–Stokes
The Navier–Stokes equations describe fluid motion by applying Newtonian mechanics to a continuous fluid.
For an incompressible fluid with constant density, a commonly used form is
$$
\frac{\partial \mathbf{u}}{\partial t}
+
(\mathbf{u}\cdot\nabla)\mathbf{u}
-\frac{1}{\rho}\nabla p
+
\nu\nabla^2\mathbf{u}
+
\mathbf{f},
$$
with
$$
\nabla\cdot\mathbf{u}=0.
$$
Here, (\mathbf{u}) is the velocity field, (p) is pressure, (\rho) is density, (\nu) is kinematic viscosity and (\mathbf{f}) represents external forcing.
The equation is deceptively compact.
The difficulty is the nonlinear advection term,
$$
(\mathbf{u}\cdot\nabla)\mathbf{u},
$$
which allows the velocity field to interact with its own gradients. At the same time, viscosity represented by
$$
\nu\nabla^2\mathbf{u}
$$
acts to smooth the flow.
The Millennium Prize question is whether a smooth three-dimensional solution that begins from smooth initial conditions must remain smooth for all time, or whether the velocity can become unbounded in finite time.
That is the central tension: nonlinear amplification versus viscous dissipation.
OpenAI’s proposed construction involves a vortex that spirals inward and becomes increasingly elongated. As the central region contracts, the fluid velocity increases without bound while the total energy remains finite.
That distinction is critical.
A trivial way to make velocity blow up would be to simply inject an infinite force into the system. The actual mathematical challenge is to produce the singularity from the dynamics of the Navier–Stokes equations themselves while maintaining a smooth external force.
OpenAI says its solution achieves that by arranging for the acceleration, pressure gradient, momentum transfer and viscous terms to become large while canceling one another with sufficient precision to leave a smooth forcing function even as the velocity diverges.
The breakthrough was not one AI thinking really hard
The conventional mental model of an AI solving a difficult mathematical problem is straightforward:
Question → giant model → answer.
That is not what OpenAI describes.
Instead, the company constructed a multi-agent computational system.
The agents were powered by an internal model that OpenAI says was significantly more capable than GPT-6 Astra. They could execute code, access a cached version of the internet and communicate within groups. The groups were deliberately varied in size and approach.
For Navier–Stokes, approximately 10,000 agents were running concurrently.
That changes the computational problem completely.
Rather than asking one model to explore a gigantic mathematical search space sequentially, OpenAI effectively created thousands of simultaneous research trajectories.
One agent could investigate a vortex construction.
Another could attack its regularity assumptions.
Another could search for an energy estimate.
Another could attempt a contradiction.
Another could investigate scaling.
Another could test whether a proposed lemma actually followed from the equations.
Another could attempt to formalize an argument.
Most of those paths could fail.
That was acceptable.
The objective was not to make every worker succeed. The objective was to make the aggregate search process succeed.
Mathematics becomes a parallel workload
This is where the OpenAI experiment starts looking surprisingly familiar to HPC engineers.
A conventional supercomputer takes a large computational problem and decomposes it into many pieces.
A computational fluid dynamics application might divide a three-dimensional domain across thousands of processors. Each process works on its local portion of the numerical domain and periodically exchanges information with neighboring processes.
The OpenAI system performed a different kind of decomposition.
It did not divide the physical fluid domain.
It divided the space of possible mathematical arguments.
Instead of exchanging pressure and velocity values, the agents exchanged mathematical information:
- conjectures,
- lemmas,
- proof fragments,
- counterexamples,
- constructions,
- failed approaches,
- transformations,
- estimates,
- and refinements.
In that sense, OpenAI’s experiment can be viewed as a primitive form of distributed reasoning architecture.
The computational domain was not physical space.
It was proof space.
The Euler equations provided the first foothold
The system did not immediately throw all available resources at the full Navier–Stokes problem.
OpenAI also gave the agents easier related problems.
One was the regularity problem for the Euler equations, obtained by removing the viscosity term from Navier–Stokes.
The Euler equations can be written schematically as
$$
\frac{\partial\mathbf{u}}{\partial t}
+
(\mathbf{u}\cdot\nabla)\mathbf{u}
-\frac{1}{\rho}\nabla p.
$$
The missing viscous term makes the problem different, and in some respects more tractable.
Nearly 100 agents worked on the unforced Euler regularity problem for approximately 50 hours and produced what OpenAI describes as a disproof.
That result became strategically important.
Once the Euler result appeared, OpenAI redirected resources toward Navier–Stokes and supplied the agents with the Euler resolution as an input to their subsequent reasoning.
This is analogous to a common HPC and numerical-science strategy:
solve a reduced problem → identify structure → use that structure to attack the full problem.
The AI system was not simply generating random mathematical guesses.
It was accumulating computationally discovered structure.
Diversity was an engineering feature
OpenAI says it deliberately encouraged different agent groups to pursue diverse approaches.
That matters because thousands of identical agents would not necessarily provide thousands of times the intellectual coverage.
If 10,000 agents all follow the same reasoning path, the system can simply produce 10,000 copies of the same failure.
Diversity increases the probability that some workers will escape local minima in the mathematical search space.
The system therefore used different formulations of the Millennium problem.
Groups were given versions labeled A and B, where establishing the relevant proposition would constitute a proof, while other groups were given C and D, where the objective was to establish a disproof.
That effectively created competing computational hypotheses.
The architecture resembles an ensemble search:
$$
H_1,H_2,H_3,\ldots,H_N
$$
where each (H_i) represents a different mathematical route.
The system does not know in advance which route will work.
It explores many.
Then the system started cross-pollinating ideas
One of the most interesting details in OpenAI’s description is the use of Codex to consolidate useful intermediate results from different groups.
This created a feedback loop.
The workflow was approximately:
parallel exploration
↓
partial mathematical discoveries
↓
consolidation
↓
new prompts informed by those discoveries
↓
another round of parallel exploration
↓
candidate proof
The importance of that architecture cannot be overstated.
Without information sharing, the 10,000 agents would largely be independent researchers.
With controlled information sharing, the system becomes an evolving computational network.
A discovery made by one group can become the starting point for thousands of other investigations.
That is conceptually similar to iterative distributed optimization, except the object being optimized is not a numerical objective function.
It is a mathematical argument.
2.7 million messages are part of the computation
During the Navier–Stokes effort, OpenAI reports that its agents exchanged approximately 2.7 million messages and generated approximately 130 billion output tokens.
Those numbers illustrate why this should not be thought of as a conventional chatbot interaction.
The system was effectively operating a large-scale computational workload in which language became the medium for transmitting mathematical state.
A conventional HPC application might communicate something like:
$$
u_{i,j,k}^{(t)}
$$
between processes.
The AI system instead communicates things closer to:
This estimate fails under this scaling assumption.
or:
This transformation preserves incompressibility.
or:
This construction causes the energy integral to diverge.
or:
This lemma closes the remaining regularity gap.
The payload is semantic rather than numerical.
That creates a fascinating new category of distributed computing.
130 billion tokens are not 130 billion FLOPS
There is an important distinction for HPC readers.
OpenAI’s 130-billion-token figure should not be interpreted as 130 billion floating-point operations.
A token is an output unit generated by a language model.
The underlying computation includes neural-network matrix operations, memory movement, accelerator utilization, synchronization, networking, and orchestration overhead.
OpenAI has not publicly disclosed enough information in this announcement to calculate a reliable FLOP count, accelerator count, GPU-hour total or energy consumption for the Navier–Stokes run.
That means comparisons with traditional supercomputers based purely on the token figure would be speculative.
But the token count is still useful because it establishes the scale of the reasoning workload.
Approximately 130 billion generated tokens were used in exploring the mathematical problem.
The significant point is that scientific reasoning itself became compute-intensive.
The real accelerator was concurrency
The 88-hour figure is impressive, but it needs context.
OpenAI did not compress approximately 90 years of mathematical history into 88 hours by making a single AI think 90 years faster.
It changed the topology of the work.
Traditional mathematical research is heavily sequential:
$$
\text{idea}
\rightarrow
\text{proof attempt}
\rightarrow
\text{failure}
\rightarrow
\text{new idea}
\rightarrow
\text{proof attempt}.
$$
The OpenAI system can execute thousands of these loops simultaneously:
$$
\begin{array}{cccc}
A_1 & A_2 & A_3 & \cdots A_{10,000}\
\downarrow & \downarrow & \downarrow & \
P_1 & P_2 & P_3 & \cdots P_{10,000}
\end{array}
$$
where each (A_i) represents an agent and (P_i) its current mathematical search path.
The overwhelming majority can fail.
The system only needs some fraction to generate useful information.
This is exactly the kind of strategy that has driven scientific computing for decades:
replace a long serial computation with a much larger parallel computation.
The difference is that the computational units are now AI researchers rather than conventional numerical kernels.
The vortex is the mathematical payoff
The final construction is particularly interesting from a computational-fluid-dynamics perspective.
OpenAI describes the solution as a vortex that spirals inward while becoming increasingly elongated.
The central region contracts.
Its rotational speed increases.
Its geometry stretches.
Yet its total energy remains finite.
That creates the critical singular behavior:
$$
|\mathbf{u}| \rightarrow \infty
$$
as
$$
t\rightarrow T^-,
$$
where (T) is a finite time.
The remarkable aspect is that the divergence occurs while the overall energy remains finite.
This is where the nonlinear terms become decisive.
The velocity field is simultaneously producing stronger gradients and stronger nonlinear transport while viscosity attempts to dissipate those gradients.
The proposed solution requires these competing contributions to become large but cancel with extraordinary precision.
OpenAI describes the resulting flow as a central vortex whose shrinking and acceleration produce the finite-time singularity while maintaining finite energy.
For numerical scientists, this is precisely the kind of regime in which straightforward simulation becomes extraordinarily difficult.
The relevant scales can separate dramatically, gradients become increasingly sharp, and numerical resolution requirements can become prohibitive.
The proof therefore matters not because a supercomputer can simply simulate the singularity.
It matters because the mathematical construction establishes what the equations themselves permit.
From probabilistic AI to deterministic proof checking
There is another layer that may ultimately prove even more important.
Large language models are probabilistic systems.
They can generate highly plausible mathematical statements that are wrong.
OpenAI therefore used a second stage: formal verification in Lean.
The agents produced an analytical proof.
That proof was then formalized and verified using Lean, with GPT-6 Astra completing the formalization and verification in approximately 17 additional hours.
The architecture can therefore be thought of as:
AI discovery
→
candidate mathematical proof
→
formalization
→
machine-checked proof
That is a powerful division of labor.
The AI is the heuristic search engine.
The formal proof system is the correctness gate.
The first stage explores an enormous space of possible arguments.
The second stage rejects arguments that do not satisfy the formal rules.
For scientific computing, that distinction is enormously important.
This could be a new model for scientific computing
Traditional HPC has generally focused on accelerating numerical computation.
The emerging AI-HPC model may instead accelerate scientific workflows.
Consider a future research system:
AI agents
generate hypotheses.
HPC simulation
tests them.
AI agents
analyze the simulation output.
Formal mathematics
checks theoretical claims.
HPC
runs higher-resolution simulations based on the surviving hypotheses.
AI agents
repeat the cycle.
That creates a closed computational loop:
$$
\text{Hypothesis}
\rightarrow
\text{Simulation}
\rightarrow
\text{Analysis}
\rightarrow
\text{Theory}
\rightarrow
\text{Verification}
\rightarrow
\text{New Hypothesis}.
$$
The OpenAI Navier–Stokes effort represents an early example of one portion of that loop becoming massively parallel.
Supercomputers may increasingly compute ideas, not just numbers
This may ultimately be the biggest takeaway.
For decades, the performance race in HPC has been measured in FLOPS.
Scientific applications have been optimized around vectorization, parallel decomposition, memory bandwidth, interconnect latency and accelerator utilization.
AI introduces another resource:
reasoning throughput.
A future scientific supercomputer may therefore contain conventional CPU/GPU resources alongside enormous fleets of inference accelerators running thousands, or potentially millions, of autonomous scientific agents.
The computational workload would not simply be:
Calculate 10 trillion pressure values.
It could be:
Explore 100 million possible mathematical explanations for why this simulation behaves this way.
That is a fundamentally different conception of supercomputing.
The caveat: a proof announcement is not the end of mathematical review
There is an important distinction between OpenAI producing and formally checking a proof and the broader mathematical community accepting the result as the definitive resolution of a Millennium Prize Problem.
OpenAI says it is releasing an analytical proof together with a Lean formalization, but also explicitly says it does not intend to claim the $1 million Millennium Prize.
That restraint is significant.
The result will require scrutiny by mathematicians who were not involved in the system, including examination of the assumptions, construction, formalization and relationship between the formal proof and the official Clay Mathematics Institute formulation.
OpenAI also acknowledges concurrent work by Levent Alpöge and NYU mathematician Tristan Buckmaster, although it says their work concerned the forced Euler problem and differed substantially from OpenAI’s result.
So the appropriate description at this stage is an AI-generated proposed resolution backed by a formal Lean verification, rather than declaring that mathematical history has already closed the book.
The bigger race is now computational
The Navier–Stokes announcement may ultimately be remembered for the mathematical breakthrough, but the supercomputing industry should focus on the underlying methodology. OpenAI demonstrated a system where 10,000 autonomous AI agents simultaneously navigated a complex scientific landscape, exchanging intermediate findings, consolidating successful approaches, and producing a verifiable solution in just 88 hours.
With 130 billion output tokens and 2.7 million inter-agent messages, this workflow represents a fundamental shift: we are moving from chatbots to distributed scientific-computing workloads. The computational unit is no longer limited to threads, processes, or GPU kernels; it now encompasses autonomous reasoning agents, while the communication fabric now transmits semantic mathematical insights rather than just floating-point arrays.
This experiment signals a new era of high-performance computing. If AI can reliably decompose scientific challenges, iterate through competing hypotheses, and leverage formal verification, the next generation of supercomputers will do more than simulate the physical world; they will accelerate our ability to reason about it. Ultimately, the benchmark of the future may not be how many calculations a machine can perform per second, but how many scientifically meaningful ideas it can explore and synthesize before the next deadline.