---
title: 'WinkTPG: Efficient MAPF Execution Framework'
url: https://www.emergentmind.com/topics/windowed-ktpg-winktpg
type: topic
---

# WinkTPG: Efficient MAPF Execution Framework

Searching arXiv for the target paper and closely related MAPF execution work to ground the article.
Windowed kTPG, abbreviated WinkTPG, is a multi-agent path-finding execution framework that incrementally refines a discrete collision-free MAPF plan into kinodynamically feasible speed profiles by combining temporal plan graph reasoning, single-agent speed optimization, and receding-horizon replanning [2508.01495]. It is introduced together with kinodynamic Temporal Plan Graph Planning (kTPG), which addresses a central limitation of standard MAPF algorithms: their reliance on simplified kinodynamic models, which can prevent agents from directly following the generated MAPF plan. WinkTPG builds on kTPG by dynamically incorporating agent information during execution through a window-based mechanism intended to reduce uncertainty while preserving collision-freeness [2508.01495].

## 1. Problem setting and formal representation

The framework is defined for the Multi-Agent Execution Problem (MAEP) over a discrete collision-free MAPF solution encoded as a Temporal Plan Graph (TPG) [2508.01495]. The agent set is denoted $\mathcal{A}=\{a_1,\ldots,a_I\}$, where each agent $a_i$ has a start $q_i^s$ and goal $q_i^g$ in an undirected graph $G_U=(V_U,E_U)$. A MAPF plan is given as $P=\{p_1,\ldots,p_I\}$, where each path is a vertex-time sequence
$$
p_i=\{(q_i^0,t_0),\ldots,(q_i^{z^i},t_{z^i})\},
$$
with $q_i^0=q_i^s$ and $q_i^{z^i}=q_i^g$. The plan is collision-free in the discrete sense, meaning that it contains no vertex conflicts and no edge-swap conflicts [2508.01495].

The TPG is a directed acyclic graph $\mathcal{G}=(V,E_1,E_2)$ with vertex set
$$
V=\{v_i^k \mid k\in[0,z^i],\, i\in[1,I]\}.
$$
Type-1 edges $E_1$ encode sequential precedence along each agent path $p_i$, while Type-2 edges $E_2$ encode inter-agent ordering at shared locations. This graph is the temporal backbone that converts a discrete MAPF solution into a constrained continuous-time execution problem [2508.01495].

The execution variables are arrival times $t_i^k\in\mathbb{R}$ for agent $a_i$ at vertex $v_i^k$, with leave times defined as $\ell_i^k \coloneqq t_i^{k+1}$. Each vertex is associated with a reserved interval $[l_i^k,u_i^k]\subseteq[0,\infty)$, initially $l_i^k=0$ and $u_i^k=\infty$, and feasible profiles must satisfy $t_i^k\in[l_i^k,u_i^k]$. Segment lengths are given by $d_i^k=d_G(q_i^k,q_i^{k+1})$, and agent dynamics are constrained by
$$
v_{\min}\leq v_i^k \leq v_{\max}, \qquad
|v_i^{k+1}-v_i^k| \leq a_{\max}\cdot (t_i^{k+1}-t_i^k).
$$
The optimization objective is to minimize total completion time,
$$
\min_{\{t_i^k,v_i^k\}} \sum_{i=1}^I t_i^{z^i},
$$
subject to boundary conditions, reserved-interval constraints, traversal-time bounds, and acceleration limits [2508.01495].

A central property of the formulation is that satisfying all reserved-interval constraints together with the kinodynamic bounds guarantees collision-free continuous execution that respects the TPG precedences [2508.01495]. This places WinkTPG in the class of execution-layer methods that preserve a discrete MAPF ordering while re-optimizing continuous timing.

## 2. kTPG as the underlying speed optimization method

kTPG is the base speed optimization algorithm on which WinkTPG is constructed. Its role is to refine a MAPF plan into a continuous, kinodynamically feasible execution by iteratively enforcing collision avoidance through reserved-interval refinement and single-agent replanning [2508.01495].

At each iteration, kTPG first identifies Type-2 edges $(v_i^{m+1}\rightarrow v_j^n)$ whose current reserved intervals overlap; these are termed conflicting edges. For each agent $a_i$, it counts how many conflicting edges originate from its unlocked vertices, where unlocked vertices are those whose incoming conflicts have already been cleared. The selected agent is the one maximizing this count [2508.01495]. This agent-selection mechanism is a scheduling policy over the TPG conflict structure rather than a global joint optimization.

