In March 2026, Yann LeCun was reported as saying that the LLM revolution is over and that physical AI is next. The reporting I have seen is a short paraphrase rather than a transcript, so what follows treats the reasoning as attributed rather than verbatim, and any caveats he offered in the room are not available to me. Most coverage read the remark as a forecast about which architecture wins the next cycle. As a forecast it is one prediction among many, and it should be discounted accordingly.
The reasoning underneath it is more interesting than the timeline, and also more vulnerable.
The claim as reported
The argument attributed to LeCun holds that you cannot guarantee an LLM's behavior from training data, because it is trained on a vanishingly small subset of all possible prompts. The input space of natural language is effectively unbounded. Any corpus, however large, samples a sliver of it, and evaluation on that sliver says nothing definite about the rest.
The proposed alternative is objective-driven AI: systems with an explicit world model, explicit goals, and a planning step. The safety property claimed for this design, as reported, is auditability. Behavior can be checked against a stated objective, and the objective is a written artifact you can read, test, and argue about.
That contrast is doing most of the work, so it is worth being precise about the other side of it. In a pure next-token predictor, the nearest thing to a specification is a conditional distribution over tokens, and it fails as an auditable object for three separate reasons. It is high-dimensional and defined pointwise over inputs, so there is no compact form to read. It is not stationary with respect to phrasing, so a check that passes on one wording gives you little about a paraphrase. And it has no separable component that corresponds to intent, so there is nothing to point at and say: this is the goal, and here is where it is encoded. An objective function fails none of those three tests. That is the real content of the explicit-versus-implicit distinction, and it survives without any commitment to world models.
The inversion
The dominant reading of the critique is architectural: LLMs are the wrong substrate, so build a different substrate. But the load-bearing part concerns whether a system's specification is written down anywhere. A world model with an explicit objective function is auditable because of the objective function, not because of the world model, and that property is neither exclusive to LeCun's preferred architecture nor guaranteed by it.
Which cuts in both directions.
It cuts against the scaling position, because "we evaluated it on a lot of prompts" is not a specification, and no benchmark suite closes the gap between a sampled input distribution and an unbounded one. I want to be careful about how strong that inference is. Coverage of an unbounded space is straightforwardly impossible. Getting from there to "therefore no behavioral guarantees" requires a further assumption: that no generalization argument can substitute for coverage. That assumption is doing real work and it is not obviously true. Statistical learning theory produces bounds without exhaustive coverage all the time, under distributional assumptions that adversarial or long-tail prompts violate. So the defensible version of the claim is narrower: absent a generalization argument that holds under distribution shift, more parameters do not convert evaluation coverage into a guarantee. Nobody has produced such an argument for open-ended language input. That is a real limit rather than a bookkeeping complaint, but it rests on a premise worth naming.
It also cuts against the objective-driven position, harder than its advocates usually acknowledge. An objective function is auditable only if it is faithful. A learned world model with an explicit reward term is still a learned world model. You have moved the unverified part from "what will it say" to "does its internal model of the world match the world, and does the written objective capture what we wanted." Specification gaming is the standing illustration: the boat-race agent in OpenAI's CoastRunners experiment maximized score by circling a lagoon collecting powerups instead of finishing the course, an explicit objective satisfied exactly as written and not at all as intended. Writing the goal down makes it inspectable. It does not make it correct.
So the honest version is narrower than "objective-driven AI is safer." Objective-driven architectures relocate the verification problem to a place where you can at least state what you are trying to verify. The framing as reported reads stronger than the reasoning supports.
The objection I have to answer
Here is where I have to apply the same knife to my own position, because the argument above has an obvious turn against it.
The unbounded-input-space problem applies to any learned component. If it disqualifies a model that emits API calls, it also disqualifies a model that parses human intent into structured intent, and I am about to propose a design that leaves exactly that component unverified. Saying "the constraint layer carries the guarantees" is a relocation of the problem, which is the precise criticism I just made of objective-driven AI. If relocation is not a resolution there, it is not a resolution here either.
What distinguishes the cases is what you get in exchange. Moving the guarantee into a hard constraint layer buys you a component whose specification is small, whose input space is structured, and whose failure modes are analyzable by ordinary software methods. Moving the guarantee into a learned world model buys you a component whose specification is written down but whose fidelity to the world is exactly as unverified as the language model was. The first trade narrows what remains unchecked. The second renames it. That is a difference of degree, and I would rather state it as a difference of degree than pretend it is a difference of kind.
What you do not get, in either case, is a guarantee about the intent-parsing step. If a user says "book me something cheap in the first week of June" and the model resolves that into a booking that satisfies every constraint but is not what the user meant, the constraint layer will not catch it. The guarantee covers the blast radius, not the correctness of intent. Anyone selling it as more than that is overselling.
Where this lands in practice
With that concession on the record, the practical implication is that the language model stops being the thing you verify. Nobody has to stop building with language models.
Consider a system that books travel. If the whole system is a model that emits API calls from a prompt, the safety story is evaluation coverage: you tested a few thousand scenarios and it behaved. You have no argument about the scenarios you did not test. Now add a constraint layer that rejects any booking over a spend limit, outside an allowed date range, or to a destination not on an approved list. The layer is small enough to read and test directly. Its behavior is analyzable rather than exhaustively enumerable, and the distinction matters: a spend limit over continuous amounts has infinitely many inputs, but it has one boundary, and boundary analysis is a tractable exercise in a way that probing a language model's behavior across paraphrases is not.
The model still does the hard part, turning messy human intent into structured intent. The constraint layer bounds what a mistake there can cost. Nothing about that arrangement requires a world model in LeCun's sense.
As a proposed design principle rather than one derived from the example: put the guarantees you need outside the component you cannot verify, and be explicit about which guarantees that leaves you without.
The same shape appears in code agents, where the sandbox boundary and the permission set carry the safety argument. A filesystem sandbox with no network egress and a read-only mount of everything outside a scratch directory gives you a claim about what the agent cannot do, independent of what it decides to do. The operating system enforces that claim, not the model's judgment, and it holds under prompt injection, which is precisely the case where the model's judgment is compromised.
A counterexample is worth naming, because the pattern is easy to overapply. Requiring citations in a retrieval system looks structural, and it buys you very little. A citation requirement constrains format. It does not constrain whether the cited passage supports the claim, and a model can satisfy it while attributing a fabricated assertion to a real document. The structural version of that guarantee would be verified entailment between claim and source, which is a much harder component to build and is itself usually a learned model. A structural constraint is worth only as much as the property it actually pins down.
I believe this is roughly what teams settle on after enough production incidents, but that is an impression from patterns I have seen described rather than a measured finding, and I would not lean on it.
What would move me
The scaling side has a counter that deserves stating. If capability improvements make models reliably follow explicit constraints given in natural language, the explicit specification exists and is simply enforced probabilistically rather than structurally. That is weaker than a hard constraint, and for some risk tolerances it may be enough. Whether instruction-following reliability is on a trajectory to get there is an empirical question I do not think is settled.
The stronger version of the objective-driven claim would need to show that a learned world model can be verified against reality in some meaningful way, beyond having a goal slot. Concretely, I would want to see a held-out test of predictive fidelity on interventions the model was not trained on, with a bound on prediction error that transfers to the planning domain. If that arrives, the argument changes shape.
The durable part
Strip out the architectural forecast and what remains is this: you cannot get behavioral guarantees from evaluation coverage over an unbounded input space, absent a generalization argument nobody has produced for open-ended language. That is a claim about verification, and it holds regardless of which architecture wins.
The response is to notice which parts of a system carry guarantees, move those parts somewhere checkable, and be candid that what remains uncheckable does not become safe by being surrounded.
On the timeline claim itself, that the revolution is over: treat it as advocacy. The verification argument does not depend on the timeline being right, which is the main reason it is the part worth keeping.