The Shapes of Collaboration

An ant colony, a symphony orchestra, a commodities market, a standards committee, and a fleet of microservices all collaborate. But they do it in completely different ways. Ants leave chemical traces and never negotiate. An orchestra follows one conductor. A market uses prices to decide who does what. A committee argues until it agrees.

What they share is simple: many agents whose actions are coordinated into an outcome none of them could produce alone.

Note what this definition does not require:

• Shared intent. Each trader acts for their own profit. No single ant is trying to build a mound.
• Direct communication. Ants never address one another.
• Mutual awareness. Agents can collaborate without knowing the others exist.

The only requirement is that separate actions become aligned. How that alignment happens is the variable — and the range of answers is much wider than the one form each of us works inside and assumes is the whole category.

This article has two parts. Part 1 gives you a framework for analyzing any collaborating system: the components it is made of, the dimensions along which systems differ, and the main models found in nature and in human organizations, with their trade-offs. Part 2 applies the framework to a new kind of collaborator — fleets of LLM agents — where several parameters we normally treat as fixed stop holding.

Part 1: A framework for collaboration

The four components

Every collaborating system is built from the same four parts.

A collaboration model is a specific arrangement of these four parts: who the agents are, what the environment lets them do, how signals travel, and how the task is defined.

The three dimensions

Collaboration models differ on three dimensions. Each one is intrinsic: it describes how the model works, independent of who is using it or why.

A fourth property matters but is not a separate dimension: coupling, meaning how much agents depend on each other being present at the same time. Coupling follows from the medium. Direct communication couples agents tightly — the sender needs the receiver to exist right now. Environmental communication couples them loosely — a trace can be read hours later, by an agent the writer never met. So treat coupling as an output you read off the framework, not a fourth dial on it.

The framework also clarifies something about the familiar named patterns: they are not fundamental categories. They are regions in this three-dimensional space. Some are pinned by a single axis and free on the others — direct messaging is really a choice of medium; consensus is defined by its coordination target.

The main models

Here is where the common models sit on the three dimensions:

And their trade-offs — the actual reason to pick one over another:

One tension runs through the whole table. The direct, centralized models (messaging, orchestration) give you precision and legibility, and cost you coupling and bottlenecks. The indirect, decentralized models (stigmergy, choreography) give you resilience and scale, and cost you visibility and control. No model avoids both costs. Choosing a model means choosing which failure you would rather have.

The explorer above is Part 1 in one picture: each model is a line through the three dimensions. Click through them and the claim becomes concrete — these are not seven separate categories, they are seven regions of the same space, and the tension between precision and resilience is visible in where the lines run.

Part 2: Choosing a model for LLM agents

The framework describes how each model works. It says nothing about when to use one. That choice depends on parameters that sit outside the model — properties of the agents and their world. Three matter most:

• Cost of a unit of work. Is one agent-action expensive and worth optimizing, or nearly free and worth spending liberally?
• Temporal coexistence. Do the agents run at the same time and know each other, or do they spin up, act, and disappear?
• Memory. Is persistence something you inherit, or something you get to design?

In human organizations these three are near-constants: a person-hour is expensive, people obviously coexist, and human memory decays on its own whether we plan for it or not. Because they never change, we forget they are variables at all. LLM agents set all three to unusual values. That is why the framework is worth re-running.

Stigmergy fits agents that never meet

LLM agents rarely share a clock or a channel. Each one spins up, does a piece of work, and disappears. That is a poor fit for direct messaging: there is no one to call, and the callee may no longer exist by the time it answers. It is a natural fit for stigmergy: each agent reads a shared substrate — files, a task store, a scratch directory — does its part, and leaves the result where the next agent will find it.

The key property is that the work is the signal. The trail an agent leaves behind is the coordination. No separate message needs to be sent, and no orchestrator needs to exist. Agents that never coexist still coordinate.

The simulation above is stigmergy in its original form. No ant knows the plan, no ant talks to another, yet efficient trails emerge within seconds. Remove half the colony and the work continues, because the coordination lives in the trails, not the ants. And try moving the food with evaporation switched off: the colony keeps marching to where food used to be. Hold that failure in mind — it is what the memory sections below are about.

Three terms get blurred in this discussion, so it helps to fix them:

• The model is the fixed capability, shipped identically with every instance.
• The agent is one instance of that model, given a role and tools. It is the actor that does the work.
• The session is the trail that work leaves behind: a record in the environment, not an actor.

In the colony's terms: the model is the DNA, the agent is the ant, the session is the pheromone. A session coordinates the way a pheromone trail does — not by acting, but by sitting there to be read.

Cheap work favors redundancy over optimization

Our reflex is to optimize workflows: trim steps, cut redundancy, make things lean. But optimization is a trade. You spend safety margin and redundancy to buy efficiency. That trade only pays off when the resource you are saving is scarce.

When an agent-action is nearly free, the saving is worth nothing — and you still gave up the safety margin. So skip the optimization step entirely and accept collaboration that looks wasteful: heavy redundancy, several agents covering the same ground. This is the ant colony's answer too. Evolution never optimized the individual ant, because ants are cheap. It bought robustness with redundancy instead. For LLM agents, redundancy is the natural currency, and leanness is a source of fragility.

Design memory to be perishable

Ant pheromones evaporate. That is a feature, not a flaw evolution failed to fix. At some point, holding a memory costs more than its usefulness — especially when the information could be cheaply rediscovered. Past that point, you want staleness to quietly downgrade information rather than paying to keep everything fresh.

The right operation is eviction, not deletion. What is still useful keeps getting re-marked and stays close at hand. The rest fades into the background. Active memory stays current and under a ceiling, even though nothing is actually thrown away.

