EDSA and Epoch Consensus Allocation

The Consensus-Based Bundle Algorithm is one of the most widely studied decentralized task allocation frameworks in robotics. No leader, no central coordinator. Information propagates through repeated peer-to-peer exchanges as agents continuously synchronize task ownership across the fleet.

That purity carries a tax.

In a traditional CBBA framework, agents exchange large portions of their local world model. When an agent broadcasts, it does not just send its own new score. It sends a 2D matrix its copy of everyone else’s scores, alongside a matrix of timestamps whose only job is to resolve arguments.

As fleet size and task count grow, communication and consensus overhead grows with them. Agents repeatedly exchange allocation information, resolve conflicting ownership views, and recompute assignments as new information arrives.

EDSA (Decentralized Event-driven State Architecture) is the architectural approach; ECA (Epoch Consensus Allocation) is the protocol underneath it.

Both are deliberately narrow, and the boundaries matter more than the names.

Untouched	Replaced
The network transport layer local broadcast, multicast or mesh, data still crosses the same physical medium	The application-layer data architecture and control flow
The evaluation math agents still use the standard CBBA scoring function to compute local utility	How that score is shared, synchronized and agreed upon

When an agent wants to make a move, it sends one line:

{
  "agent_id": 4,
  "action": "BID",
  "task_id": 3,
  "score": 88.5,
  "timestamp": 104629
}

No tables. No matrices. No tracking lists for twenty other agents.

The core of EDSA is the epoch. Instead of continuous gossip, the system operates in rapid micro-epochs, allocating on a per-task or small-batch basis so it stays dynamic and responsive.

The internal lifecycle:

1. Epoch opens. The lowest-ID agent the host initializes the event stream for the next unallocated task.
2. Agents calculate and submit. Each agent evaluates that task locally with the standard CBBA scoring function and pushes its bid into the active stream.
3. The window closes. Either deadline T is reached, or every eligible agent has submitted.
4. Distributed evaluation. Because every agent received the identical stream of bids, every machine independently runs the same deterministic computation max(score) to determine the winner. No central bottleneck, and no room for evaluation disagreement.
5. Commit event published. The host publishes the allocation, tagged <imp> for immutable.
6. The assignment locks. The <imp> tag is the absolute rule across the swarm.
7. Immediate recompute. Agents update their local bundles against the locked assignment, and the next epoch opens at once for the next unallocated task.

A worked epoch

Three agents bid on Task A:

{"agent": 1, "task": "A", "score": 30}
{"agent": 2, "task": "A", "score": 20}
{"agent": 3, "task": "A", "score": 34}

The window closes. Every agent independently arrives at Agent 3. The host publishes:

{
  "type": "COMMIT",
  "task": "A",
  "winner": 3,
  "tag": "<imp>"
}

Task A is locked, winner Agent 3, status <imp>.

Now Agent 4 drops connection, recalculates, and rejoins with a score of 50 for Task A. It is too late for Task A, and the system does not stall over it: the epoch for Task B is already open, and Agent 4 bids there in the very next cycle.

In dynamic environments, Group A may be executing a mission when Group B arrives on the scene. Under legacy CBBA, Group B’s bids flood the network immediately, forcing Group A to recalculate and potentially twitch or halt mid-operation.

EDSA handles this through epoch-bound group freezing. When an epoch is formed for a joint operation, the system can assign a whitelist of agent IDs permitted to bid; anyone outside that range is ignored for the duration of that epoch.

Three edge cases

The late superior agent. A robot with a far better score arrives after commit. The <imp> tag acts as a shield: it is ignored for the current epoch and joins the stream for unallocated tasks in the next one.

The physical collision. Two agents from previously disconnected groups arrive at the same task location. No central leader arbitrates. They read each other’s <imp> state, which already contains the winning score, and run the same deterministic max(score) check locally. The lower-scoring agent yields, updates its local state, and proceeds to its next assignment.

The stream merge. If that handover needs to reach the rest of the swarm, it travels as a lightweight <resolve> tag carrying the new winner’s ID. Other agents pick it up as they come into range and update accordingly. No timestamp matrices, no gossip storm a localized handshake that ripples cleanly through the network over time.

Any system with a host invites the same critique: a single point of failure.

In EDSA the host is the stream coordinator, not the evaluator. If it crashes, a heartbeat monitor triggers the next lowest-ID agent to take over hosting. Because every machine has been independently evaluating the same stream of bids, the incoming host already knows the exact state of the epoch. It resumes hosting; nothing is reconstructed.

If the previous host returns, predefined rules make it a follower. No conflict arises.

Stripping the data down to small ordered events managed by a deterministic stream creates a pocket of free compute. The onboard CPU is no longer sorting N×M matrix conflicts, and those cycles become available to the mission.

The architecture does not prescribe what they are spent on. Some options:

• Environmental awareness processing raw sensor feeds, real-time object detection, target tracking, rather than parsing network gossip.
• Higher-fidelity local planning running fuller local simulations before generating a bid: dynamic obstacle avoidance, wind resistance, precise battery burn curves, so the score submitted to the stream is a better one.
• Custom edge AI and sensor fusion local SLAM, fusing disparate sensors, proprietary models. The architecture gets out of the way.

The honest comparison

Legacy CBBA	EDSA / ECA
Better theoretical optimality	Bounded optimality
More churn	Bounded communication
More communication overhead	Bounded recomputation
More recomputation	Predictable, deterministic execution

That is the whole trade: marginal theoretical gains exchanged for real-world stability. Future iterations could add dynamic thresholding, where tasks above a certain importance level trigger a controlled recomputation but the baseline <imp> tag stays the foundation of swarm stability.

A lightweight prototype is open-sourced at INCURSIA/event_driven_state_architecture.