For the chosen agent, kTPG solves a single-agent subproblem:
$$
\min t_i^{z^i}
$$
subject to
$$
t_i^0=0,\quad v_i^0=0,\quad v_i^{z^i}=0,
$$
$$
l_i^k\leq t_i^k\leq u_i^k \quad \forall k,
$$
$$
t_i^{k+1}-t_i^k \geq d_i^k/v_{\max},
$$
$$
t_i^{k+1}-t_i^k \leq d_i^k/v_{\min},
$$
$$
|v_i^{k+1}-v_i^k|\leq a_{\max}\cdot (t_i^{k+1}-t_i^k).
$$
In practice, the method uses a 1D Safe-Interval Path Planning with Kinodynamic Primitives, described as a variant of SIPP-IP, to compute the time-optimal profile over discretized speed levels, with completeness and optimality for the subproblem [2508.01495].

After replanning, kTPG updates reserved intervals. For each conflicting edge $(v_i^{m+1}\rightarrow v_j^n)$ from an unlocked vertex, it sets $\ell_i^m=t_i^{m+1}$ and splits the shared-location time axis at $\ell_i^m$ into $[0,\ell_i^m]$ for $a_i$ and $(\ell_i^m,\infty)$ for $a_j$, intersecting these with the current reserved intervals. This clears the conflict and may unlock additional vertices. The process repeats until no Type-2 conflicts remain [2508.01495].

The significance of kTPG for WinkTPG is structural: the windowed framework does not replace the base optimizer, but invokes it repeatedly on restricted subgraphs so that execution and replanning can be interleaved.

## 3. Windowed execution mechanism

WinkTPG extends kTPG with a receding-horizon execution loop designed to reduce uncertainty growth along long paths [2508.01495]. The framework introduces two control parameters. The execution interval $t_e$ is the time between successive replanning events; an example given is $10\,\mathrm{s}$. The planning horizon $t_p$ specifies the size of the lookahead window, measured either in number of vertices or in time [2508.01495].

The main loop proceeds by first initializing reserved intervals to $[0,\infty)$ and computing an initial kTPGu plan. Then, while not all agents are at their goals, the system waits either $t_e$ seconds or until an agent reports a new arrival time. For each agent $a_i$, it identifies the most recently reported vertex $v_i^p$ together with the exact time $t_i^p$, and marks the next $N_E$ vertices as enqueued, meaning they can follow the previous plan [2508.01495].

The planning window $W$ is then built by including, for each agent, the vertices after $v_i^p$ up to horizon $t_p$. If any Type-2 edge crosses into $W$, predecessors are recursively added. Reserved intervals inside $W$ are reinitialized, using the actual $t_i^p$ for the last known vertex, and kTPGu is invoked on the subgraph induced by $W$ to produce new speed profiles. These profiles are then transmitted to agents for the next $t_e$ interval [2508.01495].

Three consequences are stated explicitly for this design. First, windowing confines replanning to a small subgraph. Second, actual feedback reduces temporal uncertainty. Third, the procedure ensures continuous collision-free execution [2508.01495]. A plausible implication is that WinkTPG is intended to preserve the temporal ordering guarantees of the underlying TPG while avoiding full-horizon re-optimization after every execution update.

## 4. Temporal uncertainty model and dynamic replanning

The uncertainty model in WinkTPG is temporal and edge-local. Traversal time from $v_i^k$ to $v_i^{k+1}$ is represented as
$$
\hat T_i^k = T_i^k + \mathcal{N}(0,\epsilon_i^{k\,2}), \qquad \epsilon_i^{k\,2}=K_i\cdot d_i^k.
$$
Under this model, the stochastic reach time at vertex $v_i^k$ satisfies
$$
t_i^k \sim \mathcal{N}(\mu_i^k,\sigma_i^{k\,2}),
$$
with
$$
\mu_i^k=\sum_{j<k} T_i^j,\qquad
\sigma_i^{k\,2}=\sum_{j<k}\epsilon_i^{j\,2}.
$$
Thus, the variance accumulates along the path as a sum of segment-level uncertainties [2508.01495].

For a Type-2 edge $(v_i^{m+1}\rightarrow v_j^n)$, the execution requirement is
$$
P(t_i^{m+1}<t_j^n)\geq P_d
$$
which is equivalent to
$$
\mu_j^n-\mu_i^{m+1} \geq F_{\mathcal{N}(0,\sigma_i^{m+1\,2}+\sigma_j^{n\,2})}^{-1}(P_d).
$$
The uncertainty-aware variant kTPGu enforces this by adding a safety margin $\Delta \geq F^{-1}(P_d)$ when splitting reserved intervals [2508.01495].

