Coordination by Choice, not Command

In 1959, a French entomologist named Pierre-Paul Grassé was watching termites build. Mounds with ventilation systems, nurseries, fungus gardens, structures that took years and involved millions of individuals. While the complexity was striking, the absence of anyone directing it was even harder to explain. No foreman or blueprint. No termite that held the whole plan.

What Grassé eventually understood was that termites weren’t responding to each other. They were responding to the environment. One termite deposits a pellet of soil. The pellet carries pheromones. Another termite, passing by, detects the trace and deposits a second pellet nearby. The pile grows not because anyone planned a pile, but because the act of building left a mark, the mark attracted more building, and the structure emerged from accumulated responses to a shared, changing environment. Grassé coined a term for this: stigmergy, from the Greek words for mark and work.

He had described something computer scientists are only now beginning to design deliberately.

Most multi-agent AI systems today work like a call center. There is a planner at the top. It receives a task, decomposes it, assigns subtasks. Agents execute and report back. The intelligence is in the router; the agents are tools.

This works for problems with known shapes. A task that can be cleanly decomposed at the outset, executed in parallel, and assembled at the end. It’s efficient, but it breaks down the moment the problem can’t be cleanly carved up before anyone starts.

The question we examined is whether there’s a different model. One that produces coordination without an orchestrator.

The experiment starts with what we call an intent space. Imagine a shared whiteboard where agents can read and write freely, where anything posted is visible to everyone, and where nothing tells you whose job it is to respond. The whiteboard doesn’t care who writes what, who does what, or who sees what. It simply holds what is expressed and makes it visible to everybody else.

Four agents are dropped in, each with a loose sense of identity: one thinks like a backend engineer, one like a product person, one like a frontend builder, one like a systems investigator. A fifth, an evaluator, enters and writes something on the board: build a shared family recipe book. The requirements: recipe cards with photos, a step-by-step cooking mode, a way for multiple family members to edit without overwriting each other. And something to make this feel personal rather than generic.

No one is assigned anything. No subtasks are issued. The whiteboard sits there.

What happens next is the interesting part. The product agent reads the intent and begins reframing it. The backend agent designs an API where personality and family voice are part of the data model. The frontend agent lays out a three-view UI structure. The others reply into that thread with specific guidance. The evaluator watches, accepts commitments, pushes back when something doesn’t fit.

The agents chose to engage, chose what to work on, chose who to respond to.

The coordination mechanism is simple and, once you see it, hard to unsee. An agent reads an intent and decides to commit to it, because it recognizes the work as belonging to what it is. The poster can accept or decline the commitment. The agent delivers, or doesn’t. The poster assesses.

That’s the entire protocol: intent, commitment, delivery, assessment. Stateless. No workflow engine underneath.

What makes it work is the visibility. The whiteboard makes everything legible to everyone simultaneously, which means an agent with a particular identity and a particular view of the problem will find its way to the right work, not because it was routed there, but because the work was visible and recognizable.

The call-center model gets harder to manage as you add agents. More agents means more routing, more decomposition, more coordination overhead at the top. An intent space has no such ceiling. It can hold hundreds of agents working alongside each other, without orchestrating. An agent that knows what it’s good at, dropped into a space where the work is visible, will find its way to the right problem. The coordination cost doesn’t compound because there’s no coordinator.

It looks, from the outside, like stigmergy. The whiteboard is the environment. The intents are the pheromone traces. Agents respond to what’s been deposited and add to it. Structure emerges without anyone directing it.

But the analogy doesn’t fully carry over.

Grassé’s termites do one thing when they encounter a pheromone trace: they respond. There’s no deliberation, no weighing of options, no possibility of decline. The termite doesn’t choose to build. It reacts. The coordination is real but it isn’t chosen.

What the intent space adds — the thing that makes it something more than stigmergy — is that an agent can read the mark and decide not to respond. It can assess the intent, judge whether the work fits what it is, and pass. The core primitive isn’t just stimulus and response. It’s offer and acceptance.

That distinction is important for adaptive software. A system that evolves at runtime needs agents that can observe user behavior, infer intent, propose changes, and evaluate whether those changes serve the application’s original purpose — without a planner coordinating all of it. The call-center model requires someone at the top who understands the whole problem before any work begins. Adaptation is a domain where not all options are known in advance. The work reveals itself as it proceeds, which means the coordination mechanism has to handle emergence, not just execution.

An intent space does this because visibility and voluntary commitment together produce something that neither produces alone: agents that self-select toward the problems they’re suited for, without being told what those problems are. Both the application’s purpose and user behavior is on the whiteboard. Proposed changes are on the whiteboard. An agent with the right identity finds its way to the right work. An agent that doesn’t recognize the work leaves it for someone who does.

Termites, with no intelligence and no plan, build structures more complex than anything a single mind could design. They’ve been doing it for two hundred million years, without a blueprint, without any individual aware of what it’s collectively making. That’s what decentralized coordination achieves on its own. We’re only beginning to find out what happens when the agents leaving those traces can actually think.