World Models: Three Research Programs Wearing One Name

Train a transformer on 91 million taxi rides through Manhattan and it will predict the next turn with near-perfect accuracy. Then reconstruct the street map implied by its predictions, and you get a city that does not exist: streets at physically impossible orientations, phantom flyovers vaulting across the grid, connections no car could drive. Reroute the model with detours and its navigation collapses. That experiment, from Vafa et al. at NeurIPS 2024, is the entire world models debate compressed into one result: sequence prediction can be nearly flawless while the model of the world behind it is incoherent.

"World models" is currently the most overloaded term in AI. It names a thirty-year-old idea from model-based reinforcement learning, a 2025-2026 product category of playable generated worlds, a billion-dollar bet that LLMs are a dead end, a live scientific dispute about what is inside an LLM, and, since June, an open-weights model family whose entire job is to play the environment. These are related but not the same thing, and most of the bad takes come from sliding between definitions mid-argument. This piece separates the three research programs sharing the name, spends the time the topic deserves on the language side (the one that matters most if you build with LLMs), and ends with the tests that distinguish a world model from a very good sequence model.

What a world model actually is

Strip away the branding and the definition is narrow: a world model is a learned function that predicts how an environment's state changes. Given the current state and an action, it returns the next state, and usually a reward estimate. It answers "what happens if I do X" without doing X. That distinguishes it from a policy (which answers "what should I do") and from a plain generative model (which answers "what typically comes next" with no commitment to a persistent, consistent state underneath).

The reason to want one has been stable since the model-based RL literature of the 1990s, and it comes down to three capabilities:

1. Sample efficiency. Real interactions are expensive (robot time, user sessions, API calls). A model of the environment lets the agent practice in simulation it carries in its own head.
2. Planning. With a transition function you can search: roll out candidate action sequences, score the imagined futures, pick the best. No transition function, no lookahead.
3. Counterfactuals. You can evaluate an action without executing it. For agents whose actions are irreversible (send the email, delete the record, submit the trade), this is the difference between deliberation and gambling.

The modern era of the idea starts with Ha and Schmidhuber's 2018 "World Models" paper: compress pixels into a small latent code with a VAE, learn the latent dynamics with a recurrent network, then train the controller entirely inside the learned model's own rollouts, "inside the dream," and transfer it back to the real environment. The line of work that grew from it matured into Danijar Hafner's Dreamer series, and DreamerV3 is the milestone worth knowing: published in Nature in 2025, it mastered over 150 control tasks with a single fixed configuration and became the first agent to collect diamonds in Minecraft from scratch, with no human demonstrations, by learning behaviors inside imagined rollouts of its own world model.

The loop looks like this:

Note what the loop is judged on. Not the prettiness of any reconstruction, but whether rollouts stay coherent enough, for long enough, that plans made inside the model survive contact with the real environment. Keep that criterion in mind; it is the one the marketing consistently drops.

One term, three research programs

By 2026 there are three distinct communities using the phrase, with different objectives, different artifacts, and different failure modes. Two of them are embodied; the third lives inside language models and gets its own section below.

Program one: latent dynamics models for control

This is the direct descendant of Dreamer, and its defining choice is where prediction happens: in representation space, not pixel space. The argument, made most insistently by Yann LeCun's JEPA line of work, is that most pixel-level detail is both unpredictable and irrelevant (which leaf flutters where), so a model that spends capacity rendering futures is wasting it. Predict the abstract state, skip the rendering.

The strongest published evidence for the approach is Meta's V-JEPA 2 (June 2025): a 1.2B-parameter video model self-supervised on over a million hours of video, extended into an action-conditioned variant (V-JEPA 2-AC) with only 62 hours of unlabeled robot data. The result that matters: deployed zero-shot on robot arms in labs it never saw, it planned pick-and-place by rolling out candidate actions inside its own latent model and reached 65-80% success on manipulation with novel objects. That is a real world model doing real model-predictive control, and its economics (62 hours of robot data on top of passive video) are the whole point.

The other headline planner result of the past year generates pixels rather than latents. Dreamer 4 (Hafner et al., September 2025) learned Minecraft's mechanics from a fixed corpus of gameplay video, then trained its policy entirely inside its own learned simulation, with no environment access at any point during training, and became the first agent to obtain diamonds from offline data alone; behavioral-cloning baselines given the same data get essentially zero. The unlock is speed as much as accuracy: a shortcut-forcing objective trains the model to produce good predictions in a small, fixed number of forward passes, which lets the simulator run in real time on a single GPU, which in turn is what makes practicing inside the model economically different from just playing the real game. Note the tension this creates with the JEPA argument: the two most striking agent results of the past year (Dreamer 4's diamonds, Genie 3's interactivity) both came from models that generate observations. Pixels versus latents is scaling-versus-inductive-bias transposed to world models, and it is genuinely unresolved.

