WinkTPG: Efficient MAPF Execution Framework

• WinkTPG is a multi-agent path-finding framework that refines discrete MAPF plans into continuous, kinodynamically feasible and collision-free speed profiles.
• It combines temporal plan graph reasoning, single-agent speed optimization, and receding-horizon replanning to dynamically manage uncertainties during execution.
• Empirical evaluations show near real-time replanning for up to 1,000 agents, achieving reduced suboptimality and enhanced scalability.

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

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

The TPG is a directed acyclic graph $\mathcal{G}=(V,E_1,E_2)$ with vertex set

$a_i$0

Type-1 edges $a_i$1 encode sequential precedence along each agent path $a_i$2, while Type-2 edges $a_i$3 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 (Yan et al., 2 Aug 2025).

The execution variables are arrival times $a_i$4 for agent $a_i$5 at vertex $a_i$6, with leave times defined as $a_i$7. Each vertex is associated with a reserved interval $a_i$8, initially $a_i$9 and $q_i^s$0, and feasible profiles must satisfy $q_i^s$1. Segment lengths are given by $q_i^s$2, and agent dynamics are constrained by

$q_i^s$3

The optimization objective is to minimize total completion time,

$q_i^s$4

subject to boundary conditions, reserved-interval constraints, traversal-time bounds, and acceleration limits (Yan et al., 2 Aug 2025).

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

At each iteration, kTPG first identifies Type-2 edges $q_i^s$5 whose current reserved intervals overlap; these are termed conflicting edges. For each agent $q_i^s$6, 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 (Yan et al., 2 Aug 2025). 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:

$q_i^s$7

subject to

$q_i^s$8

$q_i^s$9

$q_i^g$0

$q_i^g$1

$q_i^g$2

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

After replanning, kTPG updates reserved intervals. For each conflicting edge $q_i^g$3 from an unlocked vertex, it sets $q_i^g$4 and splits the shared-location time axis at $q_i^g$5 into $q_i^g$6 for $q_i^g$7 and $q_i^g$8 for $q_i^g$9, 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 (Yan et al., 2 Aug 2025).

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 (Yan et al., 2 Aug 2025). The framework introduces two control parameters. The execution interval $G_U=(V_U,E_U)$0 is the time between successive replanning events; an example given is $G_U=(V_U,E_U)$1. The planning horizon $G_U=(V_U,E_U)$2 specifies the size of the lookahead window, measured either in number of vertices or in time (Yan et al., 2 Aug 2025).

The main loop proceeds by first initializing reserved intervals to $G_U=(V_U,E_U)$3 and computing an initial kTPGu plan. Then, while not all agents are at their goals, the system waits either $G_U=(V_U,E_U)$4 seconds or until an agent reports a new arrival time. For each agent $G_U=(V_U,E_U)$5, it identifies the most recently reported vertex $G_U=(V_U,E_U)$6 together with the exact time $G_U=(V_U,E_U)$7, and marks the next $G_U=(V_U,E_U)$8 vertices as enqueued, meaning they can follow the previous plan (Yan et al., 2 Aug 2025).

The planning window $G_U=(V_U,E_U)$9 is then built by including, for each agent, the vertices after $P=\{p_1,\ldots,p_I\}$0 up to horizon $P=\{p_1,\ldots,p_I\}$1. If any Type-2 edge crosses into $P=\{p_1,\ldots,p_I\}$2, predecessors are recursively added. Reserved intervals inside $P=\{p_1,\ldots,p_I\}$3 are reinitialized, using the actual $P=\{p_1,\ldots,p_I\}$4 for the last known vertex, and kTPGu is invoked on the subgraph induced by $P=\{p_1,\ldots,p_I\}$5 to produce new speed profiles. These profiles are then transmitted to agents for the next $P=\{p_1,\ldots,p_I\}$6 interval (Yan et al., 2 Aug 2025).

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 (Yan et al., 2 Aug 2025). 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 $P=\{p_1,\ldots,p_I\}$7 to $P=\{p_1,\ldots,p_I\}$8 is represented as

$P=\{p_1,\ldots,p_I\}$9

Under this model, the stochastic reach time at vertex $p_i=\{(q_i^0,t_0),\ldots,(q_i^{z^i},t_{z^i})\},$0 satisfies

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

with

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

Thus, the variance accumulates along the path as a sum of segment-level uncertainties (Yan et al., 2 Aug 2025).

For a Type-2 edge $p_i=\{(q_i^0,t_0),\ldots,(q_i^{z^i},t_{z^i})\},$3, the execution requirement is

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

