XDiffuser: Extrinsic Search-Guided Diffusion

• The paper introduces a plan-first, diffuse-later approach that decouples graph-based global planning from diffusion-based trajectory refinement.
• It constructs a state-space graph using temporal-distance representations to generate soft waypoint guidance for smooth, data-consistent motions.
• Empirical results show significant improvements in long-horizon planning, efficiency, and multi-agent coordination compared to prior compositional diffusion methods.

Extrinsic Search-guided Diffuser, or XDiffuser, is an extrinsic search-guided compositional diffusion planner for offline long-horizon motion planning that is trained on short, local, and often suboptimal trajectories, yet is deployed on planning horizons substantially longer than those seen during training (Hassidof et al., 16 May 2026). Its defining decomposition is plan first, diffuse later: it first constructs a state-space graph from offline states, then runs a task-specific graph search to obtain a coarse global plan, and finally uses that plan as soft waypoint guidance while denoising a single compositional diffusion trajectory. In this formulation, graph search provides global coordination and test-time combinatorial structure, whereas diffusion supplies local smoothness, dynamic plausibility, and consistency with the offline data distribution (Hassidof et al., 16 May 2026).

1. Problem formulation and motivation

XDiffuser is posed in an offline setting with a continuous state space $\mathcal S$, a fixed dataset $D$ of previously collected trajectories, no additional environment interaction before deployment, training windows of length at most $H_{\text{train}}$, and test-time generation of a feasible trajectory $(s_1,\ldots,s_{H_{\text{test}}})$ with typically $H_{\text{test}} \gg H_{\text{train}}$ (Hassidof et al., 16 May 2026). The central challenge is therefore not short-horizon imitation, but the composition of locally valid behaviors into a globally coherent long-horizon plan.

The method is motivated by a limitation of prior compositional diffusion planners such as GSC and CompDiffuser. Those methods denoise multiple overlapping sub-trajectories and enforce overlap consistency, with the expectation that a coherent global trajectory will emerge. XDiffuser’s critique is that this mechanism is structurally insufficient when the target long-horizon behavior is never observed in training. Local consistency is propagated through a long chain of local constraints, neighboring segments may be sampled from incompatible modes of the trajectory distribution, and mode averaging at overlaps can produce invalid states. The failure mode is thus not merely optimization noise; it is a mismatch between local likelihood and global coordination (Hassidof et al., 16 May 2026).

The paper also positions itself against intrinsic search inside the denoising process. Intrinsic-search methods branch over partially denoised trajectories, evaluate alternatives, and prune or expand them during sampling. While this can improve global coherence, it is computationally expensive because diffusion inference is already costly. The stated worst-case complexity for a search procedure with branching factor $b$, depth $H$, and $K$ denoising steps per proposal is $O(KbH)$ denoiser calls, and the text additionally notes that C-MCTD’s precomputed graph can require $O(V^2 K b H)$ denoiser calls in the worst case for $D$0 graph vertices (Hassidof et al., 16 May 2026). XDiffuser’s response is to move search outside denoising: exploration is performed by a graph planner once, and diffusion is used only to realize the resulting route as a smooth trajectory.

2. State-space graph construction and planning pipeline

The full XDiffuser pipeline consists of an offline graph-construction stage followed by a test-time planning-and-denoising stage (Hassidof et al., 16 May 2026). Offline, the method constructs an undirected graph $D$1 over sampled dataset states,

$D$2

To determine which states should be connected, it learns a temporal-distance representation (TDR),

$D$3

in which Euclidean distance approximates temporal proximity. Edge costs are then defined by

$D$4

and each vertex is connected to its $D$5-nearest neighbors in TDR space subject to the threshold

$D$6

This graph is described as a lightweight local connectivity oracle. Its role is not to generate executable trajectories directly, but to encode coarse local reachability under the offline data distribution. Graph edges represent plausible local transitions; the diffusion model later refines those transitions into a full smooth trajectory.

At test time, task-specific states such as start and goal are added to the graph using the same kNN procedure. For goal-reaching, the planner computes a shortest path

$D$7

Because edge costs approximate temporal distance, the route induces cumulative nominal times

$D$8

The dense route is then downsampled at interval $D$9 into a sparse waypoint set

$H_{\text{train}}$0

