Conflict-Based Planning
- Conflict-Based Planning methods address problems where individually feasible decisions in multi-agent or multi-resource scenarios become jointly infeasible due to interactions, effectively decomposing the planning process into manageable steps for enhanced efficiency and feasibility check.
- Common methods include CBS for discrete space planning, CDITO for hybrid planning, CPS for evacuation scenarios, CBS-MP, and Kinodynamic planning techniques, each tailored to specific conflict detection and resolution mechanisms in diverse application domains.
- Techniques scale through heuristic approaches, and advanced optimizations, such as parallelization (e.g., DP-ECBS) for high throughput and efficiency in large scenarios; Additional methods adapt to continuous space and kinodynamic problems by incorporating depth-first and lazy search strategies along the CBS principle while allowing unbounded growth and motion improvisation, be it in search operations or robust repulsion negation methods.
- Practical limitations are addressed through methods like Virtual Traffic Lights, Lazy Conflict Resolution, and GPU-Accelerated planning, ensuring computational efficiency and handling scalability in real-world multi-agent systems with diverse tasks and dynamics.
Conflict-Based Planning is a family of planning and scheduling methods that uses inconsistencies in an incumbent multi-agent or multi-resource plan to generate targeted alternatives. Rather than constructing a fully coupled search or optimization model from the outset, these methods typically maintain independently generated paths, schedules, or trajectories; detect conflicts among them; encode each conflict as constraints, route alternatives, or temporal commitments; and replan only the affected components. The family includes route-generation heuristics, constraint-tree search, conflict-directed ordering, continuous kinodynamic planning, multi-objective planning, task assignment, and GPU-accelerated manipulation planning. Its defining abstraction is the decomposition
1. Conceptual foundations and scope
Conflict-Based Planning addresses problems in which individually feasible decisions become jointly infeasible because agents, routes, temporal events, or resources interact. A conflict may be a shared edge-capacity violation, a vertex collision, an overlapping robot trajectory, a temporal negative cycle, a blocked movable obstacle, or an infeasible task precedence relation. The central computational premise is that most components can often be planned independently, while only a subset requires explicit coupling.
The term encompasses several related but nonidentical paradigms. Conflict-Based Search (CBS) maintains a constraint tree whose nodes contain agent-specific constraints and corresponding low-level solutions. Conflict-Based Path Generation (CPG) instead adds alternative routes and associated variables to a growing master optimization model. Conflict-directed ordering methods learn clauses over event precedences and prune regions of a total-order tree. Continuous-space variants replace graph conflicts with geometric or time-dependent trajectory conflicts, while multi-objective variants preserve sets of Pareto-optimal alternatives at the low level.
The methods differ in what constitutes a planning entity. It may be an individual agent, an aggregate evacuation zone, a robot manipulator, a task-bearing commodity, an event sequence, or a route selected for an origin. They also differ in their guarantees. Some are complete or optimal relative to a finite graph or sampled roadmap; others are heuristic, probabilistically complete, bounded-suboptimal, or empirically motivated without formal completeness or optimality guarantees.
A common misconception is that every conflict-based method is classical CBS. CPG does not maintain a CBS constraint tree, CDITO does not branch over a CBS tree, and stop-based virtual-traffic-light coordination does not search alternative constraints. Conversely, continuous methods such as K-CBS, CBS-MP, and db-CBS preserve the CBS decomposition while changing the state representation, conflict geometry, and low-level planner.
2. Route-based decomposition and conflict-directed generation
Conflict-Based Path Generation
The Conflict-Based Path-Generation heuristic was developed for large-scale evacuation planning (Pillac et al., 2013). Its evacuation network is a directed graph
where contains evacuated origin nodes, transit nodes, and safe nodes. Each origin has demand and a deadline. Each physical edge has travel time , capacity , and a closure time 0.
The operational decisions include the safe destination assigned to each origin, the physical route assigned to that origin, departure quantities over time, and compliance with capacities, deadlines, and closures. The model imposes a single-route restriction: all evacuees from one evacuated node use one evacuation path. This reflects emergency-service procedures and distinguishes the model from free-flow network formulations that can split an origin’s flow across arbitrary routes.
A time-expanded network represents movement and scheduling. Physical edge 1 and departure time 2 generate an arc
3
and waiting arcs permit evacuees to remain at an origin or safe node. Because one physical route corresponds to many possible time-expanded paths, a complete formulation contains a large number of flow variables.
The restricted-flow mixed-integer formulation uses binary route variables 4 and time-expanded flow variables 5, together with path conservation, time-expanded flow conservation, capacity, and path-flow linking constraints. In the Hawkesbury-Nepean instance, this formulation produces approximately 4.4–4.5 million variables and approximately 5.7 million constraints.
CPG avoids initially constructing every possible route. It maintains a restricted route set 6, with 7, and solves a master problem over the currently generated routes. For path 8, 9 indicates selection, 0 represents departures at time 1, and 2 represents unevacuated demand. Edge-time capacity constraints aggregate departures from every selected route using the relevant edge at the relevant time.
The master objective first maximizes the number of evacuees reaching safety. A second optimization can maximize the first departure time while preserving that evacuation volume, or an implicit cost formulation can heavily penalize unevacuated people and penalize earlier departures. The lexicographic intent is therefore:
3
A conflict is an inadequacy in the incumbent route-and-schedule assignment. Critical origins include origins that are not fully evacuated and origins evacuated earlier than desirable because of congestion or restrictive paths. The critical set is expanded to include origins whose selected paths share edges with paths of critical origins. This permits the method to address conflicts caused by routes belonging to origins that are themselves currently fully evacuated.
New routes are generated by a multiple-origin, multiple-destination shortest-path subproblem. Its edge costs combine normalized travel time, route reuse, and current utilization:
4
with
5
The generated route therefore tends to avoid long, repeatedly used, or heavily congested edges. A new route adds a binary path-selection variable, departure-flow variables, coefficients to capacity constraints, and a path-flow linking row. The restricted master grows incrementally and can use the previous solution as a warm start.
On the Hawkesbury-Nepean case, involving approximately 70,000 evacuees, 50 evacuated nodes, 10 safe nodes, 125 transit nodes, 458 physical edges, an 18-hour horizon, and five-minute time steps, CPG produced approximately 32,000 columns and 79,000 rows, compared with approximately 4,440,000 columns and 5,655,000 rows for the restricted-flow MIP. The base case was solved in approximately 15 seconds, all tested real-size instances in under 30 seconds, and the approach achieved 100% evacuation for the base case and population increases up to 40%; at three times the population, approximately 87% were evacuated. The method is heuristic: the path-generation objective is not exact reduced-cost pricing, and a useful route may never be generated.
Relationship to column generation and conflict search
CPG resembles column generation because route generation is separated from route selection. It resembles Conflict-Based Search because conflicts in an incumbent solution guide the generation of alternatives. It is identical to neither. CPG does not solve an exact reduced-cost pricing problem, does not maintain a recursive constraint tree, and adds routes and variables to one growing optimization model.
Its principal significance is the use of conflict information as a route-pool selection mechanism. The master enforces capacity and scheduling feasibility over generated routes, while the path subproblem supplies alternatives only where the incumbent plan is inadequate.
3. Conflict trees, learned ordering constraints, and low-level search
Conflict-Based Search
Classical CBS has two levels. The high level searches a constraint tree, and the low level independently plans an agent subject to the constraints accumulated along a tree branch. A node contains constraints, one path per agent, and a node cost. The root is generated from independent paths. When a conflict is detected, the high level creates alternative branches, typically constraining one agent in one child and the other agent in the second child. Only the constrained agent is replanned.
For discrete MAPF, conflicts commonly include vertex conflicts,
6
and edge-swap conflicts in which two agents traverse the same edge in opposite directions during the same interval. Under standard assumptions—complete and optimal low-level planning, correct conflict constraints, and cost-ordered high-level expansion—CBS is complete and optimal for the selected objective.
Conflict-directed ordering
Conflict-directed Incremental Total Ordering (CDITO) applies conflict reasoning to hybrid planning and scheduling (Chen et al., 2019). Its ordering problem is
7
where 8 is a set of events, 9 is a set of clauses over precedence relations, and 0 maps a candidate total order to a consistency result and a set of conflicts.
A total order 1 is a permutation of all events. Explicit ordering relations can include task-start-before-task-end or disjunctive temporal requirements. State constraints, routing feasibility, bandwidth, resource capacity, and temporal constraints are checked by specialized sub-solvers. These solvers may discover implicit ordering relations not present in the original partial-order specification.
If a conflict is
2
CDITO learns its negation,
3
Thus a grounded inconsistency becomes a disjunctive ordering clause. State conflicts can encode mutually exclusive task overlap, while temporal conflicts can arise from negative cycles in a temporal constraint network.
CDITO explores the total-order tree used by Incremental Total Ordering. For an order
4
an order move removes the event at position 5 and inserts it immediately after position 6. A node’s level identifies the first position at which its ordering differs from the root. The fixed-event property states that, for a node of level 7, the relative ordering among events 8 remains unchanged in all descendants.
This structure enables kernels. A constituent kernel is the first search move that can negate at least one precedence in a conflict. A combined kernel is the latest constituent kernel among all conflicts and the current search status. Moves before the combined kernel leave at least one known conflict unresolved and can therefore be skipped. If no move in the current subtree can negate a conflict, the entire subtree can be pruned.
CDITO is systematic and complete with respect to the total-order tree when returned conflicts are valid explanations of inconsistency. Its worst-case search remains factorial in the number of events, but one conflict can summarize many failed orders. The method was evaluated on temporal network-configuration problems involving routing, bandwidth allocation, loss, delay, throughput, deadlines, and duration constraints. With 10, 20, 30, 40, or 50 flows and 100 trials per scenario, CDITO solved 94, 91, 86, 82, and 74 trials respectively, whereas ITO solved 9, 5, 6, 11, and 8. CDITO generally found solutions after approximately five or six calls to the expensive consistency function in solved trials.
Multi-objective CBS and safe intervals
Multi-objective Conflict-Based Search with Safe-Interval Path Planning extends CBS to multi-objective MAPF (Ren et al., 2021). Each edge has an 9-dimensional nonnegative cost vector, and the objective is to compute cost-unique Pareto-optimal joint paths. A high-level node contains individual paths, an aggregate cost vector, and accumulated constraints. For every high-level conflict, branching constrains one agent in one child and the other agent in the second child; the affected low-level planner returns all cost-unique Pareto-optimal replacements.
The low-level MO-SIPP planner compresses the time dimension by representing consecutive collision-free times at a vertex as safe intervals. A label is
0
where 1 is a safe-interval state, 2 is the cost-to-come vector, and 3 is arrival time. Ordinary vector dominance is insufficient because earlier arrival preserves more future reachability. Label dominance therefore requires both no later arrival and no worse cost after accounting for waiting.
MO-SIPP maintains a frontier of non-dominated labels for each safe-interval state. It generates earliest feasible arrivals directly rather than enumerating every wait time. The resulting planner computes all cost-unique Pareto-optimal trajectories under the stated discrete-time, nonnegative-cost assumptions. Embedded in MO-CBS, it yields MO-CBS-ts, which reported an order-of-magnitude reduction in average low-level search time relative to the earlier NAMOA*-style implementation. On a room map with two objectives, the average low-level search time fell from approximately 10 seconds to less than one second. Complete Pareto-front success improved by approximately 20% on selected room-map settings, and the success rate for finding at least one feasible solution improved by approximately 40% on a maze-map setting.
4. Continuous-space and kinodynamic conflict-based planning
Classical CBS assumes a shared discrete representation. Continuous-space methods retain the high-level conflict tree while replacing vertex-time constraints with geometric, temporal, and dynamics-aware constraints.
Heterogeneous continuous motion planning
CBS-MP adapts CBS to heterogeneous continuous-space multi-agent motion planning (Solis et al., 2019). Each agent 4 has its own configuration space 5, initial state, goal set, and sampling-based roadmap. The roadmaps may differ in dimension, topology, number of vertices, edge duration, and geometric representation.
The individual planner uses Dijkstra’s algorithm on a fixed roadmap. A CT node stores constraints, one path per agent, and a group cost such as sum of costs or makespan. Paths are converted to a common uniform time representation for conflict detection. A conflict is represented as
6
where 7 and 8 are potentially heterogeneous configurations at synchronized time 9. The two branches constrain one agent to avoid the other’s configuration at that time.
The method is representation-optimal: for fixed roadmaps, best-first CT search returns the least-cost valid solution represented in those roadmaps. Its full sampling-based version is probabilistically complete under the PRM assumptions. These properties are qualified by temporal discretization, the absence of waiting and cycles, finite roadmaps, and the quality of collision checking.
Experiments demonstrated teams of up to 32 agents, up to eight high-degree-of-freedom manipulators, and heterogeneous teams containing aerial, ground, and manipulator robots. In the heterogeneous experiment, CBS-MP succeeded in all trials while DecoupledPRM succeeded in 20% of trials.
Kinodynamic CBS
K-CBS extends CBS to continuous kinodynamic multi-robot motion planning (Kottinger et al., 2022). Robot 0 has state 1, control 2, nonlinear dynamics
3
and body geometry 4. A collision is a continuous-time overlap of robot bodies. A maximal collision interval is represented as
5
The constraint on robot 6 treats robot 7’s trajectory as a time-varying moving obstacle:
8
The low-level planner can be any sampling-based, tree-search kinodynamic planner, such as RRT or KPIECE. Failed low-level searches retain motion trees and identify frequently violated constraints. Repeated conflict between robots can trigger merging into a meta-robot, after which planning is restarted with a reduced number of planning entities.
K-CBS is probabilistically complete if the underlying planner is probabilistically complete. The guarantee relies on eventual merging, correct joint dynamics and geometry, unbounded planning effort in the limit, and suitable clearance assumptions. It does not establish deterministic completeness or optimality. In experiments using second-order car dynamics, K-CBS reliably handled instances up to 20 robots, with success rates of 92% for 10 robots and 10 obstacles, 74% for 15 robots and 10 obstacles, and 30% for 20 robots and 10 obstacles.
Discontinuity-bounded CBS
db-CBS combines CBS with discontinuity-bounded A* and joint trajectory optimization (Moldagalieva et al., 2023). Its individual trajectories are assembled from dynamically valid motion primitives, but a bounded mismatch 9 is allowed between primitive transitions. A trajectory is 0-discontinuity-bounded when
1
The first level uses db-A* to produce coordinated individual trajectories. The second detects geometric conflicts and creates time-indexed forbidden neighborhoods. The third uses differential dynamic programming to repair discontinuities, enforce exact dynamics, and improve cost.
The method progressively enlarges the motion-primitive set and reduces 2. It is claimed to be anytime, probabilistically complete, and asymptotically optimal under assumptions concerning primitive coverage, collision checking, and successful nonlinear optimization. The guarantees are asymptotic and probabilistic rather than finite-time. Experiments included first-order and second-order unicycles, double integrators, cars with trailers, and heterogeneous teams. db-CBS was the only method that consistently solved all tested combinations of dynamics and robot counts in the varying-dynamics experiments, and it produced real-robot solutions for four Crazyflie drones.
Model-predictive and repulsive variants
Conflict-Based Model Predictive Control uses a high-level conflict tree with nonlinear MPC as the low-level planner (Tajbakhsh et al., 2023). The MPC model imposes dynamics, state constraints, input limits, obstacle avoidance, robot separation, and terminal conditions. Conflicts are represented over intervals from the first predicted collision to the end of the prediction horizon, preventing the optimizer from merely shifting a collision by one timestep.
CB-MPC does not provide general feasibility or global-optimality guarantees because nonlinear MPC may converge to local minima or fail to find feasible solutions. In a narrow environment with a horizon of 20 steps, CB-MPC achieved makespan 3, compared with 4 for Joint-MPC, while reducing average per-robot solve time from 5 seconds to 6 seconds. With 12 robots in an open environment, CB-MPC was the only compared method to solve the instance.
APF-ECBS modifies low-level manipulator trajectories using artificial-potential-field repulsion (Hong et al., 17 Sep 2025). Other manipulators are represented by geometric collision bodies, and repulsive task-space forces are mapped into joint space using point Jacobians. The trajectory is updated according to
7
A fast-track procedure applies when every conflict involves one common manipulator. That manipulator is modified once using all other trajectories, potentially eliminating all conflicts without expanding the constraint tree. APF-ECBS reduced constraint-tree expansions and planning time relative to CBS, ECBS, and Gen-ECBS in dense multi-manipulator settings, but it does not preserve standard ECBS bounded-suboptimality or completeness guarantees. Its main trade-off is increased path cost and makespan caused by trajectory bending and time scaling.
5. Extensions to tasks, movable obstacles, heterogeneous solvers, and specifications
Task assignment and temporal constraints
CBS-TA-PTC extends MAPF to Task Assignment and Path Finding with Precedence and Temporal Constraints (Chong et al., 2024). Goals are action-bearing tuples
8
and actions have nonzero duration 9. A binary assignment matrix assigns every goal to one agent, while an agent may receive several goals in an ordered sequence.
The high-level search enumerates assignments and constructs roots for them. Nodes are prioritized by a user-defined reward return supplied by an environment simulator or oracle rather than by sum of path costs. Constraints include vertex and edge exclusions, absolute temporal windows, inter-goal temporal relations, precedence, and action execution times. The low level uses Multi-Label A* and a linear-programming module to prune temporally inconsistent nodes.
Whole-task CBS-TA-PTC is claimed to be complete and optimal under finite-horizon assumptions, complete and optimal low-level planning, exhaustive assignment enumeration, and valid constraint branching. Partitioning a large task into subtasks improves computational manageability but sacrifices global completeness and optimality. In bomb-defusing experiments with three agents, CBS-TA-PTC generally outperformed adapted CBS-TA in success rate and optimality ratio; at two seconds per timestep, its success rate was approximately 0.65 compared with approximately 0.15 for the adapted baseline.
Movable obstacles
M-PAMO combines MAPF with path planning among movable obstacles (Hu et al., 30 Sep 2025). Boxes move only when pushed by agents, so the environment state includes all agent and box positions. Conflicts include agent-agent, agent-box, box-box, and box-pushing-rule violations.
CBS-MOH performs ordinary low-level agent planning and simulates box trajectories at the high level. CBS-MOL uses ST-PAMO*, which searches the joint state of one agent and all boxes augmented with time. PP-PAMO* combines ST-PAMO* with prioritized planning and treats higher-priority paths as dynamic obstacles.
The critical modeling decision is to impose constraints on the agent responsible for moving a box rather than on the box itself. Box constraints are not directly actionable by the low-level planner and can recreate the same conflict because low-level calls do not maintain the complete history of box transitions.
Neither CBS-MOH nor CBS-MOL is guaranteed complete or optimal because each low-level call lacks the globally synchronized state of all boxes induced by other agents. CBS-MOL generally achieves higher success rates as box density increases, but becomes less scalable as the number of agents grows because its low-level state space is
0
Protocol-level CBS
“Conflict-Based Search as a Protocol” abstracts the low-level planner behind a single-agent API (Veerapaneni et al., 1 Oct 2025). The API receives space-time constraints and returns a path, its occupied space-time volume, and a cost:
1
The central planner is agnostic to whether the API uses A*, RRT, direct collocation, diffusion, or reinforcement learning. It detects overlaps among returned space-time volumes, generates alternative constraints, and replans only the constrained agent.
The protocol is conditionally complete when every API returns a valid bounded-cost solution whenever one exists and the generated constraints are mutually disjunctive. In practical continuous-space implementations, volume constraints are not necessarily mutually disjunctive in the classical CBS sense. The experiments therefore use a greedy CBS variant prioritizing conflict count and then cost rather than a strict optimality procedure.
The protocol demonstrated start-goal planning, coverage, surveillance, diffusion-generated motion patterns, and RL-based coverage. Across instances with two to ten agents, approximately 54% of cases with nonzero root conflicts were solved within the experimental limits. Experience reuse increased query speed substantially for several solvers, particularly direct collocation.
STL-enhanced kinodynamic planning
STL-KCBS combines constrained Bayesian Optimization-based Tree search with STL monitoring (Raxit et al., 6 Mar 2026). The low-level cBOT planner uses Gaussian-process models of local cost and feasibility, constrained expected improvement, and fourth-order Runge–Kutta propagation. The high-level planner checks geometric conflicts and evaluates STL robustness, recording a conflict when the robustness satisfies
2
The safety specification can be written as
3
STL constraints extend conflict detection beyond direct collision to temporal ordering, waiting, yielding, obstacle clearance, and other behavioral restrictions. The paper claims probabilistic completeness inherited from the underlying sampling-based planner, while noting that the complete high-level branching and constraint-generation formalization is not fully specified.
In benchmark environments with teams of 2, 4, 6, 8, 10, 12, and 50 robots, STLcBOT achieved 100% success across the evaluated settings reported in the paper. Indoor experiments with three robots produced collision-free trajectories in 42 ms, and outdoor experiments with two- and three-vehicle autonomous surface-vehicle fleets were solved in under one second.
GPU-accelerated multi-arm manipulation
cuArms integrates high-level task scheduling, reusable per-arm multimodal roadmaps, lazy conflict resolution, and GPU-batched trajectory refinement (Huang et al., 26 Oct 2026). A schedule skeleton specifies task assignments, manipulation skills, sampled parameters, and precedence. Each arm receives a reusable roadmap with mode-dependent validity masks. LaCAM- and PIBT-style lazy search then coordinates motion edges, waits, skills, and bimanual actions.
The search state includes each arm’s roadmap node and symbolic action. Candidate actions are ranked by skill priority and heuristic cost-to-go. A GPU-generated conflict table records pairwise conflicts among candidate actions, allowing recursive PIBT-style resolution to use inexpensive table lookups rather than repeated geometric checks.
The method is not presented as an exact optimizer. It relies on roadmap sampling, heuristic candidate ordering, lazy search, and greedy shortcutting. Nevertheless, in RoboBallet welding experiments with four or eight arms and 10 or 40 targets, cuArms found initial solutions in under one second and reduced final makespan by approximately 47% in the reported comparisons. In tabletop tasks with two Panda arms, it solved all reported Hold, Stack, Pack, and Unpack instances and reduced final makespan by approximately 42%–57% relative to the scheduling baseline.
6. Scalability, parallelization, guarantees, and practical limitations
Targeted parallelization
Targeted parallelization of ECBS distinguishes dense, strongly interacting instances from large, sparsely interacting ones (Guo et al., 2024). Dense instances are dominated by high-level branch growth, so Decentralized Parallel ECBS distributes constraint-tree exploration across local open and focal lists. Large sparse instances are dominated by expensive node internals, so Parallel Bypass-augmented ECBS parallelizes pairwise-disjoint bypasses and conflict counting.
DP-ECBS retains completeness and 4-bounded suboptimality under the ECBS assumptions. It uses local queues, buffers, conflict-avoidance tables, and an incumbent solution shared across workers. PB-ECBS performs parallel bypasses on conflicts involving disjoint robot pairs and distributes time-window conflict counting across workers.
On dense instances, the parallel solver achieved approximately 40% higher success rate than the serial version. On large-map experiments with approximately 4,000 robots, PB-ECBS solved instances in about 20 seconds, achieved approximately 5–6 speedup over ECBS, and maintained SOC ratios of approximately 1.0–1.1. The method does not provide one universally superior parallel strategy: branch parallelism is useful when the high-level tree dominates, while node-internal parallelism is useful when individual expansions dominate.
Stop-based and priority-based coordination
Virtual Traffic Lights uses decentralized path planning with centralized conflict detection and stop-based arbitration (Gupta et al., 11 Nov 2025). Each robot independently plans a path, while a coordinator detects spatial intersections with overlapping estimated arrival times, clusters related conflicts, and permits some robots to proceed while issuing STOP commands to others outside the conflict region.
This method is not CBS: it does not maintain a constraint tree, replan under newly generated constraints, optimize a global objective, or explore alternative branches. It is closer to priority-based traffic management and implicit reservation. At eight robots, the hybrid system achieved a 96% success rate compared with 81% for decentralized local avoidance, and the decentralized baseline required approximately four times as many global path replans. The method has no formal completeness or optimality guarantee and is sensitive to stale paths, timing errors, communication delay, conservative conflict clustering, and fairness issues.
Graph-based lazy search for manipulators
Conflict-Based Lazy Search uses reusable sparse single-manipulator graphs and Lazy Edge-based A* (Zheng et al., 5 Jul 2026). The low-level planner postpones expensive collision checks. For an edge 7, a cheap estimate 8 guides search, while the true cost is
9
LEA* maintains an edge queue ordered by
0
evaluating only promising edges. It is complete and optimal on the finite precomputed graph under positive edge costs and admissible, consistent heuristics. It is optimally vertex efficient relative to A*: the set of vertices expanded by LEA* is a subset of those expanded by A* under the stated assumptions.
In single-manipulator tests, LEA* was faster than A* and LazySP while preserving the same path lengths for 1. In three-manipulator tests with graph size 5,000, CBLS required 0.2586 seconds compared with 0.8770 seconds for CBS using A*. At graph size 40,000, the corresponding times were 0.6278 and 2.1713 seconds. CBLS remains subject to graph-resolution limitations and CBS constraint-tree growth.
General limitations
Conflict-Based Planning does not eliminate the intrinsic difficulty of multi-agent planning. Its practical and theoretical limitations recur across variants:
- High-level combinatorial growth: each unresolved conflict can generate alternative branches, and the constraint tree may grow exponentially.
- Low-level dependence: incomplete, locally optimal, or time-limited low-level planners can cause false failure or invalidate completeness arguments.
- Representation dependence: graph-optimality is not continuous-space optimality; roadmap density, motion primitives, temporal discretization, and collision geometry determine the represented solution set.
- Constraint quality: weak, non-disjunctive, or overly conservative constraints can reduce pruning effectiveness or invalidate classical CBS proofs.
- Continuous-time checking: sampled collision checks may miss interactions between samples unless swept-volume or sufficiently conservative checking is used.
- Dynamic coupling: movable obstacles, manipulation modes, attachments, and task execution can make the environment state depend on the complete history of all agents.
- Objective heterogeneity: arbitrary rewards, multi-objective costs, task priorities, makespan, sum of costs, and motion distance may not admit a common monotonic high-level ordering.
- Execution uncertainty: model mismatch, communication delay, tracking error, and changing robot velocities can invalidate predicted trajectories.
- Task decomposition: partitioning large tasks improves scalability but sacrifices global completeness and optimality.
- Parallel overhead: decentralized or GPU-parallel approaches reduce wall-clock time but incur synchronization, memory, and collision-table costs.
The broader methodological contribution of Conflict-Based Planning is therefore not a single universal algorithm. It is a reusable architecture for exploiting conditional independence: solve local planning problems with domain-specific methods, detect the interactions that invalidate their combination, and spend computational effort precisely on those interactions. Its strongest guarantees arise when the representation is finite, low-level planning is complete and optimal, and conflict branches are mutually exhaustive. Its strongest practical results arise when these assumptions are relaxed carefully and combined with warm starts, safe intervals, lazy evaluation, roadmap reuse, sampling, MPC, optimization, parallelism, or task-level scheduling.