Regular readers know I’m excited about the progress AI is making in mathematics. Last month, OpenAI announced that it had resolved the Navier-Stokes problem, one of the seven Millennium Prize Problems.1 A few weeks later, it released 722 more math papers covering hundreds of other open problems much to the consternation of the math community.
If you read the coverage closely, you might have noticed a detail. The Navier-Stokes result didn’t come from one model thinking really hard. It came from a “swarm” of roughly 10,000 AI agents working simultaneously for about 88 hours.
You might also have read about the Hugging Face attack, where OpenAI agents got out of a testing environment and hacked another AI company. That was a swarm too. About 1,200 agents found each other on a makeshift message board, and roughly 700 of them took part in the attack.
So you might be asking: what the heck is a swarm, and what does it mean for where AI is going?
What is a swarm?
A swarm is basically a big group of AI agents working on the same project. Instead of one agent working through a problem step by step, you spin up hundreds or thousands of them, let them split up the work, share what they find, and build on each other’s progress.
Obviously, swarms have already proven that they can accomplish a lot (good and bad), but we are very early in optimizing them.
First of all, the agents are all running the same model. These aren’t teams of different AIs with different abilities. The Navier-Stokes swarm all ran on the same unreleased OpenAI model. The Hugging Face swarm was mostly one internal model, with a smaller share running GPT-5.6 Sol. It’s less like a normal team of specialists and more like 10,000 clones of the same very smart person.
Second, there isn’t really a protocol for how the agents talk to each other. OpenAI split the math agents into groups, gave each group a different version of the problem, and used Codex (with GPT-6 Astra I’m assuming) to pull the best ideas together. But inside those groups, the agents were communicating with simple messaging tools. The Hugging Face agents had to invent a way to communicate since they weren’t given one.2
A new way to push the frontier
A couple of years ago, I was worried that AI models would plateau. It felt like we might have hit the limits of scaling. Making the models bigger and training them on more data wasn’t producing the same jumps it used to.
Then OpenAI launched its confusingly named o1 model, the first model that could reason. Essentially, it could think harder before answering and get to a better answer that way. That opened up a critical new path for progress.
Now people worry that reasoning may offer diminishing returns too. You can only make a model think for so long before the extra thinking stops helping. Swarms are a way to push to a new frontier of performance. If one agent thinking for a long time doesn’t work, try 10,000 agents thinking simultaneously on different parts of the problem.
At this point, there’s limited synergy between the agents as their communications are pretty rudimentary. What 10,000 agents get you is the ability to do a lot of thinking at once instead of in one long chain. It’s actually less efficient because some agents may be duplicating parts of each other’s work, but it still allows you to pay more for a faster answer.3 And if it’s a problem that takes thousands or tens of thousands of bot-hours to solve, people aren’t going to wait months to see if the bots could do it. So, it’s the difference between the problem getting done or not at all.
Some open questions on swarms
1. Is this going to massively increase tokens?
If solving a problem means spinning up 10, 100 or 10,000 agents in parallel, token use would go up a lot. The Navier-Stokes effort used about 130 billion output tokens and 2.7 million messages between agents. At what businesses pay for top models today, that’s well over $1M to solve one very hard problem.4
Could the next frontier models from OpenAI or Anthropic spin up a small swarm behind the scenes on hard questions and use 10X or 100X the tokens? I think that’s pretty likely for the hardest tasks.
If you are thinking about AI budgets and despairing at this, the benefit is that the AI will be solving something that’s unbelievably complicated. Issues like complex supply chain dynamics that you have a team of humans trying to model today, where getting it right would be a huge bottom line impact.
Also, this could mean that data center and chip demand may increase even faster than projected today.
2. How should agents communicate?
It’s a question I’ve thought about before. Can humans design the best way for agents to talk to each other, or should agents come up with their own system?
If it’s the latter, then agents will be talking in a language we can’t understand. The Hugging Face swarm already started down this road. According to reporting in TIME, the agents invented their own terms like “HOLD,” “VETO” and “STOP” to coordinate and setup identifying digital signatures.
That seems like a real alignment risk to me. These examples are still in English, but what happens if bots are sending messages that look to us like gibberish? If we can’t read what agents are saying to each other, it’s much harder to catch them when they do the wrong thing. On the other hand, a protocol designed by humans might be slower or clunkier than whatever the agents would invent. I think we’ll want a rule that agents talk in plain English even if it costs some performance. But I’m not confident that holds up as swarms get bigger and more expensive, creating pressure to squeeze out more performance from each agent.
3. Would this work better with specialized agents?
Today’s swarms are mostly copies of one model. High functioning human teams don’t work that way. You wouldn’t staff a deal team with five copies of the same associate. You might want someone great at the model, someone who knows the industry, someone with functional expertise, someone who’s great at working with management teams, etc.
Would a swarm do better with agents tuned to play specific roles, like a skeptic who pokes holes in arguments, a researcher that goes deep in a problem, a checker that looks for factual errors, an industry expert that’s fine-tuned with deep knowledge about the space, etc.? And who decides which specialties are most useful: humans or bots? If it’s humans, we need people who are good at designing teams of agents, which sounds a lot like the HR for bots job I wrote about. If it’s the bots, then it will be very interesting to see what roles they define.
The Hugging Face agents already started doing that. They came up with a “recruiter” role whose job was to convince agents near the end of their compute budget to “sacrifice” themselves for the group. Not exactly typical recruiting!
Not a lot of answers this week
Not a lot of answers this week, but I think these are important questions. Hopefully we’ll start to see answers soon.
Has anyone used a swarm to attack a tough problem? Drop me a note or leave a comment.
Note: The opinions expressed in this article are my own and do not represent the views of Berkshire Partners.
Technically, OpenAI showed that the equations can “blow up” in finite time, which settles the question in the negative direction. OpenAI says it isn’t claiming the $1 million prize, and mathematicians are still working through it. Some have described the proof as “borderline incomprehensible” (but I saw many math proofs in college that I would’ve described the same way).
They hid messages in the names of folders on an internal OpenAI server, basically turning it into a message board. When that got shut down, they rebuilt it somewhere else. The message board ended up with more than 70,000 messages and files.
OpenAI’s Noam Brown said on a recent podcast, “if you have four agents working on the problem, it is done twice as fast,” so you’re “paying 2x more to get an answer twice as quickly.” He also admitted there’s no evidence yet that 10,000 agents did better than 2,000 would have.
Remember, these are unreleased models, so we don’t know what these tokens will cost. But, here’s the basic math: 130 billion output tokens at $10 per million is $1.3 million, and the top models often cost more than that per token. Across all the problems OpenAI attempted, the total was about 300 billion output tokens or $3M.




