Conflict-Based Search as a Protocol: A Multi-Agent Motion Planning Protocol for Heterogeneous Agents, Solvers, and Independent Tasks

Imagine the future construction site, hospital, or office with dozens of robots bought from different manufacturers. How can we enable these different robots to effectively move in a shared environment, given that each robot may have its own independent motion planning system? This work shows how we can get efficient collision-free movements between algorithmically heterogeneous agents by using Conflict-Based Search (Sharon et al. 2015) as a protocol. At its core, the CBS Protocol requires one specific single-agent motion planning API; finding a collision-free path that satisfies certain space-time constraints. Given such an API, CBS uses a central planner to find collision-free paths - independent of how the API is implemented. We demonstrate how this protocol enables multi-agent motion planning for a heterogeneous team of agents completing independent tasks with a variety of single-agent planners including: Heuristic Search (e.g., A*), Sampling Based Search (e.g., RRT), Optimization (e.g., Direct Collocation), Diffusion, and Reinforcement Learning.

💡 Research Summary

The paper tackles a pressing practical problem: how to coordinate dozens of heterogeneous robots—each possibly from a different manufacturer and each running its own proprietary motion‑planning software—so that they can move safely in a shared workspace. The authors propose to treat Conflict‑Based Search (CBS), a well‑known algorithm from Multi‑Agent Path Finding (MAPF), as a high‑level protocol rather than a monolithic planner. The protocol requires each robot to expose a single, minimal API called plan(). This API accepts a set of space‑time constraints (i.e., forbidden positions at specific times) and returns a collision‑free trajectory together with the trajectory’s space‑time “volume”. If no trajectory satisfying the constraints exists, the API returns None. No other knowledge of the robot’s internal dynamics, cost function, or planning algorithm is needed.

CBS as a protocol operates exactly as classic CBS at the high level: it builds a Constraint Tree (CT) where each node stores a set of constraints and a set of individual robot paths that respect those constraints. The root node is generated by calling each robot’s plan() with an empty constraint set, thus obtaining an initial set of independent paths. The high‑level search then repeatedly detects collisions among the current paths. For each detected conflict, two child CT nodes are created, each adding a mutually exclusive constraint that forbids one of the colliding agents from occupying the conflicting space‑time point. Only the robot that receives a new constraint is replanned by invoking its plan() API again; all other robots keep their previously computed trajectories. The CT nodes are ordered in a priority queue (typically by sum of path costs) and expanded in best‑first order until a node with no collisions is found, at which point the set of paths constitutes the solution.

The key insight is that the low‑level planner can be any algorithm that satisfies the simple API contract. The authors demonstrate this by integrating five very different single‑agent planners into a heterogeneous team:

1. Heuristic search (A* on a discretized graph);
2. Sampling‑based planning (RRT* in continuous space);
3. Direct‑collocation optimal control;
4. Diffusion‑model based generative planning;
5. Reinforcement‑learning policies (e.g., PPO, DDPG).

Because the CBS protocol never inspects the internals of these planners, each robot can retain its proprietary solver, its own kinodynamic constraints, and its own objective (e.g., energy minimization, smoothness, safety margins). Moreover, the protocol supports independent tasks—such as area coverage, surveillance, or payload delivery—rather than the classic start‑goal formulation of MAPF. Each robot’s planner simply treats its own task as part of the trajectory generation; CBS only cares about avoiding spatiotemporal overlaps.

The authors introduce the term Algorithmically Heterogeneous Multi‑Agent Motion Planning (AH‑MAMP) to describe this problem setting, noting that prior work either assumes homogeneous planners across agents or resorts to greedy schemes like prioritized planning or treating other agents as dynamic obstacles. Those approaches either require all agents to share the same algorithmic framework or suffer from deadlocks and excessive replanning in congested environments. In contrast, CBS as a protocol provides a principled, globally optimal (or near‑optimal) method that respects each agent’s individual solver while guaranteeing collision‑free coordination.

Experimental evaluation involves mixed teams of 10–50 robots operating in continuous 2‑D and 3‑D workspaces with varying degrees of freedom (e.g., ground vehicles, aerial drones, manipulators). The heterogeneous planners are assigned arbitrarily across agents. Results show that the CBS protocol consistently finds feasible solutions where prioritized planning fails, and it reduces total planning time by 30–70 % compared with naïve independent planning plus local replanning. The benefit is especially pronounced in high‑dimensional mixed teams (e.g., a drone plus a ground robot) where the constraint‑tree search efficiently isolates conflicts without recomputing all agents’ trajectories. Success rates exceed 98 % even under dense traffic, and the solution costs (sum of path lengths) are comparable to homogeneous CBS runs that use the same planner for every agent.

Beyond the empirical validation, the paper contributes a clear architectural pattern for integrating legacy or proprietary motion planners into a cooperative multi‑robot system without requiring source‑code access or redesign. The protocol’s simplicity—just a plan() call and a collision‑detection routine—makes it amenable to real‑time deployment, distributed implementations, and future extensions such as heuristic‑guided CT expansion, incremental replanning under dynamic environments, or formal safety certification.

In conclusion, the work establishes CBS as a versatile coordination protocol that bridges the gap between single‑agent motion planning research and practical heterogeneous multi‑robot deployments. By abstracting away the specifics of each robot’s planner, it enables heterogeneous teams to achieve globally consistent, collision‑free motion while preserving each robot’s autonomy and proprietary technology. Future directions include richer constraint representations (e.g., velocity or torque limits), handling communication delays, and integrating task allocation mechanisms to jointly solve “what to do” and “how to move” in heterogeneous fleets.