Scaling Agent Swarm

Junxiao Yang

One starting point for this line of work is OpenAI’s Navier–Stokes result. The exact solution process has not been disclosed, but the blog offers a high-level description: agents were organized into groups, with roughly 10,000 running concurrently in the successful effort. Different groups explored different formulations of the problem, including variants aimed at either a proof or a disproof. Useful intermediate ideas were then consolidated and shared across groups.

Despite the limited detail, I see two signals here. First, diversity-guided exploration: a large open question can be broken into several research questions, and even adversarial proposals can produce a wider range of claims to test. Second, decentralization with organization: scaling agents calls for moving beyond the rigid pattern of a main agent spawning subagents, which creates bottlenecks in both information flow and scheduling. At the same time, agents still need ways to organize and broadcast what they learn. I like OpenAI’s term cross-pollination: groups can deliberately share and absorb useful ideas from one another. The resulting discovery loop is: divide into groups, consolidate findings, broadcast them, and repeat.

Two recent papers on agent swarms, both from Microsoft Research, are especially interesting:

• Scaling Discovery through Test-Time Communication
• Agensh: Scaling Organizational Intelligence to 1,024 Agents

The first paper compares Best@n with Team@n across ARC-ACI-3, Polyomino Packing, and MNIST Compression, showing gains from communication between agents. Its figure matches my intuition. On shorter, less complex tasks such as math problems and AIME, best@k can already work well: there is little time for collaboration to add value, and independent sampling can reach the ceiling. On longer and more complex tasks, however, we do not know which direction will work best. Directions may also overlap or depend on one another. In those settings, some communication—or cross-pollination—should intuitively help.

The implementation still uses fairly preliminary design choices, and the code has not been released yet. Here is how I understand it:

1. An agent claims a slot and begins investigating a direction. Agents that claim later slots can see the directions already chosen, so they can choose different ones.
2. Each agent writes its findings to a shared document. It can broadcast its own discoveries and read those of other agents. The agents do this proactively, without a hard-coded harness governing every interaction.
3. If an agent fails to improve the result several times in a row, it switches direction. If another direction is promising, it can recognize that result and build on the existing work.

The following diagram sketches this process. To me, it is close to an ideal way for a small agent swarm to collaborate.

The second paper scales to a much larger number of agents. Its underlying idea is similar: decentralized organization.

The figures and explanations in this paper are intuitive and easy to follow, and its early results and demo are interesting. Still, I have two questions that I want to revisit when the code is released. First, where do the gains from scaling the agent swarm actually come from? I do not think program bench is an especially suitable setting for this kind of scaling: it seems more like development work than an open-ended exploration problem. I discussed with the authors whether a pass@n comparison would be appropriate. To me, that remains an open question, and I lean toward requiring evidence that communication between agents is what matters.

Second, I am skeptical that simple infrastructure can support meaningful decentralized communication among 1,024 agents. The two papers use broadly similar approaches. My intuition is that this design’s capacity for handling information may not scale much beyond about 32 agents; above that, it is hard to see how the same mechanism could sustain useful exchange. That is a hypothesis, though, and I would need to run experiments and study the source code before drawing a firmer conclusion.

Overall, scaling agent swarms is an interesting topic and a new scaling dimension. I see two key starting points: diverse, decentralized exploration across multiple directions, and free, proactive information sharing through shared files. Personally, I would also keep task constraints as light as possible and the search space as broad as possible. Otherwise, there is little point in studying the scaling of an agent swarm. There are many open questions here, and I look forward to more papers and reports.