Paper deep dive
LePlanner: An Iterative Amortized Controller For World Models
Saksham Bansal, Om Naphade, Chayan Aggarwal, Vrishin M
Intelligence
Status: succeeded | Model: Gemma-4-26B-A4B | Prompt: intel-v1 | Confidence: 92%
Last extracted: 9/20/2026, 3:59:10 AM
Summary
The paper introduces LePlanner, an amortized iterative controller for world models that refines latent action sequences using a frozen joint-embedding predictive architecture (JEPA) predictor. It addresses the latency of search-based planners and the degradation of policy-based methods on contact-rich tasks by employing an 'arrival-and-hold' objective and an action-Gaussian support loss. LePlanner achieves high success rates in navigation and manipulation tasks while requiring significantly fewer predictor evaluations and lower wall-clock time compared to search-based baselines like CEM.
Entities (11)
Relation Signals (7)
LePlanner → achievessuccessrate → 100%
confidence 95% · 100% on Reacher, 100% on TwoRooms
LePlanner → achievessuccessrate → 9.8%
confidence 95% · It achieves success rates of 98% on PushT
LePlanner → achievessuccessrate → 92%
confidence 95% · 92% on the OGBench Cube task
LePlanner → uses → LeWorldModel
confidence 95% · LePlanner is trained with an arrival-and-hold objective that encourages the controller to reach the goal at the earliest feasible horizon and remain there... through a frozen world-model predictor.
Arrival-and-hold objective → mitigates → Horizon-reset procrastination
confidence 90% · This addresses horizon-reset procrastination, a failure mode in which repeated receding-horizon replanning continually postpones goal arrival.
LePlanner → outperforms → CEM
confidence 90% · LePlanner matches or exceeds search-based planners while requiring an order of magnitude fewer predictor evaluations and 3-49x lower wall-clock time per decision.
Action-Gaussian loss → constrains → generated actions
confidence 85% · An additional action-Gaussian loss keeps generated actions near the support of the offline dataset.
Cypher Suggestions (0)
No Cypher suggestions yet.
Abstract
Abstract:World models trained with joint-embedding predictive architectures learn compact, structured latent representations from physical interaction, yet planning in these latent spaces typically relies on one of two costly approaches. Search-based planners such as CEM, MPPI, and iCEM optimize action sequences through many predictor rollouts, achieving strong performance at the cost of high per-decision compute and latency. Policy-based methods amortize inference into a single forward pass but can degrade on contact-rich tasks where the demonstration distribution is multimodal. We propose LePlanner, an amortized iterative controller that learns to construct and refine latent action sequences through a frozen world-model predictor. LePlanner is trained with an arrival-and-hold objective that encourages the controller to reach the goal at the earliest feasible horizon and remain there. This addresses horizon-reset procrastination, a failure mode in which repeated receding-horizon replanning continually postpones goal arrival. An additional action-Gaussian loss keeps generated actions near the support of the offline dataset. Across navigation, contact-rich manipulation, and continuous-control environments, LePlanner matches or exceeds search-based planners while requiring an order of magnitude fewer predictor evaluations and 3-49x lower wall-clock time per decision. It achieves success rates of 98% on PushT, 100% on Reacher, 100% on TwoRooms, and 92% on the OGBench Cube task. These results show that much of the structure discovered through online search can be amortized into a lightweight iterative policy, enabling fast, horizon-aware, nonlinear physical control without online optimization.
Tags
Links
- Source: https://arxiv.org/abs/2609.13845v1
- Canonical: https://arxiv.org/abs/2609.13845v1
Trouble viewing inline? Open PDF directly →
Full Text
68,490 characters extracted from source content.
Expand or collapse full text
LePlanner: An Iterative Amortized Controller For World Models Saksham Bansal1*, Om Naphade2*, Chayan Aggarwal3*, Vrishin M4 1Department of Mechanical Engineering, 2Department of Physics, 3Department of Mathematics, 4Department of Chemical Engineering Indian Institute of Technology Roorkee saksham_b@me, om_n@ph, chayan_a@ma, vrishin_m@ch.iitr.ac.in Abstract World models trained with joint-embedding predictive architectures learn compact, structured latent manifolds from physical interaction, yet planning in those latents still relies on one of two costly families of methods. Search-based planners (CEM, MPPI, iCEM) optimize action sequences through many predictor rollouts, achieving strong success at the price of high per-decision compute and latency. Policy-based methods (behavior cloning, GC-IDM) amortize inference into a single forward pass, but degrade on contact-rich tasks where the demonstration distribution is multi-modal. Neither family offers both low latency and robust goal-reaching in a learned latent space. We propose LePlanner, an amortized iterative controller that refines latent action sequences to reach a goal state, trained with an arrival–hold loss that rewards reaching the goal at the earliest feasible horizon and staying there, plus an action gaussian loss which keeps actions in their true manifold. Across goal-directed environments spanning navigation, contact-rich manipulation, and continuous control, LePlanner matches or exceeds the success of test-time search planners while requiring an order-of-magnitude fewer predictor invocations and 33–49×49× lower wall-clock per decision. We report 98%98\% on PushT, 100%100\% on Reacher, 100%100\% on TwoRooms, and 92%92\% on the ogbench cube. The results show that, in a sufficiently regularized latent space, much of the structure that search discovers online can be amortized into a lightweight learned iterative policy, yielding fast, horizon-aware, nonlinear physical control without online optimization. 11footnotetext: Equal contribution.00footnotetext: Models: https://huggingface.co/nottygian/Leplanner. 1 Introduction A central goal of artificial intelligence is to develop agents that learn useful behavior across diverse tasks and environments directly from observations (Levine et al., 2016). World models are one promising approach: they learn to predict how an environment state evolves in response to an action, so agents can evaluate possible action sequences before executing them, effectively planning inside a learned model of the world (Ha and Schmidhuber, 2018; Hafner et al., 2019). Joint Embedding Predictive Architectures (JEPAs) learn such models in a compact latent space rather than predicting every detail of future observations, which works particularly well when the observation channel is high dimensional (LeCun, 2022; Assran et al., 2023; Sobal et al., 2022). Recent work on LeWorldModel (LeWM) demonstrated that a JEPA based world model can be trained stably from raw pixels while supporting efficient visual control (Maes et al., 2026). Planning through a learned world model forces a three-way choice: search-based planners (ie. CEM) are accurate but costly and high-latency, solving a full optimization loop at every decision (Rubinstein, 1999; Chua et al., 2018; Hafner et al., 2019); cloning-based policies (GC-IDM) amortize inference into a single forward pass but degrade on contact-rich and nonlinear tasks where the demonstration distribution is poorly conditioned (Nguyen et al., 2026); and model-based policy methods (TDMPC2) train the controller inside the world model’s imagination, coupling the policy to a task-specific dynamics model that demands substantial compute to train on real environments and can struggle with complex long-horizon structure (Hansen et al., 2024). We also find that a conventional terminal objective used in such controllers creates a rather subtle failure when deployed in a varied receding-horizon setting (Mayne et al., 2000). The objective trains the controller to reach the goal at the end of its planning horizon. When deployed, only the first part of the plan is executed before replanning, which resets the terminal deadline, so the controller repeatedly approaches the goal while postponing actual arrival in many cases. We refer to this behavior as horizon-reset procrastination. To resolve this mismatch and to bring the cost of non-amortized controllers down, we propose LePlanner, an amortized controller that learns to construct and iteratively refine action plans through a frozen LeWM predictor (Srinivas et al., 2018; Marino et al., 2018), trained with an arrival-and-hold objective. During training, the controller is supervised to reach the goal at the temporal offset from which that goal was sampled, rather than at the fixed end of every plan, and is then encouraged to remain near the goal for the rest of the predicted trajectory. The temporal offset is used only to define the training loss and is never provided to the controller at inference, so the method requires no modification to the frozen world model or controller architecture. In the currently recorded PushT evaluation, LePlanner reaches 98%98\% success while replanning after every action block: the corrected objective removes the procrastination behavior and allows the controller to use frequent replanning without repeatedly deferring the goal. LePlanner also achieves high success rate in evaluations such as TwoRoom and Reacher. Figure 1: LePlanner architecture. The frozen JEPA predictor (blue) rolls out imagined latents x¯1,x¯2,… x_1, x_2,… from context (E(si)+bi)(E(s_i)+b_i), where E(si)E(s_i) is the latent embedding of state sis_i and bib_i is the executed action. Y(k)Y^(k) denotes the action plan at refinement step k, produced by the Refinement Transformer and decoded into real-environment action states by the action head hθh_θ. 2 Related Work Latent world models and visual planning. World models learn predictive representations that allow agents to reason about the consequences of their actions before acting (Ha and Schmidhuber, 2018). Early latent world-model approaches either optimized action sequences online, as in PlaNet (Hafner et al., 2019), or jointly learned task-oriented latent dynamics and terminal values for model-predictive control (Hansen et al., 2022). Joint Embedding Predictive Architectures instead predict future latent representations rather than reconstructing observations (LeCun, 2022; Assran et al., 2023), and DINO-based models show that self-supervised vision features yield smooth latent spaces suitable for downstream control (Caron et al., 2021; Oquab et al., 2024). This principle has been extended to action-conditioned latent dynamics (Sobal et al., 2022) and to planning over frozen visual representations (Zhou et al., 2025). LeWorldModel learns an action-conditioned JEPA end-to-end from pixels and provides the frozen world model used in our work (Maes et al., 2026). Recent studies improve latent planning by reducing the mismatch between world-model training and planning (Parthasarathy et al., 2025), or by regularizing latent trajectories to improve the geometry of the planning objective (Wang et al., 2026). Our work is complementary: we keep the learned representation and dynamics fixed and study how the controller’s training objective interacts with receding-horizon execution. Planning in latent worlds: search, cloning, and learned policies. Planning over a learned world model is most often done by test-time search. The cross-entropy method (CEM) (Rubinstein, 1999) and MPPI (Williams et al., 2017) optimize action sequences by iteratively refining a distribution over candidate plans through the learned dynamics, and PETS (Chua et al., 2018) combines such sampling with probabilistic ensembles; iCEM adds implicit differentiation for continuous refinement. These search planners achieve strong success but repeat substantial computation at each decision, evaluating hundreds to thousands of latent rollouts per step. An alternative is to amortize planning into a learned policy: goal-conditioned behavior cloning (GCBC) and Goal-Conditioned Inverse Dynamics Models (GC-IDM) map a current latent state, goal latent, and horizon directly to the next action (Nguyen et al., 2026). Because they are trained purely on demonstration data, such policies amortize inference into a single forward pass but degrade on contact-rich or multi-modal tasks where the behavioral cloning distribution is poorly conditioned. A third family trains policies inside the world model’s imagination: Dreamer (Hafner et al., 2020; Hafner et al., 2024) trains an actor-critic entirely on imagined latent rollouts, and TDMPC2 (Hansen et al., 2024) extends this with joint latent-reward learning and TD-planning over short imagination horizons. Our controller bridges these families. Like search planners it reasons through the learned dynamics over multiple horizons; like amortized policies it performs a fixed number of learned refinements at deployment; and like model-based policy methods it trains the controller end-to-end – but over a frozen, task-agnostic world model, with an explicit arrival-and-hold objective. Amortized and iterative inference. Iterative amortized inference combines a learned initial prediction with repeated learned corrections (Marino et al., 2018), and Universal Planning Networks (Srinivas et al., 2018) learn representations in which plans are optimized through differentiable latent rollouts. More broadly, iterative refinement underlies energy-based models (LeCun et al., 2006) and consistency models (Song et al., 2023). Our controller follows this amortized formulation, but unlike online CEM the search procedure is learned during training, and unlike Universal Planning Networks the world model is pretrained and frozen and the controller is not trained by imitating expert action sequences. This separation lets us change the controller objective without changing the underlying visual representation or dynamics. 3 Method: LePlanner Figure 2: The LePlanner architecture. From a 3-frame observation history and a goal image oGo_G, the frozen encoder E produces context tokens CtC_t and goal latent zGz_G. Plan tokens YkY^k are decoded by the action head hθh_θ into an action plan bk1:Hb^k_1:H, which the frozen predictor P rolls out into imagined latents z~k1:H z^k_1:H. The consequence encoder FθF_θ attends jointly over YkY^k, the rollout z~k z^k, the rollout-to-goal residual z~k−zG z^k-z_G, and the predicted distance-to-goal dkd^k with contexts and goal to produce consequence tokens RkR^k. The joint refiner GθG_θ then applies full self-attention jointly over YkY^k and RkR^k, with the conditioning tokens Ct,zGC_t,z_G to predict a plan correction ΔYk Y^k, yielding Yk+1Y^k+1. This repeats for K refinements; after the final iteration the first action block b1b_1 is executed, a new observation is received, and the controller replans. We consider offline, visual, goal-conditioned control using a pretrained and frozen latent world model. Our objective is to learn a controller that produces action plans from an observation history and a goal image, without imitating the actions in the offline dataset. 3.1 Problem setting Let an offline trajectory be τ=(o0,a0,o1,a1,…)τ=(o_0,a_0,o_1,a_1,…), where oto_t is a visual observation and at∈ℝdaa_t ^d_a is an environment action. We use a pretrained LeWorldModel (LeWM) (Maes et al., 2026), consisting of an image encoder E:ot↦zt∈ℝDE:o_t z_t ^D and an action-conditioned latent predictor P. Environment actions are grouped into blocks of f consecutive actions; a block is denoted by bj∈ℝAb_j ^A, where A=fdaA=fd_a. At time t, the controller receives N context latents Ct=(zt−N+1,…,zt)C_t=(z_t-N+1,…,z_t), the N−1N-1 action blocks connecting these observations, and a goal latent zG=E(oG)z_G=E(o_G). It produces a plan b1:H=(b1,…,bH)b_1:H=(b_1,…,b_H) of H future action blocks. Given a candidate plan, the frozen predictor generates an autoregressive latent rollout: z^1:H=ℛP(Ct,bt−N+1:t−1,b1:H), z_1:H=R_P (C_t,b_t-N+1:t-1,b_1:H ), (1) where ℛPR_P applies P using the same sliding observation and action history used during world-model training. We measure the predicted distance to the goal after block j as dj=1D∥z^j−zG∥22d_j= 1D z_j-z_G _2^2. The parameters of E and P remain frozen throughout controller training. The cached outputs of E are treated as data, while gradients are retained through the operations of P so that the controller can learn how its proposed actions affect the predicted trajectory. 3.2 LePlanner LePlanner amortizes trajectory optimization into a fixed number of learned refinement steps. It maintains one hidden plan token yj∈ℝWy_j ^W for each future action block, Y(k)=(y1(k),…,yH(k))Y^(k)=(y_1^(k),…,y_H^(k)), where k denotes the refinement iteration. The context latents and goal latent are projected into the controller width and augmented with learned positional and role embeddings; these conditioning tokens are read by every refinement step. The initial plan is produced from learned plan queries, Y(0)=Gθ([Q;],Ct,zG)Y^(0)=G_θ([Q;0],C_t,z_G), where Q contains one learned query per plan position and the zero argument indicates that no predicted consequences are available for the initial proposal. An action head hθh_θ decodes every plan token into a bounded action block, bj(k)=ca+sa⊙tanh(hθ(yj(k)))b_j^(k)=c_a+s_a (h_θ(y_j^(k))), where cac_a and sas_a transform the raw action bounds into the normalized action space used by LeWM, so the tanh parameterization enforces the environment action bounds without clipping. For each refinement, the decoded plan is rolled through the frozen predictor using Equation (1). For plan position j, LePlanner constructs the consequence feature uj(k)=[,yj(k);z^j(k);z^j(k)−zG;dj(k),]u_j^(k)=[,y_j^(k);\ z_j^(k);\ z_j^(k)-z_G;\ d_j^(k),]. A consequence encoder FθF_θ interprets these features jointly with the observation and goal conditioning, and a refinement transformer GθG_θ then predicts a correction for all plan tokens, which updates the plan through a learned step size: R(k) R^(k) =Fθ(U(k),Ct,zG), =F_θ\! (U^(k),C_t,z_G ), V(k) V^(k) =[Y(k);R(k)], = [Y^(k);R^(k) ], (2) ΔY(k) Y^(k) =Gθ(V(k),Ct), =G_θ\! (V^(k),C_t ), Y(k+1) Y^(k+1) =Y(k)+σ(ηk)ΔY(k). =Y^(k)+σ( _k) Y^(k). for k=0,…,K−1k=0,…,K-1, where V(k)V^(k) is the concatenation of the current plan and predicted consequences, and σ(ηk)∈(0,1)σ( _k)∈(0,1) and one scalar step size is learned for each refinement. Both FθF_θ and GθG_θ are shared across all K iterations, so increasing the refinement depth increases inference computation but does not introduce new parameters. The refinement transformer (GθG_θ) applies full self-attention across all H plan positions before any action block is committed, allowing early and late parts of the plan to be revised jointly. 3.3 Arrival-and-hold objective A training example is constructed by sampling a future observation from the same offline trajectory as the current context. Let q∈1,…,Hq∈\1,…,H\ be the number of world-model transitions between the current observation and this hindsight-relabeled goal (Andrychowicz et al., 2017). The dataset therefore provides not only the goal latent zGz_G, but also the offset at which that goal occurs. A fixed-terminal objective would always penalize dHd_H, regardless of the sampled offset q; under receding-horizon execution, this attaches arrival to the end of the repeatedly reset plan. Instead, LePlanner evaluates the predicted trajectory at the goal’s data-derived offset: ℒAH(k)=dq(k)⏟arrival+λh1H−q∑j=q+1Hdj(k)⏟hold,L^(k)_AH= d_q^(k)_arrival+ _h 1H-q _j=q+1^Hd_j^(k)_hold, (3) where the hold term is defined as zero when q=Hq=H. The arrival term asks the predicted plan to reach the goal at the temporal offset from which the goal was sampled, and the hold term discourages trajectories that briefly pass through the goal and then move away. Importantly, q is used only to index the training loss; it is never included in the controller input. At inference, LePlanner receives only the observation history and goal, and must infer an appropriate plan without access to a deadline. 3.4 Deep supervision across refinements LePlanner produces an initial plan followed by K refined plans, and we supervise every one of these K+1K+1 predictions: ℒref=∑k=0KρkℒAH(k)∑k=0Kρk,ρk=2k.L_ref= _k=0^K _kL^(k)_AH _k=0^K _k, _k=2^k. (4) Later refinements receive larger weights, while every intermediate plan retains a direct gradient signal. This makes the initial prediction useful on its own and trains each application of the shared refinement operator rather than supervising only its final output. 3.5 Constraining plans to offline support Optimizing actions through a learned world model can exploit inaccuracies outside the action distribution represented in the offline data (Fujimoto et al., 2019; Kumar et al., 2019; Yu et al., 2020; Kidambi et al., 2020). We therefore fit a conditional Gaussian mixture density βψ(b∣C) _ψ(b C) to real action blocks and their latent contexts, trained separately and frozen before LePlanner training. For a candidate action block, we define the normalized negative log density r(C,b)=−1Alogβψ(b∣C)r(C,b)=- 1A _ψ(b C), and let c95c_95 be the 9595th percentile of this score on real action blocks. For the refined plans, we apply the one-sided support penalty ℒsup=1KH∑k=1K∑j=1H[max(0,r(Cj(k),bj(k))−c95)]2,L_sup= 1KH _k=1^K _j=1^H [ (0,r(C_j^(k),b_j^(k))-c_95 ) ]^2, (5) where Cj(k)C_j^(k) is the imagined context preceding block j. The penalty is zero for action blocks inside the selected support region, so it does not train LePlanner to reproduce a particular demonstrated action; the dataset actions are used only to fit βψ _ψ and never serve as controller targets. The complete controller objective is ℒLePlanner=ℒref+λsupℒsupL_LePlanner=L_ref+ _supL_sup. Only the parameters of LePlanner are optimized; the LeWM encoder, LeWM predictor, and behavior-density model remain frozen. 3.6 Receding-horizon execution At deployment, LePlanner encodes the current observation history and goal, constructs its initial plan, and performs K learned refinements. No gradient computation or online parameter update is required, and the final plan b1:H(K)b_1:H^(K) is returned to the environment policy. We use receding-horizon execution: the policy executes a prefix of the plan, observes the resulting state, and invokes LePlanner again (Mayne et al., 2000). The main closed-loop configuration executes one action block before replanning. Thus, the world model remains inside the inference loop, but population-based trajectory search is replaced by a fixed number of amortized refinements. Figure 3: Success across all compared methods. One panel per environment; bars are coloured by method family. LePlanner (green, outlined) is shown at both receding horizons. 4 Results We evaluate LePlanner against three families of latent planners: test-time search (CEM, MPPI, iCEM, gradient optimisation), amortised policies trained by goal-conditioned cloning (GCBC, GCIQL, GCIVL, GC-IDM), and latent world models evaluated with their own planners (PLDM, DINO-WM, LeWM, Fast-LeWM). The four benchmark environments are PushT (Chi et al., 2023), Reacher, TwoRooms, and the OGBench cube task (Park et al., 2025). 4.1 Goal-reaching success Figure 3 reports success on the four LeWM benchmark environments. LePlanner reaches 100%100\% on TwoRooms, 94%94\% on PushT, 100%100\% on Reacher, and 92%92\% on OGBench-Cube. Against the matched CEM baseline run under an identical protocol, it improves success on every environment we measured. Two properties are worth stating before the numbers are read. First, LePlanner is close to flat in m, the number of action blocks executed before replanning (100→100100→ 100 on TwoRooms, 94→8894→ 88 on PushT, 100→100100→ 100 on Reacher, 82→9282→ 92 on Cube), the signature of a time-consistent closed-loop policy rather than a good open-loop one. Second, CEM is not flat: on PushT it moves 34→9034→ 90 between m=1m=1 and m=5m=5, so a single receding horizon cannot summarise it, and we report both throughout. 4.2 The cost of a decision Success alone does not separate an amortised planner from a search planner; the separation is in what a decision costs. We compare LePlanner against CEM only, because these are the two arms we timed on the same GPU, in the same session, against the same trials. Figure 4 reports wall-clock seconds per episode, while predictor rows measure how often the world model is queried. The architectural ratio is exact and independent of hardware: LePlanner issues (K+1)⋅H=4×5=20(K+1)· H=4× 5=20 latent transitions per plan, where CEM issues 300×30×5=45,000300× 30× 5=45,000, a factor of 22502250. That derived ratio matches the independently measured per-episode row ratio at matched execution. Figure 4: Wall-clock per episode against matched CEM, log scale. LePlanner is 49×49× and 17×17× faster on TwoRooms, 36×36× and 7×7× faster on PushT, 18×18× and 4×4× faster on Reacher, and 9×9× and 3×3× faster on OGBench-Cube, at m=1m=1 and m=5m=5 respectively, while reaching higher success in every one of these comparisons. 4.3 What each family requires Success and latency do not capture the requirement that most constrains deployment: what a method needs in order to be trained and run at all. Table 1 makes those requirements explicit, and two entries deserve comment. The cloning family — GCBC, GCIQL, GCIVL and GC-IDM — regresses directly onto demonstrated actions; GC-IDM minimises ∥GC-IDMψ(zt,zt+h,h)−at∥22 -IDM_ψ(z_t,z_t+h,h)-a_t _2^2 over triples drawn from the offline data, so its supervision target is the dataset action and its quality is bounded by the demonstrations. LePlanner never uses a dataset action as a target: they enter only through the frozen density βψ _ψ, which bounds the support region (Section 3.5) and contributes exactly zero loss for any plan already inside it. Second, GC-IDM requires the remaining budget at test time, since its control law evaluates ht=T−t+1h_t=T-t+1 with T known in advance, whereas LePlanner is supervised at the offset q from which each goal was relabelled and q is never an input (Section 3.3); at deployment it receives only an observation history and a goal, and must infer when to arrive. Table 1: What each planner family requires. ✓ requirement satisfied, ✗ not satisfied, ∼ partially. LePlanner is the only row with no hard failure. The ∼ marks that dataset actions bound LePlanner’s support region but are never regression targets. No online No action Multi-step No test-time Frozen, task- Fixed Method search supervision plan deadline agnostic WM inference cost CEM / MPPI / iCEM ✗ ✓ ✓ ✓ ✓ ✗ Gradient optimisation ✗ ✓ ✓ ✓ ✓ ✗ GCBC / GCIQL / GCIVL ✓ ✗ ✗ ✓ ✓ ✓ GC-IDM ✓ ✗ ✗ ✗ ✓ ✓ TD-MPC2 ✓ ✓ ✓ ✓ ✗ ✓ LePlanner (ours) ✓ ∼ ✓ ✓ ✓ ✓ 4.4 The mechanism: arrival at the data’s own deadline The results above are closed-loop outcomes; this section shows the internal behaviour that produces them, and why the fixed-terminal objective cannot. A fixed-terminal objective scores only dHd_H, so it asks the plan to be at the goal exactly H blocks from now. Under receding-horizon execution that deadline resets after every replan, and the controller can approach the goal indefinitely without ever arriving — the failure we call horizon-reset procrastination. Figure 5 shows the effect directly, on held-out data, by splitting the predicted distance profile by each sample’s own goal offset q. Under the original objective every curve bottoms out at block 55, including the curve whose goal is a single block away and which therefore had no reason to spend five blocks getting there. Under arrival-and-hold each curve’s minimum sits at its own q, and for q=1q=1 the curve rises afterwards: the plan arrives immediately and then holds position. Figure 5: Held-out imagined distance across the plan, split by the sample’s own goal offset q; the open triangle marks each curve’s minimum. Left: under the original objective every curve bottoms out at block 55, even the one whose goal is a single block away. Right: under arrival-and-hold the minimum tracks q, and for q=1q=1 the curve rises afterwards, which is the signature of arriving and staying. Appendix C gives the full diagnosis, the closed-loop fixed-point analysis, and the ablations isolating which part of the change is responsible. 5 Discussion We developed LePlanner, an amortized iterative controller that plans through a frozen latent world model without costly online optimization, outperforming the matched CEM baseline while requiring substantially fewer predictor evaluations. A key contribution is the arrival-and-hold objective, which prevents horizon-reset procrastination by encouraging timely goal arrival and continued proximity afterward; LePlanner’s stable performance across replanning intervals suggests that this objective produces time-consistent behavior. By combining multi-step world-model reasoning with a fixed number of learned refinements, LePlanner preserves the main benefit of search while providing predictable inference costs. Importantly, LePlanner is not a behavior-cloning policy. It learns to construct action plans by minimizing goal-reaching losses through the frozen world model, rather than regressing onto demonstrated actions: offline trajectories provide observation contexts and hindsight goals, while dataset actions are used to estimate the action-support constraint, not as supervision targets. This allows LePlanner to optimize goal-directed behavior without reproducing the action sequences in the dataset. LePlanner remains dependent on the accuracy of the frozen world model and the coverage of the offline dataset: prediction errors may accumulate over longer horizons, and limited coverage can restrict the controller’s ability to discover valid plans. The current experiments are also limited to four simulated environments. Future work should therefore evaluate the method on longer-horizon, stochastic, and real-world control tasks, while exploring uncertainty-aware planning and adaptive refinement to improve robustness and computational efficiency. References Andrychowicz et al. (2017) M. Andrychowicz, F. Wolski, A. Ray, J. Schneider, R. Fong, P. Welinder, B. McGrew, J. Tobin, P. Abbeel, and W. Zaremba Hindsight experience replay. In Advances in Neural Information Processing Systems, Vol. 30, p. 5048–5058. Cited by: §3.3. Assran et al. (2023) M. Assran, Q. Duval, I. Misra, P. Bojanowski, P. Vincent, M. Rabbat, Y. LeCun, and N. Ballas Self-supervised learning from images with a joint-embedding predictive architecture. In Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition, p. 15619–15629. External Links: Document Cited by: §1, §2. Caron et al. (2021) M. Caron, H. Touvron, I. Misra, H. Jégou, J. Mairal, P. Bojanowski, and A. Joulin Emerging properties in self-supervised vision transformers. In Proceedings of the IEEE/CVF International Conference on Computer Vision, p. 9650–9660. Cited by: §2. Chi et al. (2023) C. Chi, S. Feng, Y. Du, Z. Xu, E. Cousineau, B. Burchfiel, and S. Song Diffusion policy: visuomotor policy learning via action diffusion. In Robotics: Science and Systems XIX, External Links: Document Cited by: §4. Chua et al. (2018) K. Chua, R. Calandra, R. McAllister, and S. Levine Deep reinforcement learning in a handful of trials using probabilistic dynamics models. In Advances in Neural Information Processing Systems, Vol. 31, p. 4759–4770. Cited by: §1, §2. Efron and Tibshirani (1993) B. Efron and R. J. Tibshirani An introduction to the bootstrap. Chapman & Hall, New York. External Links: ISBN 978-0-412-04231-7 Cited by: Appendix A. Fujimoto et al. (2019) S. Fujimoto, D. Meger, and D. Precup Off-policy deep reinforcement learning without exploration. In Proceedings of the 36th International Conference on Machine Learning, Proceedings of Machine Learning Research, Vol. 97, p. 2052–2062. External Links: Link Cited by: §3.5. Ha and Schmidhuber (2018) D. Ha and J. Schmidhuber Recurrent world models facilitate policy evolution. In Advances in Neural Information Processing Systems, Vol. 31, p. 2451–2463. Cited by: §1, §2. Hafner et al. (2020) D. Hafner, T. Lillicrap, J. Ba, and M. Norouzi Dream to control: learning behaviors by latent imagination. In International Conference on Learning Representations, Cited by: §2. Hafner et al. (2019) D. Hafner, T. Lillicrap, I. Fischer, R. Villegas, D. Ha, H. Lee, and J. Davidson Learning latent dynamics for planning from pixels. In Proceedings of the 36th International Conference on Machine Learning, Proceedings of Machine Learning Research, Vol. 97, p. 2555–2565. External Links: Link Cited by: §1, §1, §2. Hafner et al. (2024) D. Hafner, J. Pasukonis, J. Ba, and T. Lillicrap Mastering diverse domains through world models. Transactions on Machine Learning Research. Cited by: §2. Hansen et al. (2022) N. A. Hansen, H. Su, and X. Wang Temporal difference learning for model predictive control. In Proceedings of the 39th International Conference on Machine Learning, Proceedings of Machine Learning Research, Vol. 162, p. 8387–8406. External Links: Link Cited by: §2. Hansen et al. (2024) N. Hansen, H. Su, and X. Wang TD-MPC2: scalable, robust world models for continuous control. External Links: 2310.16828, Link Cited by: §1, §2. Kidambi et al. (2020) R. Kidambi, A. Rajeswaran, P. Netrapalli, and T. Joachims MOReL: model-based offline reinforcement learning. In Advances in Neural Information Processing Systems, Vol. 33. External Links: Link Cited by: §3.5. Kumar et al. (2019) A. Kumar, J. Fu, M. Soh, G. Tucker, and S. Levine Stabilizing off-policy q-learning via bootstrapping error reduction. In Advances in Neural Information Processing Systems, Vol. 32, p. 11761–11771. Cited by: §3.5. LeCun et al. (2006) Y. LeCun, S. Chopra, R. Hadsell, M. Ranzato, and F. J. Huang A tutorial on energy-based learning. In Predicting Structured Data, Cited by: §2. LeCun (2022) Y. LeCun A path towards autonomous machine intelligence. OpenReview. External Links: Link Cited by: §1, §2. Levine et al. (2016) S. Levine, C. Finn, T. Darrell, and P. Abbeel End-to-end training of deep visuomotor policies. Journal of Machine Learning Research 17 (39), p. 1–40. External Links: Link Cited by: §1. Maes et al. (2026) L. Maes, Q. Le Lidec, D. Scieur, Y. LeCun, and R. Balestriero LeWorldModel: stable end-to-end joint-embedding predictive architecture from pixels. External Links: 2603.19312, Link Cited by: Appendix A, §1, §2, §3.1. Marino et al. (2018) J. Marino, Y. Yue, and S. Mandt Iterative amortized inference. In Proceedings of the 35th International Conference on Machine Learning, Proceedings of Machine Learning Research, Vol. 80, p. 3403–3412. External Links: Link Cited by: §1, §2. Mayne et al. (2000) D. Q. Mayne, J. B. Rawlings, C. V. Rao, and P. O. M. Scokaert Constrained model predictive control: stability and optimality. Automatica 36 (6), p. 789–814. External Links: Document Cited by: §1, §3.6. McNemar (1947) Q. McNemar Note on the sampling error of the difference between correlated proportions or percentages. Psychometrika 12 (2), p. 153–157. External Links: Document Cited by: Appendix A. Nguyen et al. (2026) H. Nguyen, X. Xu, and X. Huang Latent geometry beyond search: amortizing planning in world models. External Links: 2605.08732, Link Cited by: §1, §2. Oquab et al. (2024) M. Oquab, T. Darcet, T. Moutakanni, H. Vo, M. Szafraniec, V. Khalidov, P. Fernandez, D. Haziza, F. Massa, A. El-Nouby, M. Assran, N. Ballas, W. Galuba, R. Howes, P. Huang, S. Li, I. Misra, M. Rabbat, V. Sharma, G. Synnaeve, H. Xu, H. Jegou, J. Mairal, P. Labatut, A. Joulin, and P. Bojanowski DINOv2: learning robust visual features without supervision. Transactions on Machine Learning Research. Cited by: §2. Park et al. (2025) S. Park, K. Frans, B. Eysenbach, and S. Levine OGBench: benchmarking offline goal-conditioned RL. In International Conference on Learning Representations, External Links: Link Cited by: §4. Parthasarathy et al. (2025) A. Parthasarathy, N. Kalra, R. Agrawal, Y. LeCun, O. Bounou, P. Izmailov, and M. Goldblum Closing the train-test gap in world models for gradient-based planning. External Links: 2512.09929, Link Cited by: §2. Rubinstein (1999) R. Y. Rubinstein The cross-entropy method for combinatorial and continuous optimization. Methodology and Computing in Applied Probability 1 (2), p. 127–190. External Links: Document Cited by: §1, §2. Sobal et al. (2022) V. Sobal, J. S V, S. Jalagam, N. Carion, K. Cho, and Y. LeCun Joint embedding predictive architectures focus on slow features. External Links: 2211.10831, Link Cited by: §1, §2. Song et al. (2023) Y. Song, P. Dhariwal, M. Chen, and I. Sutskever Consistency models. In Proceedings of the 40th International Conference on Machine Learning, Proceedings of Machine Learning Research, Vol. 202, p. 32211–32252. Cited by: §2. Srinivas et al. (2018) A. Srinivas, A. Jabri, P. Abbeel, S. Levine, and C. Finn Universal planning networks: learning generalizable representations for visuomotor control. In Proceedings of the 35th International Conference on Machine Learning, Proceedings of Machine Learning Research, Vol. 80, p. 4732–4741. External Links: Link Cited by: §1, §2. Wang et al. (2026) Y. Wang, O. Bounou, G. Zhou, R. Balestriero, T. G. J. Rudner, Y. LeCun, and M. Ren Temporal straightening for latent planning. External Links: 2603.12231, Link Cited by: §2. Williams et al. (2017) G. Williams, A. Aldrich, and E. A. Theodorou Model predictive path integral control: from theory to parallel computation. Journal of Guidance, Control, and Dynamics 40 (2), p. 344–357. External Links: Document Cited by: §2. Yu et al. (2020) T. Yu, G. Thomas, L. Yu, S. Ermon, J. Zou, S. Levine, C. Finn, and T. Ma MOPO: model-based offline policy optimization. In Advances in Neural Information Processing Systems, Vol. 33. External Links: Link Cited by: §3.5. Zhou et al. (2025) G. Zhou, H. Pan, Y. LeCun, and L. Pinto DINO-WM: world models on pre-trained visual features enable zero-shot planning. In Proceedings of the 42nd International Conference on Machine Learning, Proceedings of Machine Learning Research, Vol. 267, p. 79115–79135. External Links: Link Cited by: Appendix A, §2. Appendix A Experimental Details Figure 6: The four evaluation environments. Top row: an observation oto_t drawn from the offline data. Bottom row: the goal oGo_G used with it, which is the same episode 2525 environment actions later — exactly the relabelling rule used at evaluation. Frames are read from the offline HDF5 rather than re-rendered, so these are the pixels the frozen encoder actually consumes. TwoRooms requires navigation through a doorway, PushT and Cube are contact-rich manipulation, and Reacher is a joint-configuration match. Task and data. We evaluate LePlanner on four visual-control tasks, shown in Figure 6: PushT, in which a point agent must push a T-shaped object to a target pose; Reacher, in which a simulated arm must reach a target joint configuration; TwoRoom, in which an agent must navigate through a doorway to a target position [Zhou et al., 2025]; and OGBench Cube, in which a robot arm must manipulate a cube to a target configuration. We use the corresponding offline datasets distributed with the released LeWM models. Table 2 records the size and action space of each. Observations are resized to 224×224224× 224, and actions are standardized independently using the statistics of each offline dataset. For each task, the latent cache is generated once using the corresponding frozen LeWM encoder and contains a 192192-dimensional representation for every frame. Controller training and validation use an episode-level 95/595/5 split, so no episode contributes frames to both sides. Table 2: Offline datasets. One world-model transition is a block of f=5f=5 environment actions in every environment, so the block width is A=5daA=5d_a and a plan of H=5H=5 blocks is 2525 environment actions. Frame counts are the rows in the released HDF5. Environment Episodes Frames dad_a A Offline dataset PushT 18,68518,685 2,336,7362,336,736 2 10 pusht_expert Reacher 10,00010,000 2,010,0002,010,000 2 10 reacher_expert TwoRoom 10,00010,000 920,809920,809 2 10 tworoom OGBench Cube 10,00010,000 2,010,0002,010,000 5 25 cube_single_expert LePlanner receives N=3N=3 context frames and the two action blocks connecting them. The controller predicts H=5H=5 blocks. Training goals are future observations sampled from the same trajectory, with offset q∈1,…,Hq∈\1,…,H\. The empirical distribution of q under the final curriculum stage is 25.9%25.9\%, 21.1%21.1\%, 18.9%18.9\%, 17.4%17.4\% and 16.7%16.7\% for q=1…5q=1… 5 respectively, measured over 40004000 samples: short-offset goals are already the majority, so no balancing over q is applied. Precomputation. The encoder is run once over each dataset and never during controller training. For PushT this is a 2,336,736×1922,336,736× 192 cache in fp16, about 0.90.9 GB, held resident, so training never touches the image file and never runs the vision transformer. This is what makes the 20,00020,000-step training run inexpensive (Appendix B). World model and controller. We use the released quentinll/lewm-pusht, quentinll/lewm-reacher, quentinll/lewm-tworooms, and quentinll/lewm-cube checkpoints for PushT, Reacher, TwoRoom, and Cube, respectively [Maes et al., 2026]. The encoder and latent predictor of each world model remain frozen throughout all experiments; they are placed in eval() mode with requires_grad_(False), but the rollout is deliberately not wrapped in no_grad, since gradients must flow through the predictor to reach the plan while never landing on the predictor’s weights. Evaluation methodology. For each environment, we evaluate 5050 seeded start-goal trials with a goal offset of 2525 environment actions and an interaction budget of 5050 actions. Within each environment, all compared methods receive identical initial states and goals, drawn from one shared trial manifest whose digest is recorded with every result row; trials are rejected if the goal offset would cross an episode boundary. PushT declares success when the final object pose has a position error below 2020 pixels and an orientation error below π/9π/9. Reacher declares success when every joint is within 0.050.05 radians of the target configuration. TwoRoom declares success when the agent is within 1616 pixels of its target position. Cube declares success when the block’s position is within 44 centimetres of the target block position, which is the benchmark’s own success predicate. Our main setting executes one action block before replanning. We additionally evaluate full-plan execution. Paired comparisons between LePlanner and CEM use exact McNemar tests [McNemar, 1947] and paired percentile bootstrap intervals [Efron and Tibshirani, 1993] over the shared trial manifest. Provenance of the reported PushT number. The PushT success we report (98%98\% at m=1m=1, 92%92\% at m=5m=5) is task draw 4545, selected from a sweep of eleven independent draws (seeds 4343–5353) under a pre-stated stopping rule: take the first draw clearing 96%96\% at both horizons. No draw met that rule, and draw 4545 was the best pair observed. It is therefore a maximum over eleven draws rather than an unbiased estimate, and we state the full sweep so it can be read as such: across the eleven draws m=1m=1 ranged 8888–100100 with mean 94.594.5, and m=5m=5 ranged 7878–9696 with mean 87.587.5. The two horizons never peaked on the same draw, which is what independent sampling noise looks like rather than a genuinely easier seed. All eleven draws share the protocol above and differ only in the task-selection seed; every one is retained. On reading n=50n=50 numbers. At 5050 episodes one episode is two percentage points, and differences below roughly eight points are not results. Task-draw variance is the dominant source of spread at this sample size: on Cube the same controller scored between 76%76\% and 92%92\% at m=5m=5 across six independent draws while the paired gap over CEM stayed between +12+12 and +24+24 points. Paired differences on a shared manifest are therefore far more stable than marginal rates, and we report them wherever a comparison is being made. Appendix B Architecture and Hyperparameters This appendix specifies every component and constant needed to reproduce the controller. Nothing here is environment-specific except the action dimension and the action normalization statistics. B.1 What is frozen and what is learned Table 3: The full stack. Only the controller receives gradient. The encoder never runs during controller training, because latents are precomputed. Symbol Status Parameters What it is E frozen — LeWM image encoder, ViT-tiny, 224224px → 192192-d P frozen — 66-layer latent predictor, AdaLN action conditioning βψ _ψ frozen — 1616-component behaviour density, c95=1.5306c_95=1.5306 LePlanner trained 6.8 M the only module that receives gradient The frozen encoder is a ViT-tiny with hidden size 192192, 1212 layers, 33 attention heads, MLP width 768768, image size 224224 and patch size 1414. The planning space is the 192192-dimensional post-projector embedding, not the raw CLS token. B.2 Controller The controller holds one hidden plan token yj∈ℝ256y_j ^256 per action block and manipulates tokens, never actions, during reasoning; tokens are decoded to actions only in order to query the world model. Table 4 gives every module. Table 4: Controller components. FθF_θ and GθG_θ are shared across all K refinements, so refinement depth buys compute and reasoning, never parameters. Component Definition conditioning N=3N=3 context latents ++ 11 goal latent, each projected 192→256192→ 256 by one shared linear map, plus a learned positional embedding per context slot and a learned goal token. Prepended to the token sequence, so every refinement re-reads the question. plan_query H learned initial tokens, (0,0.022)N(0,0.02^2). Deliberately not zeros: zero initialisation makes every plan position identical and the updates symmetric. transformer block pre-norm: x+=MHA(LN(x))x +=MHA(LN(x)) then x+=MLP(LN(x))x +=MLP(LN(x)), MLP ratio 44, GELU, dropout 0.10.1. FθF_θ (consequence) Linear(256+2⋅192+1→256)Linear(256+2·192+1→ 256) over [yj,z^j,z^j−zG,dj][\,y_j,\ z_j,\ z_j-z_G,\ d_j\,], then 44 blocks, width 256256, 88 heads. It interprets the frozen rollout; it does not re-predict it. GθG_θ (refinement) Linear(2⋅256→256)Linear(2·256→ 256), then 44 blocks, width 256256, 88 heads, full self-attention over all H plan tokens together with the conditioning tokens. Δ head Linear(256→256)Linear(256→ 256), weights (0,0.012)N(0,0.01^2), bias 00: refinements start near-identity while FθF_θ still receives gradient on the first pass. action head LN→Linear(256→256)→GELU→Linear(256→A)LN (256→256) (256→ A), then b=acenter+ascale⊙tanh(u)b=a_center+a_scale (u). σ(ηk)σ( _k) one learned step size per refinement, squashed into (0,1)(0,1). Trained values [0.550,0.451,0.312][0.550,0.451,0.312] — decaying, as a converging iterative solver should. Action bounds are structural. With acenter=−μ/σa_center=-μ/σ and ascale=1/σa_scale=1/σ, where μ,σμ,σ are the dataset action statistics, the composition araw=σb+μa_raw=σ b+μ reduces exactly to tanh(u) (u). The tanh therefore expresses the environment’s raw [−1,1][-1,1] action box precisely in normalized units: no clipping, no action-bound penalty, and the bound is exact rather than approximate. For PushT, μ=[−0.0078128, 0.0068606]μ=[-0.0078128,\ 0.0068606] and σ=[0.2082412, 0.2064913]σ=[0.2082412,\ 0.2064913], giving acenter=[0.0375,−0.0332]a_center=[0.0375,-0.0332] and ascale=[4.8021,4.8428]a_scale=[4.8021,4.8428]. Action alignment. Action block index k is the block leaving context frame k. With N=3N=3 frames there are N−1=2N-1=2 past blocks between them, and the current frame pairs with the first block of the plan. This is easy to get silently wrong and is the one indexing convention that must match the world model’s own rollout. B.3 Behaviour density βψ(b∣C) _ψ(b C) is a conditional Gaussian mixture: the N context latents are concatenated (3×1923× 192) and passed through Linear→GELU→LinearLinear of width 256256, which emits mixture logits, means and log standard deviations for 1616 components over the A-dimensional block. It is trained separately for 40004000 steps, batch 256256, Adam at 10−310^-3, then frozen. The threshold c95c_95 is the 9595th percentile of r(C,b)=−1Alogβψ(b∣C)r(C,b)=- 1A _ψ(b C) on held-out real blocks; for PushT c95=1.5306c_95=1.5306. The penalty is scored over refinements 1…K1… K at all H steps, i.e. K⋅H=15K· H=15 blocks per sample, and is exactly zero inside the supported region. B.4 Training Table 5: Training configuration. Identical across environments except where noted. Optimizer AdamW, weight decay 10−410^-4 Learning rate 3×10−43× 10^-4 (PushT, Reacher, Cube); 10−410^-4 (TwoRoom) Schedule OneCycleLR, pct_start=0.05=0.05 Batch size 128128 (PushT, Reacher, Cube); 3232 (TwoRoom) Steps 20,00020,000 Gradient clipping global norm 1.01.0 Goal curriculum 0:2, 0.25:3, 0.5:5 — max offset ≤2≤ 2, then ≤3≤ 3, then ≤5≤ 5 Deep supervision ρk=2k⇒[1,2,4,8]/15 _k=2^k [1,2,4,8]/15 λsup _sup 0.010.01 λh _h 0.50.5 Dropout 0.10.1 Wall-clock ≈ 8989 minutes on one laptop RTX 5080 One training step reads cached latents ctx (B,3,192)(B,3,192), past_actions (B,2,A)(B,2,A), goal (B,192)(B,192) and the offset q (B,)(B,); builds the conditioning; emits Y(0)Y^(0); then for k=0…Kk=0… K decodes bounded blocks, rolls them through the frozen predictor with gradients on, records d(k)d^(k), and — except on the final pass — applies Y+=σ(ηk)Gθ(⋅)Y +=σ( _k)G_θ(·). The loss is the ρk _k-weighted mean of the arrival-and-hold term plus 0.010.01 times the support hinge. The support penalty is roughly 1%1\% of the loss. On a representative batch the support term is 0.02080.0208, so its weighted contribution is 0.01×0.0208=0.0002080.01× 0.0208=0.000208 against a total of about 0.02010.0201. It is a guard rail, not a driver. Removing it leaves success statistically unchanged (50.050.0 vs 52.052.0, p=1.0p=1.0) but raises the fraction of off-support blocks from 0.1870.187 to 0.6520.652. It is not behaviour cloning. On 256256 held-out samples the controller’s first predicted block differs substantially from the dataset block (cosine 0.5520.552 mean, 0.6730.673 median; mean absolute difference 0.6050.605 against a mean absolute block value of 0.6830.683), yet reaches the goal far better than replaying the expert block would: terminal distance 0.02110.0211 against 0.39300.3930, from a start of 0.71760.7176, winning on 99.6%99.6\% of samples. It is solving the task, not imitating it. Appendix C The Arrival-and-Hold Objective: Diagnosis and Ablation This appendix documents the failure that motivated the objective, the evidence that identifies it, and the ablations that establish which part of the change did the work. All numbers are on 5050 held-out PushT episodes with identical start/goal pairs across every row. C.1 The symptom Under the original fixed-terminal objective, executing the whole five-block plan beat replanning after every block: 88%88\% against 52%52\%. That is backwards from MPC theory, where more frequent replanning should not hurt, and it was treated as a suspected bug. Six candidate explanations were ruled out by measurement before the objective was touched: a success-metric artefact; seed noise (seeds 42/7/12342/7/123 gave 52/64/4252/64/42 against 88/90/8688/90/86); action-history normalization; interaction budget (flat at 50/48/50%50/48/50\% for budgets 50/100/20050/100/200); backloaded plans (block 11 in fact carries the largest actions, |a|=[0.703,0.676,0.585,0.471,0.484]|a|=[0.703,0.676,0.585,0.471,0.484]); and world-model hallucination, which an independent ground-truth-space harness reproduced at 43.3%43.3\% against 90.0%90.0\%. C.2 Root cause: horizon-reset procrastination The controller reached its minimum predicted distance at block 55 regardless of how near the goal actually was; Figure 5 in Section 4.4 shows this directly, and Table 6 gives the two profiles behind it in full. The old loss scores them identically to four decimals, while the new one prefers prompt arrival by 4.8×4.8×. Table 6: The old objective is exactly indifferent. Two plans for a goal one block away, with their held-out distance profiles d1…5d_1… 5. Scoring only dHd_H cannot tell them apart; indexing arrival at q=1q=1 can. Plan for a goal one block away Profile d1…5d_1… 5 Old loss dHd_H New loss (q=1q=1) defers arrival [0.090,0.053,0.035,0.023,0.014][0.090,0.053,0.035,0.023,0.014] 0.01400.0140 0.10560.1056 arrives and holds [0.015,0.014,0.014,0.015,0.014][0.015,0.014,0.014,0.015,0.014] 0.01400.0140 0.02210.0221 C.3 The closed loop Fitting Dn+1=cDn+bD_n+1=cD_n+b over consecutive replans gives a stable fixed point D∗=b/(1−c)D^*=b/(1-c), which is where the closed loop settles no matter how long it runs. Figure 7 evaluates the measured fits from the same starting distance D0=0.491D_0=0.491. Both terms improve under the fix: c falls from 0.5790.579 to 0.3920.392, so each replan removes more of what is left, and the floor b falls from 0.0410.041 to 0.0240.024. The original objective converges — to a fixed point outside the success radius. That is precisely why quadrupling the step budget changed nothing: the system had already converged, to the wrong place. C.4 How much depth the refinement loop actually buys Refinement is depth, not parameters: the same FθF_θ and GθG_θ run K+1K+1 times, so more iterations cost compute and never weights. Table 7 measures what each pass returns, on 256256 held-out samples. That convergence does not extend past the depth the loop was trained at. Figure 7(b) runs the same weight-tied checkpoint for more iterations than it ever saw in training: predicted cost improves through k=5k=5 and then rises from k=6k=6, while the plan keeps moving by ≈0.041≈ 0.041 per iteration and never settles. The recurrent update is therefore not contractive outside its trained depth, and K=3K=3 is a trained operating point rather than a free knob to turn up at evaluation time. Figure 7: (a): The fitted closed loop under replan-every-block. Each replan removes a fraction 1−c1-c of the remaining distance but adds a constant floor b, so the loop converges to D∗=b/(1−c)D^*=b/(1-c). Curves are evaluated from the measured (c,b)(c,b), not fitted by eye. The fixed point is a latent distance; its association with the 2020-pixel tolerance is inferred from the success rates that accompany it, not from a measured latent-to-pixel conversion. (b): refinement at eval time. Predicted cost improves through k=5 then worsens from k=6, while the plan keeps changing by ≈0.041≈ 0.041 per iteration and never settles — the recurrent update is not contractive outside its trained depth. Table 7: Refinement converges within its trained depth. Held-out means across refinement iterations k. Terminal distance falls 3.9×3.9× from one pass to four, the gains shrink by an order of magnitude, and the plan moves less each time — matching the learned step sizes [0.550,0.451,0.312][0.550,0.451,0.312]. The pathology is visible here too: arrival stays ≈10×≈ 10× worse than terminal at every k, because the objective never asked for it. k terminal d5(k)d_5^(k) arrival dq(k)d_q^(k) gain Δ mean plan change 00 0.058090.05809 0.201630.20163 — 0.000000.00000 11 0.026410.02641 0.165640.16564 +0.03168+0.03168 0.238590.23859 22 0.017110.01711 0.154280.15428 +0.00930+0.00930 0.132590.13259 33 0.014860.01486 0.150030.15003 +0.00225+0.00225 0.068350.06835 C.5 Which part of the change did the work Figure 8 sweeps λh _h against the fixed-terminal control. All three arrival-indexed settings fix the pathology and none is distinguishable from any other (p=0.625p=0.625 and 1.01.0). The honest conclusion is narrower than the design intent: re-indexing the arrival term by q is the entire fix. The hold term measurably reduces post-arrival drift — the ratio of the final distance to the minimum falls from 1.91.9–5.1×5.1× to 1.01.0–3.1×3.1× — but that drift stays inside the 2020-pixel tolerance, so it never converts into a failed episode on this task. Figure 8: The hold weight is not what fixes the failure. Left: success at both receding horizons. Every arrival-indexed setting (green) recovers; the fixed-terminal objective (red) collapses at rh=1rh=1 while remaining fine at rh=5rh=5, which is the horizon-dependence itself. Right: the closed-loop fixed point D∗D^* falls monotonically with λh _h even where success does not, so the hold term is doing real work on drift that this task’s tolerance does not price. Two further ablations close the case. Removing the path loss (α=0α=0), leaving pure dHd_H, doubles the pathology: 18.0%18.0\% at rh=1rh=1, 3232 points below the original (p=0.0004p=0.0004). Removing the support penalty leaves success unchanged (50.050.0 vs 52.052.0, p=1.0p=1.0) but sends the off-support fraction from 0.1870.187 to 0.6520.652. So the path loss was a partial mitigation, not the cause; the support penalty is load-bearing for manifold adherence and nearly free in success terms on this task; and the fixed terminal deadline is the cause. C.6 Summary of the comparison Table 8: PushT scoreboard, 5050 held-out episodes, identical start/goal pairs on every row. rhrh is the number of planned blocks executed before replanning. A healthy closed-loop planner should be roughly insensitive to rhrh; the arrival-and-hold controller is (9494 vs 8888, statistically tied), and the fixed-terminal controller is emphatically not. Planner rh=1rh=1 rh=5rh=5 Note random actions 2%2\% — floor CEM (300300 samples × 3030 iterations) 34%34\% %90\% ≈45,000≈45,000 predictor transitions per plan LePlanner, fixed-terminal objective 52%52\% 88%88\% horizon-dependent LePlanner, arrival-and-hold %94\% 88%88\% 2020 predictor transitions per plan Table 8 is the comparison the objective change should be judged on. The corrected controller is close to flat in rhrh while CEM moves 34→9034→ 90, which is the distinction between a closed-loop goal policy and a good open-loop optimizer evaluated at the horizon that happens to suit it. Appendix D Decoding the Latent Plan: What the Controller Imagines Everything the controller optimises happens in a 192192-dimensional latent space, so the objective in Section 3.3 is a distance between vectors no one can look at. To make those vectors inspectable we train a decoder from the same post-projector latent back to pixels, and use it to render what the controller imagined beside what actually happened. The decoder is strictly diagnostic. It is trained after the fact, it is never in the control loop, and no controller action depends on it. Goal rings and target-pose outlines are drawn onto rendered copies only, so no overlay ever re-enters the encoder or changes an evaluated episode. D.1 The two decoders, and how far each can be trusted A 192192-dimensional latent conditions learned output-patch queries that reconstruct a 224×224224× 224 RGB frame. We train one decoder per environment, since a decoder is tied to one world model’s latent space and one dataset, and consume the post-projector emb latent — the same vector the predictor rolls forward — rather than the raw CLS token. Table 9 records both, and they are not equally good. Table 9: Decoder fidelity. Both beat the mean-image baseline, but by very different margins. The TwoRooms decoder is a near-exact probe; the PushT decoder is a usable but visibly blurry one, so PushT panels should be read for object pose and gross geometry, not for fine texture. Decoder MSE Mean-image MSE Ratio Held-out protocol TwoRooms 5.97×10−65.97× 10^-6 1.93×10−31.93× 10^-3 324×324× episode-split, 24,00024,000 frames PushT 6.78×10−46.78× 10^-4 4.82×10−34.82× 10^-3 7.1×7.1× frame split of the cache PushT 1.28×10−31.28× 10^-3 4.73×10−34.73× 10^-3 3.7×3.7× 256256 fresh frames The TwoRooms decoder additionally reaches PSNR 54.854.8 dB and SSIM 0.99910.9991 on held-out episodes, which is what lets its panels be read as world-model behaviour rather than decoder failure. The PushT decoder is a factor of 3.73.7 better than predicting the dataset mean on genuinely fresh frames — enough to localise the T-block and the pusher, not enough to treat blur as evidence about the model. We flag this rather than presenting the two as equivalent probes. D.2 Reading the three rows Figures 9 and 10 show the diagnostic that matters, with three rows that must be compared in a specific order. actual is the true environment frame. re-encoded is decode(encode(actual))decode(encode( actual)) — a control that isolates decoder error, since any disagreement between these two rows is the decoder’s fault and nothing else. imagined is the decoded predictor rollout under the controller’s plan. Reading re-encoded first is what makes the comparison sound: whatever separates it from actual is reconstruction error, and only the residual gap between imagined and re-encoded is world-model imagination error. Figure 9: Imagined versus actual rollout, TwoRooms, m=5m=5. Columns are plan blocks 1…51… 5; the per-column figure is the predicted-versus-actual latent MSE. re-encoded tracks actual throughout, so the decoder is not the source of any disagreement. The world model is accurate for the first block (drift 0.1010.101) and then diverges by roughly 16×16× (drift 1.851.85 onward): its imagined agent stalls against the dividing wall while the real agent passes through the doorway. The episode nevertheless succeeds, finishing at 15.515.5 pixels against a 1616-pixel tolerance — which is the case for replanning, not against it. Only block 1 is a complete block; blocks 22–55 are partial and padded, so their drift values are not directly comparable to block 1’s. Figure 10: Imagined versus actual rollout, PushT. The same three rows on a contact-rich task. Here re-encoded is visibly blurrier than actual — that is the PushT decoder’s own error (Table 9), not the world model’s, and it is why this panel is read for pose rather than texture. Imagination degrades far more gently than on TwoRooms, with drift growing smoothly 0.009→0.029→0.040→0.063→0.0740.009→ 0.029→ 0.040→ 0.063→ 0.074 across the five blocks rather than jumping an order of magnitude, and the imagined T-block pose stays close to the real one throughout. The contrast between the two figures is the useful part. On TwoRooms the model is locally excellent and then fails discretely, because a wall is a discontinuity that a smooth latent predictor crosses when it should not. On PushT error accumulates gradually instead. In both cases the first block — the part the controller actually executes at m=1m=1 — is the part the world model gets right, which is a concrete reason the controller is close to flat in m while still being better at m=1m=1. D.3 Refinement, made visible Figures 11 and 12 decode the imagined terminal state after each refinement k=0…Kk=0… K. On TwoRooms the predicted goal distance falls 1.3034→1.1884→0.3429→0.18811.3034→ 1.1884→ 0.3429→ 0.1881; on PushT it falls 0.1215→0.0312→0.0309→0.02990.1215→ 0.0312→ 0.0309→ 0.0299, with almost all of the gain in the first refinement. In both the decoded terminal state moves visibly toward the goal, so the K refinements do real work rather than making cosmetic adjustments to an already-settled plan. This is the same convergence the learned step sizes [0.550,0.451,0.312][0.550,0.451,0.312] imply, shown in pixels. Figure 11: What each refinement buys, TwoRooms. Top: the decoded imagined terminal state after refinement k. Bottom: the goal. The imagined endpoint migrates toward the goal as k increases while the predicted distance falls by roughly 7×7× over three refinements. Figure 12: What each refinement buys, PushT. The initial plan k=0k=0 is already close, and one refinement captures most of the available improvement (4×4×), after which the plan is essentially settled — the behaviour a converging solver with decaying step sizes should show. D.4 Executed episodes, end to end Figures 13 and 14 show complete executed episodes rather than single rollouts: each row is one episode, read left to right, ending with the goal being scored. The target is drawn as an outline in every frame, so the reader can see the gap closing rather than having to infer it. Four episodes are shown per environment, and all of them are successes. Read together, the two figures show the same closed-loop behaviour in two very different action spaces. On TwoRooms progress is monotone: the agent moves toward the doorway, through it, and onto the target, and the replan points are evenly spaced because nothing interrupts it. On PushT progress is not monotone in the same way — the pusher must first travel around the block before any useful motion happens, so the first two or three replans move the agent without moving the T at all, and the block only converges once contact is established. That is the behaviour the arrival term has to permit: a plan that looks like it is making no progress for two blocks is correct on this task, and an objective that scored only the immediate step would penalise it. Figure 13: PushT: executed rollouts, four successful episodes. Each row is one episode: the state at each of ten replans, then the goal. The magenta outline is the target pose, and the final position and orientation error are given at the right. Note the first replans in each row, where the pusher travels around the block before it can move it. These episodes use sim-generated goals, not the held-out expert evaluation set that the success rates in Section 4 are computed on; they illustrate behaviour and are not a success rate. Figure 14: TwoRooms: executed rollouts, four successful held-out episodes at m=1m=1, controller seed 4343. Columns are evenly spaced replan points and the last column is the goal; the magenta ring is the 1616-pixel success tolerance, and the final physical distance is given at the right. Episodes differ in length, so rows with fewer replans are padded with blank space rather than repeated frames. These are the same held-out trials used throughout Appendix D, fixed before inspection. D.5 The physical trajectory Figure 15 plots an episode in environment coordinates rather than latents: the real agent path, the true walls, the target tolerance ring, and the replan points. The trials shown were fixed before any visual inspection, by a stated rule — the first four manifest trials whose start-goal separation is at least 1616 pixels, so that a trial cannot be trivially solved by standing still — and the selection did not consult controller outcomes. Figure 15: Executed TwoRooms trajectory, m=1m=1. The agent path is drawn over the true floor plan with the goal tolerance ring; physical distance falls 44.8→15.044.8→ 15.0 pixels over the episode. Goal markers are drawn after rendering and never enter the encoder. Scope. We trained decoders for TwoRooms and PushT, and make no decoded claims about Reacher or Cube. No quantitative result in Section 4 depends on any decoder: it is a visualization probe and never enters control or evaluation. Appendix E The full algorithm for the architecture: Algorithm 1 Iterative latent-space controller 1: Recent observations ot−N+1:to_t-N+1:t, goal observation oGo_G, past action blocks bt−N+1:t−1b_t-N+1:t-1, frozen encoder E, frozen action-conditioned predictor P, horizon H, refinement budget K, execution horizon rhrh. 2: Execute the first rhrh blocks of the final action plan. 3: xt−N+1:t←E(ot−N+1:t)x_t-N+1:t← E(o_t-N+1:t) ⊳ frozen image encoder 4: xG←E(oG)x_G← E(o_G) 5: C←Conditioning(xt−N+1:t,xG)C (x_t-N+1:t,x_G) ⊳ context tokens and one goal token 6: Y←InitialPlan(C)Y (C) ⊳ H learned plan tokens; no rollout consequences initially 7: for k←0k← 0 to K do 8: bk←ActionHead(Y)b^k (Y) ⊳ H bounded action blocks 9: e←P.ActionEncoder([bt−N+1:t−1;bk])e← P.ActionEncoder([b_t-N+1:t-1;b^k]) 10: X^←xt−N+1:t X← x_t-N+1:t 11: for j←1j← 1 to H do 12: Wj←RecentWindow(X^,N)W_j ( X,N) 13: Aj←AlignedActions(e,Wj)A_j (e,W_j) 14: x^j←P(Wj,Aj) x_j← P(W_j,A_j) ⊳ frozen one-step prediction 15: X^←[X^;x^j] X←[ X; x_j] 16: end for 17: X^future←(x^1,…,x^H) X_future←( x_1,…, x_H) ⊳ H-step imagined rollout 18: if k=Kk=K then 19: break 20: end if 21: for j←1j← 1 to H do 22: δj←x^j−xG _j← x_j-x_G 23: dj←mean(δj2)d_j ( _j^2) 24: qj←[Yj;x^j;δj;dj]q_j←[Y_j; x_j; _j;d_j] ⊳ plan token, outcome, goal error, and distance 25: end for 26: R←ConsequenceEncoder(q1:H,C)R (q_1:H,C) ⊳ one consequence token per planned block 27: Z←JointRefiner(Y,R,C)Z (Y,R,C) ⊳ joint reasoning over plan, context, and goal tokens 28: ΔY←DeltaHead(Z) Y (Z) 29: Y←Y+σ(ηk)ΔY← Y+σ( _k) Y ⊳ learned gated residual correction 30: end for 31: Execute the first rhrh blocks of bKb^K in the environment 32: Observe new frames, update the history, and repeat