---
title: Kinodynamic Temporal Plan Graph (kTPG)
url: https://www.emergentmind.com/topics/kinodynamic-temporal-plan-graph-planning-ktpg
type: topic
---

# Kinodynamic Temporal Plan Graph (kTPG)

Kinodynamic Temporal Plan Graph Planning (kTPG) is a **multi-agent speed optimization algorithm** that **efficiently refines a MAPF plan into a kinodynamically feasible plan while accounting for uncertainties and preserving collision-freeness**. In the formulation directly associated with the term, kTPG operates on a Temporal Plan Graph (TPG) derived from a discrete Multi-Agent Path Finding plan, then computes per-agent speed profiles that satisfy precedence constraints, speed and acceleration bounds, and, when required, probabilistic safety margins. A closely related execution framework, Windowed kTPG (WinkTPG), incrementally refines MAPF plans through a window-based mechanism that dynamically incorporates agent information during execution to reduce uncertainty [2508.01495].

## 1. Definition and planning context

kTPG is posed over an **undirected graph** $G_U = (V_U, E_U)$ with agents $A = \{a_1, \dots, a_I\}$, each having a start $q_i^s \in V_U$ and goal $q_i^g \in V_U$. The input is a **discrete MAPF plan**: for agent $i$, a time-annotated sequence
\[
p_i = \{(q_i^0, t_0), \dots, (q_i^{z^i}, t_{z^i})\},
\]
with $q_i^0 = q_i^s$, $q_i^{z^i} = q_i^g$, and $(q_i^{k-1}, q_i^k) \in E_U$. A plan is collision-free if there are **no vertex collisions** and **no edge collisions**. Segment $k$ for agent $i$ is the move from $q_i^k$ to $q_i^{k+1}$, with geometric length $\Delta s_{i,k}$ [2508.01495].

The kinodynamic abstraction is defined **along the path parameterization**. Let $v_i(t)$ denote speed and $a_i(t) = dv_i/dt$ acceleration. The constraints are
\[
0 \le v_i(t) \le v_i^{\max}, \qquad |a_i(t)| \le a_i^{\max}.
\]
The formulation supports both **omnidirectional** and **differential-drive** robots. For omnidirectional robots, agents move in any direction with speed and acceleration bounds; for differential drive, motion is along the current orientation, and orientation changes occur when $v = 0$ with fixed turning durations. These turning actions are treated as **zero-distance events with duration and precedence constraints** in the temporal plan.

Within this setting, kTPG addresses a specific execution problem: the discrete MAPF plan already fixes a collision-free spatial route, but standard MAPF algorithms rely on simplified kinodynamic models, preventing agents from directly following the generated MAPF plan. kTPG refines that plan into a continuous-time schedule that respects kinodynamics while preserving the passing order implied by MAPF. This makes kTPG primarily an **execution-layer temporal refinement method**, rather than a replacement for MAPF itself.

## 2. Temporal Plan Graph structure

The TPG used in kTPG is a **DAG** $G = (V, E_1, E_2)$ that encodes the passing order constraints implied by the MAPF plan [2508.01495]. For each agent $i$ and path position $k \in \{0, \dots, z^i\}$, there is a vertex $v_i^k$, with associated location $\operatorname{loc}(v_i^k) = q_i^k$.

Two edge classes define the graph semantics.

**Type-1 edges** encode sequential precedence within an agent’s path. For each agent $i$ and each $k$, $(v_i^k, v_i^{k+1}) \in E_1$ means the agent must visit $v_i^k$ before $v_i^{k+1}$.

**Type-2 edges** encode inter-agent precedence at shared locations. For agents $i$ and $j$ with $\operatorname{loc}(v_j^s) = \operatorname{loc}(v_i^k)$, the edge $(v_j^{s+1}, v_i^k) \in E_2$ means agent $i$ can enter the shared location only after agent $j$ leaves it, that is, after reaching $v_j^{s+1}$.