As execution advances and actual times are reported, the accumulated uncertainty $\sigma$ diminishes, and the required margins shrink correspondingly [2508.01495]. This is the formal basis for the claim that windowing reduces uncertainty during execution: feedback narrows the temporal distributions that otherwise broaden along long, unreconciled trajectories.

A frequent misconception in MAPF execution is that a discrete collision-free plan is sufficient for direct deployment. The formulation here explicitly rejects that assumption. In this framework, discrete collision-freeness is only the starting point; safe continuous execution further requires reserved-interval satisfaction and kinodynamic feasibility [2508.01495].

## 5. Complexity and scalability characteristics

The complexity analysis separates the base optimizer from the windowed framework. For kTPG and kTPGu, each iteration clears at least one Type-2 edge. Since there are at most $|E_2|$ such edges and at most $\sum_i(z^i+1)=|V|$ vertices, the number of iterations is $O(\min(|V|,|E_2|))$. Each iteration solves one single-agent SIPP-IP problem in $O(L\log L)$ time, where $L$ is path length, yielding an overall complexity of roughly
$$
O(\min(|V|,|E_2|)\cdot L\log L).
$$
[2508.01495]

For WinkTPG, execution is divided into approximately $W\approx \mathrm{TotalTime}/t_e$ windows. Each window considers only $t_p$ vertices per agent, reducing the per-window complexity to
$$
O(\min(|V_W|,|E_{2,W}|)\cdot t_p\log t_p).
$$
The paper states that by choosing $t_p$ small, such as $20$–$40$ vertices, and $t_e$ moderate, such as $10\,\mathrm{s}$, the planner runs in milliseconds per window even for $I=1{,}000$ [2508.01495].

The stated scalability enablers are decoupled single-agent subproblems, conservative but efficient reserved-interval updates that avoid a global MILP, and the receding horizon, which limits problem size [2508.01495]. This suggests that WinkTPG is architected as a decomposition-based alternative to approaches whose central bottleneck is coupled global optimization.

## 6. Experimental evaluation and reported performance

The evaluation uses MovingAI benchmark maps: empty $32\times 32$, random $64\times 64$, room $64\times 64$, den520d $256\times 257$, Boston $256\times 256$, and warehouse-large $340\times 164$, with up to $1{,}000$ agents and paths generated by PBS [2508.01495]. Two robot models are considered. The first is omnidirectional with $v\in[0,2]\,\mathrm{m/s}$ and $a\in[-1,1]\,\mathrm{m/s^2}$, using speed discretization $\{0,\sqrt{2},2\}\,\mathrm{m/s}$. The second is differential-drive with turns at zero speed, taking $0.5\,\mathrm{s}$ for a $90^\circ$ turn and $0.9\,\mathrm{s}$ for a $180^\circ$ turn [2508.01495].

The reported metrics are the suboptimality ratio,
$$
(T_{\mathrm{sum}}-T_{\mathrm{ideal}})/T_{\mathrm{ideal}},
$$
runtime, defined as total planning time for kTPG or per-window planning time for WinkTPG, MAPF time, and success rate [2508.01495].

For omnidirectional robots without uncertainty, kTPG is compared with ADG and KDN. The reported findings are that kTPG improves over ADG by up to $51.7\%$ suboptimality reduction on the warehouse map; KDN slightly outperforms kTPG but fails beyond approximately $200$ agents because of exponential MILP behavior; and both kTPG and ADG maintain $100\%$ success up to $1{,}000$ agents, with kTPG runtime below $1\,\mathrm{s}$ per problem [2508.01495].

Under stochastic noise $\epsilon\in[0,0.05]$, WinkTPG is compared with ADG. For $\epsilon<0.03$, WinkTPG yields $10$–$20\%$ better solution quality than ADG. The study also reports that smaller execution windows $t_e$, corresponding to more frequent replanning, and choices with $t_p>t_e$ improve quality. For $1{,}000$ agents, per-window planning time is approximately $0.34\,\mathrm{s}$ when $t_p=10\,\mathrm{s}$, compared with approximately $28\,\mathrm{s}$ when $t_p=\infty$ [2508.01495].

Overall, the reported conclusion is that WinkTPG achieves near real-time replanning for up to $1{,}000$ agents, robustly handling uncertainty and improving execution efficiency over ADG and KDN [2508.01495]. A plausible interpretation is that its empirical contribution lies less in altering discrete path assignment than in making MAPF plans executable under kinodynamic and stochastic timing constraints at large scale.

Source: https://www.emergentmind.com/topics/windowed-ktpg-winktpg