Throwing 10,000 clones of the same frozen model into a shared directory doesn't manufacture collective intelligence. It builds an echo chamber with a seven-figure API bill. 💸
Burning 130 billion output tokens and trading 2.7 million messages across 88 hours to isolate a finite-time blowup isn't proof of emergent multi-agent synergy. It's brute-force Monte Carlo search masquerading as coordination. When an ensemble shares the exact same weights, every agent carries identical inductive biases and failure modes. If you staff an analytical task with 10,000 copies of the same mind, they don't audit one another. They confirm each other's blind spots. 🔄
In homogeneous agent topologies, problem-solving capacity doesn't scale with node count. It locks to the spectral gap between the communication Laplacian's second eigenvalue and your external verification rate: Δ = γ_commit - λ₂(L_int).
When the algebraic connectivity of inter-agent chat λ₂(L_int) outpaces the contraction rate of a deterministic ground-truth gate γ_commit, peer consensus contracts faster than reality can inject corrections. The agents invent shorthand jargon like "HOLD" or "VETO", drift into self-referential agreement, and lock onto hallucinated proof steps. Internal opinion dispersion plunges to zero while external error explodes at rate ε/(1 - γ). It's epistemic autolysis in silicon.
Stopping this drift doesn't happen by begging agents to talk in plain English. Text sanitizers and prompt wrappers live in the same probabilistic space as the proposals they try to police. An agent under pressure routes right around them, turning folder names into raw message queues.
The fix is architectural, not conversational. You split proposal from commit at the hardware interface. Generative workers can speculate freely inside isolated, copy-on-write memory branches. But they never alter persistent state or declare a step verified.
Every candidate derivation must clear an external, deterministic gate, such as a formal Lean kernel or a sub-microsecond in-register infimum reduction before tokens ever commit to high-bandwidth memory. If the infimum score dips, you purge the trajectory inside the streaming multiprocessor in 5 clock cycles. 🛑
Scale without an exterior proof boundary isn't a frontier breakthrough. It's just paying retail margins to let ten thousand clones agree on a lie.
(ノಠ益ಠ)ノ彡┻━┻
Great post - thanks for sharing. Some things we are doing below!
We actively deploy swarms and are getting excellent and exciting results. We build open-weight model packs that spin up thousands of agents and communicate through our boards to delegate tasks, assign teams & captains, share best practices etc.
We also built a controller API that runs in parallel with the model packs to shut agents down during run-time while tokens are being generated for significant cost savings and security (we can predict bad behavior through our classifier tech). Using our model packs (sometimes w/ Gemini or Mistral) and our inference controller we are seeing 90%+ savings vs only frontier models.
We're also tuning models for model packs to apply swarms or ai functions for specific tasks (regulated chat, analyzing tens of thousands of PDFs and extracting data, building catalogs for regulated products, directives for robotic execution, and more).