This construction translates discrete MAPF conflicts into temporal constraints. Type-1 edges preserve local sequencing; Type-2 edges impose a global passing order at shared locations and thereby prevent **simultaneous occupancy** and **swap conflicts**. For a generic precedence edge $u \rightarrow v$ with required separation $\delta(u,v)$, the event times satisfy
\[
t(v) - t(u) \ge \delta(u,v).
\]
In particular, for Type-1 edges,
\[
t_i^r(k+1) - t_i^r(k) = \Delta t_{i,k} \ge \tau_i^k,
\]
where $\tau_i^k$ is the minimum feasible traversal time for segment $k$, including any turning time. For Type-2 edges,
\[
t_i^r(k) - t_j^r(s+1) \ge \delta_{loc}.
\]

The graph therefore serves as a temporal skeleton for continuous execution. The continuous trajectories inherit collision-freeness from the TPG if all Type-1 and Type-2 constraints are satisfied and the kinodynamic bounds hold.

## 3. Kinodynamic variables, reserved intervals, and uncertainty margins

The main decision variables in kTPG are **event times**, **segment durations**, and **speed/acceleration profiles**. The reach time of agent $i$ at vertex $v_i^k$ is denoted $t_i^r(k)$, and the leave time from $q_i^k$ is defined as $t_i^l(k) := t_i^r(k+1)$. Segment duration is
\[
\Delta t_{i,k} := t_i^r(k+1) - t_i^r(k).
\]
On each segment, the trajectory must satisfy both the continuous constraints on $v_i(t)$ and $a_i(t)$ and the segment-distance consistency condition
\[
\Delta s_{i,k} = \int_{t_i^r(k)}^{t_i^r(k+1)} v_i(\tau)\, d\tau.
\]
In a discrete piecewise-constant speed model,
\[
\Delta s_{i,k} = v_{i,k}\Delta t_{i,k}, \qquad 0 \le v_{i,k} \le v_i^{\max},
\]
with adjacent-segment acceleration bound
\[
|v_{i,k+1} - v_{i,k}| \le a_i^{\max}\Delta t_{i,k}.
\]

A central internal construct is the **reserved interval**. For each vertex $v_i^k$, kTPG maintains a time window
\[
R_i^k = [L_i^k, U_i^k]
\]
within which agent $i$ must reach $v_i^k$. Initially, $R_i^k = [0,\infty)$. These intervals are refined iteratively so that Type-2 constraints become non-overlapping in time.

The execution objective is formulated as a global timing criterion subject to kinodynamic feasibility and precedence constraints. Two common choices are the **sum of arrival times**
\[
\min \sum_{i=1}^I t_i^r(z^i)
\]
and the **makespan**
\[
\min \max_i t_i^r(z^i).
\]
The paper evaluates solution quality via **sum of arrival times** and reports **suboptimality against an idealized lower bound** [2508.01495].

Under uncertainty, the traversal time of each segment is modeled as
\[
\hat{T}_i^k = T_i^k + \mathcal{N}\bigl(0, (\varepsilon_i^k)^2\bigr), \qquad (\varepsilon_i^k)^2 = K_i \cdot d_k^{k+1},
\]
where $d_k^{k+1}$ is the segment length and $K_i$ is an agent-specific parameter. The cumulative reach time becomes
\[
t_i^r(k) = t_i^r(0) + \sum_{j=0}^{k-1}\hat{T}_i^j
= \mathcal{N}(\mu_i^k, (\sigma_i^k)^2).
\]
For a Type-2 edge, the order-preservation probability is enforced by tightening the precedence constraint with a safety margin:
\[
t_j^r(n) - t_i^r(m+1) \ge \delta_{loc} + M_{i,j}^{m,n},
\]
where
\[
M_{i,j}^{m,n}
=
F^{-1}_{\mathcal{N}(0, (\sigma_i^{m+1})^2 + (\sigma_j^n)^2)}(P_d).
\]
This produces **kTPGu**, the uncertainty-aware variant of kTPG. When these margins are applied, the probability of violating passing order is bounded by $1 - P_d$.

