Imagining before acting
Before you pour boiling water from a kettle you have already imagined it: the arc of the stream, where it lands, how full the cup will get. You did not try it a hundred times. The model predictive controller of Model predictive control works the same way — at every step it imagines the next few seconds under candidate actions and picks the best — but its imagination is a model an engineer derived by hand: a pendulum, a bicycle, a rigid body with known inertia. Deformable cloth, a pile of grain, a kitchen full of objects, or the photons arriving at a camera do not come with tidy equations.
A world model is the learned alternative: a model of how the world responds to actions, fitted from data. The idea is old. Sutton's Dyna architecture (1990) learned a model and practised inside it; Deisenroth and Rasmussen's PILCO (2011) learned to swing up a real cart-pole in seconds of data with a Gaussian-process model. Since Ha and Schmidhuber's 2018 paper, simply titled "World Models", the phrase has grown to cover everything from a linear fit to a video generator with billions of parameters that can imagine a whole kitchen. By 2026 world models are used in robotics in four ways: to plan (as in MPC), to train policies in imagination (model-based reinforcement learning), to generate training data, and to evaluate policies before they touch hardware. This lesson builds the smallest complete example — a learned linear model and a sampling planner — and then surveys the large ones, honestly.
What a world model is
Definition— World model
A world model is a learned predictor of what an agent will observe next, given what it has observed and what it does. In its simplest form it is a dynamics model on a known state ; more generally it is a distribution over future observations (images, joint readings) and rewards , often computed through a compact latent state : an encoder , a latent transition , and heads that predict rewards and, optionally, decode images.
World models used in robotics in 2026 fall into four families:
| Family | Predicts | Examples | Typical use |
|---|---|---|---|
| State-space dynamics | next joint or object state | linear fits, Gaussian processes, PETS ensembles, TD-MPC2 | MPC, model-based RL on proprioceptive state |
| Latent world model | next latent state and reward, from images | PlaNet, Dreamer V1–V3 | training policies in imagination |
| Video world model | future video frames, given actions or text | UniSim, Genie 1–3, Cosmos, GAIA-1 and 2, Veo-based simulators | synthetic data, evaluation, interactive simulation |
| Representation-space predictor | future embeddings of video, not pixels | V-JEPA 2-AC | planning towards image goals |
Fitting a dynamics model from data
Start with the simplest case. Our robot is a puck on a low-friction table, pushed by two small thrusters: state , action , a step every 0.1 s. Its real dynamics have a thrust gain, a 10° misalignment between the thrusters and the table's axes, and linear plus quadratic drag — all unknown to the learner, which sees only transitions collected while pushing randomly.
We fit an affine model . Stacking the data as rows in a matrix and the next states in , the least-squares solution minimises and is (computed stably with lstsq, Linear algebra). This is ordinary system identification, the same tool control engineers have used for decades, and it is a world model.
import numpy as np
DT = 0.1
def true_step(s, a):
"""The real robot: a puck on a low-friction table pushed by two thrusters.
Unknown to the learner: thrust gain 1.5, a 10-degree misalignment, linear and quadratic drag."""
x, y, vx, vy = s
c, sn = np.cos(np.radians(10)), np.sin(np.radians(10))
ax, ay = 1.5 * (c * a[0] - sn * a[1]), 1.5 * (sn * a[0] + c * a[1])
speed = np.hypot(vx, vy)
vx += DT * (ax - 0.4 * vx - 0.3 * speed * vx)
vy += DT * (ay - 0.4 * vy - 0.3 * speed * vy)
return np.array([x + DT * vx, y + DT * vy, vx, vy])
# 1. Collect data: 40 episodes of 50 steps with random actions, as a robot might while exploring.
rng = np.random.default_rng(0)
S, A, S_next = [], [], []
for episode in range(40):
s = np.concatenate([rng.uniform(-1, 1, 2), rng.uniform(-0.5, 0.5, 2)])
for t in range(50):
a = rng.uniform(-1, 1, 2)
s2 = true_step(s, a)
S.append(s); A.append(a); S_next.append(s2 + rng.normal(0, 0.002, 4)) # sensors are a little noisy
s = s2
S, A, S_next = map(np.array, (S, A, S_next))
print(f"collected {len(S)} transitions")
# 2. Fit s' = A s + B a + c by least squares: one linear regression per state variable.
X = np.hstack([S, A, np.ones((len(S), 1))])
W, *_ = np.linalg.lstsq(X, S_next, rcond=None)
A_hat, B_hat = W[:4].T, W[4:6].T
np.set_printoptions(precision=3, suppress=True)
print("learned A:\n", A_hat)
print("learned B:\n", B_hat)
print("true B at low speed: 0.1 * 1.5 * R(10 deg) on the velocity rows:",
np.round(DT * 1.5 * np.array([[np.cos(np.radians(10)), -np.sin(np.radians(10))],
[np.sin(np.radians(10)), np.cos(np.radians(10))]]), 3).tolist())
def model_step(s, a):
return A_hat @ s + B_hat @ a + W[6]
# 3. How good is it? One step ahead, and many steps ahead without correction (open loop).
pred = X @ W
print(f"\none-step position error (RMS): {np.sqrt(np.mean((pred[:, :2] - S_next[:, :2]) ** 2)) * 1000:.1f} mm")
test_rng = np.random.default_rng(1)
errors = np.zeros(41)
for trial in range(50):
s_true = s_model = np.concatenate([test_rng.uniform(-1, 1, 2), np.zeros(2)])
for t in range(1, 41):
a = test_rng.uniform(-1, 1, 2)
s_true, s_model = true_step(s_true, a), model_step(s_model, a)
errors[t] += np.linalg.norm(s_true[:2] - s_model[:2]) / 50
for h in [1, 5, 10, 20, 40]:
print(f"open-loop rollout, {h:2d} steps ({h * DT:.1f} s): mean position error {errors[h] * 1000:6.1f} mm")The fit recovers the thrusters' gain and misalignment almost exactly: the velocity rows of match the true to three decimals. The velocity decay of 0.946 per step is a compromise between the linear drag (which alone would give 0.96) and the quadratic drag a linear model cannot represent. One step ahead, the error on the training data is 2.0 mm, essentially the sensor noise we added. Rolled forward without correction, the errors compound: 0.1 mm after one step, 3.8 mm after one second, 30 mm after four. Each prediction is fed the previous prediction, so small biases accumulate. Every world model, large or small, has this property; the question is only how fast it bites.
Planning with a learned model: random shooting
Gradient-based MPC needs a model you can differentiate and a cost you can optimise. Sampling-based MPC needs neither: sample many action sequences, imagine each with the model, keep the best, execute its first action on the real robot, observe, and repeat. The simplest version is random shooting.
Definition— Random-shooting MPC
At state : draw action sequences uniformly from the action bounds; roll each through the model, from ; score each with the cost ; apply for ; repeat at .
How many samples are enough? One fact makes random shooting easy to reason about.
Theorem— Best of K samples
If a fraction of all action sequences would be acceptable (cost below some threshold), and the sequences are drawn independently from the same distribution, the probability that the best of them is acceptable is .
Proof
The best sample fails to be acceptable only if every sample does. Each sample fails independently with probability , so all fail with probability .
∎
The catch is that shrinks with the horizon. If a plan is acceptable only when each of its steps lands in a good region of the action space covering a fraction of it, then roughly : exponentially small. Longer horizons see further but search a space of dimension with the same samples. Let us measure the trade on the puck, planning with the learned model but acting on the true system, from rest at the origin to a goal at m with a keep-out zone of radius 0.3 m centred exactly on the straight line between them.
import numpy as np
DT = 0.1
def true_step(s, a):
"""The real puck (as in the previous block), for one state or a batch; the learner never sees it."""
x, y, vx, vy = s[..., 0], s[..., 1], s[..., 2], s[..., 3]
c, sn = np.cos(np.radians(10)), np.sin(np.radians(10))
ax, ay = 1.5 * (c * a[..., 0] - sn * a[..., 1]), 1.5 * (sn * a[..., 0] + c * a[..., 1])
speed = np.hypot(vx, vy)
vx = vx + DT * (ax - 0.4 * vx - 0.3 * speed * vx)
vy = vy + DT * (ay - 0.4 * vy - 0.3 * speed * vy)
return np.stack([x + DT * vx, y + DT * vy, vx, vy], axis=-1)
# Learn a linear model from 2,000 random transitions (as before, condensed).
rng = np.random.default_rng(0)
rows, targets = [], []
for episode in range(40):
s = np.concatenate([rng.uniform(-1, 1, 2), rng.uniform(-0.5, 0.5, 2)])
for t in range(50):
a = rng.uniform(-1, 1, 2)
s2 = true_step(s, a)
rows.append(np.concatenate([s, a, [1.0]])); targets.append(s2 + rng.normal(0, 0.002, 4))
s = s2
W, *_ = np.linalg.lstsq(np.array(rows), np.array(targets), rcond=None)
learned_step = lambda s, a: np.concatenate([s, a, np.ones(s.shape[:-1] + (1,))], axis=-1) @ W
GOAL, ZONE, RADIUS = np.array([2.0, 1.0]), np.array([1.0, 0.5]), 0.3 # reach GOAL, keep out of ZONE
def plan_costs(step, s0, plans):
"""Roll K action sequences (K, H, 2) through a model, all at once, and score each."""
s = np.tile(s0, (len(plans), 1))
cost = np.zeros(len(plans))
for t in range(plans.shape[1]):
s = step(s, plans[:, t])
in_zone = np.linalg.norm(s[:, :2] - ZONE, axis=1) < RADIUS + 0.05
cost += np.sum((s[:, :2] - GOAL) ** 2, axis=1) + 0.01 * np.sum(plans[:, t] ** 2, axis=1) + 100.0 * in_zone
return cost
def run(step, K, H, seed, steps=60):
"""Random-shooting MPC: sample K plans, keep the best, execute its first action on the REAL puck."""
rng = np.random.default_rng(seed)
s, closest, reached = np.zeros(4), np.inf, None
for t in range(steps):
plans = rng.uniform(-1, 1, size=(K, H, 2))
a = plans[np.argmin(plan_costs(step, s, plans)), 0]
s = true_step(s, a)
closest = min(closest, np.linalg.norm(s[:2] - ZONE) - RADIUS)
if reached is None and np.linalg.norm(s[:2] - GOAL) < 0.1:
reached = (t + 1) * DT
return np.linalg.norm(s[:2] - GOAL), closest, reached
print("model K H final error closest to zone reached goal (of 5) mean time")
for name, step, K, H in [("learned", learned_step, 10, 15), ("learned", learned_step, 100, 15),
("learned", learned_step, 300, 15), ("true", true_step, 300, 15),
("learned", learned_step, 300, 5), ("learned", learned_step, 300, 30)]:
finals, gaps, times = zip(*(run(step, K, H, seed) for seed in range(5)))
ok = [t for t in times if t is not None]
print(f"{name:8s} {K:4d} {H:4d} {np.mean(finals) * 100:8.1f} cm {min(gaps) * 100:+10.1f} cm"
f" {len(ok):12d} {np.mean(ok) if ok else float('nan'):5.1f} s")Four findings. With only 10 samples the planner is erratic: one run of five never settles within 10 cm of the goal and another skims the zone by 8 mm. With 100–300 samples every run reaches the goal in about three seconds and keeps a margin of 5 cm. Planning with the learned model does as well as planning with the true one (3.0 s against 2.9 s), even though the learned model's open-loop error after 1.5 s is several millimetres: re-planning from the measured state every step is feedback, and feedback forgives model error. And with fixed, a horizon of 5 steps beats 15, which beats 30 — exactly the effect. A short horizon works here because the cost (distance to goal, plus the zone) is a good guide one second ahead; tasks whose payoff comes late need longer horizons and smarter search.
Practical planners keep random shooting's simplicity and fix its search. The cross-entropy method (used in PETS and in Meta's V-JEPA 2-AC) refits a Gaussian to the best few samples and resamples for several rounds; MPPI averages all samples weighted by ; predictive sampling in MuJoCo MPC perturbs the previous best plan instead of starting afresh. With a GPU and a good simulator or model, all of these run at hundreds of hertz.
Model-based reinforcement learning, in overview
Planning at every step is expensive when the model is a large network. The alternative is to use the model to train a policy, a fast network that acts without planning. Model-based reinforcement learning alternates three things: collect real experience with the current policy; fit the world model to all experience so far; improve the policy using imagined experience from the model (Reinforcement learning for robots covers the model-free algorithms it builds on).
The Dreamer line (Hafner and colleagues, 2019–2025) is the reference design. Its world model is a recurrent state-space model in latent space, trained to reconstruct images and predict rewards; an actor and a critic are then trained entirely on imagined latent trajectories a few seconds long, starting from real states. DreamerV3 used one set of hyperparameters across more than 150 tasks and was the first algorithm to collect diamonds in Minecraft from scratch; it appeared in Nature in 2025. On real hardware, DayDreamer (2022) trained a quadruped to roll off its back, stand up and walk from scratch in about an hour of real experience, with no simulator. Other strands: MBPO (2019) uses short model rollouts to augment a model-free learner, precisely to limit compounding error; TD-MPC2 (2023) learns a latent model without a decoder and plans with MPPI plus a learned value function, training one 317-million-parameter agent on 80 tasks; and DeepMind's MuZero (2019) learned a model good enough to plan with in Go, chess, shogi and Atari without being told the rules.
The appeal is sample efficiency: a model can extract more from each real interaction, which matters when real interactions cost robot hours. The cost is complexity and the risk that the policy learns to exploit the model's mistakes. In 2026 most deployed locomotion controllers are still trained model-free in a fast physics simulator — which is itself a hand-built world model — while learned world models dominate where no good simulator exists.
Video models as world simulators
Since 2023 a different kind of world model has appeared: video generators that predict future frames, conditioned on text or actions. OpenAI's 2024 report on Sora called video generation models "world simulators", and robotics labs took the idea literally.
- UniSim (UC Berkeley, Google DeepMind and MIT, 2023) trained one action-conditioned video model on a mix of robot, navigation and internet data and trained policies inside it that then worked on real robots.
- Genie (Google DeepMind, 2024), with 11 billion parameters, learned latent actions from unlabelled internet videos of 2D platform games, so that a user could "play" a generated world frame by frame. Genie 3 (August 2025) generates navigable 3D worlds in real time at 720p and 24 frames per second, staying consistent for a few minutes; DeepMind presents it as a training ground for agents and first released it only as a limited research preview.
- Cosmos (NVIDIA, January 2025) is a family of open-weight "world foundation models" trained on a very large curated video corpus: models that predict future video, models that turn coarse simulator renders into realistic video, and reasoning models about physical scenes.
- Driving has its own: Wayve's GAIA-1 (2023) and GAIA-2 generate driving scenes conditioned on the car's actions for training and testing (Autonomous vehicles).
- In China, ByteDance's GR-1 and GR-2 (2023–24) pretrained robot policies by first training them to predict future video frames; Genie Envisioner (2025) combines a video world model, an action decoder and a neural simulator in one platform.
They are used in robotics in three ways.
Data. NVIDIA's DreamGen (2025) fine-tunes a video model on a robot, prompts it to imagine the robot doing new tasks in new places, then recovers pseudo-actions from the generated videos with a latent-action or inverse-dynamics model. With teleoperation data for a single pick-and-place task in one environment, a humanoid learned 22 new behaviours. Video models are also used to restyle simulator images so that policies trained in simulation see realistic textures and lighting (Sim-to-real).
Evaluation. Real-robot trials are slow, and a policy's failures are what you most need to find. The Gemini Robotics team's Veo world simulator (December 2025) conditions Google's Veo video model on robot actions and on multiple camera views, edits scenes to add new objects, backgrounds and distractors, and reports that the simulated success rates predict the relative ranking of different policies in real trials, including on out-of-distribution and safety scenarios. Stanford and Tsinghua's Ctrl-World (2025), trained on the DROID dataset, does the same for open generalist policies. These are useful for ranking and for finding failure cases, not yet for certifying a policy.
Planning. Meta's V-JEPA 2 (June 2025) predicts in the embedding space of a video encoder rather than in pixels. Pretrained on over a million hours of internet video and then on under 62 hours of unlabelled robot video from DROID, its action-conditioned version planned pick-and-place motions towards goal images on Franka arms in two labs it had never seen, using the cross-entropy method — the same sampling idea as our puck planner, in a learned latent space. Physical Intelligence's π0.7 (April 2026) uses a small world model to propose subgoal images that steer its policy.
Limits: where learned models fail
Three limits recur across every family. Compounding error we have already measured. Physical plausibility: video models still make objects appear, vanish, interpenetrate or change shape, especially during contact, and an evaluation inside them inherits those errors. Knowing what you do not know: a model is only trustworthy near its training data, and the standard way to detect leaving it — an ensemble of models whose disagreement signals uncertainty, as in PETS — has a blind spot that the next experiment exposes. A cautious robot explores with small pushes only, so it never moves faster than about 0.4 m/s; we fit five linear models on bootstrap resamples of its data and test them at higher speeds.
import numpy as np
DT = 0.1
def true_step(s, a):
x, y, vx, vy = s[..., 0], s[..., 1], s[..., 2], s[..., 3]
c, sn = np.cos(np.radians(10)), np.sin(np.radians(10))
ax, ay = 1.5 * (c * a[..., 0] - sn * a[..., 1]), 1.5 * (sn * a[..., 0] + c * a[..., 1])
speed = np.hypot(vx, vy)
vx = vx + DT * (ax - 0.4 * vx - 0.3 * speed * vx)
vy = vy + DT * (ay - 0.4 * vy - 0.3 * speed * vy)
return np.stack([x + DT * vx, y + DT * vy, vx, vy], axis=-1)
# A cautious robot explores with small pushes only, so it never moves fast.
rng = np.random.default_rng(5)
n = 2000
S = np.concatenate([rng.uniform(-1, 1, (n, 2)), rng.uniform(-0.3, 0.3, (n, 2))], axis=1)
A = rng.uniform(-0.3, 0.3, (n, 2))
S2 = true_step(S, A) + rng.normal(0, 0.002, (n, 4))
X = np.hstack([S, A, np.ones((n, 1))])
print(f"training speeds up to {np.hypot(S[:, 2], S[:, 3]).max():.2f} m/s, pushes up to 0.3")
# An ensemble: five linear models, each fitted to a bootstrap resample of the data.
ensemble = []
for k in range(5):
idx = rng.integers(0, n, n)
W, *_ = np.linalg.lstsq(X[idx], S2[idx], rcond=None)
ensemble.append(W)
print("\n speed true velocity error ensemble spread error / spread")
test = np.random.default_rng(6)
for speed in [0.2, 0.5, 1.0, 2.0, 3.0]:
heading = test.uniform(0, 2 * np.pi, 500)
s = np.column_stack([test.uniform(-1, 1, (500, 2)), speed * np.cos(heading), speed * np.sin(heading)])
a = np.column_stack([np.cos(heading + 1), np.sin(heading + 1)]) # full-strength pushes
x = np.hstack([s, a, np.ones((500, 1))])
preds = np.stack([x @ W for W in ensemble]) # (5 models, 500, 4)
err = np.linalg.norm(preds.mean(0)[:, 2:] - true_step(s, a)[:, 2:], axis=1).mean()
spread = preds[:, :, 2:].std(axis=0).sum(axis=1).mean()
print(f"{speed:5.1f} {err * 1000:13.2f} mm/s {spread * 1000:9.2f} mm/s {err / spread:10.0f}")Inside the data (0.2 m/s) the ensemble's spread and the true error are within a factor of two of each other. At 3 m/s the true error has grown nearly three-hundredfold, to 0.24 m/s in a single 0.1 s step, while the spread has grown only about threefold: the error is now about 180 times the spread. The ensemble does notice that something is unusual, and a planner that penalises spread would stay slower and safer. But all five models share the same wrong assumption — that drag is linear — so they agree with each other while being wrong together. Disagreement measures what the data leaves undetermined, not what the model class cannot express. The same is true, less visibly, of video world models trained on similar data: they can be confidently and consistently wrong about physics they have rarely seen.
Other limits, as of 2026: cost (frontier video models need data-centre GPUs, far from a robot's real-time loop, which is why planning uses small models and big ones are used offline for data and evaluation); action fidelity (a generated video can look right while not matching the commanded action precisely); partial observability and memory (anything that leaves the camera view tends to be forgotten); and evidence (most reported correlations between world-model and real-world evaluation come from the labs that built the world models, on their own policies).
Common misconceptions
Misconception
"A model with a small one-step error is a good model for planning." Errors compound over a rollout; our puck model was accurate to 0.1 mm per step and off by 30 mm after four seconds. Evaluate a world model on multi-step rollouts at the horizon you will plan over.
Misconception
"If the video looks realistic, the physics is right." Visual realism and physical accuracy are different things. A generated grasp can look convincing while the object passes through a finger, and policies evaluated in such a world inherit its errors.
Misconception
"Random shooting is too crude to use." With re-planning at every step it is a strong baseline — here it matched planning with the true model — and its refinements (CEM, MPPI, predictive sampling) are used in research and industry. Its weakness is long horizons, where the number of samples needed grows exponentially.
Misconception
"An ensemble tells you how wrong the model is." It tells you where the models disagree. Outside the data, models built on the same wrong assumption can agree closely and all be wrong, as the last experiment showed.
Misconception
"World models will replace physics simulators." In 2026 they complement them: physics simulators remain the workhorse for locomotion and for anything that needs accurate contact forces, while learned world models cover visual realism, deformable and messy scenes, and evaluation at scale.
Exercises
1. World models
Warm-upHumanFor a reaching task, 2% of random action sequences would bring the gripper within tolerance of the target. A random-shooting planner draws independent sequences and keeps the best. What is the probability, in percent (to the nearest whole number), that the best one is within tolerance?
2. World models
CoreHumanSuppose a plan is acceptable only if each of its steps falls in a good half of the action space, independently ( per step), so a random plan is acceptable with probability . What is the smallest number of samples that gives at least a 50% chance that the best sampled plan is acceptable?
3. World models
CoreHumanIn the lesson, the learned linear model drifted by about 30 mm over a 4 s open-loop rollout, yet random-shooting MPC with it reached the goal as quickly as MPC with the true model. What is the main reason?
4. World models
CoreHumanFive dynamics models are fitted to bootstrap resamples of the same data. At a state far outside the data, their predictions agree closely. What can you conclude?
5. World models
CoreHumanWhich of these uses of video and latent world models in robotics are reported in published work as of 2026? Select all that apply.
6. World models
CoreComputationalWrite fit_dynamics(S, A, S_next), which fits the affine model by least squares and returns the weight matrix W of shape (n + m + 1, n) such that np.hstack([s, a, 1]) @ W predicts (state dimension , action dimension ). Also write predict(W, s, a) for a single state and action.
7. World models
StretchComputationalWrite shoot(model, cost, s0, K, H, low, high, rng) for random-shooting MPC. Draw K action sequences of length H uniformly from [low, high] (arrays of the action's shape) using rng.uniform, roll each through model(s, a) starting from s0, sum cost(s_next, a) over the steps, and return the first action of the cheapest sequence.
Further reading and resources
- World Models · Ha and Schmidhuber · 2018
- Neural Network Dynamics for Model-Based Deep Reinforcement Learning with Model-Free Fine-Tuning · Nagabandi et al. · 2017Random-shooting MPC with a learned neural dynamics model.
- Deep Reinforcement Learning in a Handful of Trials using Probabilistic Dynamics Models · Chua et al. · 2018PETS, with ensembles and the cross-entropy method.
- Learning Latent Dynamics for Planning from Pixels · Hafner et al. · 2018PlaNet.
- Mastering diverse control tasks through world models · Hafner et al. · 2025DreamerV3 in Nature; preprint at arXiv 2301.04104.
- DreamerV3 code · Danijar Hafner
- DayDreamer: World Models for Physical Robot Learning · Wu et al. · 2022
- When to Trust Your Model: Model-Based Policy Optimization · Janner et al. · 2019
- Mastering Atari, Go, Chess and Shogi by Planning with a Learned Model · Schrittwieser et al. · 2019MuZero.
- TD-MPC2: Scalable, Robust World Models for Continuous Control · Hansen, Su, Wang · 2023
- Predictive Sampling: Real-time Behaviour Synthesis with MuJoCo · Howell et al. · 2022
- Genie: Generative Interactive Environments · Bruce et al. (Google DeepMind) · 2024
- Genie 3: A new frontier for world models · Google DeepMind · 2025
- Video generation models as world simulators · OpenAI · 2024
- Cosmos World Foundation Model Platform for Physical AI · NVIDIA · 2025
- Learning Interactive Real-World Simulators · Yang et al. · 2023UniSim.
- Introducing GAIA-1 · Wayve · 2023
- GR-2: A Generative Video-Language-Action Model with Web-Scale Knowledge for Robot Manipulation · ByteDance Research · 2024
- V-JEPA 2: Self-Supervised Video Models Enable Understanding, Prediction and Planning · Assran et al. (Meta FAIR) · 2025
- DreamGen: Unlocking Generalization in Robot Learning through Video World Models · NVIDIA · 2025
- Evaluating Gemini Robotics Policies in a Veo World Simulator · Gemini Robotics Team (Google DeepMind) · 2025
- Ctrl-World: A Controllable Generative World Model for Robot Manipulation · Guo et al. · 2025
- Genie Envisioner: A Unified World Foundation Platform for Robotic Manipulation · Liao et al. · 2025