which is equivalent to

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

The uncertainty-aware variant kTPGu enforces this by adding a safety margin $p_i=\{(q_i^0,t_0),\ldots,(q_i^{z^i},t_{z^i})\},$6 when splitting reserved intervals (Yan et al., 2 Aug 2025).

As execution advances and actual times are reported, the accumulated uncertainty $p_i=\{(q_i^0,t_0),\ldots,(q_i^{z^i},t_{z^i})\},$7 diminishes, and the required margins shrink correspondingly (Yan et al., 2 Aug 2025). 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 (Yan et al., 2 Aug 2025).

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 $p_i=\{(q_i^0,t_0),\ldots,(q_i^{z^i},t_{z^i})\},$8 such edges and at most $p_i=\{(q_i^0,t_0),\ldots,(q_i^{z^i},t_{z^i})\},$9 vertices, the number of iterations is $q_i^0=q_i^s$0. Each iteration solves one single-agent SIPP-IP problem in $q_i^0=q_i^s$1 time, where $q_i^0=q_i^s$2 is path length, yielding an overall complexity of roughly

$q_i^0=q_i^s$3

(Yan et al., 2 Aug 2025)

For WinkTPG, execution is divided into approximately $q_i^0=q_i^s$4 windows. Each window considers only $q_i^0=q_i^s$5 vertices per agent, reducing the per-window complexity to

$q_i^0=q_i^s$6

The paper states that by choosing $q_i^0=q_i^s$7 small, such as $q_i^0=q_i^s$8–$q_i^0=q_i^s$9 vertices, and $q_i^{z^i}=q_i^g$0 moderate, such as $q_i^{z^i}=q_i^g$1, the planner runs in milliseconds per window even for $q_i^{z^i}=q_i^g$2 (Yan et al., 2 Aug 2025).

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 (Yan et al., 2 Aug 2025). 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 $q_i^{z^i}=q_i^g$3, random $q_i^{z^i}=q_i^g$4, room $q_i^{z^i}=q_i^g$5, den520d $q_i^{z^i}=q_i^g$6, Boston $q_i^{z^i}=q_i^g$7, and warehouse-large $q_i^{z^i}=q_i^g$8, with up to $q_i^{z^i}=q_i^g$9 agents and paths generated by PBS (Yan et al., 2 Aug 2025). Two robot models are considered. The first is omnidirectional with $\mathcal{G}=(V,E_1,E_2)$0 and $\mathcal{G}=(V,E_1,E_2)$1, using speed discretization $\mathcal{G}=(V,E_1,E_2)$2. The second is differential-drive with turns at zero speed, taking $\mathcal{G}=(V,E_1,E_2)$3 for a $\mathcal{G}=(V,E_1,E_2)$4 turn and $\mathcal{G}=(V,E_1,E_2)$5 for a $\mathcal{G}=(V,E_1,E_2)$6 turn (Yan et al., 2 Aug 2025).

The reported metrics are the suboptimality ratio,

$\mathcal{G}=(V,E_1,E_2)$7

runtime, defined as total planning time for kTPG or per-window planning time for WinkTPG, MAPF time, and success rate (Yan et al., 2 Aug 2025).

For omnidirectional robots without uncertainty, kTPG is compared with ADG and KDN. The reported findings are that kTPG improves over ADG by up to $\mathcal{G}=(V,E_1,E_2)$8 suboptimality reduction on the warehouse map; KDN slightly outperforms kTPG but fails beyond approximately $\mathcal{G}=(V,E_1,E_2)$9 agents because of exponential MILP behavior; and both kTPG and ADG maintain $a_i$00 success up to $a_i$01 agents, with kTPG runtime below $a_i$02 per problem (Yan et al., 2 Aug 2025).

Under stochastic noise $a_i$03, WinkTPG is compared with ADG. For $a_i$04, WinkTPG yields $a_i$05–$a_i$06 better solution quality than ADG. The study also reports that smaller execution windows $a_i$07, corresponding to more frequent replanning, and choices with $a_i$08 improve quality. For $a_i$09 agents, per-window planning time is approximately $a_i$10 when $a_i$11, compared with approximately $a_i$12 when $a_i$13 (Yan et al., 2 Aug 2025).

Overall, the reported conclusion is that WinkTPG achieves near real-time replanning for up to $a_i$14 agents, robustly handling uncertainty and improving execution efficiency over ADG and KDN (Yan et al., 2 Aug 2025). 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.