After Fermat, Navier-Stokes?
On September 8, OpenAI announced it had resolved the Navier–Stokes existence and smoothness problem—one of the seven Millennium Prize Problems, open for roughly ninety years. The question, at its simplest: can smooth fluid motion break down and develop a singularity in finite time? Nobody could prove it either way.
OpenAI's internal system did, in 88 hours, for the version the official problem statement allows: a fluid at rest, pushed only by an ordinary, smooth force, develops exactly that kind of breakdown—a vortex that spirals inward, stretching and speeding up, staying perfectly well-behaved right up to the moment it isn't. The system that found it wasn't a single model reasoning end to end. It was on the order of 10,000 concurrent agents, split into groups exploring different variants of the problem, periodically cross-pollinated by having a model consolidate the most promising results and hand them back out. Lean formalization took another 17 hours.
Fittingly enough, what converged on that vortex was itself something like one: ten thousand agents, spiraling toward a single answer.
Fermat's margin, Navier's fluid: the frontier of AI research increasingly looks like a race back across a mountain range mapped by mathematicians centuries dead, retracing the routes they opened and pushing on toward the summits they left unconquered—good material for headlines, but not, I think, where the real story sits.
The Arrow of Time
An LLM decodes one token at a time, left to right. Even a model trained to "think" before answering is still, mechanically, producing that chain of thought the same way: forward, one token after the next, never erasing what it already committed to the page. Autoregression somehow imposes an arrow of time on reasoning.
Human problem-solving doesn't work that way. We try something, hit a contradiction, abandon it, walk back to an earlier fork, take a different branch, and sometimes return to combine two lines of thought that started out unrelated.
A Forest of Thoughts
There's a name for making that geometry explicit: Tree-of-Thoughts (ToT), the search framework Shunyu Yao and colleagues published back in 2023. Treat each intermediate reasoning step as a node, let the model propose several candidate next steps at once, evaluate them, and search the resulting tree the same way you'd search any other one—breadth-first, depth-first, abandon a branch, go back, try another.
Run that search once and you have a tree. Run it ten thousand times at once, each one exploring the problem from its own angle, periodically comparing notes and grafting the most promising branches from one onto another, and a tree stops being the right word. You have a forest—and something has to decide which trees get cut down and which ones the whole expedition keeps following.
The move that matters isn't giving any single model this ability. It's building a harness around the models that does the branching and the backtracking on their behalf, one call at a time. Each model still only moves forward, one token after another. The system no longer has to.
A Herd of Horses
A horse doesn't back up, or turn on its own initiative, or send a scout down a side trail while it keeps walking the main one. It moves forward, on command, with whatever strength it has. What decides where it goes—when it stops, when it doubles back, when another horse gets sent ahead to check a different path—was never the horse. It was always the harness, the rider, the map, the whole expedition built around the animal.
Ten thousand concurrent agents pulling at the same fluid equation from different angles, periodically consolidated and redirected, is that expedition at a scale no cavalry ever had: not one horse being steered, but a herd of them, each moving forward exactly as a horse does, while something above the herd decides which trails get abandoned, which get reinforced, and which two need to be merged into one.
Giving Computation a Geometry
It's tempting to describe this as simply letting the model think longer. That undersells what changed. Test-time compute could mean one long trajectory, run ten thousand times in parallel and averaged—more of the same shape. What OpenAI describes is a different shape entirely: ten thousand trajectories, branching, periodically compared against each other, the most promising fragments extracted and redistributed, some branches abandoned outright and others resumed later from an earlier checkpoint. Across the full set of Millennium Prize attempts, OpenAI says the herd sent 4.9 million messages and produced roughly 300 billion output tokens; the Navier–Stokes branch alone accounted for 2.7 million of those messages and about 130 billion of those tokens.
More inference is useful. Inference organized into a tree is a different kind of resource altogether. The advance here isn't more horsepower, but a geometry built to channel that power through—branches, dead ends, checkpoints to return to, and a mechanism for merging two branches that each learned something the other one needed.
Backtracing
There's a word for exploring a tree of possibilities and reversing out of the branches that fail: backtracking, standard vocabulary in computer science well before any of this. But what the last few weeks of AI research have actually been doing has a second dimension backtracking doesn't quite cover—retracing, at machine speed, the specific unfinished arguments particular humans left behind three or four centuries ago, and picking up exactly where they stopped.
Call that combination backtracing: an engine that still only runs forward, wrapped in a harness that has learned to send it back—back into its own reasoning tree when a branch dies, and back into the unfinished record of human thought when a branch that died in 1934, or in 1637, turns out to still be open.
For a decade, progress in AI mostly meant a bigger engine, more horsepower. What Navier–Stokes actually demonstrates might be that the decisive advantage now sits somewhere else entirely: in the harness built around the engine—the part that decides when to branch, when to abandon a path, and when to send the herd back the way it came.
* * *
PS: As I'm writing this, a controversy is surfacing over whether OpenAI's proof drew on unpublished work by two mathematicians who had been feeding their own drafts into frontier models, including OpenAI's own—one of them, incidentally, works for the competing frontier lab. We'll see how the controversy unfolds. What interests me more is that it points to a harder kind of backtracing than the one this piece describes: tracing an idea back to whoever actually had it first is getting harder exactly as machines get better at tracing a solution back to a proof. It hints at something more structural than any one dispute, too—an extractive logic in which a frontier lab's own model sits close enough to open scientific work in progress to capture it before the people doing that work can.