The paper notes that shortest-path timing may be too optimistic, so waypoints are temporally dilated by a constant factor so that the number of generated chunks roughly matches CompDiffuser’s chunk count (Hassidof et al., 16 May 2026).

The denoising stage then generates a single long trajectory

$H_{\text{train}}$1

using a pretrained compositional diffusion model over overlapping segments $H_{\text{train}}$2. This is the key operational difference from intrinsic-search approaches: XDiffuser does not branch over partially denoised trajectories. Search is completed before denoising begins, and denoising is subsequently performed once under graph-derived guidance.

3. Compositional diffusion and waypoint-guided denoising

XDiffuser inherits the compositional factorization used in CompDiffuser, where a long trajectory is approximated through overlapping short-horizon factors. The paper writes the approximate compositional distribution as

$H_{\text{train}}$3

where $H_{\text{train}}$4 and $H_{\text{train}}$5 are the start and goal conditions, and each factor is implemented by the same short-horizon diffusion model (Hassidof et al., 16 May 2026). This factorization enforces local consistency but neglects non-local dependencies, which is precisely the gap filled by the graph scaffold.

The graph plan enters denoising through a soft waypoint energy. Each waypoint $H_{\text{train}}$6 influences nearby times through a triangular temporal window

$H_{\text{train}}$7

where $H_{\text{train}}$8 is the window radius. The corresponding trajectory-wide waypoint energy is

$H_{\text{train}}$9

This produces the guided distribution

$(s_1,\ldots,s_{H_{\text{test}}})$0

with score modification during denoising

$(s_1,\ldots,s_{H_{\text{test}}})$1

Several properties of this formulation are central. First, the graph plan is introduced only through $(s_1,\ldots,s_{H_{\text{test}}})$2; the base diffusion prior remains unchanged. Second, guidance is soft rather than hard interpolation, so the model can trade off waypoint attraction against local feasibility and data-likeness. Third, the triangular window spreads each waypoint’s influence across a neighborhood of time indices instead of forcing an exact state match at a single instant. The appendix observation that attracting only a single time step gives weak global guidance, whereas the window aligns segments more effectively, clarifies why the temporal window is not a minor implementation choice but part of the core guidance mechanism (Hassidof et al., 16 May 2026).

This formulation also explains the phrase plan first, diffuse later. The graph planner determines which broad route should be taken, while diffusion determines how to traverse that route in a smooth and dynamically plausible manner. Search and generation are therefore decoupled but coupled again through the waypoint energy.

4. Test-time combinatorial generalization

A defining feature of XDiffuser is that the graph planning module is task-dependent but model-agnostic: the pretrained diffuser remains fixed, and only the graph objective or solver is changed at test time (Hassidof et al., 16 May 2026). This creates a form of test-time combinatorial generalization, because the diffusion model need only know how to generate local, smooth, data-consistent motions, while the graph layer handles ordering, routing, collision constraints, and discrete combinatorial structure.

Task	Graph objective / solver	XDiffuser variant
Goal-reaching	Shortest-path search	XDiffuser
Multi-agent path finding	Multi-agent priority planner (Erdmann and Lozano-Perez, 1987)	PP-XDiffuser
Inspection planning	Graph-IP MILP solver of Morgan et al. (2026)	MILP-XDiffuser

For ordinary goal-reaching, start and goal are added to the graph, a shortest path is computed, the path is downsampled to temporal waypoints, and the same diffusion generator is guided accordingly. For multi-agent path finding (MAPF), the paper evaluates AntMaze Stitch Medium with $(s_1,\ldots,s_{H_{\text{test}}})$3 ant robots. Each agent $(s_1,\ldots,s_{H_{\text{test}}})$4 has start $(s_1,\ldots,s_{H_{\text{test}}})$5, goal $(s_1,\ldots,s_{H_{\text{test}}})$6, and trajectory $(s_1,\ldots,s_{H_{\text{test}}})$7, with success requiring both goal attainment and pairwise collision constraints

$(s_1,\ldots,s_{H_{\text{test}}})$8

Crucially, the diffusion model used here was trained only on single-agent data and never saw interaction constraints. In PP-XDiffuser, a multi-agent priority planner assigns priorities, each agent solves a shortest-path problem on its graph, lower-priority agents treat higher-priority agents as dynamic obstacles, and each route is converted into agent-specific waypoints for guided denoising (Hassidof et al., 16 May 2026).