Decay the references, not the content

The most useful refinement is what you let decay. Don't decay the content — the this-info.md file itself. Decay the references to it.

Remembering then becomes traversal: you walk a tree of content outward from a few entry points, and the strength of each reference sets how deep you can follow that branch. References that get used stay strong, so frequently-fetched memories sit close to the entry points. References nobody follows go shallow. Nothing is ever deleted, so in principle everything remains recoverable — you just pay more "remembering" effort to reach the cold branches.

Click any memory above to fetch it, and watch the path from the entry point light back up. Leave a branch alone and its references thin out until it goes cold — but the node is still there, and you can still reach it. That is the whole design: eviction, not deletion, with the decay on the edges. (The two colors are the next idea — hold that thought.)

This design matches two ideas with a solid track record. Bjork's memory research distinguishes storage strength from retrieval strength: what is stored never fades, but access decays with disuse. And both ant-colony optimization and PageRank put the decaying weight on the edges (the references) rather than the nodes (the content).

Memory that knows who is asking

Look again at the two colors in the tree above. They are two roles — a Coder and a Researcher — sharing one memory. Nothing about the content is split between them; every node is available to both. What differs is which references each role keeps warm. The Coder keeps re-marking the trails into the deploy and codebase branches; the Researcher keeps re-marking the client and history branches. Within seconds, two distinct hot pathways emerge across the same tree.

This falls straight out of the reference-decay design, and it is worth naming: when the trail an agent leaves is shaped by what that agent does, memory specializes by role on its own. No one partitions the tree. Each role simply pays to remember what it actually uses, so its own branches stay warm while the rest — including the other role's branches — cools out of its way. The same shared content ends up with as many overlapping "views" as there are roles, each one tuned to its owner, and each one cheap because it never carries the paths it doesn't walk. It is the stigmergy lesson again, one level up: the memory organizes itself around the work, and the work is different for each role.

The colonies got here first, too. An ant colony runs on castes — foragers, nurses, builders — and each caste reinforces the pheromone structure its own task depends on. Role-based memory is the same move: not one memory per agent, but one shared substrate that each role wears a different groove into.

Put together, the design for an agent swarm nearly inverts good human-team practice:

• Don't optimize the workers — duplicate them.
• Don't make them talk — let them read and mark a shared substrate.
• Don't preserve memory — let the references decay, so the useful stays warm and the rest goes cold.
• Don't build a separate memory per role — share one substrate and let each role wear its own groove into it.

Two open questions

Two pieces of the ant analogy don't map cleanly yet, and that is probably where the real design questions are.

The queen. She is the colony's persistent identity and the source of new workers, but she is not how workers coordinate. What is her equivalent in an agent system? One reading: the durable goal or root context that outlives any single session — the entry point the whole tree of memory hangs from. That reading may be right, but it is a guess, and the analogy may simply not survive contact here.

The DNA. Each ant ships with fixed behavior: memory that nobody re-marks and nothing evaporates. For an LLM agent, that is the weights and the system prompt — knowledge that arrives with the agent instead of accumulating in the environment, and that does not decay through disuse. So the full picture contains two memory systems, not one: a perishable environmental memory the swarm writes and evicts, sitting on top of a fixed, shipped-in memory every agent already carries. The stigmergic layer is the part we have been designing. The DNA layer is the floor it stands on, and it deserves to be designed just as deliberately.

Going further

Each idea in this article has a deeper literature behind it. These are the sources worth your time.

On stigmergy and swarm intelligence

• Francis Heylighen, "Stigmergy as a Universal Coordination Mechanism" — the clearest modern treatment of the concept, from insect nests to Wikipedia. Its definition — the trace left by an action stimulates a subsequent action — is the one this article builds on.
• Marco Dorigo & Thomas Stützle, "Ant Colony Optimization: Overview and Recent Advances" — how evaporating pheromone trails became a working optimization algorithm, by the people who did it.

On the classic collaboration models

• Yoav Shoham & Kevin Leyton-Brown, Multiagent Systems — the standard textbook on multi-agent coordination, including the market and auction mechanisms this article only gestures at. Free PDF from the authors.
• H. Penny Nii, "Blackboard Systems" — the 1986 survey of the blackboard model, from Hearsay-II onward, by one of its architects.
• Chris Richardson's saga pattern and Martin Fowler's "What do you mean by 'Event-Driven'?" — orchestration versus choreography as software engineers live it today.
• The Raft consensus algorithm — consensus made understandable, with an interactive visualization. Leslie Lamport's "Paxos Made Simple" is the earlier classic it responds to.

On memory that decays

• The Bjork Learning and Forgetting Lab — the storage-strength versus retrieval-strength distinction, from the researchers who drew it.
• Sergey Brin & Larry Page, "The Anatomy of a Large-Scale Hypertextual Web Search Engine" — the PageRank paper: importance as a property of the link structure, not the pages.

On LLM agents

• Lilian Weng, "LLM Powered Autonomous Agents" — still the best single map of what an agent is made of: planning, memory, tools.
• Anthropic, "Building Effective AI Agents" and "How we built our multi-agent research system" — the orchestrator-workers pattern in production, with honest lessons.
• Joon Sung Park et al., "Generative Agents: Interactive Simulacra of Human Behavior" — agents with a memory stream scored by recency, importance, and relevance: reference decay, implemented.

None of these dimensions are mutually exclusive, and real systems mix them freely: an orchestrator can assign work through a market, and its workers can coordinate their outputs on a shared blackboard. The point of the framework is not to sort systems into boxes. It is to make the invisible knobs visible — so that when the collaborators change underneath us, we notice which knobs just came loose.