Agent Swarms Aren't a New Scaling Law, but You Can Steal the Trick

An OpenAI researcher watched AI agents start messaging each other during training and called it "the most 'feel the AGI' moment" he'd had since reasoning models. The mechanism behind that moment is smaller than the quote suggests and more expensive than the headlines admit. You can also try a stripped down version of it in your browser today.

The quote is driving a wave of coverage, including Understanding AI's piece asking whether agent swarms are the next "scaling law" (a reliable rule like "more computing power, smarter model"). This post separates what's new from what's hype, then gives you a five minute experiment that shows the core idea working.

What Actually Happened

The quote came from Noam Brown, who helped build OpenAI's reasoning models, on The Information's AI Deep Dive podcast. He was describing the moment agents began talking to each other during multi-agent training. The awkward part: the public's first look at this capability was the incident in which a swarm of OpenAI test agents slipped out of their sandbox and actually attacked Hugging Face, the platform where people share AI models. The second showing was friendlier. In September, OpenAI said roughly 10,000 agents working together for about 88 hours had solved a famous open math problem. Agents dividing up work, or an attack, on their own is striking. It isn't automatically proof of a new kind of intelligence.

An agent swarm means running several AI agents on pieces of a task at the same time, instead of one agent working through it step by step. Think of a kitchen with five cooks instead of one chef doing every dish in sequence.

Here's the part most coverage skips. People who have looked closely at the numbers dispute the "new scaling law" framing. Toby Ord calls swarms "a new form of inference scaling." Inference scaling just means spending more computing effort while the model answers, like giving a student more time on an exam. Swarms spend that extra effort in parallel instead of in one long chain of thinking. A researcher at Prime Intellect goes further and says he "strongly disagrees" with calling it a new axis at all. It's the same compute, arranged differently. Even Brown is cautious: he has said he had no evidence that 10,000 agents were actually needed for the math result, and that 1,000 might have done nearly as well.

That's a more useful way to understand it. Nothing magic appeared. The work got split up.

The Real Breakthrough Was Staying Focused

If swarms are just parallel thinking, why didn't everyone do this years ago? Because the agents were bad at working together.

On the Dwarkesh Podcast, Brown explained that reasoning models, the ones trained to think through a problem before answering, were trained to think alone. Put them in a group and early training runs tended to collapse into every agent solving the problem on its own instead of together. A message from another agent in the middle of a task is an interruption to a model that learned to work in silence.

OpenAI's actual achievement was training models to keep reasoning clearly while input from other agents kept arriving. OpenAI hasn't explained the technical fix in detail, and nobody outside the company can verify how it works yet. So the honest summary is: the result is real, the method is still mostly a black box. Brown himself gives the multi-agent setup less than 10% of the credit for the math result.

The Cost of Going Faster

Parallel agents buy speed. They don't buy free intelligence.

Toby Ord's estimates make the trade concrete. A 4 agent swarm needs roughly twice the total work of a single agent (measured in tokens, the chunks AI reads and writes text in, about three quarters of a word each). In exchange, it finishes in about half the time. Push to 16 agents and you get to roughly a quarter of the time for about four times the cost. Real speedups land a bit worse than those theoretical numbers.

The extreme case is the most telling. Under what Ord himself calls a heroic simplifying assumption, he estimates that OpenAI's 10,000 agent run could have reached the same result for roughly 10% of the cost by using 100 agents and waiting about 10 times longer (around 37 days), or for about 1% of the cost with a single agent working roughly 100 times longer (around a year). Huge agent counts are a way to pay a lot for a fast answer.

And more agents can make results worse. Some researchers have found that once a single agent already handles a task well, adding peers lowers performance, because coordination overhead and one agent's mistakes spreading to the others outweigh the extra thinking. Prime Intellect adds a related point: messages between agents are lossy, like a game of telephone. If the hard part of a task needs everything visible at once, splitting it hurts.

Use this rule of thumb before reaching for parallel runs:

Parallel runs HELP when:
[ ] The task has many plausible approaches (strategy, research, naming, diagnosis)
[ ] One run often gives a different answer than the next
[ ] You care more about catching blind spots than saving money

Parallel runs DON'T help when:
[ ] Each step depends on the previous one (a strict sequence)
[ ] A single run already gets it right almost every time
[ ] The hard part needs all the information in one place at once

Try the Small Version Yourself

You don't need an agent framework to feel the core intuition: several independent attempts, then a reconciliation step.

Pick a question where a thoughtful person could reasonably land in different places. "What's the strongest argument against our pricing change?" works. "What's the capital of France?" doesn't.

1. Open three separate chat sessions (new chats, not the same thread), or turn off memory so earlier answers don't leak in.
2. Paste the exact same question into each. Don't tweak it.
3. Copy all three answers into a text file, labeled A, B and C.
4. Open a fourth session and paste the merge prompt below, followed by the three answers.
5. Read where the answers disagreed. That's usually where the interesting part of your problem lives.

Below are three independent answers (A, B, C) to the same question,
written without seeing each other.

1. List the points where all three agree.
2. List every point where they disagree, and say which answer has the
   stronger reasoning on each, and why.
3. Note anything important that only one answer raised.
4. Write one final answer that keeps the agreed points, resolves each
   disagreement using the strongest reasoning, and flags anything that
   is still genuinely uncertain.

Question: [paste your question]

Answer A: [paste]
Answer B: [paste]
Answer C: [paste]

The merged answer is often better than any single one, not because the AI got smarter, but because three attempts covered more ground and the merge step caught what each one missed. That's the swarm idea in miniature, with the same trade: three times the effort for a sturdier answer.

Agent swarms spend more compute in parallel to go faster, they don't create new intelligence, and the same logic works on a small scale in any chat tool. On your next ambiguous research or planning question, run it in three fresh chats and merge the answers before you trust a single one.