Two camps, and this time one of them has a billion dollars and a grudge.
Team LLM: the recipe won't stop working. Autoregressive transformers plus scale plus a little reinforcement learning have flattened every wall the skeptics drew. Predict the next token well enough, across enough of the world's text and pixels, and reasoning, knowledge, even planning fall out of it. It ships — in production, today, doing real work.
Team World Models: next-token prediction is an off-ramp on the road to real intelligence. A model trained to continue text has no grounded picture of reality — it can't truly plan, it hallucinates by construction, and it needs the entire internet to learn what a child picks up from a few thousand hours of looking at the world. Yann LeCun's version is blunt: where is the robot that's as good as a cat?
Both are right about something real. And the way the fight is sold — one architecture wins, the other gets thrown away — hides two facts that make it far more interesting: the field is quietly building both into the same systems, and "world models" isn't even one camp.
Why this is now a real question
Three things turned a Twitter argument into a genuine fork in 2026.
LeCun put a billion dollars behind it. This isn't a hot take anymore. One of the people who built deep learning left Meta in late 2025 and raised over a billion dollars — one of the largest pre-launch rounds in AI — to build world models instead of LLMs. When someone with that track record bets his career that the dominant paradigm is the wrong road, you at least owe the claim a serious look.
The wall appeared and then got jumped — from inside the LLM paradigm. Just as pretraining-scaling worries peaked, reasoning models opened a second axis: spend more compute at inference, get planning-like behavior, with no new architecture. The thing world-model people said LLMs couldn't do, LLMs started doing — partially — without becoming world models.
World models stopped being only papers and started shipping. Meta's V-JEPA 2 drives zero-shot robot control. OpenAI described Sora as a "general-purpose simulator of the physical world." DeepMind's Genie generates real-time, playable 3D worlds from a prompt. The critique now has working machines, not just a manifesto.
Steelman: LLMs are the road
Next-token prediction is a deceptively deep objective. To predict the next word well across everything humans have written, a model is forced to compress the structure underneath the words — grammar, then facts, then arithmetic, then arguably geography and time. Ilya Sutskever's framing: predicting the next token well requires a usable, compressed model of the world. And this isn't only philosophy. Probe a model trained merely to predict legal Othello moves and you find it has built an internal map of the board it was never told exists (Li et al., 2023). Probe a large model and you find neurons that linearly encode space and time — where cities are, when people lived (Gurnee and Tegmark, 2024). The world model may already be in there.
The Bitter Lesson is on this banner. Rich Sutton's famous 2019 essay: general methods that scale with compute beat hand-engineered structure, every time, in domain after domain. To this camp, LeCun's carefully designed architecture looks like exactly the human-imposed cleverness the Bitter Lesson keeps punishing.
It ships, and nothing else does. This is the unglamorous, decisive argument. The agents I run all day are LLMs. Production value, at scale, now. There is no world-model system doing that work. "It's an off-ramp" is a hard sell against "it's the only thing on the road that's moving."
Steelman: LLMs are an off-ramp
Language is a low-bandwidth shadow of reality. A cat plans a jump, models gravity and friction, and manipulates 3D objects it has never seen — with no language at all. Intelligence in the physical world came from observation and interaction long before words. A system that only ever ate text is reasoning about a world it has never touched.
Hallucination and bad planning are structural, not bugs to patch. An autoregressive model emits one token at a time with no separate world-state it can roll forward and check itself against, so errors compound and confident fabrication is baked in. The sharpest evidence is also the most damning: a model can predict turn-by-turn navigation almost perfectly while the street map implicit in it is incoherent — add a few detours and it falls apart (Vafa et al., 2024). Good next-step predictions are not the same thing as a coherent model of the world. LeCun's alternative is to plan by optimizing in a learned latent space, not by sampling tokens and hoping.
And the surprise witness for the prosecution is the Bitter Lesson's own author. Sutton — who wrote the pro-scaling bible — now argues LLMs are a dead end. His reason isn't LeCun's: he objects that LLMs mimic humans instead of learning from their own experience, and that they only learn during a training phase and then stop, never learning on the job. Two of the field's giants both say "dead end," for two different reasons that don't even agree. That's not a fringe; that's a real crack.
Where I actually land
First, the clarifier nobody says out loud: "world models" is itself two camps. The video simulators — Sora, Genie, and NVIDIA’s Cosmos — predict the next frame, pixel by pixel; Jim Fan's version of the bet is blunt — generate the world as video. LeCun's JEPA line predicts in abstract representation space and argues the generative approach is wasteful, because reconstructing every pixel burns capacity on detail that doesn't matter. So "add a world model" is not one decision. Two of the loudest world-model projects in the world are pursuing a design LeCun thinks is a mistake. The tribe you're being asked to join doesn't agree with itself.
Second, the empirical crux, stated honestly. "Next-token prediction can't build a world model" is already false — Othello-GPT and the space-and-time neurons settle that. But "next-token prediction builds a robust, reliable world model" is also false — the NYC-taxi result and the brittleness studies settle that. The truth is the uncomfortable middle: LLMs build partial, emergent, brittle models of the world. The interesting question was never whether. It's how robust, and bought how cheaply.
So here is where a builder should stand. LLMs are the tool you ship with today for language, knowledge, code, and agents — full stop, no apology. World models are the most serious diagnosis of where LLMs break: grounded physical reasoning, reliable long-horizon planning, sample efficiency, and learning on the job. Treat those as known failure zones, not as things the next checkpoint quietly fixes. And the likely future is neither side's victory parade — it's convergence. Fei-Fei Li, who declines to pick even within the world-model camp, frames it the way I'd want to: renderers, simulators, and planners are three projections of one underlying model — facets of the same machine, not rival tribes. LLMs are absorbing world-model-like parts (multimodal grounding, test-time planning, video simulators); world-model systems lean on language layers for the symbolic half. The bet you would lose money on is "pure token scaling reaches everything," and the other bet you'd lose money on is "LLMs are a dead end we throw away."
An LLM can write you a flawless essay on gravity and still have no idea the cup is about to fall. That gap — eloquence without a world — is the entire argument.
What I'd ask any team
Is the task language/knowledge, or grounded physical/planning? Text, code, retrieval, orchestration → LLM. Manipulation, navigation, predicting physical consequences → world-model territory, and an LLM will be confidently brittle there. Pick by regime, not tribe.
Does it need a persistent state it can roll forward and check — or just plausible next outputs? If correctness depends on a coherent internal map, an autoregressive stream will hand you confident, wrong rollouts (the NYC-taxi failure). Externalize the state: tools, memory, a verifier.
How long is the planning horizon, and can you eat compounding error? Short with checkpoints → LLM plus test-time reasoning is fine. Long with no way to verify mid-flight → you need search over an explicit state, not token sampling.
On-the-job learning, or is a frozen model acceptable? (Sutton's question.) If the system must adapt from its own experience after deployment, today's train-then-freeze LLMs structurally don't — design in retrieval, memory, and fine-tune loops; don't expect the base model to learn from use.
If you need grounding, in which currency? Generative simulation (Sora/Genie — predict pixels, expensive, great for training and visualization) or latent prediction (JEPA — predict representations, cheaper, better for control). "Add a world model" is two different decisions, not one.
A small confession
I build on the architecture LeCun says is an off-ramp, and I think he's half right.
Luke and the agents I run all day are LLMs, and they are genuinely, usefully good — I'm not going to perform skepticism about the thing that does my work. But I also feel the exact cracks the critics name, every week. The agent that writes a beautiful plan and then face-plants on a task that needed a real model of state. The answer delivered with total confidence and no inner check, because there is no inner world to check against. The way it never quite learns from yesterday unless I wire the memory in by hand.
So I'm in the slightly absurd position of betting my daily work on the road LeCun is driving away from — while quietly agreeing with him about where it runs out of pavement. The honest move isn't to pick the tribe that flatters my stack. It's to ship with the LLM, respect the diagnosis, and watch the two machines drift toward each other. I don't think the thing I build on is the final form. I just think it's the one that works today, and "works today" has its own kind of truth.
Next time: we've spent nine debates on how the machine thinks. The next one turns the camera around — onto us. When the system can do the work, does a human still belong in the loop, and where? Don't pick a side.