---
title: 'ADPP: Asynchronous Decentralized Prioritized Planning'
url: https://www.emergentmind.com/topics/asynchronous-decentralized-prioritized-planning-adpp
type: topic
---

# ADPP: Asynchronous Decentralized Prioritized Planning

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 [1210.6855][1409.2399].

## 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 [1210.6855][1409.2399].

## 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:

```python
# Initialization
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

# Consistency and planning
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

# Message handler
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 [1210.6855][1409.2399].

## 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 [1210.6855].

## 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 [1210.6855][1409.2399].

### 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 [1210.6855][1409.2399].

## 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) [1210.6855].
- **Realistic environments**: simple halls, office corridors, and warehouses using PRM-based spatial graphs [1409.2399].

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 [1210.6855][1409.2399]. 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 [1409.2399].
- **Communication:** Reliable FIFO channels are essential; lossy networks demand augmentation (e.g., ACKs, periodic rebroadcasts) [1409.2399].
- **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 [1210.6855][1409.2399].
- **Communication overhead:** Quadratic scaling in dense, highly coupled teams [1210.6855].
- **Excessive replanning for low-priority agents** in congested scenarios [1409.2399].
- **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 [1409.2399].

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 [1409.2399].

## 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 [1210.6855][1409.2399].

Source: https://www.emergentmind.com/topics/asynchronous-decentralized-prioritized-planning-adpp