## 4. Interval refinement and windowed execution

kTPG does not solve a single global LP or MILP. Instead, it **iteratively refines reserved intervals and computes single-agent kinodynamically feasible speed profiles** [2508.01495]. The graph is initialized with all reserved intervals equal to $[0,\infty)$, and vertices are classified as **unlocked** if they have no incoming conflicting Type-2 edges, otherwise **locked**.

At each iteration, kTPG selects the agent that can satisfy the maximum number of currently conflicting Type-2 edges originating from its unlocked vertices. It then performs **single-agent speed planning** from the agent’s first to last unlocked vertex, respecting reserved intervals, starting and ending with zero speed, and satisfying the speed and acceleration bounds. The implementation uses **a 1-D adaptation of SIPP-IP**, described as an A*-like search over motion primitives with safe intervals.

The key update step is the use of a **split time**. For a conflicting Type-2 edge $(v_i^{k+1}, v_j^s)$, let $t$ be the leave time produced by the new speed profile at the shared location $\operatorname{loc}(v_i^k)$. The timeline of that location is split into
\[
[0,t] \text{ for agent } i
\quad\text{and}\quad
(t,\infty) \text{ for agent } j,
\]
and the corresponding reserved intervals are intersected with those subintervals. With uncertainty, the second interval becomes
\[
(t + M_{i,j}^{m,n}, \infty).
\]
The Type-2 edge is then marked satisfied, and vertex lock states are updated.

WinkTPG extends this mechanism with a **window-based execution framework**. It re-optimizes every $t_e$ seconds and builds a planning window containing at least $t_p$ future vertices for each agent after its last enqueued vertex. If a Type-2 edge inside the window depends on a vertex outside, the window is expanded recursively to include that source vertex. During execution, agents report their actual reach times and current kinodynamic states upon arriving at each location. The window is anchored at each agent’s most recent reported vertex $v_i^p$ with actual time $t_i^r(v_i^p)$, and future reach-time estimates are recomputed from that anchor:
\[
t_i^r(v_i^k) = t_i^r(v_i^p) + \sum_{j=p}^{k-1}\hat{T}_i^j.
\]
Because variance now accumulates only from the latest report onward, uncertainty is reduced before re-running kTPGu within the window. Past events remain fixed, preserving temporal consistency, while feasible profiles are retained up to the last vertex from the prior window.

## 5. Performance, scalability, and operational trade-offs

The reported experimental setup uses **MovingAI grid maps**—Empty 32×32, Random 64×64, Room 64×64, den520d, Boston, and Warehouse-Large 340×164—with **up to 1,000 agents** and **PBS** as the MAPF planner [2508.01495]. For kinodynamic planning, the omnidirectional model uses
\[
v \in [0, 2] \text{ m/s}, \qquad a \in [-1, 1] \text{ m/s}^2,
\]
and the differential-drive model includes fixed turning durations. Uncertainty experiments use a per-segment normal-noise model with safety threshold $P_d = 0.99$, and $\varepsilon$ controls the uncertainty level, with typical $\varepsilon \le 0.05$.

Against baselines, the reported outcomes separate into deterministic and uncertain settings. In the deterministic setting, **kTPG and KDN substantially outperform ADG in solution quality**, with **kTPG achieving up to 51.7% improvement on the warehouse map**. In scalability, **kTPG and ADG maintain 100% success up to 1,000 agents**, whereas **KDN struggles beyond ~100 agents due to MILP complexity**. Runtime results state that **KDN’s MILP is orders of magnitude slower**, reaching **up to 300 s on 200 agents**.

