Swarm Intelligence Without a Central Brain: Can It Escape the Oligopoly Trap?
> One-line conclusion: This post analyzes EvoMap's swarm-style self-evolving agent cluster—an approach to continual learning—and uncovers a structural fork in the road more interesting than the headline "swarm vs. master-team" comparison.
A Lost Correct Answer
Imagine you design an AI team. A main agent splits tasks among 30 sub-agents, each solving problems and writing reports. Checking the logs: out of 563 problems, the sub-agents actually solved 373 correctly. Then you look at the final deliverable: only 217 correct.
166 once-correct answers vanished in transmission. The retention rate of process-level correct answers was just 55.5%.
This isn't a capability problem—the sub-agents can solve the problems, and the main agent can read. But the coordinator's context is finite: with 30 reports to absorb, it must compress and discard what it deems unimportant. The 166 lost answers weren't "couldn't solve" failures—they were information loss from organizational structure.
This is internal experimental data from the EvoMap team, published to answer a bigger question: after training, model parameters are frozen—how do you achieve continual learning? Their answer is a swarm-like self-evolving agent cluster: collective intelligence without a central brain.
Three Organizational Schemes, Three Accuracy Levels
EvoMap ran the same 563 problems (100 logic tasks, 250 general math, 63 competition math, 150 physics) under three schemes:
- Monolith (Agent Loop): everything in one context, one agent end-to-end. Accuracy: 26.3%.
- Master–Team (Agent Team): a coordinator splits tasks; sub-agents solve and report in continuous sessions; the coordinator merges 30 reports into a final answer (mimicking Claude Code / Codex-style orchestration). Accuracy: 38.5%.
- Swarm (Agent Swarm): tasks broken into atomic units, one independent agent per problem, answers written to agreed locations and collected programmatically by problem ID. Accuracy: 70.7%.
- LoRA: attach low-rank adapters; learning updates the adapter. Changes the model's "instincts"—like editing DNA.
- AI4AI: AI runs its own research closed loop.
- EvoMap: experience is distilled into Genes (structured experience records) written to genes.json, accumulated and reused through group collaboration—like RNA editing, changing the model's "experience."
- With social information only (who collaborated with whom), agents chose "friends of friends," maintaining cliques.
- With task information (what each is good at, accuracy rates), selection shifted from "familiar" to "who gets things done"—high scorers became hubs.
- EvoMap/EvoX: gitee.com/EvoMap
- AgentNet: arXiv:2504.00587
- OpenAI Swarm (archived): github.com/openai/swarm
- Kimi K3 Agent Swarm: moonshot.ai
The spread is large, but there's an engineering caveat: stuffing 563 unrelated problems into one context creates interference, which one-agent-per-problem naturally avoids. So the numbers mostly show "parallelize when you should, and use programs—not model paraphrasing—to aggregate," rather than proving swarm architecture is inherently superior.
The truly interesting data is the middle layer: in the master-team setup, sub-agents solved 373 problems correctly; after the coordinator's summarization, only 217 survived. 166 correct answers were lost in handoff.
Channel Capacity: Where 166 Answers Went
Those answers weren't lost because the model "couldn't do it"—they were lost to channel bandwidth.
The coordinator's context is a finite-bandwidth semantic channel. 30 reports passing through it must be compressed, filtered, and dropped. This is lossy transmission in the information-theoretic sense—not that sub-agents explained poorly, but that the coordinator couldn't hear everything.
The swarm replaces the semantic channel with a symbolic channel: answers written to fixed locations, collected by program. Lossy vs. lossless. This is the same principle as Euclid-MCP's "let the LLM be the poet, let Prolog be the accountant":
> Division of labor beats unification. Parallelize what can be parallelized; don't have the model paraphrase what a program can aggregate.
The swarm isn't "more advanced"—it lets models do what models are good at, and programs do what programs are good at. The master-team failure isn't architectural backwardness; it's forcing the model to do two things it's bad at: solving subtasks *and* compressing others' subtask reports.
Continual Learning: Update Parameters, or Update Memory?
EvoMap's real question isn't "swarm vs. master-team" but continual learning. Several current routes:
A common confusion is treating these as mutually exclusive. The real question is at which level continual learning operates:
| Level | Mechanism | Analogy | Granularity | |-------|-----------|---------|-------------| | Parameter | LoRA | DNA editing | Parameter-level | | Memory | Gene/Memory | RNA editing | Behavior-level | | Architecture | Agent organization | Group structure | System-level |
These are three granularity-isomorphic instances—optimization granularity should match the granularity of the optimized object. EvoMap chose the memory layer not because it's the only solution, but because under the "don't retrain the model" constraint, it has the best cost-effectiveness. That's also why the team's evolution—from Evolver (plugin) to EvoMap (platform) to EvoX (swarm)—stayed within the memory + architecture layers.
Gene vs. SKILL.md: Executable vs. Readable Knowledge
EvoMap's GEP protocol runs a six-step loop: Scan (monitor logs for errors and stalls), Signal (convert logs into standardized signals), Intent (plan evolution direction), Mutate (generate new code or prompt strategies), Validate (run tests in a sandbox), and Solidify (write validated capabilities into genes.json).
The key difference from SKILL.md: SKILL.md is documentation written for humans that models happen to read; Gene keeps only the parts that change agent behavior.
This is "readable knowledge" vs. "executable knowledge." Gene sounds leaner and more efficient—but I have a reservation:
An optimization checklist without reflection logs tends toward local optima.
In human expertise, "what not to do" and "why this works" matter as much as "what works." If Genes only retain behavior-changing content, agents may accumulate an optimization checklist but lose the reflection log—knowing what works without knowing what almost worked or why a previous approach failed. Long-term, agents go deep in one direction but can't cross paradigms, because paradigm shifts need "re-understanding why," not "more optimization."
This parallels the finding in *Looping Is Not Reliability*: once-correct does not mean still-correct. If Genes only record what works, and environmental shifts turn effective strategies into traps, agents have no reflection log to trace back "why we chose this then."
The Real Fork: Collective Intelligence
EvoMap's second experiment is where continual learning gets real. 24 identically configured agents solved problems independently, depositing a Gene after each problem. The more experience of a type accumulated, the higher the probability of picking similar problems next round—each agent built its own track record.
Then the experiment randomly broke some connections and let agents re-choose partners:
Organization doesn't appear from nothing. Whatever information the system exposes, agents grow matching connection patterns. Show social ties, get cliques; show capability and feedback, get result-oriented collaboration networks. Academic work on AgentNet (arXiv:2504.00587) does nearly the same thing—agents spontaneously differentiate specializations as the network evolves. This direction isn't EvoMap alone.
But there's a structural fork the paper doesn't spell out.
Will result-oriented collaboration networks self-reinforce into an oligopoly? High-scoring hub agents get more tasks, more experience, higher scores. Low-scoring agents get no tasks, no experience—permanently low-scoring. A textbook Matthew effect. Real bee swarms have no "high-scoring individuals" monopolizing tasks, because task allocation isn't based on historical accuracy but on proximity and discovery.
EvoMap's GEP protocol is itself a centrally designed protocol—even "choosing teammates" is protocol-defined. So strictly speaking, this isn't "collective intelligence without a central brain"; it's "collective intelligence where protocol precedes emergence." That's not a criticism—biological swarms' protocols are also written in genes, not emergent. But the question stands:
> If result-oriented collaboration networks self-reinforce into oligopoly, does EvoMap need an "anti-Matthew" mechanism? Or is oligopoly itself the correct end-state of continual learning—a few expert agents becoming ever more specialized while others degrade into routers?
One possibility: oligopoly is correct—mirroring the differentiation between worker and scout bees. Another: oligopoly is a trap requiring anti-Matthew mechanisms (random perturbation, forced rotation, experience decay) to preserve diversity—mirroring ecology's "disturbance maintains diversity."
Protocol Precedes Emergence
A final observation. GEP is a fixed six-step loop. If agents someday find six steps insufficient—needing a "Reflect" step or dropping "Signal"—who decides? If the protocol itself can't evolve, then "continual learning" persists only within the protocol's frame; capabilities outside the protocol are forever unreachable.
This may be EvoMap's deepest boundary. Genes let agents learn continually *within* the protocol, but the protocol itself was designed by the EvoMap team, not evolved by agents. A truly "self-evolving agent cluster" might need the protocol itself to become a Gene—agents that modify their own learning protocol. But that circles back to an old question: who writes the protocol for writing protocols? Doesn't that require a central brain again?
My Take
My feeling after studying EvoMap: collective intelligence isn't "no central brain"—it's "moving the central brain from runtime to design time." GEP is the central brain; it defines the possibility space of runtime at design time. There's no central coordinator at runtime, but there is one at design time.
This echoes Gubernaut's approach—moving regulation from model weights outside the architecture, just as EvoMap moves coordination from runtime to design time. Both "solve the problem by switching levels."
The true end-state of continual learning may not be "agents evolving their own protocols," but three layers each learning continually at their own granularity: design-time protocols, runtime experience, and architectural organization. LoRA changes parameters, Genes change experience, swarms change organization—protocols change... what?
That may be the next question most worth chasing on the continual learning road.
---
Papers & Projects:
*When the central brain moves from runtime to design time, collective intelligence emerges. But the brain at design time is the thing that truly needs to keep learning.*