The latent program also just became the most expensive conviction in AI. LeCun left Meta in late 2025 and founded AMI Labs on the explicit thesis that autoregressive LLMs will not reach general intelligence and JEPA-style world models will; the company raised a reported $1.03B seed round in March 2026. Whatever you think of the thesis, note the honest baseline: today's published wins for this program are short-horizon manipulation tasks at 65-80% success, in research settings. The bet is on the slope, not the current position.

Program two: generative world simulators

The second program keeps the pixels. Here the world model is the environment: a generative model you can step through with actions, rendering the consequences frame by frame. This is the branch that produced the demos everyone has seen.

Google DeepMind's Genie 3 (August 2025) is the reference point: from a text prompt it generates a navigable world at 720p and 24 frames per second in real time, holds it consistent for a few minutes, and accepts "promptable world events" (change the weather, add an object) mid-interaction. The consistency is the technically interesting part. Earlier interactive video models forgot what was behind the camera the moment you turned around; Genie 3 exhibits emergent object permanence over minutes, which is exactly the axis on which a video model becomes a world model. It remains a research preview, and the few-minutes horizon is the frontier, not a footnote.

Around it sits a rapidly commercializing category. World Labs (Fei-Fei Li's startup) shipped Marble in late 2025, generating persistent, exportable 3D environments, and takes the position that a world should be a spatial object you can edit and reuse, not a stream of frames. NVIDIA's Cosmos family (rolling out since January 2025) targets physical AI directly: open world foundation models used mainly to synthesize physics-plausible training data and to serve as evaluation environments for robot and driving policies. And the framing traces back to OpenAI's February 2024 Sora technical report, literally titled "Video generation models as world simulators."

Before crediting any of it, run the honest-baseline check: the alternative to a learned simulator is not nothing, it is the hand-built simulator (a game engine, MuJoCo, a driving sim like CARLA), which offers exact physics, unlimited horizon, and perfect state access. A learned world simulator earns its place only where hand-built ones cannot go: open-ended visual diversity, environments too expensive to model by hand, and behavior distributions scraped from the real world rather than authored. That is precisely the niche the synthetic-data and robot-evaluation use cases occupy, which is why they are the ones actually shipping.

The Sora title is also where the skepticism belongs. A video model is optimized for plausible pixels; a world model is accountable to consistent state. Those objectives overlap enough that scale keeps buying startling improvements (Genie 3's object permanence was not hand-engineered), and they diverge exactly where it hurts: learned physics is regularity, not law, so simulated dynamics drift, contacts glitch, and errors compound over rollout length. Which is why the honest description of what this program ships in 2026 is not "simulated reality" but two humbler products: synthetic data engines and agent training environments. Those are valuable. They are also evaluated on a much easier criterion than "plans made inside the model survive outside it."

Program three: the world models allegedly inside LLMs

The third program did not build a world model at all. It claims one comes free with language: train on enough text describing the world and the model induces an internal model of the world, because modeling the generator of the text is the cheapest way to predict it. Whether that claim is true, in what sense, and how you would know, is the most consequential version of the question for anyone shipping LLM systems. It deserves its own section.

Language world models

The stakes here are concrete, not philosophical. If an LLM maintains a coherent model of the situations it reads and writes about, then LLM agents can predict the consequences of their actions before taking them, and long-horizon reliability is a matter of harnessing what is already there. If it maintains a bag of local heuristics that merely imitate such a model, then every agent framework built on "the model understands the state" inherits a hidden fragility. The empirical record, honestly read, says: both, and the second part dominates exactly when it is most expensive.

The evidence that they form

The cleanest positive result is Othello-GPT (Li et al., ICLR 2023). Train a small GPT on nothing but Othello move sequences, no rules, no board, and probe its residual stream: the full board state is recoverable from the activations. Intervene on that internal representation (flip a square from the outside) and the model's predicted legal moves update to match the edited board. It was never asked to track a board; tracking the board turned out to be the efficient way to predict moves, so it learned to. Neel Nanda's follow-up sharpened the result: the representation is linear, provided you decode it in the frame the model actually uses ("mine vs. yours" rather than "black vs. white"), with probes exceeding 99% accuracy from mid-network onward, and the interventions remain causal.

This is not an isolated curiosity. Probing work on open models has found linear representations of geography and time (Gurnee and Tegmark's 2023 study recovered latitude, longitude, and dates from the Llama-2 models it examined, the standard open baseline of that period), and the broader mechanistic interpretability literature keeps finding structured, causally load-bearing state where "stochastic parrot" predicted none. Sequence prediction at scale demonstrably builds state representations nobody asked for. That much is settled.

The evidence that they are incoherent

Settled, and insufficient. The Manhattan taxi experiment that opened this piece (Vafa et al., "Evaluating the World Model Implicit in a Generative Model," NeurIPS 2024) is the strongest negative result precisely because it grants the positive one. The transformer trained on 91 million rides does build internal structure, and its next-turn predictions are almost always valid. But the authors did what probing studies usually do not: they reconstructed the entire world implied by the model's predictions and compared it to the true one. The recovered map is a fever dream of nonexistent streets and impossible geometry. And the incoherence is not cosmetic: introduce detours, forcing the model off the distribution of routes it memorized regularities from, and its routing ability falls apart. The model had learned an enormous pile of route-shaped heuristics that agree with the map almost everywhere while not containing the map.

The follow-up (Vafa et al., ICML 2025, "What Has a Foundation Model Found?") generalizes the method and the worry. The team trained sequence models on orbital trajectories; the models predict planetary motion with Kepler-grade accuracy. Then they asked the question that actually defines a world model: when adapted to new tasks from the same universe, does the model apply the underlying law? It does not. Asked to produce force vectors, the trajectory-perfect model outputs nonsense inconsistent with Newtonian mechanics, having fit task-specific heuristics instead of the physics. The authors call the diagnostic an inductive bias probe, and the framing is exact: Kepler predicted the planets without the law; Newton had the law. Sequence models keep turning out to be Keplers.

Read together, the two bodies of evidence are not in conflict. Small closed worlds with fully visible state (an 8x8 board) yield genuine, causal, even linear world models. Large open worlds sampled through narrow slices of behavior (rides through a city, trajectories without forces) yield fragments: locally excellent, globally inconsistent, and brittle precisely under the interventions and distribution shifts that planning requires. LLMs trained on the internet sit far toward the second regime. The right claim is not "LLMs have no world model" or "LLMs model the world." It is: LLMs contain partial, task-shaped state representations that degrade under intervention, and nothing in the training objective pushes them to become consistent.

Making the world model explicit

The interesting engineering response is to stop arguing about implicit world models and build explicit ones into the language stack. Three patterns are live.

Train on state transitions, not just text. Meta FAIR's Code World Model (CWM, September 2025) is the clearest instance: a 32B dense, open-weights model (research license) mid-trained on more than 120 million Python execution traces, sequences that pair each line of code with the interpreter's variable state after it runs, plus agentic interactions in containerized repos. The model is trained to predict what code does, not just what code looks like. It posts competitive coding results (65.8% on SWE-bench Verified, 68.6% on LiveCodeBench), but the benchmark line is the least interesting part. Code is the one domain where the world (the interpreter) provides unlimited, perfectly labeled state transitions for free, which makes it the natural first domain for language world models the way math was for reasoning models: the ground truth is checkable, so the world-modeling objective has teeth.

Use the LLM as the world model in an agent loop. If an LLM's situational model is partial but cheap, spend it where partial is enough: predicting outcomes before acting. The World-Model-Augmented web agent (ICLR 2025) trains an LLM to predict the state delta of a webpage (the price that will update, the panel that will appear) before the agent commits an action, and uses those simulated outcomes to select policies; it improves success on WebArena and Mind2Web without touching the base policy, and the paper's motivating observation is blunt: the 2024-era agent stacks it studied (built on GPT-4o and Claude 3.5 Sonnet) would repeatedly take actions like buying non-refundable items because nothing in the loop asked "and then what?" Parallel work (WebDreamer) frames the same move as model-based planning with the LLM as simulator. The bar here is refreshingly low. As a planner, a mediocre world model must merely beat no lookahead at all, and for irreversible actions, a veto that is right even 70% of the time changes the failure economics of the whole agent.

Train the model to be the environment. Qwen-AgentWorld (June 2026, Apache 2.0) inverts the stack entirely: instead of an agent with a better internal model, it is a model whose job is to play the environment. Given an agent's action (a tool call, a shell command, a tap on an Android screen), it predicts the observation the environment would return, reasoning through long chain-of-thought about what state the system must be in. It ships in two MoE configurations (35B-A3B and 397B-A17B, 256K context), trained in three stages on more than 10 million real interaction trajectories across seven digital domains: tool use (MCP), search, terminal, software engineering, Android, web, and OS. Why would anyone want this? Because the environment is the bottleneck in agent development: real sandboxes are slow, stateful, flaky, rate-limited, and expensive to reset, and the eval harness routinely costs more than the agent. A learned environment is the Dreamer move applied to digital agents: train and evaluate the policy inside the simulator, touch the real environment only to collect fresh trajectories and run final validation.

Treat the numbers with the standard discipline. Qwen's own benchmark (AgentWorldBench, a rubric scoring predicted observations on format, factuality, consistency, realism, and quality) puts its 397B variant first overall at 58.71, with the 35B variant gaining 8.66 points over its non-world-model base; a vendor's model winning a vendor's benchmark is a hypothesis, not a result. But notice what the absolute value says, because it is the more interesting fact: the best environment simulator anyone has measured scores 58.71 on its own maker's rubric. Nobody, including the people most motivated to claim otherwise, is claiming language world models are high-fidelity yet.

There is also a structural reason this arrived in terminals and browsers rather than kitchens. Digital environments have text-native state, logged transitions, and cheap verification: a shell session is a sequence of (state, action, observation) triples, and millions of them are already sitting in existing agent logs. That puts language world models on the favorable side of the Othello-versus-taxi divide (dense coverage of a bounded world), at least within each domain. Almost. The failure mode to watch is the one Dreamer-style training has always had, now wearing text: the policy exploits the simulator's errors. An agent trained against a learned environment that is 90% faithful will concentrate its behavior precisely in the 10% where the simulator is generous, because that is where imagined reward is easiest. In robotics this is the sim-to-real gap and everyone respects it; in agent land it will look like an agent that aces the simulated terminal and fumbles the real one, and the aggregate benchmark number will not tell you, for the same reason the taxi model's directions looked perfect until the detour. If you adopt a learned environment for agent training, the non-negotiable is a real-environment holdout: final numbers come from the actual sandbox, never from the model that generated the training experience, and the loop needs fresh real trajectories flowing in or it converges on its own artifacts.

Notice the shape of the three patterns. The first two take the world-model question out of the realm of probing debates and attach it to a checkable environment (an interpreter, a webpage). The third makes the environment itself the learned object, which is why its evaluation problem is the hardest of the three. That is the same lesson the RL program learned decades ago: a world model is not something you have; it is something an environment continuously grades.

There is also a quieter connection to the reasoning-model story. Test-time search (sampling candidate solutions, expanding partial plans) only converts compute into accuracy when something can score the candidates, and in the domains where reasoning models actually delivered (math, code), that something is an external checker: the unit test, the answer verifier. Squint and the verifier is playing exactly the role the transition model plays in Dreamer: the thing that tells you how the world responds before you commit. Seen from the world-models side, the reason inference-time scaling concentrated in verifiable domains is that those are the only domains where the language stack currently has access to a trustworthy world model, even if nobody calls it that. Extending those gains to open-ended tasks and language world models converging on reliable outcome prediction are, to a first approximation, the same problem.

How to tell a world model from a sequence model

Every program above eventually collides with the same evaluation problem, and it is the part most coverage skips. Demos select for generation fidelity; world models are defined by state coherence. The evaluation crisis playbook applies here with unusual force, because in this field the impressive number (next-token accuracy, video quality, a rubric score) is almost perfectly uncorrelated with the property being claimed. Four tests, all drawn from the work above, actually discriminate:

1. Probe for state, causally. Can the full environment state be decoded from internal activations, and does intervening on the representation change behavior coherently? (Othello-GPT passes; passing requires a small enough world to enumerate.)
2. Reconstruct the implied world. Aggregate the model's predictions into the world they collectively imply and diff it against ground truth. Near-perfect local prediction with a garbage global reconstruction is the taxi-map signature, and you will not see it unless you look.
3. Intervene and perturb. Detours, mid-rollout edits, counterfactual events. Genie 3's promptable world events and its object permanence are exactly this test applied to video; the detour collapse is the same test failed in language.
4. Transfer the law. Adapt the model to a new task from the same underlying world. If performance transfers through the governing structure (forces, the map, the rules), you have a world model; if the model refits fresh heuristics, you had a Kepler.

To these add the operational metric the control program has always used: rollout horizon, the number of steps before compounding error makes plans made inside the model worthless outside it. Genie 3's "a few minutes" is a horizon statement, and it is the most honest spec in the category.

What actually ships, and what is still a bet

Run the reality-gap filter over the field and 2026 sorts cleanly.

Shipping now. World models as data engines and evaluation environments: Cosmos-style synthetic data generation for robotics and driving, learned simulators for closed-loop policy testing, Genie-class environments positioned (explicitly, by DeepMind) as training grounds for embodied agents. World models as content: Marble sells generated 3D spaces today. And in language, the quiet, unglamorous wins: execution-trace training in code models, outcome prediction bolted onto agent loops, and now learned environments for agent training.

That last one is worth a pilot if you train agents for digital work, and the pilot is nearly free to run (Qwen-AgentWorld's 35B-A3B is Apache 2.0 and runs on owned hardware). The shape that respects the failure modes above:

1. Take one agent task family where you already have a real sandbox and an eval (say, terminal tasks).
2. Replay 50-100 of your existing logged trajectories through the world model: feed each recorded action, compare the predicted observation to the logged one. This calibrates simulator fidelity on your distribution before you trust it with anything.
3. If fidelity holds, use the simulated environment for the high-volume, low-stakes middle of the loop: rollout generation, regression sweeps, cheap A/Bs between agent versions.
4. Keep the real sandbox at both ends: fresh trajectories in, final evaluation out. Report only real-sandbox numbers.

Step 2 is the one teams skip and should not: it is a few hours of work, and it converts "the vendor says 58.71" into "on our tasks, the simulator matches logged reality N% of the time," which is the only fidelity number that matters for your decision. Simulator scores are training telemetry, not results.

Not shipping. An online world-model planner inside a mainstream product. Today's production LLM agents remain almost entirely model-free: act, observe, retry. The robotics results (V-JEPA 2-AC's 65-80% zero-shot manipulation) are genuine research milestones at reliability levels no product can absorb yet. And no deployed system yet closes the full Dreamer loop (learn the model online, plan in it, act, update) outside constrained research settings.

The bet. The billion-dollar positions (AMI Labs, DeepMind's framing of Genie as a step toward AGI, World Labs' spatial-intelligence thesis) share a premise this site has endorsed before: feedback-loop training is necessary but not sufficient, and grounding through world models is among the missing pieces. That premise looks right. It does not follow that any particular program gets there on any particular schedule, and the evidence pattern to date (clean wins in small closed worlds, fragments in large open ones) suggests the gap between a Kepler and a Newton does not close by scaling the Kepler.

For practitioners the pragmatic read is simpler than the discourse. You do not need to pick a side in the LeCun-vs-LLM fight to use what the field has already produced: cheap outcome prediction in front of irreversible agent actions, execution-grounded training where your domain has a checkable interpreter, learned environments for the cheap middle of the agent-training loop with real-sandbox holdouts at both ends, and the four tests above whenever a vendor slide says "world model" over a video reel.

Key Takeaways

1. A world model is a transition function, not a vibe: given state and action, predict the next state well enough that plans made inside the model survive the real environment. Judge every claimed world model against that criterion, not against generation quality.
2. Three research programs share the name: latent dynamics models for control (Dreamer, V-JEPA 2), generative world simulators (Genie 3, Cosmos, Marble), and world models in language (implicit maps inside LLMs, explicit ones like CWM and Qwen-AgentWorld). Arguments that slide between definitions produce most of the confusion.
3. The strongest existence proof is offline: Dreamer 4 learned Minecraft from a fixed video corpus, practiced entirely inside its own learned simulation, and obtained diamonds with zero environment access during training; behavioral-cloning baselines on the same data get essentially zero.
4. The evidence on LLMs is precisely split: Othello-GPT provably tracks board state (linear probes above 99%, causal interventions), while a transformer trained on 91M taxi rides predicts turns near-perfectly atop an incoherent map that collapses under detours. Dense coverage of small worlds yields real state; thin coverage of large worlds yields shortcut meshes.
5. The productive move is making the world model explicit: train on state transitions where the environment is checkable (CWM's 120M+ Python execution traces), or use the LLM to predict action outcomes before committing (WMA-style agents on WebArena/Mind2Web).
6. Language world models now include the environment itself: Qwen-AgentWorld (35B-A3B and 397B-A17B, Apache 2.0) simulates seven digital domains so agents can train against a learned environment. Agents exploit simulator errors, so calibrate fidelity on your own logged trajectories and keep real-sandbox holdouts at both ends; even the best self-reported score (58.71, on Qwen's own rubric) says fidelity is far from solved.
7. Evaluate with interventions, not demos: probe causally, reconstruct the implied world, perturb the rollout, and test whether structure transfers to new tasks. Rollout horizon (Genie 3: minutes) is the most honest spec in the category.
8. What ships in 2026 is data engines, eval environments, and agent lookahead, not online planners. V-JEPA 2's 65-80% zero-shot manipulation and Dreamer 4's offline diamonds are milestones, and milestones are not products; treat the AGI framing as a funded hypothesis, not a roadmap.