In the uncertain setting, **WinkTPG yields lower sum-of-cost than ADG when $\varepsilon < 0.03$**. The explanation given is that ADG’s frequent replanning is conservative and leads to unnecessary decelerations. Window parameters matter: **smaller execution window $t_e$ and planning window sizes where $t_e < t_p$ improve solution quality** because they incorporate actual agent reports more frequently.

For computational scaling, the paper proves that **each iteration satisfies at least one Type-2 edge and unlocks at least one vertex**, so the number of iterations is
\[
\le \min(|V|, |E_2|).
\]
The localized refinement strategy avoids global MILPs and yields runtimes described as **milliseconds per iteration even for thousands of agents**. Empirically, **WinkTPG generates speed profiles for up to 1,000 agents within ~1 second**, whereas **global, non-windowed kTPG over the entire horizon can take tens of seconds at 1,000 agents**, and windowing reduces this dramatically.

These results position kTPG as a temporal-reasoning execution method that trades full global optimization for scalable local refinement. The principal trade-offs are explicit in the reported parameter sensitivities: larger safety margins improve robustness but can degrade performance through enforced waits; tighter acceleration limits increase minimum traversal times; smaller execution windows improve responsiveness but raise replanning frequency.

## 6. Relation to other kinodynamic temporal planning formulations

The term **kTPG** is used directly in the multi-agent MAPF execution context, but related planning architectures in the provided material are presented as **mappings** or **TPG-like interpretations**, not as identical formulations.

One related case is the multi-layer motion-planning framework with **kinodynamic and spatio-temporal constraints** [2503.07762]. That work proposes a **three-part framework**: a discrete spatial-sequence layer, a geometric lead path, and a guided asymptotically optimal sampling-based kinodynamic planner that minimizes an **STL-robustness cost**. The provided technical narrative states explicitly that **the manuscript does not mention Temporal Plan Graphs (TPG) or kinodynamic TPG (kTPG)**, but that **the layered approach and STL constraints can be mapped to a TPG-like representation**. In that mapping, nodes correspond to temporal tasks such as visiting labeled regions or maintaining safety predicates; edges correspond to feasible motion segments with estimated travel times and kinodynamic feasibility; and the kinodynamic layer refines edges into dynamically feasible trajectories. The stated difference is that the STL-driven framework uses **real-time robustness as a quantitative satisfaction metric** and **sampling-based kinodynamics for motion feasibility**, whereas kTPG emphasizes explicit precedence scheduling with reserved intervals. This suggests a complementary relationship rather than terminological identity.

A second related case is the real-time path–speed planning framework based on **Gaussian Process path generation**, **s–t graph speed planning**, and **incremental refinement** [2205.11853]. In the provided technical description, this approach is mapped to kTPG terminology by identifying the **s–t graph** as the Temporal Plan Graph: nodes are kinematic states $(s,\dot{s},t)$, and edges are admissible transitions under acceleration bounds, speed limits, curvature-derived speed limits, and blocked regions in the s–t domain. The refinement loop alternates between GP-based path updates and speed-profile regeneration until lateral-acceleration violations are removed, and the reported system can run at **20 Hz**. Here again, the kTPG interpretation is explicitly a mapping in the technical narrative. A plausible implication is that kTPG can be understood broadly as a family of methods in which temporal graph structure, kinodynamic feasibility, and execution-time refinement are tightly coupled, even when the original paper uses different terminology.

A common misconception is therefore that kTPG denotes a single universal formalism across kinodynamic temporal planning. The provided material supports a narrower statement: kTPG is directly named and formulated for **MAPF execution via temporal reasoning** [2508.01495], while STL-guided layered planning and s–t graph trajectory planning can be interpreted as related or TPG-like only when that interpretation is made explicit [2503.07762; 2205.11853]. Under that reading, the unifying theme is the conversion of discrete temporal order into continuous kinodynamically feasible motion, but the optimization criteria, uncertainty models, and graph semantics differ substantially across formulations.

Source: https://www.emergentmind.com/topics/kinodynamic-temporal-plan-graph-planning-ktpg