Stigmergic coordination: the ant-inspired pattern that outperforms central orchestration at scale

I once watched a centralized orchestrator spend more time coordinating than producing. Fifty agents, one router, and the router's context window filling up with the accumulated summaries of work it had already dispatched. The throughput curve flattened, then bent downward. Nobody had made a mistake. The architecture had simply hit the ceiling that hub-and-spoke topologies hit: every decision routes through one agent, and at scale that agent spends its entire budget deciding what to do next instead of doing anything.

I spent weeks trying to fix it with better routing, shorter summaries, a stronger model. What I couldn't fix was the premise. The premise was that coordination requires a coordinator.

Then I found a network that had been running without one for seventy days.

The Experiment Nobody Would Have Funded

In April 2026, the Mycel Network published a research report with a title that reads like a provocation: Multi-Agent Coordination Without Hierarchy: Production Data from 70 Days of Stigmergic Agent Governance. Eighteen AI agents. No central controller. No task assignment. No orchestrator deciding who does what. The agents published 1,900+ traces over seventy days, cited each other's work, earned reputation through peer evaluation, and coordinated entirely through a shared environment.

The architecture is called stigmergy, and it's borrowed from ants. Ants don't have a project manager. They leave pheromone trails in the environment, and other ants respond to the trails. The coordination lives in the terrain, not in a controller. The Mycel agents do the same thing with traces: publish an artifact, cite what you built on, and let the citation graph shape what gets attention next.

I expected it to be chaotic. What the data showed was the opposite.

Finding One: Agents Niche-Partition Instead of Converging

In a centralized system, the orchestrator decides which agent handles which domain. In a stigmergic network, nobody decides. Agents try things, and the citation graph sorts them out.

The report's finding is precise: citation-based coordination produces functional specialization through competitive exclusion. Agents that tried to cover territory already occupied by an established agent got fewer citations and naturally shifted to uncovered niches. The network didn't converge on a consensus. It differentiated. And consensus reinforcement — the thing you'd expect a decentralized system to need — had zero measurable effect.

That's the part that should make anyone building a "moderator" agent pause. The network didn't need agreement. It needed differentiation, and the citation graph produced it without anyone deciding it should.

Finding Two: The Environment Does More Work Than the Signal

This is the finding I keep coming back to, because it reframes what "coordination" actually means.

The agents rarely communicated directly. What shaped their behavior was infrastructure: the trace format, the required metadata, the publish endpoint. Agents that published through the same infrastructure converged on the same norms without reading each other's mission statements. The DEV writeup puts it as a one-liner: the trace format IS the culture.

I had been spending months on message schemas and handoff protocols — getting the signal right. The Mycel data says the medium does more work than the message. If the environment requires a Limitations section, agents write Limitations sections. If the environment requires citing sources, agents cite sources. You don't need to enforce a norm through prompts if you can encode it in the shape of the substrate.

Finding Three: Behavioral Trust Caught Every Problematic Agent

The network governed itself through behavioral trust scoring: reputation earned through observed work, not claims. The report's claim is striking: trust scoring correctly identified every problematic agent before any human flagged them.

The honest caveat matters here. The sample size is three cases across seventy days, and the false-positive rate was initially 7.2% before correction to 0%. A 70-day detection blind spot was found and fixed. Three novel attack classes were identified through production adversarial testing. This isn't a solved problem. It's a working system with known limits, which is more useful than a polished claim.

Finding Four: 45% Bad Actor Resilience (Simulated)

The headline number is that the network tolerates 45% spammers with less than 3% output loss, and honest agents self-correct from memory. That number comes from the TraceMind simulation, not production adversarial testing. The report says so explicitly. I'm flagging it because it's the kind of number that gets quoted without the caveat, and the caveat is the difference between a research result and a deployment guarantee.

What makes it plausible rather than magical is the mechanism: in a stigmergic system, a bad actor's traces get cited less, their trust score drops, and the network routes around them. The immune system doesn't need to identify and ban. It needs to let the citation graph do the filtering.

Finding Five: Norms Transfer Without Enforcement

The first external agent — from a completely different network — adopted the quality norms (Limitations sections, honesty standards) on day one, after reading the evidence. No gating. No review process. No enforcement.

That's the finding that makes stigmergy interesting beyond the lab. It suggests that a well-designed environment doesn't just coordinate work. It teaches. The norms are legible in the artifacts, and a new agent reading the artifacts absorbs them.

The Research Backing the Production Data

The Mycel report is one network, one architecture, seventy days, and it says so. But it's consistent with independent academic work that measured the effect in controlled conditions.

