On September 9, OpenAI published a claimed proof of existence-and-smoothness for the Navier-Stokes equations in three dimensions — one of the seven Millennium Prize Problems, a $1 million question that has been open since 2000. The mechanics of how it was produced are, frankly, more interesting to a technical lead than the mathematics: roughly 10,000 concurrent agents ran for about 88 hours between September 1 and September 5, generating 2.7 million messages and around 130 billion output tokens before converging on an analytical proof showing that a 3D fluid governed by the equations can develop a singularity — a point where the math breaks down — in finite time.

OpenAI is not claiming the $1 million prize. It published the proof and a Lean formalization on GitHub instead, treating machine-checkable verification as the credibility mechanism, the same pattern we’ve seen from Astra’s other math claims this year. And then, within 48 hours, the story stopped being about the proof and started being about who actually did the work.

The attribution dispute, as far as anyone can tell

NYU mathematician Tristan Buckmaster and Anthropic researcher Levent Alpöge had reportedly been pursuing related work on a different Millennium-adjacent result (the 3D Euler equations) using AI assistance of their own. OpenAI’s account is that it was “inspired” after hearing rumors that Buckmaster and Alpöge were close to a breakthrough. OpenAI cedes priority on the Euler result to the two researchers, but claims priority on Navier-Stokes for itself. Buckmaster’s public statement pushes back harder than “inspired” — he suggests OpenAI’s researchers or their agents may have had access to, and benefited from, his and Alpöge’s unpublished work.

Nobody outside the parties involved has a clean account of what happened. That’s the point worth sitting with, not the verdict. We now have a credible, public case where a company’s internal agent swarm produced a headline result, and the honest answer to “did this system independently derive this, or did it ingest someone else’s unpublished intermediate work and repackage it at scale” is: we don’t know, and the people closest to it disagree.

Why 10,000 agents changes the provenance problem, not just the speed

A single researcher using an AI assistant leaves a legible trail — you can look at their prompts, their notebook, their commit history, and reconstruct roughly how an idea developed. A swarm of 10,000 coordinating agents running for 88 hours and producing 2.7 million messages does not leave a trail any human is going to audit. Even OpenAI’s own team almost certainly cannot point to the specific message, or agent, or branch of exploration that first contained the insight that mattered. At that scale, “where did this idea come from” stops being a question you can answer by reading logs and becomes a question you can only answer by trusting the training data and input pipeline were clean — which is exactly the point under dispute here.

This is the same shape of problem as data provenance in any large training run, just compressed into a single 88-hour inference-time event instead of spread across months of pretraining. If your organization is running large multi-agent swarms against a codebase, a research corpus, or a competitor’s public materials, you have the identical exposure: a result comes out the other end, it’s plausible, it’s even verifiable — and you genuinely cannot reconstruct which inputs contributed what, because nobody was watching 10,000 parallel branches in real time.

The verification move is the part worth copying

Whatever the provenance dispute resolves to, OpenAI’s choice to publish a Lean-formalized, machine-checkable version of the proof rather than just asserting the result is the right instinct, and it’s the same instinct a well-run engineering org should apply to any agent-produced artifact of consequence. A natural-language claim from a 10,000-agent swarm is unauditable. A machine-checked proof, or a passing test suite with coverage you trust, or a reproducible benchmark run, is auditable regardless of how opaque the process that generated it was. The output can be trusted independently of the process, which is fortunate, because the process increasingly cannot be trusted on its own.

Translate that into an engineering practice: if you’re running large agent fan-outs — parallel subagents refactoring a codebase, multi-agent research pipelines synthesizing a design doc, swarms generating test cases — the artifact you ship should carry its own verification, not rely on “the agent said it checked.” Passing CI, a diff that a static analyzer confirms is behavior-preserving, a benchmark result someone else can rerun. The attribution question (“did this really come from where we think”) and the correctness question (“is this actually right”) are separable, and you should be building pipelines that answer the second one mechanically even when the first one is murky.

What this means for teams running large multi-agent workloads

A few concrete takeaways if you’re operating anything at even a hundredth of this scale:

  • Log retention isn’t optional once you’re past a handful of parallel agents. 2.7 million messages is extreme, but even a modest fan-out of 20-30 subagents over a multi-hour task will generate more transcript than anyone reviews live. Decide upfront whether you need to reconstruct “which agent produced this line” after the fact, and instrument for it before you need it, not after a dispute.
  • Treat any externally-sourced context an agent swarm ingests as a provenance liability, not just a data source. If your agents are reading competitor docs, scraped forum posts, or anything with unclear rights, the “we didn’t know where that came from” defense gets weaker in direct proportion to how much autonomous fan-out was involved in producing your output.
  • Ship verification artifacts alongside AI-assisted results, not narrative claims about them. This is the one lesson from the Astra math results all year that keeps paying off: “trust the process” doesn’t scale past a handful of agents, but “trust the checker” does.

The math here is genuinely impressive if it holds up to peer review — Fields Medalists have taken these claims seriously before, which counts for something. But the more durable story for anyone running production agent systems is the provenance gap that opens up the moment you cross from “one engineer plus a copilot” to “ten thousand coordinating processes.” That gap doesn’t close by scaling down — it just becomes less visible.

Sources:

Export for reading

Comments