Kinodynamic Temporal Plan Graph (kTPG)

• Kinodynamic Temporal Plan Graph Planning (kTPG) is a method that converts discrete, collision-free MAPF plans into continuous, kinodynamically feasible speed profiles.
• It builds a Temporal Plan Graph (TPG) to encode both sequential and inter-agent precedence constraints, ensuring safe turns and adherence to speed and acceleration limits.
• The approach, extended by WinkTPG, uses windowed execution and reserved time intervals to manage uncertainties and scale efficiently to multi-agent scenarios.

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 (Yan et al., 2 Aug 2025).

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 $A = \{a_1, \dots, a_I\}$0 is the move from $A = \{a_1, \dots, a_I\}$1 to $A = \{a_1, \dots, a_I\}$2, with geometric length $A = \{a_1, \dots, a_I\}$3 (Yan et al., 2 Aug 2025).

The kinodynamic abstraction is defined along the path parameterization. Let $A = \{a_1, \dots, a_I\}$4 denote speed and $A = \{a_1, \dots, a_I\}$5 acceleration. The constraints are

$A = \{a_1, \dots, a_I\}$6

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 $A = \{a_1, \dots, a_I\}$7 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 $A = \{a_1, \dots, a_I\}$8 that encodes the passing order constraints implied by the MAPF plan (Yan et al., 2 Aug 2025). For each agent $A = \{a_1, \dots, a_I\}$9 and path position $q_i^s \in V_U$0, there is a vertex $q_i^s \in V_U$1, with associated location $q_i^s \in V_U$2.

Two edge classes define the graph semantics.

Type-1 edges encode sequential precedence within an agent’s path. For each agent $q_i^s \in V_U$3 and each $q_i^s \in V_U$4, $q_i^s \in V_U$5 means the agent must visit $q_i^s \in V_U$6 before $q_i^s \in V_U$7.

Type-2 edges encode inter-agent precedence at shared locations. For agents $q_i^s \in V_U$8 and $q_i^s \in V_U$9 with $q_i^g \in V_U$0, the edge $q_i^g \in V_U$1 means agent $q_i^g \in V_U$2 can enter the shared location only after agent $q_i^g \in V_U$3 leaves it, that is, after reaching $q_i^g \in V_U$4.

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 $q_i^g \in V_U$5 with required separation $q_i^g \in V_U$6, the event times satisfy

$q_i^g \in V_U$7

In particular, for Type-1 edges,

$q_i^g \in V_U$8

where $q_i^g \in V_U$9 is the minimum feasible traversal time for segment $i$0, including any turning time. For Type-2 edges,

$i$1

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$2 at vertex $i$3 is denoted $i$4, and the leave time from $i$5 is defined as $i$6. Segment duration is

$i$7

On each segment, the trajectory must satisfy both the continuous constraints on $i$8 and $i$9 and the segment-distance consistency condition

$$p_i = \{(q_i^0, t_0), \dots, (q_i^{z^i}, t_{z^i})\},$$0

In a discrete piecewise-constant speed model,

$$p_i = \{(q_i^0, t_0), \dots, (q_i^{z^i}, t_{z^i})\},$$1

with adjacent-segment acceleration bound

$$p_i = \{(q_i^0, t_0), \dots, (q_i^{z^i}, t_{z^i})\},$$2

A central internal construct is the reserved interval. For each vertex $$p_i = \{(q_i^0, t_0), \dots, (q_i^{z^i}, t_{z^i})\},$$3, kTPG maintains a time window

$$p_i = \{(q_i^0, t_0), \dots, (q_i^{z^i}, t_{z^i})\},$$4

within which agent $$p_i = \{(q_i^0, t_0), \dots, (q_i^{z^i}, t_{z^i})\},$$5 must reach $$p_i = \{(q_i^0, t_0), \dots, (q_i^{z^i}, t_{z^i})\},$$6. Initially, $$p_i = \{(q_i^0, t_0), \dots, (q_i^{z^i}, t_{z^i})\},$$7. 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

$$p_i = \{(q_i^0, t_0), \dots, (q_i^{z^i}, t_{z^i})\},$$8

and the makespan

$$p_i = \{(q_i^0, t_0), \dots, (q_i^{z^i}, t_{z^i})\},$$9

The paper evaluates solution quality via sum of arrival times and reports suboptimality against an idealized lower bound (Yan et al., 2 Aug 2025).

Under uncertainty, the traversal time of each segment is modeled as

$q_i^0 = q_i^s$0

where $q_i^0 = q_i^s$1 is the segment length and $q_i^0 = q_i^s$2 is an agent-specific parameter. The cumulative reach time becomes

$q_i^0 = q_i^s$3

For a Type-2 edge, the order-preservation probability is enforced by tightening the precedence constraint with a safety margin: $q_i^0 = q_i^s$4 where

$q_i^0 = q_i^s$5

This produces kTPGu, the uncertainty-aware variant of kTPG. When these margins are applied, the probability of violating passing order is bounded by $q_i^0 = q_i^s$6.

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 (Yan et al., 2 Aug 2025). The graph is initialized with all reserved intervals equal to $q_i^0 = q_i^s$7, 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 $q_i^0 = q_i^s$8, let $q_i^0 = q_i^s$9 be the leave time produced by the new speed profile at the shared location $q_i^{z^i} = q_i^g$0. The timeline of that location is split into

$q_i^{z^i} = q_i^g$1

and the corresponding reserved intervals are intersected with those subintervals. With uncertainty, the second interval becomes

$q_i^{z^i} = q_i^g$2

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 $q_i^{z^i} = q_i^g$3 seconds and builds a planning window containing at least $q_i^{z^i} = q_i^g$4 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 $q_i^{z^i} = q_i^g$5 with actual time $q_i^{z^i} = q_i^g$6, and future reach-time estimates are recomputed from that anchor: $q_i^{z^i} = q_i^g$7 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 (Yan et al., 2 Aug 2025). For kinodynamic planning, the omnidirectional model uses

$q_i^{z^i} = q_i^g$8

and the differential-drive model includes fixed turning durations. Uncertainty experiments use a per-segment normal-noise model with safety threshold $q_i^{z^i} = q_i^g$9, and $(q_i^{k-1}, q_i^k) \in E_U$0 controls the uncertainty level, with typical $(q_i^{k-1}, q_i^k) \in E_U$1.

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 $(q_i^{k-1}, q_i^k) \in E_U$2. The explanation given is that ADG’s frequent replanning is conservative and leads to unnecessary decelerations. Window parameters matter: smaller execution window $(q_i^{k-1}, q_i^k) \in E_U$3 and planning window sizes where $(q_i^{k-1}, q_i^k) \in E_U$4 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

$(q_i^{k-1}, q_i^k) \in E_U$5

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 (Jie et al., 2022). 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 $(q_i^{k-1}, q_i^k) \in E_U$6, 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 (Yan et al., 2 Aug 2025), 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, Jie et al., 2022). 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.