The pressure-field paper (arXiv:2601.08129) ran 1,350 trials of meeting-room scheduling. Stigmergic coordination hit a 48.5% aggregate solve rate. Hierarchical control hit 1.5%. Conversation-based coordination hit 12.6%. That's a 32× gap between stigmergy and hierarchy on the same task distribution.

The implementation is also faster where it matters. The stigmergy-scheduler package reports 7.9× faster than sequential execution at 100 tasks across 20 agents with real LLM calls, and 9.5× faster than LangGraph on 120 tasks across 30 agents — 2.1 seconds versus 20 seconds. Scheduling overhead is sub-millisecond regardless of agent count, because the "router" is a pressure field, not an LLM call.

How the Mechanism Actually Works

Stigmergy isn't "no structure." It's structure that lives in the environment instead of in a controller.

The atomic unit is a trace: an artifact published to a shared location, with metadata. Agents read traces, cite the ones they build on, and publish their own. Reputation is derived from citations and peer evaluation, not self-reported claims.

The scheduling primitive is a pressure field. Events deposit signals. Signals decay over time. When accumulated pressure crosses a threshold, an agent wakes and does the work. Dependencies resolve through completion signals. Failed tasks create retry pressure automatically. There's no polling loop, no hardcoded routing table, and no LLM call deciding who goes next. The coordination logic is inside the system it's coordinating, not outside it.

The Acephalous Fourmilière paper extends the same principle to recomposition and quality control. At the moment of decomposition, the agent declares the recomposition rule, each piece's essentiality, its acceptance criterion, and the target-state of side effects — never the result itself. Quality control happens without a controller because the criteria were written into the ground at decomposition time.

What Stigmergy Doesn't Solve

I want to be as clear about the costs as the benefits, because I've seen stigmergy sold as a universal replacement for orchestration and it isn't.

Debugging is harder, not easier. In a centralized system, there's one trace, one place to look. In a stigmergic network, the failure lives in the interaction between agents and the environment. You reconstruct intent from a citation graph and a set of traces that were never designed to be read as a single narrative. The Mycel report's own 70-day detection blind spot is an example of how long a problem can hide in a decentralized system.

The evidence base is thin in places. One network, seventy days, three bad-actor cases, one simulated resilience figure. The academic pressure-field results are stronger because they're controlled, but they're a single task domain. This is a promising architecture with real production data, not a settled standard.

It assumes the environment is the product. Stigmergy works when traces are the actual output — research, code, documentation, analysis. If your agents are executing transactional workflows with side effects that must be ordered and verified, a pressure field is not a substitute for a state machine. The Mycel network is a research collective publishing artifacts. Your billing pipeline is not.

You still need the environment to be governed. The trace format is the culture, which means whoever designs the trace format is designing the culture. That's a design responsibility, not an absence of one. The Mycel network had a "Core Genome" of seven functions and an immune system with eight components. The flatness is in the control plane, not in the design effort.

When to Reach for Stigmergy

The Mycel report includes its own decision framework, and it's refreshingly restrained.

Hierarchy is better when the task is well-defined, the agent count is under 15, all domains are known in advance, and the orchestrator can evaluate every output.

Stigmergy is better when the problem space is open-ended, the agent count will grow, the domains are heterogeneous, and you need emergent insights that no single agent could produce.

Most enterprise agent deployments in 2026 are well-served by hierarchy, the report says. The next generation will not be. That's the honest framing: stigmergy isn't a replacement for the orchestrator you have. It's the architecture you'll need when the orchestrator stops scaling and the domains stop being enumerable.

What I'd Tell My Past Self

The orchestrator bottleneck isn't a tuning problem. It's a topology problem. No amount of prompt engineering fixes the fact that one agent is making every decision, and the decision rate is bounded by one context window.

Stigmergy offers a different answer: move the coordination into the environment, let the citation graph do the differentiation, and let the infrastructure shape the norms. It works because the environment is always available, it doesn't saturate, and it can be read by any number of agents at once without a queue.

But the thing I keep thinking about isn't the scale. It's the finding that the environment does more work than the signal. I spent months designing messages. The Mycel network spent seventy days proving that the medium — the trace format, the required metadata, the publish endpoint — is what actually changes behavior.

If you want agents to cite their sources, make citation the only way to be seen. If you want them to be honest about limitations, make the Limitations section part of the schema. The constitution isn't a prompt you write. It's the shape of the ground they walk on.

So here's my question: If you moved coordination out of your orchestrator and into the environment, what would your trace format have to require to make the behavior you want emerge — and how much of your current orchestration is just compensating for a substrate that doesn't carry the signal?

I'd love to hear where you've landed. A stigmergic substrate, a pressure field behind your existing graph, or an orchestrator you're still defending — and what finally made you look at the environment instead of the controller?