The inspection-planning setting is more explicitly combinatorial. A drone must inspect a set of POIs $(s_1,\ldots,s_{H_{\text{test}}})$9, where POIs need not be physically visited but must be observed from feasible viewpoints. The graph interface is constructed by assigning to each POI its $H_{\text{test}} \gg H_{\text{train}}$0 nearest graph vertices in state space as candidate viewpoints. The covering-tour problem is then solved using the Graph-IP MILP solver with a single-commodity-flow MILP formulation and a timeout of 3 minutes. The resulting sequence of graph vertices is transformed into temporal waypoints and passed to the same diffusion model (Hassidof et al., 16 May 2026). This is why the paper characterizes the method as handling tasks beyond goal-reaching, including multi-agent coordination and TSP-style reasoning.

5. Empirical results and efficiency profile

The experimental suite spans OGBench goal-reaching and MAPF, as well as a separate PyBullet bridge-inspection environment, with evaluation performed on executed behavior rather than only geometric plans (Hassidof et al., 16 May 2026). For goal-reaching, the metric is execution success rate, with 5 start-goal tasks per environment, 20 episodes each, repeated over 5 random seeds. Reported environments include PointMaze Stitch Giant, AntMaze Stitch Giant, AntMaze Stitch Large, AntMaze Stitch Medium, AntMaze Explore Large, and AntMaze Explore Medium.

The clearest headline result is on AntMaze Explore Large, a low-quality random-walk-style dataset: CD scores 27 ± 1, whereas XDiffuser reaches 98.5 ± 0.5 (Hassidof et al., 16 May 2026). On AntMaze Explore Medium, the corresponding scores are 81 ± 2 for CD and 99.3 ± 0.5 for XDiffuser. On long-horizon stitch settings, the gains remain strong though smaller: AntMaze Stitch Giant improves from 65 ± 3 for CD to 90.0 ± 2.2 for XDiffuser; AntMaze Stitch Large improves from 86 ± 2 to 96.3 ± 0.9; AntMaze Stitch Medium improves from 96 ± 2 to 98.1 ± 1.2; and PointMaze Stitch Giant improves from 68 ± 3 to 100 ± 0 (Hassidof et al., 16 May 2026). The performance pattern is consistent with the method’s intended use: the largest gains occur when tasks are genuinely long-horizon and the data are low quality or suboptimal.

Runtime behavior is also part of the empirical claim. The paper states that CDGS took about 10× longer than XDiffuser on their hardware, while C-MCTD reported runtimes 5× longer than XDiffuser for PointMaze Giant even on much stronger hardware (Hassidof et al., 16 May 2026). In the 4-agent MAPF setting, priority search in PP-XDiffuser takes about 10 s, denoising takes $H_{\text{test}} \gg H_{\text{train}}$1 s, and total runtime is roughly 58 s, whereas prioritized CDGS generation takes $H_{\text{test}} \gg H_{\text{train}}$2 s (Hassidof et al., 16 May 2026). These figures directly support the efficiency argument for extrinsic rather than intrinsic search.

The multi-agent results illustrate the importance of explicit global coordination. On AntMaze Stitch Medium, PP-XDiffuser achieves 88.33 ± 6.24 for 2 agents, 73.33 ± 2.36 for 3 agents, and 58.33 for 4 agents, compared with 65.00 ± 8.16, 30.00 ± 4.08, and 13.33 ± 6.24 for Prioritized CDGS, respectively (Hassidof et al., 16 May 2026). Since the diffusion model was trained only on single-agent data, these results indicate that the multi-agent structure is being supplied by graph search, not learned by the generator.

The inspection-planning results are even more stark. Table 3 reports IP-CDGS average coverage 21.8 versus MILP-XDiffuser average coverage 95.5 (Hassidof et al., 16 May 2026). Example instances include 4 POIs, where coverage is 33.3 ± 12.1 for IP-CDGS versus 83.3 ± 12.1 for MILP-XDiffuser; 8 POIs, 12.5 ± 8.6 versus 95.8 ± 6.1; and 16 POIs, 11.8 ± 2.0 versus 100.0 ± 0.0. Figure 1 is summarized as showing steady, monotonic coverage growth for MILP-XDiffuser, while IP-CDGS plateaus early.

