Autonomous mobile robots navigating cluttered, previously unseen indoor environments without a pre-built map is still a hard problem in robotics. Today, most mapless navigation solutions rely on reactive policies trained via model-free reinforcement learning, such as Proximal Policy Optimization (PPO). Reactive policies are fast, but they can’t look ahead. They have no way to imagine what an action will lead to or spot a collision before it happens.
World models take a different approach. By learning an internal predictive model of environmental transition dynamics, a robot can mentally simulate candidate action trajectories in latent space, evaluate risk over multi-step horizons, and select optimal actions before executing them in the physical world.
Across my Master’s research project at the University of Adelaide, supervised by Prof. Peng Shi and Dr. Bing Yan, I set out to investigate whether a lightweight, action-conditioned Recurrent State-Space Model (RSSM) could accurately predict future visual depth observations and power real-time planning, first across 617,000 simulated steps and then on a real Unitree Go2 EDU quadruped robot.
The Promise & Reality of Model-Based Navigation
Model-based reinforcement learning has demonstrated remarkable success in simulated control benchmarks like Atari and MuJoCo through foundational architectures like Dreamer. However, translating these theoretical successes onto resource-constrained physical robots operating in real physical space introduces severe challenges.
First, mobile robots are subject to non-holonomic kinematics, actuator lag, sensor noise, and real-world floor texture changes. On a quadruped like the Unitree Go2, the camera undergoes violent trotting oscillations with every gait cycle. If a world model cannot separate sensor noise from true environmental dynamics, planning inside its imagination leads directly to collisions.
Second, running high-frequency trajectory optimization onboard a mobile platform requires an inference budget of under 50 milliseconds per planning step. We needed an architecture compact enough to train on a consumer GPU while still capable of predicting complex spatial depth up to 15 steps into the future.
RSSM Architecture: Deterministic GRU & Stochastic VAE
Our world model is built on an action-conditioned Recurrent State-Space Model (RSSM). The latent state is factorized into two complementary components: a deterministic recurrent state h_t computed by a GRU, and a stochastic state z_t modeled as a diagonal Gaussian distribution.
The deterministic recurrent state tracks long-term historical context and velocity momentum across consecutive frames. Meanwhile, the stochastic state captures perceptual uncertainty, occlusions, and sudden obstacle appearances that cannot be inferred deterministically.
During training, the posterior encoder observes both past latent states and the current incoming depth observation to infer the true latent distribution. In parallel, a prior network learns to predict the identical latent transition using only the previous latent state and the executed action. The entire network is trained end-to-end minimizing reconstruction loss against true depth frames plus a KL-divergence regularization term between posterior and prior distributions.
import torch
import torch.nn as nn
import torch.distributions as td
class RSSMDynamics(nn.Module):
"""Action-conditioned Recurrent State-Space Model for depth imagination."""
def __init__(self, action_dim=2, deter_dim=256, stoch_dim=32, embed_dim=512):
super().__init__()
self.cell = nn.GRUCell(embed_dim + action_dim, deter_dim)
self.prior_net = nn.Sequential(
nn.Linear(deter_dim, 256),
nn.ELU(),
nn.Linear(256, 2 * stoch_dim)
)
def forward_prior(self, prev_deter, prev_action):
"""Imagine one step into the future without ground-truth observations."""
x = torch.cat([prev_deter, prev_action], dim=-1)
deter = self.cell(x, prev_deter)
stats = self.prior_net(deter)
mean, std = torch.chunk(stats, 2, dim=-1)
std = torch.nn.functional.softplus(std) + 0.1
prior_dist = td.Independent(td.Normal(mean, std), 1)
stoch = prior_dist.rsample()
return deter, stoch, prior_distScaling Data: 617K Simulation Steps to Real Go2 Hardware
In Research A, we developed a high-throughput 2D/3D occupancy grid simulation environment reproducing TurtleBot3 Waffle kinematics. Across five procedurally generated room topologies (corridors, open spaces, cluttered obstacles, mazes, and mixed layouts), we collected 617,000 transition tuples comprising linear/angular velocity commands, odometry telemetry, and rendered 64x64 depth frames.
In simulation, the trained RSSM achieved a held-out Structural Similarity Index (SSIM) of 0.815 and a Mean Squared Error (MSE) of 0.031 for multi-step predictive rollouts. Visual reconstructions accurately captured wall contours and closing distances over 10-step horizons.
In Research B, we deployed onto real hardware: a Unitree Go2 EDU quadruped. We collected approximately 10,800 real transitions across three distinct operational regimes: empty arena walking, obstacle navigation, and near-collision approach-back-turn recovery maneuvers. Under real sensor noise, camera pitch wobble, and floor reflectance, the model achieved a held-out real-world SSIM of 0.70.
Hybrid Cross-Entropy Planning vs Reactive PPO
To navigate using the world model, we developed a hybrid Cross-Entropy Method (CEM) trajectory optimizer. At every decision step, the planner samples 500 candidate action sequences over a 15-step planning horizon. Candidate trajectories are rolled out entirely within the RSSM’s latent imagination.
Each trajectory is scored using a composite cost function: rewarding forward progress toward the target waypoint, penalizing high angular jerk, and heavily penalizing latent states whose decoded depth maps indicate imminent collision.
The top 10% elite candidate trajectories are selected to refit the mean and variance of the action distribution over 3 optimization iterations. The first action of the converged distribution is dispatched to the robot’s low-level gait controller.
“Accurate visual prediction does not automatically translate into effective planning. Without collision-aware inductive biases, high SSIM scores can mask catastrophic closed-loop failures.”
The Sim-to-Real Reality Check & Proximity-Gating
One of the most valuable contributions of this research was an honest scientific post-mortem. When evaluating cross-domain performance, we observed a pronounced domain diagonal: models trained purely on simulation struggled to generalize to real Go2 trotting dynamics, and fine-tuning simulated weights on the 10.8K real dataset provided no statistically significant gain over training from scratch.
Furthermore, in closed-loop evaluation against a no-model heuristic control, raw visual imagination added only a modest +1.3 percentage point improvement in arrival rates. Decoded latent states sometimes smoothed out sharp obstacle edges, which is a serious problem for thin obstacles like chair legs.
To resolve this, we introduced a lightweight proximity-gating mechanism inspired by ChronoDreamer (Zhou & Negrut, 2025). When real-time time-of-flight depth signals detected an obstacle within critical braking distance, the planner dynamically overrode imaginary rollout optimism with deterministic repulsive braking. This hybrid safety gate boosted navigation success by an additional +2.0 percentage points and completely eliminated hardware collisions.
The main takeaway: world models have real potential for sample-efficient autonomous robotics, but real-world deployment requires coupling generative imagination with strict safety-critical geometric reflexes.