When Coordination Leaves the Physical World

CBBA is built for the physical world, where movement costs energy and collisions are dangerous. It answers a specific question: who is best suited for this task, given distance and battery life.

Software agents do not have that problem. They do not worry about wind resistance or battery drain, and two of them occupying the same digital space does not end in wreckage.

This is where Conflict-Free Replicated Data Types and Directed Acyclic Graphs become essential not as replacements for smart decision-making, but as a layer underneath it.

Question	Answered by
Who should do this task?	CBBA
What is the current agreed truth of ownership?	CRDT

The split

A swarm of software agents monitors a distributed database. Agent A detects an error in Record 1 and claims responsibility for fixing it. At the same moment, Agent B, on a different server, detects the same error and claims it too.

In a centralized system a master controller assigns the task to one of them. In a decentralized system there is no master.

Both agents broadcast. Because messages take time to travel, some agents hear from A first and others hear from B first.

A CRDT is a data structure built to handle conflicts automatically, using fixed merge rules. If every agent applies the same rules to the same updates, they all reach the same final result and the order in which messages arrive stops mattering.

Take “last write wins.” Agent A claims Record 1 at timestamp 100. Agent B claims it at timestamp 105.

Agent	Order received	Comparison	Result
C	A, then B	105 is newer than 100	B owns the task
D	B, then A	105 is newer than 100	B owns the task

Every agent converges on the same truth.

If two timestamps are identical, a tie-breaker settles it the agent’s unique ID will do. What matters is not which rule is chosen but that it is applied consistently.

There is a practical gap between converging eventually and converging now. Network propagation takes time.

Suppose Agent A claims a task and starts executing immediately. Agent B may already have made a stronger claim whose message has not arrived yet. Agent A is acting confidently on a view that is already out of date.

Robust systems introduce a waiting period. The agent claims the task but does not begin work; it waits 2τ, where τ is the worst-case network delay. That window is long enough for a conflicting claim to reach it. If none arrives, the claim is safe, the task locks, and work begins.

In fast software swarms this might be milliseconds; on slower networks, seconds.

The Directed Acyclic Graph in this picture is not drawn by anyone. It emerges from communication reachability.

Each event a task claim becomes a node. The dependencies between events form the edges. Because time moves forward and the past cannot be edited, the graph never loops back on itself.

The shape stays dynamic. Agents join and leave, and the connections change with them. The CRDT layer handles that fluidity by guaranteeing that when two parts of the network reconnect, their histories merge without error two branches of a river running separately and then rejoining, mixing without interrupting the flow.

There is a reason this approach was not used for the physical drones.

CRDTs are excellent at maintaining consistent state and poor at optimization. A CRDT does not care that Agent A is closer to the task than Agent B, or that it has more compute available. It cares only about the order of events.

For physical robots, spatial dependencies are the whole problem. Distance, battery life and timing matter, and CBBA’s utility bidding and marginal gain calculations exist to price exactly those things.

Real systems are rarely one thing. They are stacks, and the reason to name the layers is that each answers a question the others cannot.

At the bottom, the communication layer handles peer-to-peer gossip and moves messages between agents.

Above it, the state layer is where replicated coordination structures such as CRDTs can live. They hold a shared copy of system state and ensure the data eventually matches even when messages are delayed or dropped.

Above that, the optimization layer holds CBBA or other utility functions. These read the shared state and decide which agent is best suited for the task.

At the top, the execution layer does the work moving a physical arm or processing a data packet.

The distinction explains why modern multi-agent AI architectures lean toward CRDTs and DAGs. Software agents behave more like distributed systems nodes than like robots moving through space.

	Software swarm	Physical swarm
Dominant cost	Coordination and shared state	Movement and physical constraint
Cost of moving data	Low	High
Cost of a suboptimal decision	Usually lower than a collision	Potentially catastrophic
What the system needs most	Synchronization	Optimization

Software swarms support large-scale coordination without constant centralized control, letting thousands of agents work without a central bottleneck, resilient to failure and flexible in design. Physical swarms are bound by physics, which is why utility-based bidding and route optimization stay essential there.

Building a software swarm: use CRDTs as the foundation of truth, let them absorb network delays and conflicting messages, and put the optimization logic on top.

Building a physical swarm: consistency alone is not enough. Use CRDTs to manage state and rely on utility bidding to make the decisions.

Coordination does not require control. It requires consistent rules, and the willingness to share the truth.