An important ablation concerns whether graph search alone is sufficient. A graph-only baseline that computes a shortest path, linearly interpolates waypoints, and executes via inverse dynamics reaches 77 ± 1.4% in one setting, indicating that the graph captures a meaningful high-level route. But on AntMaze Giant it reaches only 6 ± 0% success (Hassidof et al., 16 May 2026). The implication is not that graph search replaces diffusion, but that graph search supplies the backbone and diffusion supplies executability and robustness.

6. Relation to adjacent guided-diffusion paradigms and known limitations

XDiffuser sits within a broader family of inference-time control methods for diffusion models, but its defining characteristic is the use of extrinsic search outside denoising rather than intrinsic self-guidance or purely gradient-based objective steering. The closest general formulation appears in “Inference-time Scaling of Diffusion Models through Classical Search,” which leaves a pretrained diffusion model unchanged and adds an external verifier $H_{\text{test}} \gg H_{\text{train}}$3 together with local annealed Langevin refinement and BFS/DFS search over denoising trajectories; conceptually, this is an abstract XDiffuser-like framework in which the generator is a proposal mechanism and the external objective governs search allocation (Zhang et al., 29 May 2025). By contrast, XDiffuser specializes this idea to long-horizon offline planning by instantiating the external search layer as graph planning and the guidance layer as waypoint energy over a single denoising run (Hassidof et al., 16 May 2026).

This design differs sharply from RS-Diffuser, which is also externally guided but not explicitly search-based. RS-Diffuser is a risk-sensitive offline diffusion planning framework in which a separate distributional value critic evaluates noisy plans and supplies gradients from tail-aware objectives such as CVaR at every denoising step. That setup exemplifies extrinsic objective guidance, but it does not perform beam search, MCTS, candidate reranking, or other explicit search over alternative trajectories; evaluation is local, continuous, and gradient-based rather than graph- or tree-based (Gong, 26 Jun 2026). Relative to XDiffuser, RS-Diffuser is best understood as a strong precursor in the direction of external denoising guidance, but not as an instance of extrinsic search over candidate plans.

It also differs from Self-Guided Action Diffusion, which addresses a related inference-time control problem for chunked robot action generation but uses intrinsic/self-guidance rather than an external planner or verifier. Self-GAD guides the current denoising trajectory toward consistency with the policy’s own previously selected action chunk through a weighted overlap loss, replacing explicit candidate search with an internal consistency prior. This makes it computationally attractive under tight sample budgets, but its objective is trajectory coherence across chunk overlap rather than optimization under an external task-specific search criterion (Malhotra et al., 17 Aug 2025). In the terminology of the provided sources, Self-GAD is a design alternative to extrinsic search-guided diffusion, not a direct substitute for XDiffuser when the objective is externally specified.

The XDiffuser paper also identifies several limitations and assumptions (Hassidof et al., 16 May 2026). The method depends on the quality of the connectivity graph; if the sampled graph is poor or disconnected, planning degrades. The graph construction is intentionally minimal, relying on sampled states, TDR embeddings, and symmetric kNN edges, and because temporal distance is symmetric the graph is undirected, which does not faithfully represent directed or asymmetric dynamics. The graph captures only coarse reachability, not full dynamic feasibility, and the authors explicitly note that this may be inadequate under stochastic dynamics. Waypoint interval $H_{\text{test}} \gg H_{\text{train}}$4 introduces a trade-off between dense guidance, which can overconstrain the denoiser, and sparse guidance, which may be too weak; Appendix Table 5 is summarized as showing moderate sensitivity with $H_{\text{test}} \gg H_{\text{train}}$5 performing best in their setup. The gains are correspondingly smaller on easier tasks such as AntMaze Stitch Medium and Large, where the base denoiser is already strong and additional waypoints can slightly overconstrain it (Hassidof et al., 16 May 2026).

Taken together, these comparisons clarify the scope of the term Extrinsic Search-guided Diffuser. In the narrow sense exemplified by XDiffuser, it denotes a diffusion-based planner in which global exploration is delegated to an external search mechanism before denoising, and denoising is then guided by the search output. In the broader literature, neighboring methods may share the use of external evaluators or inference-time control, but differ in whether the control signal is graph-based, tree-search-based, critic-gradient-based, or self-referential.