A latent world model's decoder is trained on states anchored to observations and deployed on the model's own free-running rollout. RDR is one loss term that trains it where it is deployed: free-run during training, decode every rollout latent, penalize the error against ground truth. It adds no parameters and changes no architecture, so every comparison is a one-flag A/B. The full paper, which covers all of this in far greater detail, is published at doi.org/10.5281/zenodo.21894547.
Latent world models learn three components: an encoder that maps observations to a compact state, a transition that advances the state, and a decoder that maps states back to observation space. The standard training objective supervises the decoder on posterior latents, states computed while observations are available, and on predictions one teacher-forced step from them. Multi-step training signals, where present, act in latent space only. At deployment the model free-runs. The transition iterates on its own outputs, and the decoder is applied to latents that have drifted for tens or hundreds of steps without being conditioned on an observation. The decoder's training distribution and its deployment distribution therefore diverge exactly where long-horizon behavior is decided.
The gap is named but unmeasured. PlaNet identified the direct fix, observation overshooting, which decodes the multi-step rollout latents, and set it aside as too expensive in image domains, so what it is worth was never established; the Dreamer line trains its decoder on posterior latents only and never decodes an imagined state as a training loss. The gap has stood open in every latent world model since. Rollout-Decoded Reconstruction (RDR) closes it directly. During training the model is rolled free-running from an encoded initial state, exactly as evaluation will roll it; every rollout latent is decoded; and the reconstruction error against ground truth is penalized. The term adds no parameters, changes no architecture, and reduces to the standard objective when its weight λ is zero, so every comparison is a controlled A/B at fixed data, seeds, budget, and parameter count, differing in one flag.
On the chaotic Kuramoto–Sivashinsky equation, a standard long-horizon benchmark with exact ground truth, RDR raises valid prediction time from 3.87 ± 0.23 to 6.97 ± 0.42 time units: a 1.80× improvement at an identical 193,568 parameters, confirmed on fresh seeds and at both evaluation horizons, with the direction holding in 10 of 10 preregistered configurations at ratios of 1.71 to 2.50×. The effect is attributable to the decoder's training distribution rather than to capacity, and it grows with latent width while the standard objective anti-scales. In model-based control, ensembles of RDR world models reach useful behavior in fewer optimizer steps and are robust to a planner–training rollout mismatch that costs the standard objective more return in 4 of 4 measured rows. Both results come from the same single term. RDR is an objective rather than an architecture: it composes with any world model that retains a decoder.
Every latent world model in current use trains a decoder and then deploys it somewhere else. Training supervises the decoder on states computed while observations are available, plus predictions one teacher-forced step from them. Inference free-runs: the transition iterates on its own output, and by the time long-horizon behavior is decided the decoder is reading latents hundreds of steps from the last observation it saw. Multi-step training signals do exist in this lineage, but they act in latent space, so the decoder itself is never exposed to a multi-step rollout latent. The distribution the decoder is fit on and the distribution it is used on are different, and the difference is unmeasured.
Two concurrent 2026 preprints are the closest work. NeuroWorld decodes a frozen dynamics model's rollout latents with a separately trained subject decoder for fMRI prediction; Koopman Dreamer includes an open-loop observation-prediction term among several auxiliaries around a spectrally constrained transition. Neither isolates the decoder's training distribution as the object of study. From the reduced-order modeling side, Rollout-LaSDI reaches the same construction for latent space dynamics identification, but its latent evolution is a per-parameter linear system fit by regression rather than a learned nonlinear transition applied recursively to its own output, its system is a smooth viscous PDE rather than a chaotic one, it reports no action-conditioned or control result, and it holds the latent width fixed, so the capacity behavior has no counterpart there.
The model is a deliberately plain instance of the encoder, transition, decoder triplet, so that the objective is the only thing under test. An MLP encoder Eφ maps a field snapshot ut ∈ ℝ64 to a latent zt ∈ ℝd through two hidden layers of 256 with GELU. A state-space predictor fθ, a four-layer S5 stack with state size 64, advances the latent one step. A decoder Dψ, an MLP with one hidden layer of 512, maps latents back to field space. A target encoder Ē, the exponential moving average of Eφ with decay 0.999, provides latent regression targets, written z̄t = Ē(ut) and called posterior by analogy with RSSM practice.
Four standard terms train the triplet. Writing sg for the stop-gradient and ẑt+k for the free-running rollout, with gradients flowing through the whole chain:
| Term | What it supervises |
|---|---|
| LTF | teacher-forced one-step latent prediction |
| LR | multi-step latent rollout consistency, in latent space only |
| LOBS | decode the teacher-forced prediction |
| Lrecon | reconstruction anchor on the online encoder |
In all four terms the decoder is supervised only on posterior latents or on predictions one teacher-forced step from them. No term exposes it to a multi-step rollout latent. That is the gap.
RDR decodes the same free-running rollout that LR constrains, and that evaluation will score, against the ground-truth fields:
LRDR = (1 / K) Σk=1K ‖ Dψ(ẑt+k) − ut+k ‖², L = LTF + αe LR + LOBS + Lrecon + λ LRDR (1)
A single decoder serves two roles under RDR, sharp on-manifold reconstruction and robust off-manifold rollout decoding, and these could in principle conflict. A variant therefore gives the rollout term its own decode head of identical shape, +25.7% total parameters, under two evaluation policies: the sharp head everywhere (variant B), or a ramp from the sharp to the rollout head across the horizon (variant C). Variant C was fixed by preregistration as the primary arm before any result existed. Section 4.3 shows that at the operating point the split spends parameters without improving on the shared decoder, and that its usefulness depends on latent size.
Kuramoto–Sivashinsky is integrated on L = 22 with 64 grid points by ETDRK4 at dt = 0.1, discarding a 2000-step transient, generating 512 training, 64 validation, and 64 test trajectories of 256 snapshots each from disjoint seeds. Training draws one fixed 160-snapshot window per trajectory and unrolls the rollout losses over K = 128 steps, at batch size 32, Adam at 3 × 10⁻⁴, three seeds per arm. The headline configuration is latent 32, decoder width 512, λ = 0.3, 320 epochs.
Evaluation free-runs each model from the first snapshot of every held-out trajectory through the same rollout path used in training, decodes, and scores normalized RMSE against the climatological standard deviation of the scored window. Valid prediction time (VPT) is the time of the first crossing of 0.5, in time units (tu). The canonical horizon is 200 steps (20 tu); the long horizon is 1300 steps (130 tu) on separately generated, dealiased records. For this domain one Lyapunov time is 23.26 tu.
Re-scoring earlier checkpoints under the final protocol completes a four-point latent bracket at one recipe (decoder 512, 160 epochs, λ = 0.3, three paired seeds per rung).
| Latent | Posterior-only (tu) | + RDR, shared decoder (tu) | Ratio |
|---|---|---|---|
| 16 | 3.00 ± 0.36 | 4.20 ± 0.27 | 1.41 ± 0.10 |
| 24 | 2.77 ± 0.06 | 4.73 ± 0.15 | 1.71 ± 0.09 |
| 32 | 2.60 ± 0.27 | 5.90 ± 0.46 | 2.30 ± 0.43 |
| 48 | 2.27 ± 0.06 | 5.67 ± 0.55 | 2.50 ± 0.22 |
The objective is carried to two classic control tasks, pendulum swing-up and a cartpole swing-up variant, with action-conditioned world models. Ensembles of ten models per arm drive a cross-entropy-method MPC planner with 128 sampled action sequences per step and no disagreement bonus, scored over 20 paired episodes with identical episode seeds. Two properties are established, each by a matched control.
A deployed planner may roll the world model with an implementation that differs from the one used in training; a common variant re-initializes the recurrent state at each planning step rather than carrying it. Both arms are evaluated under the stateful rollout, which matches training, and under the per-step-reset variant, on both tasks and both seed sets.
| Row | Posterior gain | RDR gain |
|---|---|---|
| pendulum, seeds 0–19 | +9.04 | +1.82 |
| pendulum, seeds 100–119 | +18.12 | +3.59 |
| cartpole, seeds 0–19 | +17.08 | +12.80 |
| cartpole, seeds 100–119 | +12.71 | +10.64 |
Moving from the per-step-reset to the stateful planner improves both arms in all four measured rows, and the posterior arm gains more in every row. The asymmetry follows from the objective: RDR trains its decoder on free-running rollouts and is largely indifferent to the planner's rollout function, while the posterior-only decoder, trained exclusively on encoder posteriors and teacher-forced latents, absorbs the mismatch as lost return. RDR is robust to planner–training rollout mismatch, an implementation class that is easy to ship and that the standard objective silently converts into lost return. Under the stateful planner the arms perform equivalently, margins of +0.61 and +1.24 on the primary rows, which bounds the property: RDR insulates against mismatch rather than planning better under matched conditions.
Under the stateful planner, ensemble MPC over the learned world models matches planning with the true dynamics at the same search budget: on pendulum the RDR ensemble returns −177.45 against the oracle planner's −183.67, and on cartpole 158.57 against 151.01. The posterior-only ensemble shares the property (−178.06 and 157.33 on the same rows). This is a statement about ensembles of learned models, quoted as scope for the control experiments, and not an RDR result.
A fair reading of the main result requires the strongest non-latent control. An observation-space pushforward predictor, trained on its own unrolled outputs at the winner's budget, reaches 7.00 ± 0.26 tu.
| Model | Params | VPT canonical (tu) | VPT long (tu) |
|---|---|---|---|
| latent + RDR, shared decoder (headline) | 193,568 | 6.97 ± 0.42 | 6.90 ± 0.44 |
| latent + RDR, split head (preregistered primary) | 243,296 | 6.47 ± 0.40 | 6.40 ± 0.40 |
| observation-space pushforward | 230,464 | 7.00 ± 0.26 | 6.90 ± 0.26 |
| latent, posterior-only | 193,568 | 3.87 ± 0.23 | 3.77 ± 0.23 |
That is parity with the capacity-matched RDR arm, with every gap far inside one seed-level standard deviation, and ahead of the preregistered primary arm. Both model classes scale with training at nearly the same rate, the latent stack from 5.27 to 6.90 against observation-space from 5.80 to 7.00 over the same budget change, which is why the 5.77 bar, measured at the smaller budget, is not the matched comparison. On a fully observed, 64-dimensional system, the latent bottleneck buys nothing over a direct observation-space predictor at matched budget.
This result bounds the bottleneck rather than the objective. The RDR contrast is within-latent throughout, and every arm in the table carries a latent, so the class comparison leaves it unaffected. What it does establish is what this system can and cannot demonstrate: a 64-dimensional fully observed field is small enough to predict directly, so the architecture RDR improves is not the one a practitioner would choose here. The settings that force a latent, partial observability, pixel observations, or a planner that requires a compact state, are also the settings in which an observation-space predictor is unavailable. Measuring the effect in one of those is the natural next experiment.
A latent world model's decoder is deployed on the model's own free-running rollout and trained, almost universally, on something else. Rollout-Decoded Reconstruction closes that gap with one loss term and no new parameters. On a chaotic PDE it nearly doubles valid prediction time at an identical parameter count, in 10 of 10 preregistered configurations, with an advantage that grows as the latent widens while the standard objective anti-scales. In control it yields step-efficiency and robustness to rollout mismatch, each established by a matched control. On a fully observed low-dimensional system an observation-space predictor reaches parity at matched budget, which marks where a latent bottleneck earns its place and leaves the within-latent effect standing.
The architectures this reaches are already in use. Every model in the Dreamer lineage trains its decoder on posterior latents and free-runs it at inference, and adopting RDR in any of them means adding one term and choosing one weight; on the system measured here that is worth almost a doubling of usable horizon. The scaling behavior indicates where it repays most: over the range measured, the wider the latent, the more the standard objective leaves on the table, and deployed world models run latents far wider than any rung tested here. Measuring the effect where a latent is required, under partial observability, pixel observations, or planning over compact states, is the direct next step.
The paper, "Rollout-Decoded Reconstruction for Latent World Models," is published at doi.org/10.5281/zenodo.21894547. All training ran on short-lived cloud GPU instances for roughly $155; every evaluation and figure runs on a laptop CPU from the archived checkpoints, and the figure script re-asserts each quoted number against those artifacts and fails the build on drift.
The world-model lineage. The gap RDR closes was named in PlaNet and left open across the Dreamer line (Dreamer, DreamerV2, DreamerV3). The decoder-free models RDR does not reach are TD-MPC2 and MuDreamer.
Training on model-generated outputs. Scheduled sampling and professor forcing address the input; the pushforward trick and solver-in-the-loop unroll observation-space PDE surrogates; Self Forcing, Diffusion Forcing, and Next Forcing train on their own rollouts in pixel space. The closest concurrent work is NeuroWorld and Koopman Dreamer, and the same construction is reached from reduced-order modeling by Rollout-LaSDI.
The domain and its conventions. The predictor is an S5 stack; the planner is cross-entropy-method MPC (PETS, Pinneri et al.). Horizons are calibrated in Lyapunov times using the literature value for Kuramoto–Sivashinsky, and the strongest published latent-space results on this domain, which use symmetry reduction and are orthogonal to the training objective studied here, are Linot and Graham.