ADPP: Asynchronous Decentralized Prioritized Planning

• ADPP is a decentralized framework for cooperative multi-agent pathfinding where agents autonomously compute collision-free trajectories without global synchronization.
• It extends classical prioritized planning by enabling asynchronous communication and local re-planning, which reduces wall-clock time and adapts to communication constraints.
• Empirical results show ADPP and its interruptible variant IADPP achieve up to 60% speedup in planning with moderate optimality trade-offs in both synthetic and real-world scenarios.

Asynchronous Decentralized Prioritized Planning (ADPP) is a distributed algorithmic framework for cooperative multi-agent pathfinding, where each agent autonomously computes a collision-free trajectory in a shared workspace, considering dynamically updated information about the intentions of higher-priority agents. ADPP extends the classical prioritized planning paradigm—where agents sequentially plan in priority order to avoid conflicts—to decentralized, asynchronous settings. This design removes global synchronization barriers, enabling improved wall-clock performance and more robust operational autonomy in networked multi-robot teams, especially under communication or privacy constraints (Čáp et al., 2012, Čáp et al., 2014).

1. Problem Formulation and Prioritized Planning Framework

ADPP addresses the cooperative pathfinding problem in continuous or discretized workspaces. Consider $n$ agents, each with an initial position $\mathit{start}_i$, goal $\mathit{dest}_i$, and dynamic constraints permitting a trajectory $p_i(t)$. The joint solution $P = \{p_1, ..., p_n\}$ must ensure collision-free space-time trajectories:

$$\forall\,i \neq j:~~\neg C(p_i, p_j), \quad\text{where}\quad C(p_i, p_j) = \exists\, t \ge 0 ~:~ p_i(t) = p_j(t)$$

Performance is assessed by the sum of agent arrival times

$\mathit{dur}(P) = \sum_{i=1}^n t_i^{\mathit{dest}}$

and its relative cost compared to the sum for individually time-optimal, unconstrained paths.

Prioritized planning imposes a total agent order $1 \prec 2 \prec ... \prec n$; agents plan their trajectories successively, each viewing the trajectories of all higher-priority agents as dynamic obstacles. The single-agent planning primitive is:

$$\mathit{BestPath}_i(\mathit{start}, \mathit{dest}, \mathit{Avoids})$$

which returns a feasible, time-optimal trajectory for agent $i$ that avoids the space-time occupancy of $\mathit{Avoids}$.

In traditional centralized algorithms, this process is strictly sequential and often infeasible for large teams due to computational and communication bottlenecks, motivating decentralized variants (Čáp et al., 2012, Čáp et al., 2014).

2. Core Structure of ADPP

ADPP decomposes computation by delegating planning and coordination to individual agents. Each agent maintains:

• AgentView (or $H_i$): the set of latest trajectories broadcast by all higher-priority agents.
• $\mathit{CheckFlag}_i$: a control flag indicating receipt of new information.
• Local planning and broadcast logic: an agent initiates replanning whenever its current path becomes inconsistent with updated higher-priority plans, immediately upon message receipt.

The pseudocode structure for an agent $i$ is as follows:

AgentView_i = ∅ Path_i = ∅ CheckFlag_i = False do: CheckFlag_i = False CheckConsistencyAndPlan() wait until (CheckFlag_i == True) or global termination detected while not global termination def CheckConsistencyAndPlan(): if Path_i conflicts with any in AgentView_i: Avoids = {p_j | (j, p_j) in AgentView_i} Path_i = BestPath_i(start, dest, Avoids) for j in (i+1) to N: send INFORM(i, Path_i) to agent j on INFORM(j, p_j): update AgentView_i with (j, p_j) CheckFlag_i = True

Agents only send INFORM messages to lower-priority agents. Communication must guarantee reliable FIFO delivery for correctness and termination (Čáp et al., 2012, Čáp et al., 2014).

3. Interruptible Variant: IADPP

IADPP augments ADPP by introducing interruptibility to the planning thread. If a new INFORM message arrives while an agent is replanning, the current best-response computation is aborted and restarted immediately with the updated AgentView. This further reduces wasted computation time, especially in scenarios with frequent updates or highly entangled conflicts. All other ADPP properties, including correctness and termination, remain intact (Čáp et al., 2012).

4. Correctness, Termination, and Complexity

Correctness and Termination

ADPP guarantees that:

• All INFORM messages eventually quiesce (finite termination), by induction on agent priority: once all higher-priority agents stop changing paths, each lower-priority agent can make a finite number of replans before settling.
• The final agent trajectories are provably collision-free, since every agent's last plan is consistent with all higher-priority final plans (Čáp et al., 2012, Čáp et al., 2014).

Complexity Analysis

Let $T_i$ denote agent $i$'s worst-case time to solve the single-agent planning problem.

• Centralized and Synchronized Runtime: $\sum_{i=1}^n T_i$
• Best-case ADPP Runtime: $\max_i T_i$ (full parallelism, disjoint conflicts)
• Worst-case ADPP Runtime: $\sum_{i=1}^n T_i$ (all conflicts entangled)
• Message Complexity: $O(n^2)$ INFORMs ($\leq n(n-1)/2$ in a single INFORM cascade)

The memory overhead per agent is $O(n)$, as each stores all higher-priority paths (Čáp et al., 2012, Čáp et al., 2014).

5. Experimental Findings

Empirical validation on grid and real-world maps comprised:

• Synthetic scenarios (e.g., circular “superconflicts,” spiral conflicts, independent subproblems, and large random agent ensembles) (Čáp et al., 2012).
• Realistic environments: simple halls, office corridors, and warehouses using PRM-based spatial graphs (Čáp et al., 2014).

Key findings include:

Scenario	CA	SDPP	ADPP	IADPP
Single superconflict	10.3 s	26.2 s	11.9 s	9.5 s
4 homogeneous superconflicts	45.8 s	27.0 s	13.9 s	11.6 s
4 heterogeneous superconflicts	9.08 s	16.0 s	4.89 s	2.59 s
Spiral superconflict	6.15 s	21.0 s	17.6 s	3.77 s

In random scenarios (30–100 agents), ADPP and IADPP reduced wall-clock planning time by ~65% versus centralized and ~45% versus synchronized versions. Solution quality was typically within 10–20% of the ideal joint optimum; failure rates across decentralized methods were comparable (Čáp et al., 2012, Čáp et al., 2014). In real-world environments (empty halls, offices, warehouses), ADPP achieved up to 40–60% speedup over synchronized decentralization, with moderate overheads in communication and marginal prolongation over the no-collision baseline.

6. Practical Considerations, Extensions, and Limitations

Key implementation concerns:

• Priority assignment: Fixed, globally agreed priorities are standard (e.g., IDs, heuristic task lengths), but performance is sensitive to order; dynamic or auction-based priorities are not part of canonical ADPP (Čáp et al., 2014).
• Communication: Reliable FIFO channels are essential; lossy networks demand augmentation (e.g., ACKs, periodic rebroadcasts) (Čáp et al., 2014).
• Single-agent planner: Completeness and performance are governed by the chosen best-response algorithm; A*, RRT*, and time-optimal randomized planners can be used according to domain requirements.

Principal limitations:

• Algorithmic incompleteness: Inherits failure modes from prioritized planning—if a global solution exists but an agent’s priority order precludes it, ADPP may fail without backtracking (Čáp et al., 2012, Čáp et al., 2014).
• Communication overhead: Quadratic scaling in dense, highly coupled teams (Čáp et al., 2012).
• Excessive replanning for low-priority agents in congested scenarios (Čáp et al., 2014).
• Infrastructure requirements: Correctness and completeness (in RPP variants) are established under “valid infrastructure” conditions, where static start and goal occupancy are non-overlapping and single-agent paths exist avoiding relevant endpoints (Čáp et al., 2014).

Extensions reported in the literature include local gossip communication, incremental team adjustment (agents joining/leaving), and priority-swapping mechanisms to escape deadlocks, as well as integration with reactive navigation layers for robustness under execution uncertainties (Čáp et al., 2014).

7. Relation to Broader Multi-Agent Planning Research

ADPP’s asynchronous, decentralized approach contrasts with both fully centralized trajectory planners and reactive methods such as ORCA. Compared to classical prioritized planning, ADPP achieves substantial reductions in wall-clock planning time for heterogeneous or large-scale teams—trading mostly communication and mild optimality loss for scalability and robustness. It provides a foundation for real-world deployment of multi-robot fleets in domains such as automated warehouses, mobile delivery, and air or underwater vehicle swarms, particularly where minimizing coordination overhead and preserving agent autonomy are operationally critical (Čáp et al., 2012, Čáp et al., 2014).