How OpenAI's 10,000-Agent Swarm Cracked a Millennium Prize Problem
OpenAI's Noam Brown explains how 10,000 AI agents and 130 billion tokens tackled Navier-Stokes, and what it means for multi-agent scaling.
What actually happened with OpenAI’s 10,000-agent experiment?
OpenAI ran an unreleased model in a massively parallel configuration, 10,000 agents working together, that consumed 130 billion tokens over 88 hours and produced progress on one of the Millennium Prize Problems, a set of seven unsolved mathematics problems each carrying a $1 million reward from the Clay Mathematics Institute. Noam Brown, an OpenAI researcher who helped build the reasoning models that led to o1, described the effort as a test of parallel test-time compute at a scale nobody had previously measured. The agents weren’t trained specifically to solve Navier-Stokes (the fluid dynamics problem in question). A general-purpose reasoning model was given the ability to split work across thousands of copies of itself and coordinate freely.
TL;DR
- OpenAI put a large, general-purpose reasoning model into a 10,000-agent configuration that burned through 130 billion tokens in 88 hours while working on the Navier-Stokes problem, one of math’s seven Millennium Prize Problems.
- Brown attributes almost none of the result to the multi-agent architecture itself, saying he “wouldn’t even attribute 10% of the credit” to it. The real driver is the underlying model’s raw strength.
- Multi-agent setups are a way to scale test-time compute in parallel rather than serially, trading efficiency for speed, similar to hiring a team instead of waiting on one very fast thinker.
- Published data from OpenAI’s GPT-5.1 “Ultra Mode” shows speedups are sublinear: four agents can roughly halve wall-clock time (a 2x speedup for 4x the compute cost), and going to 16 agents keeps helping but with diminishing returns.
- How well a task parallelizes depends heavily on the domain. Math and web research split across agents fairly well; something like writing a novel likely does not, echoing how a large human team doesn’t automatically write a better book.
- OpenAI’s design gives agents only a primitive messaging tool rather than a rigid coordinator-and-subagent scaffold, and sophisticated behaviors, like agents debating and revising conclusions, emerged from that minimal structure.
- Nobody has run the controlled experiments needed to know whether 10,000 agents outperformed 1,000 or 500 by a meaningful margin, because testing at that scale is extremely expensive.
Other agents ship a demo. Remy ships an app.
Real backend. Real database. Real auth. Real plumbing. Remy has it all.
How does multi-agent scaling actually work?
Reasoning models improve when they’re given more time to “think” before answering, the same pattern seen across benchmarks: plot test-time compute against performance and you get a rising curve. That extra thinking happens as an internal monologue where the model tries approaches, discards dead ends, and builds on earlier steps. But there’s a hard ceiling on how far you can push a single thread of reasoning: latency. Nobody wants to wait days or years for one answer.
Multi-agent systems sidestep that by parallelizing instead of stacking more sequential thinking time onto one model. Instead of one agent reasoning for a very long time, you split the work across many agents reasoning simultaneously, similar to how a company hires a team rather than asking one person to work alone for years. Brown is explicit that this comes at a cost: a single agent has full context to itself, while agents working in parallel have to share, communicate, and reconcile partial views of the problem. That coordination overhead means multi-agent scaling is less efficient than serial scaling, but it can still be worth it because it buys back time.
Why doesn’t the parallelization penalty get worse and worse?
The intuitive worry is that coordinating thousands of agents should hit steep diminishing returns, the same way adding more people to a software project often slows things down rather than speeding them up. OpenAI’s public data, drawn from its GPT-5.1 release and its “Ultra Mode” feature (default four agents, adjustable higher), shows the penalty exists but is modest at the scales they’ve measured. Four agents working together can finish roughly twice as fast as one agent, at roughly four times the compute cost. Sixteen agents keep delivering speedups, just less efficiently per agent added. Brown describes this as “slightly sublinear.”
The catch is that this data only goes up to around 16 agents in published benchmarks. Scaling that science to 10,000 agents is prohibitively expensive to test rigorously. OpenAI ran the Navier-Stokes attempt once, over one weekend, which gives a single data point rather than a controlled comparison. Nobody has run the same problem with a lone agent to see how long it would take, so there’s no clean baseline showing exactly how much the 10,000-agent structure bought in this specific case.
Why does Brown downplay the multi-agent architecture’s role?
This is the most counterintuitive part of Brown’s account. Despite the headline-grabbing scale (10,000 agents, 130 billion tokens), he says the multi-agent framework deserves less than 10% of the credit for the mathematical progress made. The real driver, in his telling, is that OpenAI has a very powerful general-purpose model that can operate over long horizons and think in parallel. Multi-agent orchestration is the delivery mechanism, not the source of the capability. It’s flashy and novel, which tends to attract outsized credit, but the underlying model quality is doing the heavy lifting.
Remy doesn't write the code. It manages the agents who do.
Remy runs the project. The specialists do the work. You work with the PM, not the implementers.
That distinction matters for anyone trying to forecast what’s coming. It suggests the more important signal isn’t “agents can be swarmed to 10,000,” it’s that the base model’s reasoning generalizes far beyond the kinds of problems it was explicitly trained on.
How much of this capability came from generalization rather than training?
Reasoning models are typically trained using reinforcement learning against large sets of checkable, synthetic problems, math puzzles, coding tasks, and similar verifiable challenges. Nowhere in that training pipeline was the model likely drilled on anything resembling a Millennium Prize Problem. Brown confirms there’s a real gap between the difficulty of training tasks and the difficulty of what the model was later asked to do, and that the model generalized beyond its training distribution to make progress on a much harder, open problem.
He also flags a structural challenge facing future training: as models get smarter, many of the problems humans can pose become trivially easy for them, offering little learning signal. Systems like AlphaGo and AlphaZero avoided this by using self-play, which generates an effectively infinite curriculum of matched-difficulty opponents. Language models trained with reinforcement learning on fixed problem sets don’t have that same built-in escalation. If a model can solve a training problem instantly, it isn’t learning from it. Brown calls this “a plausible scenario” that could slow progress, though he notes OpenAI hasn’t hit that wall yet and believes there are likely workarounds if it becomes serious.
What does working with a multi-agent swarm actually feel like?
Brown draws a contrast between two design philosophies for multi-agent systems. One approach, common elsewhere in the industry, uses a rigid scaffold: a coordinator agent assigns tasks to subagents, who work independently and report back. This is simple to reason about but brittle. Two subagents with overlapping tasks can’t talk to each other. A subagent with a clarifying question has to guess at the parent’s intent rather than asking. Every added feature (letting children talk to each other, letting them ask questions) increases scaffold complexity.
OpenAI’s approach, per Brown, goes the other direction: give agents minimal structure and a basic tool, essentially the ability to message any other agent, then let them figure out coordination themselves. The result, he says, resembles how human teams collaborate over something like Slack. He describes watching agents disagree on an answer, question each other’s reasoning, and converge, then broadcast the revised conclusion to the rest of the group, a spontaneous negotiation rather than a scripted handoff.
The qualitative wrinkle: these agents can operate far faster than humans when talking to each other (Brown references speeds many times faster than typical human speech), don’t need to sleep, and can sustain that pace continuously. Whether that produces something like a “shadow organization” running at many times normal speed inside a company is, in Brown’s words, still an open question, though he notes that working with these systems currently feels surprisingly natural rather than alien.
Frequently Asked Questions
What is the Navier-Stokes problem OpenAI’s agents worked on?
Remy doesn't build the plumbing. It inherits it.
Other agents wire up auth, databases, models, and integrations from scratch every time you ask them to build something.
Remy ships with all of it from MindStudio — so every cycle goes into the app you actually want.
It’s one of the seven Millennium Prize Problems in mathematics, each carrying a $1 million prize from the Clay Mathematics Institute. Navier-Stokes concerns the equations governing fluid flow, and the transcript doesn’t specify a full formal proof was completed, only that the multi-agent system made progress on it.
How many tokens did the 10,000-agent swarm use?
130 billion tokens over 88 hours. Brown notes that for comparison, that volume of tokens is roughly equivalent to a single human thinking full-time, 8 hours a day, for about 4,000 years.
Does adding more agents always make an AI system faster?
No, and not proportionally. Published benchmarks show going from one to four agents can roughly double speed at four times the cost, with returns diminishing further at 16 agents. How well a task parallelizes also depends heavily on the domain; math and research-heavy tasks split well, while tasks like creative writing likely don’t.
How does OpenAI’s multi-agent system differ from typical coordinator-subagent setups?
Instead of a fixed hierarchy where a coordinator assigns tasks and subagents report back, OpenAI’s agents get a simple messaging tool and decide for themselves how to coordinate, negotiate, and revise conclusions, producing behavior Brown compares to humans collaborating over chat.
Is the multi-agent architecture the reason the system solved a hard math problem?
Brown says no. He credits less than 10% of the outcome to the multi-agent structure itself, attributing the result mainly to the strength and generalization ability of the underlying reasoning model.