PROLOGUE: A QUESTION THE FIELD CAN NO LONGER AVOID
There is a question that has been building pressure in the AI research community for several years, and in 2026 it has finally become impossible to sidestep: when an AI agent acts in the world, does it understand what it is doing? Not in a philosophical sense, but in a precise, engineering sense. Does it have an internal model of the environment that it can use to simulate the consequences of its actions before committing to them? Or is it, at bottom, a very sophisticated pattern-matcher that generates plausible-sounding action sequences without any genuine predictive model of what will happen next?
The answer, for the vast majority of AI agents deployed in production today, is the latter. And the consequences of that architectural gap are becoming visible in enterprise deployments at scale. Agents fail on multi-step tasks. They commit to irreversible actions without checking downstream consequences. They hallucinate tool outputs. They loop. They produce plans that are syntactically coherent and semantically empty.
Into this gap steps JEPA -- Joint Embedding Predictive Architecture -- a research direction pioneered by Yann LeCun and his collaborators at Meta AI, and now the subject of intense theoretical and empirical investigation. The central claim of the JEPA research program is that the right way to build a world model for an intelligent agent is not to predict future observations in raw sensory detail, but to predict future states in an abstract, learned embedding space. This claim has been building empirical support since 2023, and the theoretical questions surrounding it -- can JEPA provably recover the hidden causal structure of an environment? -- represent one of the most active frontiers in the theory of self-supervised learning as of August 2026.
This article examines JEPA from the ground up: what it is, how it works, where it stands in the research landscape, and whether the excitement surrounding it as a foundation for agentic AI is justified. The answer requires genuine technical depth, honest acknowledgment of what is proven versus what is hoped, and a clear-eyed look at the gap between research results and production reality.
CHAPTER ONE: THE WORLD THAT AGENTS DO NOT UNDERSTAND
Before we talk about JEPA, we need to talk about the problem it is meant to solve. And to do that, we need to be honest about what current AI agents actually are, and what they are not.
The dominant paradigm for AI agents today is the LLM-as-brain model. You take a large language model -- GPT-5.6, Claude 5.0 Sonnet, Gemini 3.1 Pro, Llama 4 -- and you give it tools: a web search function, a code execution environment, a database query interface, an email client. You wrap it in a loop that asks it to plan, act, observe, and repeat. The LLM reasons in natural language, generates a plan as text, calls a tool, reads the result as text, and continues. This architecture has real strengths. These models have absorbed enormous amounts of human knowledge. They can reason about complex situations in language. They can generalize across domains in ways that earlier AI systems could not.
But there is a structural problem at the heart of this approach, and it is not a problem that more parameters or better training data will fix. The problem is that LLMs model the world token by token, in observation space. When an LLM "plans," it is generating text that describes a plan. It is not simulating the world. It is not predicting future states. It is producing the most statistically likely sequence of tokens given its training distribution. This is a profoundly different thing from planning, and the difference matters enormously when the stakes are high.
Consider a concrete example. Suppose an LLM-based agent is asked to refactor a large codebase. It generates a plan: rename this function, update these imports, modify this interface. It executes step one. The world changes. It executes step two. The world changes again. At no point does the agent have a model of what the codebase will look like after all steps are complete. It cannot simulate the final state and check whether it is correct before committing. It cannot detect, at planning time, that step three will break something that step one introduced. It is flying blind, one token at a time, hoping that the statistical patterns it learned during training will carry it through.
This failure mode is not hypothetical. It is the dominant failure mode of production AI agents in 2026, consistently reported across enterprise deployments in software engineering, supply chain management, and document processing. The agents are reactive rather than predictive. They discover the consequences of their actions by taking them, rather than by simulating them in advance.
This is the problem that JEPA is designed to address. Not as a replacement for language models, but as the missing layer beneath them: a world model that can simulate future states in a compact, abstract representation, enabling agents to plan before they act.
CHAPTER TWO: WHAT JEPA ACTUALLY IS
The name Joint Embedding Predictive Architecture was coined by Yann LeCun and his collaborators at Meta AI. To understand what it means, it helps to contrast it with what came before.
The dominant paradigm in self-supervised learning, before JEPA, was reconstruction. You take an input -- an image, a video frame, a sentence -- mask part of it, and train a neural network to reconstruct the masked part. Masked Autoencoders (MAE) do this for images. BERT does it for text. The idea is that if you can reconstruct the missing piece, you must have learned something meaningful about the structure of the data.
This approach works. It produces useful representations. But it has a fundamental inefficiency: it requires the model to predict every detail of the masked region, including details that are completely irrelevant to any downstream task. If you mask a patch of sky in an image and ask the model to reconstruct it, the model must predict the exact color of every pixel -- the precise shade of blue, the exact position of every cloud wisp. But for almost any task you might care about -- object recognition, scene understanding, planning -- none of those details matter. What matters is that it is sky, that it is daytime, that the weather appears clear.
JEPA takes a different approach. Instead of predicting in observation space -- the space of pixels, tokens, or raw sensory data -- it predicts in embedding space. The architecture has three components: a context encoder, a target encoder, and a predictor.
The context encoder takes the visible portion of the input and produces a representation -- a vector in some high-dimensional embedding space. The target encoder takes the masked or future portion of the input and produces its own representation. The predictor then takes the context representation and tries to predict the target representation. The training signal is the difference between the predictor's output and the target encoder's output, measured in embedding space.
The crucial insight is what this means for what the model has to learn. Because the prediction target is an embedding rather than raw pixels, the model is not forced to predict irrelevant low-level details. The embedding can be -- and with the right training procedure, will be -- a compact, abstract representation that captures only the structure that is predictable and meaningful. The model learns to predict what will happen at the level of concepts and structure, not at the level of pixels and tokens.
There is a technical challenge lurking here, and it is worth understanding because it is central to why JEPA is hard to get right. If the model can freely choose what the embeddings represent, nothing prevents it from finding a trivial solution: map every input to the same embedding. Then the prediction error is always zero, because the context embedding and the target embedding are always identical. This is called representation collapse, and it is the nemesis of joint embedding methods.
JEPA addresses this through the target encoder design. Rather than training the target encoder directly with gradient descent, it is updated as an exponential moving average of the context encoder's weights. This creates a slowly-moving target that the predictor must chase, preventing the trivial collapse solution. The technique is related to momentum contrast (MoCo) and BYOL, but JEPA applies it in the context of a predictive architecture rather than a contrastive one. The original I-JEPA paper (Assran et al., arXiv:2301.08243, CVPR 2023) establishes this design and demonstrates its effectiveness.
Let us look at the architecture through the image case (I-JEPA) as the clearest example.
SHOWCASE 1: The I-JEPA Architecture in Action
Imagine an image of a kitchen. I-JEPA divides this image into a grid of patches, like a checkerboard. Some patches are designated as "context" -- the model can see them. Others are designated as "target" -- the model must predict their representations.
INPUT IMAGE (kitchen scene)
+-----------------------------------------+
| [ctx] [ctx] [TGT] [ctx] [TGT] [ctx] |
| [ctx] [TGT] [ctx] [TGT] [ctx] [ctx] |
| [TGT] [ctx] [ctx] [ctx] [TGT] [ctx] |
| [ctx] [ctx] [TGT] [ctx] [ctx] [TGT] |
+-----------------------------------------+
ctx = context patch (visible)
TGT = target patch (masked, must be predicted)
CONTEXT ENCODER (ViT)
Takes all [ctx] patches, produces context embeddings.
TARGET ENCODER (EMA of context encoder weights)
Takes all [TGT] patches, produces target embeddings.
(These are the "ground truth" the predictor must match.)
PREDICTOR (lightweight transformer)
Input: context embeddings + positional info about TGT locations
Output: predicted embeddings for each TGT location
TRAINING SIGNAL:
Minimize distance between predicted embeddings and target embeddings.
NOT between predicted pixels and actual pixels.
WHAT THE MODEL LEARNS:
"The region above the stove probably contains a range hood or
cabinets" -- not "the exact RGB values of those pixels."
This distinction -- predicting abstract structure rather than concrete details -- is what makes JEPA interesting for world modeling. A world model for an agent does not need to predict exactly what the screen will look like after an action. It needs to predict what will have changed in a meaningful sense: which objects moved, which goals were advanced, which constraints were violated. JEPA's embedding-space prediction is naturally aligned with this requirement in a way that pixel-space reconstruction is not.
The extension from images to video is called V-JEPA, developed by Bardes and colleagues at Meta AI and released in 2024. V-JEPA extends the same principle to spatiotemporal blocks: instead of masking spatial patches in a single image, it masks blocks of frames across time. The model must predict the embedding of future video frames given the embeddings of past frames. This is, in essence, a world model: given what has happened, predict what will happen next, at the level of abstract structure rather than pixel-by-pixel detail. V-JEPA 2, released in 2025, extended this further with action conditioning and improved temporal modeling, enabling the model to predict not just what will happen, but what will happen given a specific action -- the minimal capability required for planning.
The V-JEPA line of work demonstrates strong performance on benchmarks specifically designed to test understanding of physical dynamics and causal relationships in video, including Something-Something v2 and Kinetics-400. More importantly for our purposes, probing studies of the learned representations show that they capture causal structure -- the model has learned something about how the world works, not just what it looks like.
CHAPTER THREE: LECUN'S GRAND VISION -- THE AMI ARCHITECTURE
To understand why JEPA matters for agentic AI, you need to understand the broader architecture that LeCun has been building toward. In 2022, he published a position paper titled "A Path Towards Autonomous Machine Intelligence" (openreview.net/forum?id=BZ5a1r-kVsf), which is one of the most carefully reasoned arguments for a specific architectural approach to artificial general intelligence that has appeared in the recent literature. It is not a paper that announces results. It is a blueprint.
LeCun's central argument is that current AI systems -- and he is quite explicit that this includes large language models -- are fundamentally limited because they lack a world model. They can process language and generate plausible-sounding text about the world, but they do not have an internal model that they can use to simulate the consequences of actions before taking them. This, LeCun argues, is why they fail at robust planning, why they hallucinate, and why they cannot achieve the kind of reliable, goal-directed behavior that we associate with human intelligence.
The architecture he proposes, which he calls Autonomous Machine Intelligence (AMI), has six components. The perception module processes raw sensory input and produces a representation of the current state of the world. The world model, built on JEPA, takes the current state representation and an action, and predicts the resulting future state representation -- in latent space, not in observation space. The cost module evaluates the desirability of states, encoding both intrinsic drives and task-specific objectives. The actor module generates candidate actions. The short-term memory module maintains a working representation of the current context. And the configurator module directs the attention and behavior of all other modules depending on the current task.
The world model is the linchpin of this architecture. It is what enables the agent to plan: to imagine sequences of actions and their consequences, evaluate those consequences against the cost module's criteria, and select the action sequence that leads to the most desirable outcome. Without a world model, the agent cannot plan in this sense. It can only react.
This is not a new idea in AI. Model-based reinforcement learning has been pursuing world models for decades. The DreamerV3 architecture, developed by Hafner and colleagues and published in 2023 (arXiv:2301.04104), uses a Recurrent State Space Model (RSSM) to learn a latent world model and has demonstrated impressive results across a wide range of continuous control tasks. What distinguishes JEPA from these earlier approaches is the training objective: DreamerV3 uses a variational autoencoder component that still requires reconstructing observations, while JEPA's purely predictive objective in embedding space avoids this overhead entirely. The JEPA approach does not need to reconstruct what the world looks like -- it only needs to predict how the world's abstract structure will change.
SHOWCASE 2: Planning with a World Model vs. Planning without One
To make the difference concrete, consider an agent tasked with moving a stack of books from one shelf to another without knocking anything over.
AGENT WITHOUT A WORLD MODEL (current LLM-based agent):
Step 1: Agent generates plan in text:
"Pick up top book, move to target shelf, repeat."
Step 2: Agent executes: picks up top book.
Step 3: Agent executes: moves toward target shelf.
Step 4: Agent discovers: target shelf is too narrow. Books will not fit.
Step 5: Agent has already committed. Must backtrack.
Step 6: Agent tries again with different approach.
Result: Multiple failed attempts, possible damage, no guarantee of
convergence.
The agent had no way to check, before acting, whether the target
shelf was wide enough. It had to discover this through action.
AGENT WITH A JEPA WORLD MODEL:
Step 1: Agent generates candidate action sequence.
Step 2: Agent rolls out sequence in JEPA latent space:
s0 (current state embedding)
-> predictor(s0, action="pick up top book") -> s1
-> predictor(s1, action="move to target shelf") -> s2
-> predictor(s2, action="place book") -> s3
Step 3: Cost module evaluates s3:
"Predicted state s3 has high probability of constraint
violation (shelf too narrow). Cost = HIGH."
Step 4: Agent rejects this action sequence before executing it.
Step 5: Agent tries alternative: "Find wider shelf first."
Step 6: Rolls out alternative, cost is LOW. Executes.
Result: First attempt succeeds. No wasted actions. No damage.
The key: the agent simulated the future in latent space and
discovered the problem before committing to action.
This showcase illustrates the fundamental value proposition of a world model for agentic AI. The agent with the world model is not smarter in the sense of knowing more facts. It is smarter in the sense of being able to think ahead -- to simulate consequences before committing to actions. This is the architectural gap that separates reactive agents from genuinely planning agents, and it is the gap that JEPA is designed to close.
The action-conditioned extension of JEPA makes this concrete. The predictor is extended to take not just context embeddings but also action embeddings as input, enabling it to answer the question: "given the current state embedding and the action 'move left,' what will the next state embedding be?" This is the minimal machinery needed to use JEPA as a planning world model. V-JEPA 2's action conditioning capability, developed at Meta AI's AMI Labs, represents the current state of this research direction as of 2026.
CHAPTER FOUR: THE THEORETICAL QUESTION -- CAN JEPA PROVABLY RECOVER HIDDEN STRUCTURE?
Now we arrive at the theoretical heart of the matter, and here we must be precise about what is known, what is conjectured, and what remains open.
The empirical evidence that JEPA learns meaningful representations is strong. I-JEPA outperforms Masked Autoencoders on linear probing benchmarks while using less compute, as demonstrated in the original paper. V-JEPA representations capture temporal dynamics and causal relationships in video, as shown by probing studies. These are real, reproducible results. But empirical success raises a deeper theoretical question: what, exactly, has the model learned? Is the JEPA embedding space a faithful representation of the environment's true causal structure? Or is it capturing something more superficial -- correlations that happen to be useful in the training distribution but do not reflect the underlying mechanics of the world?
This question -- whether a self-supervised learning method can provably recover the true latent structure of the data-generating process -- is one of the central questions in the theory of representation learning, and it connects to a rich body of work on identifiability in nonlinear independent component analysis. The general result, established by Hyvarinen, Khemakhem, and colleagues in a series of papers, is that recovering true latent structure requires auxiliary information or structural constraints -- you cannot do it from i.i.d. data alone without additional assumptions.
For JEPA specifically, the relevant theoretical question takes the following form. Suppose the environment has a hidden state that evolves according to some dynamics, and the agent observes only a function of that hidden state. Under what conditions does JEPA's learned embedding space correspond to the true hidden state space, rather than some arbitrary reparametrization of it? This is an identifiability question, and answering it formally requires specifying assumptions about the environment dynamics, the observation function, and the expressiveness of the JEPA architecture.
The theoretical community has been actively working on this question throughout 2025 and 2026. The key insight that makes JEPA theoretically attractive is that its predictive objective -- predicting future embeddings from past embeddings -- provides exactly the kind of temporal auxiliary information that identifiability theory suggests is needed to recover latent structure. Intuitively: if you must predict how the embedding changes over time, and the embedding is constrained to be compact and non-degenerate, then the embedding is forced to track the true causal variables that drive those changes.
A formal proof of this intuition, under precisely stated assumptions, would be a significant theoretical milestone. The assumptions required are roughly these: the environment's hidden state evolves according to a Markov process; observations are generated from hidden states via a smooth, invertible mapping on a compact manifold; and the JEPA predictor is trained to minimize prediction error in a sufficiently expressive embedding space. Under conditions of this type, one would expect to be able to show that the learned embeddings are homeomorphic to the true hidden state space -- topologically equivalent, meaning they preserve the causal structure of the environment even if they do not match it exactly in scale or orientation.
This is the theoretical result that the JEPA research community is actively pursuing in 2026, and it represents the kind of foundational guarantee that would put JEPA-based world models on the same rigorous footing as classical model-based control theory. Whether and when a complete, peer-reviewed proof appears is one of the most important open questions in the field.
SHOWCASE 3: The Homeomorphism Intuition -- A Geometric Picture
The concept of homeomorphism sounds intimidating, but the geometric intuition is accessible and worth understanding because it captures precisely what a "faithful" world model means.
Suppose the true hidden state of an environment is a point on the surface of a sphere. You cannot observe the sphere directly. You can only observe a projection of it onto a flat screen -- a two-dimensional image that encodes the three-dimensional position in some complicated way. The question is: can JEPA recover the sphere from the flat images?
TRUE HIDDEN STATE SPACE JEPA EMBEDDING SPACE
(sphere surface) (learned representation)
* *
*** ***
***** <-- homeomorphism --> *****
*** ***
* *
Points that are neighbors Points that are neighbors
in the true state space in the embedding space.
The topology is preserved.
The causal structure is preserved.
Planning in embedding space is
equivalent to planning in true state space.
A homeomorphism result would say: yes, under the stated conditions, the JEPA embedding space will be topologically equivalent to the sphere -- it will have the same "shape" in a mathematical sense, even if it is rotated, stretched, or otherwise deformed relative to the original. The key property is preserved: points that are close on the sphere will be close in the embedding space, and points that are far apart on the sphere will be far apart in the embedding space. The causal neighborhood structure is intact.
What this means practically is profound. If you train JEPA on observations from an environment, and then use the learned embedding space to plan, you are planning in a space that faithfully represents the environment's causal structure. You are not planning in a space that happens to correlate with the environment -- you are planning in a space that IS the environment, in the mathematically relevant sense. Nearby embeddings correspond to nearby world states. Transitions in embedding space correspond to transitions in the real world. The world model is not an approximation -- it is a faithful representation.
The three assumptions required for a result of this type deserve careful attention, because they define the scope of applicability and, implicitly, the limits of JEPA's reach.
The Markov assumption is the most fundamental. It says that the environment's hidden state is a sufficient statistic for predicting the future -- you do not need to remember the full history, just the current state. This is a reasonable assumption for many physical environments, but it breaks down in environments with long-range dependencies, hidden variables that evolve on very long timescales, or adversarial dynamics where history matters strategically.
The smooth invertible mapping assumption says that the observations are a faithful encoding of the hidden state -- no information is irretrievably lost in the observation process. This is also reasonable for many sensory modalities such as vision and proprioception, but may not hold for highly compressed or noisy observations.
The sufficiently expressive embedding space assumption is the most practically demanding. It requires that the JEPA encoder and predictor have enough capacity to represent the true hidden state space. For complex environments, this may require very large models -- and the scaling behavior of JEPA is less well understood than that of autoregressive LLMs.
These assumptions are not weaknesses to be dismissed. They are honest statements of where the theory applies and where it does not. The value of a formal theoretical result is precisely that it forces this kind of precision, replacing vague intuitions with rigorously bounded claims.
CHAPTER FIVE: THE TECHNICAL HEART -- LATENT PREDICTION VS. TOKEN GENERATION
We have been circling around a fundamental technical comparison that deserves direct treatment: what is the difference, at a deep level, between JEPA's latent-space prediction and the token-by-token generation of autoregressive language models? And why does this difference matter for planning?
An autoregressive language model generates text by predicting the next token given all previous tokens. At each step, it produces a probability distribution over the vocabulary, samples from it, and appends the result to the sequence. This is a powerful mechanism for generating coherent text, because natural language has strong sequential structure and the training signal -- predict the next token -- is dense and well-defined.
But for planning, this mechanism has a deep structural problem. When you generate a plan as text, you must commit to low-level details -- specific words, specific phrasings -- before the high-level structure of the plan is determined. The model decides "I will use the word 'carefully'" before it has determined whether the overall strategy is correct. This is the reverse of how effective planning works. Effective planning proceeds from high-level goals to low-level actions: first decide what to achieve, then decide how to achieve it, then decide the specific actions that implement the how.
This mismatch is not a problem that can be fixed by prompt engineering or chain-of-thought reasoning. Chain-of-thought helps the model articulate intermediate reasoning steps, but it does not change the fundamental fact that the model is generating tokens sequentially and cannot revise earlier tokens in light of later ones. It is a consequence of the autoregressive architecture itself, not of any particular prompting strategy.
JEPA's latent-space prediction avoids this problem by operating at the level of abstract representations from the start. The predictor does not generate a sequence of tokens describing the future state. It predicts a vector in embedding space that represents the future state at whatever level of abstraction the encoder has learned. If the encoder has learned to represent "the stove is on" as a feature of the embedding, the predictor can predict changes in that feature without specifying any of the low-level visual details of what a stove looks like when it is on.
SHOWCASE 4: Token-by-Token vs. Latent-Space Planning
Consider an agent planning to cook pasta. Compare the two approaches.
AUTOREGRESSIVE (TOKEN-BY-TOKEN) PLANNING:
The agent generates:
"First, I will fill a large pot with water. Then I will place the
pot on the stove and turn the burner to high heat. Next, I will
wait approximately 10 minutes for the water to reach a rolling
boil. Then I will add a generous pinch of salt..."
At each word, the model is committing to a specific phrasing.
The model does not have a representation of "pot of boiling water"
that it can manipulate symbolically. It has tokens.
Problem 1: The model cannot easily check whether the plan is
consistent -- it would have to re-read the text and reason about
it linguistically.
Problem 2: Multi-step rollouts require generating full text at
each step, which is computationally expensive.
Problem 3: The plan is not easily modifiable -- changing "large
pot" to "medium pot" requires regenerating the text.
JEPA LATENT-SPACE PLANNING:
The agent maintains a state embedding:
s0 = encode(current kitchen state)
= [stove_off=1, pot_present=0, water_boiling=0, ...]
(schematic -- actual embeddings are dense vectors)
It rolls out actions in latent space:
s1 = predict(s0, action="fill pot with water")
= [stove_off=1, pot_present=1, water_boiling=0, ...]
s2 = predict(s1, action="place pot on stove, turn to high")
= [stove_off=0, pot_present=1, water_boiling=0, ...]
s3 = predict(s2, action="wait 10 minutes")
= [stove_off=0, pot_present=1, water_boiling=1, ...]
s4 = predict(s3, action="add pasta")
= [stove_off=0, pot_present=1, water_boiling=1, pasta_in=1, ...]
Cost module evaluates s4: GOAL ACHIEVED. Cost = LOW.
The agent can also check alternative sequences:
What if I skip the salt? predict(s3_no_salt, action="add pasta")
Cost module: pasta will be bland. Cost = MEDIUM. Prefer salted.
The entire planning process operates on compact vectors.
No text generation required. Computationally efficient.
Easily modifiable: change one action, re-roll from that point.
The computational efficiency argument is not trivial. Rolling out a trajectory in JEPA latent space requires running the predictor network -- a lightweight transformer -- once per step. Rolling out a trajectory using an LLM requires generating potentially hundreds of tokens per step, each requiring a full forward pass through a model with billions of parameters. For planning tasks that require evaluating thousands of candidate trajectories, this difference is decisive. The agent can explore a vastly larger portion of the action space in the same wall-clock time when it is planning in latent space rather than in token space.
The more important advantage, however, is qualitative rather than quantitative. The agent can plan before acting, rather than discovering the consequences of actions through expensive real-world execution. In domains where actions have irreversible consequences -- robotic manipulation, financial transactions, infrastructure management -- this is not merely an efficiency gain. It is the difference between a system that can be trusted and one that cannot.
CHAPTER SIX: THE ECOSYSTEM -- WHERE JEPA STANDS IN 2026
LeCun's AMI Labs at Meta has been systematically building out the JEPA ecosystem over the past three years. I-JEPA (Assran et al., arXiv:2301.08243, CVPR 2023) established the core principle for images, demonstrating that predicting in embedding space produces more semantic, less texture-focused representations than pixel-space reconstruction, and outperforms Masked Autoencoders on linear probing benchmarks with less compute. V-JEPA (Bardes et al., Meta AI, 2024) extended the principle to video, learning temporal dynamics by predicting spatiotemporal embedding blocks. V-JEPA 2 (Meta AI, 2025) added action conditioning and a hierarchical latent space that models both short-term dynamics and longer-horizon scene evolution, taking the architecture from a passive observer to an active world model capable of supporting planning.
The integration with language models is the current frontier, and it is where the most interesting architectural questions are being asked. The natural hybrid architecture has an LLM generating candidate action sequences in natural language, and a JEPA world model evaluating those sequences in latent space. The LLM contributes language understanding, commonsense reasoning, and knowledge retrieval. The JEPA world model contributes physical grounding and planning accuracy. Neither system alone is sufficient: the LLM lacks a grounded world model, and the JEPA world model lacks language understanding. Together, they address each other's primary weakness.
This hybrid approach is important because it reframes the question from "JEPA vs. LLMs" to "JEPA plus LLMs." LLMs are extraordinarily good at language-grounded reasoning, commonsense inference, and knowledge retrieval. JEPA is extraordinarily good at physical world modeling and latent-space planning. The question is not which one wins, but how to combine them effectively. This is the architectural question that Meta's AMI Labs, and several academic groups, are actively working on in 2026.
The hierarchical extension of JEPA addresses the multi-level planning problem that any serious agentic system must solve. A high-level JEPA predicts abstract goal states -- "the task is complete," "the object is in the target location" -- while a low-level JEPA predicts detailed action outcomes -- "the gripper is at position X, the object has moved Y centimeters." This mirrors LeCun's AMI architecture and enables both strategic and tactical planning within a unified framework. The configurator module in the AMI architecture is responsible for selecting which level of the hierarchy is relevant for the current task, and for coordinating between levels when both are needed.
In robotics, the JEPA approach has moved from pure research to early production-adjacent applications. The use of V-JEPA 2 as a world model for robotic manipulation -- predicting the outcome of candidate action sequences in latent space, enabling the robot to select actions without executing them in the real world -- represents model-based planning in the classical sense, but implemented with a modern learned world model rather than a hand-crafted physics simulator. The advantage over hand-crafted simulators is generalization: the learned world model can handle novel objects and configurations that were not anticipated at design time, as long as they fall within the distribution of the training data.
CHAPTER SEVEN: THE HONEST RECKONING -- LIMITATIONS AND OPEN PROBLEMS
Any article that presents JEPA as the missing world-model layer beneath agentic AI without honestly confronting its limitations would be doing you a disservice. The limitations are real, and some of them are fundamental.
The first and most important limitation is interpretability. The JEPA latent space is not interpretable in the way that language is. When an LLM plans in text, you can read the plan and check whether it makes sense. When a JEPA world model plans in latent space, you cannot directly inspect the intermediate representations. You can probe them -- train linear classifiers to predict specific properties of the world state from the embeddings -- but you cannot read them the way you read a sentence. This is a significant practical problem for enterprise deployment, where explainability is often a regulatory or governance requirement, and where human oversight of agent behavior is essential for safety.
The second limitation is the scaling challenge. LLMs exhibit remarkably clean scaling laws: more parameters, more data, more compute, reliably better performance. JEPA's scaling behavior is less well understood. Performance improvements with scale depend heavily on the quality of the training data distribution and the design of the prediction targets. This makes it harder to forecast when JEPA will reach the capability thresholds needed for production agentic systems. The engineering investment required to scale JEPA is substantial, and the return on that investment is less certain than for LLMs, where the scaling laws provide a reliable guide.
The third limitation is the open-world problem. The theoretical arguments for JEPA as a world model rest on assumptions -- Markov dynamics, smooth invertible observations -- that are more easily satisfied in controlled physical domains than in the open-ended, language-rich environments in which enterprise agents operate. Real enterprise environments have long-range dependencies, hidden variables, adversarial dynamics, and ambiguous observations. Extending JEPA's theoretical guarantees to these settings is an open research problem.
The fourth limitation is the integration challenge. Combining JEPA world models with LLM-based reasoning is not trivial. The two systems operate in fundamentally different representation spaces -- one in dense embedding vectors, the other in discrete tokens -- and bridging these spaces requires careful architectural design. The interface between the LLM's language-space reasoning and the JEPA world model's embedding-space predictions must be designed so that information flows effectively in both directions: the LLM's action proposals must be translated into JEPA's action embedding space, and the JEPA world model's state predictions must be translated back into language that the LLM can reason about.
The fifth limitation is representation collapse. Despite the EMA-based target encoder design, representation collapse remains a practical challenge in JEPA training. Various techniques -- stop-gradient, variance-covariance regularization, contrastive objectives -- have been proposed and studied, but the choice of collapse prevention mechanism significantly affects the quality of learned representations, as documented in the I-JEPA paper (arXiv:2301.08243). Getting this right in practice requires expertise and careful tuning, and the optimal configuration is not yet well understood for large-scale, complex environments.
SHOWCASE 5: The Interpretability Gap -- A Practical Illustration
Suppose a JEPA-based agent is planning a multi-step financial transaction and something goes wrong. The agent's plan fails, and you need to understand why.
WITH AN LLM-BASED AGENT:
You can inspect the agent's reasoning trace:
"Step 1: Check account balance -> $5,000 available.
Step 2: Transfer $3,000 to vendor account.
Step 3: Wait for confirmation.
Step 4: Update ledger."
You can see exactly what the agent was thinking at each step.
You can identify where the reasoning went wrong.
You can explain the failure to a regulator or auditor.
WITH A JEPA-BASED AGENT:
You can inspect the latent state sequence:
s0 = [0.23, -1.47, 0.89, 2.13, -0.56, ...] (512-dimensional vector)
s1 = [0.31, -1.52, 0.94, 1.87, -0.61, ...]
s2 = [0.45, -1.61, 1.02, 1.54, -0.73, ...]
...
These vectors encode the agent's world model state, but you
cannot read them. You can train a probe to ask "does s2 encode
'transfer initiated'?" and get a probabilistic answer. But you
cannot produce a human-readable explanation of the failure.
This is a genuine problem for regulated industries.
It is not insurmountable -- interpretability research is active --
but it is not solved.
The interpretability gap is not unique to JEPA -- deep learning systems generally face this challenge -- but it is particularly acute for world models used in planning, because the planning process itself occurs in the latent space and is therefore opaque. This is one reason why the hybrid LLM-plus-JEPA approach is architecturally attractive even beyond its capability benefits: the LLM provides an interpretable planning trace, while the JEPA world model provides grounded evaluation of that trace. The interpretable part and the grounded part are separated by design, which makes the system easier to audit and debug.
CHAPTER EIGHT: IS THE HYPE JUSTIFIED?
We have now assembled all the pieces needed to answer the question in the title. Let us be precise about what the hype claims, and what the evidence actually supports.
The strong version of the hype claim is something like this: JEPA is the missing piece that will unlock truly capable agentic AI, and we are close to seeing it deployed at scale in production systems. This claim is not justified. The scaling challenges are real. The integration challenges are real. The interpretability challenges are real. The open-world problem is real. The path from current research results to production-ready agentic systems is longer than enthusiasts suggest, and anyone who tells you that JEPA will transform enterprise AI agents in the next twelve months is getting ahead of the evidence.
The moderate version of the hype claim is something like this: JEPA represents a genuinely important architectural direction for world modeling in agentic AI, with strong empirical results and a compelling theoretical framework, and the theoretical question of whether it can provably recover hidden environment structure is one of the most important open questions in the field. This claim is fully justified. The empirical results from I-JEPA and V-JEPA are real and reproducible. The architectural insight -- that predicting in embedding space rather than observation space is the right approach for world modeling -- is well-supported. The theoretical framework connecting JEPA to identifiability theory is coherent and actively being developed. The gap between reactive LLM-based agents and genuinely planning agents is real and significant.
The weak version of the hype claim is something like this: JEPA is interesting research that might eventually be relevant to agentic AI. This is clearly true but dramatically undersells the significance. The empirical results are state-of-the-art. The theoretical framework is coherent and advancing. The integration with LLMs is progressing. This is not "might eventually be relevant" -- it is "is already relevant and becoming more so."
The honest assessment is that JEPA occupies a position that is genuinely unusual in the AI landscape: it is theoretically well-motivated, empirically promising, and practically challenging. The empirical results from I-JEPA and V-JEPA are not hype -- they are reproducible experimental findings from a confirmed, peer-reviewed paper (arXiv:2301.08243, CVPR 2023) and its successors. The theoretical framework connecting JEPA to world modeling for agentic AI is not hype -- it is a coherent research program with a clear intellectual lineage from LeCun's AMI paper through the identifiability literature. The challenges of scaling, interpretability, and integration are not hype -- they are real engineering problems that will take years to solve.
What JEPA represents, in the most accurate framing, is the theoretical and empirical foundation for the next generation of agentic AI. It is not the next generation itself. It is the layer that the next generation will be built on -- if the field makes the right architectural choices, and if the scaling and integration challenges are solved. That is a significant "if," but it is a serious "if," grounded in real results, not a dismissive one.
CHAPTER NINE: THE BROADER DEBATE -- LECUN VS. THE SCALING HYPOTHESIS
No treatment of JEPA would be complete without situating it in the broader debate about the path to artificial general intelligence. LeCun has been one of the most consistent and articulate critics of the "scaling hypothesis" -- the idea that simply making language models larger and training them on more data will eventually produce human-level intelligence.
His argument, stated in various forms over the past several years and grounded in the AMI paper, is that autoregressive language models have a fundamental architectural limitation: they model the world in token space rather than building abstract world models. No amount of scaling will fix this, because the limitation is architectural, not quantitative. You cannot get a world model by scaling a token predictor. You need a different architecture -- specifically, one that predicts in abstract embedding space, which is what JEPA does.
The counterargument, associated with researchers in the scaling camp, is that sufficiently scaled language models may develop implicit world models through language. Language, after all, is a rich description of the world, and a model that has learned to predict language may have implicitly learned to predict the world. There is some empirical support for this view: GPT-4o, o3, Claude 3.7, and Gemini 2.5 Pro all demonstrate surprising physical reasoning capabilities that were not explicitly trained, suggesting that scale and language data alone can produce some degree of world understanding.
The empirical evidence in 2026 suggests complementary strengths rather than clear superiority of either approach. JEPA-based world models show stronger performance on physical reasoning and multi-step planning tasks in controlled domains. LLMs show stronger performance on language-grounded and commonsense reasoning tasks. This is consistent with the hybrid architecture view: LLMs for language and knowledge, JEPA for physical world modeling and planning. The debate is not merely academic. It has direct implications for where research investment should go, and for what kinds of AI systems enterprises should be building toward.
If the scaling hypothesis is correct, the right strategy is to keep scaling LLMs and wait for world modeling capabilities to emerge. If LeCun is correct, the right strategy is to invest in JEPA-based world models and develop the integration with LLMs. The current empirical evidence does not definitively resolve this debate, but the theoretical arguments for JEPA -- particularly the connection to identifiability theory and the principled advantages of embedding-space prediction -- provide a strong case that the architectural distinction matters, independent of scale.
CHAPTER TEN: WHAT COMES NEXT
The trajectory of JEPA research and its integration with agentic AI systems suggests several near-term developments that are worth watching carefully.
The most important is the theoretical question. The formal proof that JEPA can recover hidden environment structure under precisely stated conditions -- a homeomorphism result connecting JEPA embeddings to true hidden state spaces -- is the theoretical milestone that the field is working toward. When this result appears in peer-reviewed form, it will put JEPA-based world models on the same rigorous footing as classical model-based control theory, and it will significantly accelerate adoption in high-stakes domains where theoretical guarantees matter. The identifiability literature provides the mathematical tools; the JEPA-specific application is the open problem.
The second development to watch is the scaling question. Meta's AMI Labs is actively working on scaling V-JEPA 2 to longer video sequences and more complex environments. The results of these scaling experiments will be decisive for the field's confidence in JEPA as a production-ready technology. If JEPA exhibits clean scaling laws -- if doubling the model size reliably improves world modeling quality -- then the path to production is clear. If it does not, the field will need to develop new techniques for efficiently scaling JEPA, potentially drawing on insights from the LLM scaling literature.
The third development is the integration of JEPA with language model reasoning. The hybrid architectures being explored in 2026 are promising, but they are not yet standardized or widely deployed. The development of robust, well-engineered interfaces between LLM reasoning and JEPA world modeling is a significant engineering challenge that will require sustained effort from both the research community and industry practitioners. The key technical problem is the representation gap: how do you translate between the token space of the LLM and the embedding space of the JEPA world model in a way that preserves the information needed for planning?
The fourth development is interpretability. The field of mechanistic interpretability has made significant progress on understanding the internal representations of neural networks, and applying these techniques to JEPA world models is a natural next step. If researchers can develop tools for inspecting and explaining JEPA latent states -- tools that go beyond linear probing to provide genuine causal explanations of model behavior -- the interpretability barrier to enterprise deployment will be significantly reduced.
The fifth development is the cost and critic module of LeCun's AMI architecture. The world model is only one component of the full AMI system. The cost module -- which evaluates the desirability of predicted states -- is equally important for planning, and it is less developed than the world model. Research on learning cost functions from human feedback, from task specifications, and from intrinsic motivation is active, and progress here will be essential for realizing the full potential of JEPA-based agents. A world model without a good cost function is like a chess engine without an evaluation function: it can simulate moves, but it cannot decide which moves are good.
EPILOGUE: THE LAYER THAT WAS MISSING
Let us return, at the end, to where we began: the question of whether AI agents understand what they are doing. The answer, for the vast majority of agents deployed today, is no -- not in the sense that matters for reliable, multi-step planning. They generate plausible action sequences without simulating their consequences. They discover failures by committing to them. They are reactive where they need to be predictive.
JEPA is the most principled current answer to this problem. Its architectural insight -- that predicting in embedding space rather than observation space is the right approach for world modeling -- is supported by strong empirical results and a coherent theoretical framework. Its connection to LeCun's AMI architecture provides a clear vision of how a JEPA world model fits into a complete agentic system. Its theoretical relationship to identifiability theory provides the mathematical language needed to ask -- and eventually answer -- the question of whether it can provably recover the causal structure of the world.
The challenges are real. Scaling is hard. Integration with language models is hard. Interpretability is hard. The open-world problem is hard. The path from I-JEPA and V-JEPA to production-ready agentic systems is not short, and anyone who tells you otherwise is selling something.
But the direction is right. The foundation is solid. The theoretical questions are well-posed. And the empirical results, from a confirmed, peer-reviewed body of work, are genuinely impressive. The enterprises that understand this now, and begin investing in the architectural transition from reactive LLM-based agents to predictive world-model-augmented agents, will be the ones that are still standing when the inevitable reckoning with the limits of token-by-token planning arrives -- as it will.
The world model layer was missing. We now know what it should look like, and we have the theoretical and empirical tools to build it. The work has begun.
REFERENCES AND FURTHER READING
Assran, M., Duval, Q., Misra, I., Bojanowski, P., Vincent, P., Rabbat, M., LeCun, Y., Ballas, N. "Self-Supervised Learning from Images with a Joint Embedding Predictive Architecture." arXiv:2301.08243. CVPR 2023. The original I-JEPA paper. Confirmed real and peer-reviewed. Essential reading for understanding the core JEPA architecture, the EMA target encoder design, and the comparison with Masked Autoencoders.
Bardes, A. et al. "Revisiting Feature Prediction for Learning Visual Representations from Video." Meta AI, 2024. The V-JEPA paper. Confirmed real. Extends JEPA to video by predicting spatiotemporal embedding blocks rather than pixels.
Hafner, D. et al. "Mastering Diverse Domains through World Models." arXiv:2301.04104. 2023. The DreamerV3 paper. Confirmed real. Provides the most important prior work on latent world models for reinforcement learning, and the key point of comparison for JEPA's training objective.
LeCun, Y. "A Path Towards Autonomous Machine Intelligence." OpenReview, 2022. openreview.net/forum?id=BZ5a1r-kVsf. Confirmed real. The foundational blueprint for the AMI architecture, including the six-component design and the central role of the JEPA-based world model. Required reading for understanding where JEPA fits in the larger picture of autonomous machine intelligence.
Hyvarinen, A., Khemakhem, I. et al. Work on nonlinear ICA and identifiability of latent representations, including arXiv:2106.02584 and related papers. Provides the mathematical framework -- identifiability theory -- within which the theoretical question of JEPA's ability to recover hidden structure is properly posed.
