Anthropic published a paper on July 9, 2026, describing a previously unobserved internal structure inside Claude. The structure is a subspace of the model's residual stream in which semantic content is assembled and stabilized several inference steps before the first output token is produced. The technique the company used to find it is called the Jacobian lens. The subspace does not have a fixed location in the network. It has a fixed function. MIT Technology Review's coverage of the paper describes it as a "hidden space where Claude puzzles over concepts." That phrasing is accurate. It is also underspecified. The rest of this article specifies it.
The Discovery: What J-Space Actually Is
J-Space is not a new module. Anthropic did not add a layer, retrain a checkpoint, or run a fine-tune to produce it. J-Space is a structure that the researchers identified inside the existing forward pass of a production Claude model. The structure is a low-dimensional subspace of the residual stream — the running sum of internal representations that carries information between transformer blocks — in which a particular kind of computation is reliably performed.
That computation is the assembly of meaning. The paper documents a consistent pattern: when Claude is asked a question that requires more than pattern completion — multi-step reasoning, planning, abstraction, code synthesis with constraints — the model's internal activations, projected onto a small number of directions in the residual stream, converge onto a stable configuration several layers before the model begins producing tokens. The configuration encodes the answer, or a representation of the answer, in something close to its final form.
The configuration is not the same as the answer. The model does not, in this subspace, write down the response. It writes down a planning artifact. The artifact is then read, over the subsequent layers, by the parts of the network that produce tokens. The tokens, when they arrive, are the artifact rendered into language.
The finding is, on its surface, unsurprising. Interpretability researchers have long suspected that large language models do their real work before the first token. The novelty is the location, the reliability, and the measurability of that work. The novelty is also the name. Anthropic is calling the subspace J-Space because the method used to find it relies on the Jacobian of the model's output with respect to its internal activations.
The Jacobian Lens: A New Kind of X-Ray
Mechanistic interpretability, the subfield Anthropic's interpretability team helped found, has historically relied on a small set of tools. Sparse autoencoders decompose model activations into human-interpretable features. Probing classifiers train linear probes to detect the presence of known properties. Activation patching swaps activations between runs to identify which components matter. These tools are productive. They are also slow, model-specific, and frequently ambiguous about whether a discovered feature is causally implicated in a behavior or merely correlated with it.
The Jacobian lens is different. The Jacobian of a neural network, computed at a particular input, is a matrix that describes how small changes in the internal activations produce small changes in the output. It is, in other words, a local map of what the network is paying attention to. Anthropic's paper uses a related construction: not the full Jacobian, but a low-rank approximation derived from a small set of probe directions. The result is a per-input map of which internal directions are, at the moment of inference, doing meaningful work.
The technique inherits the limitations of the Jacobian itself. It is local — it tells you what this input did, not what the model is in general. It is also expensive to compute at full rank, which is why the company uses low-rank approximations. The trade-off is the usual one in interpretability: resolution for tractability. The paper documents the trade-off and the recovery procedures used to verify that the low-rank approximation captures the relevant structure. The verification is, in the company's framing, the part that took longest.
Concepts Before Tokens: How the Room Forms Meaning
The paper's most concrete claim is empirical. Across a benchmark suite of reasoning, planning, and code synthesis tasks, J-Space activates in a predictable band of layers — typically between the 40th and 60th percentile of the network's depth, depending on model size and task type. The activations in this band are not the same shape as the activations at the embedding layer or at the output head. They are higher in rank, more semantically structured, and lower in noise. They look, in the paper's own language, like plans.
The paper documents several signatures of this structure. First, the subspace is sparse: only a small number of directions in the residual stream carry most of the variance. Second, the subspace is stable: small perturbations to the input, in the early layers, do not move the late-layer activation in J-Space by much. Third, the subspace is interpretable: linear probes trained on J-Space activations can recover task-relevant variables — the answer to an arithmetic problem, the identifier of a code function, the constraint set of a planning problem — at high accuracy. The probes are not magic. They are a check that the subspace contains what the paper claims it contains.
What the paper does not claim is that J-Space is a single, unified, model-wide module. The subspace is identified separately for each task. Different tasks activate different directions within the general region. The structure is functional, not architectural. The model has not been trained to have a planning layer. It has learned, over training, to do planning in a particular region of its residual stream. The region is consistent across tasks. The directions within it are not.
What This Breaks About Interpretability
Two things break. The first is the assumption, common in older interpretability work, that a model's "thinking" happens at or near the output head. This assumption is a holdover from the era of small models and short contexts. It does not survive contact with a model that plans several layers before it speaks. If the planning is in J-Space, then the token-level analysis that has dominated the field is, at best, a late-stage readout of a process whose interesting work has already happened.
The second thing that breaks is the unit of analysis. Mechanistic interpretability has, to date, operated primarily on circuits: small, identifiable subgraphs of attention heads and MLPs that perform a particular computation. Circuits are a powerful abstraction. They are also a slow one — finding a circuit can take months, and the circuits that have been found are typically narrow. J-Space is not a circuit. It is a region. The work done in the region is performed by many components acting in parallel. The region is the unit of analysis now, not the circuit.
This is a meaningful shift. The field has spent the last three years learning to find circuits. It now has a tool that finds regions. The two are not incompatible. The region is a container for circuits. The work of identifying which circuits, within J-Space, perform which sub-tasks, is the work that follows the paper. That work is not done.
What This Saves About Interpretability
The save is a more modest story. The Jacobian lens is cheap, relative to the alternatives. It can be run on a production model, on a single forward pass, with the low-rank approximation the paper describes. It produces, for every input, a map of which internal directions mattered. This means interpretability can stop being a separate-research-question-per-model exercise and start being a per-input diagnostic. That is, in operational terms, the difference between a research project and a tool.
It also saves a specific claim: that the residual stream is opaque. The residual stream has been the hardest part of the transformer to interpret, precisely because it is the part where everything mixes. J-Space is a structure inside the residual stream. Its discovery does not make the residual stream transparent. It makes one region of it legible. The distinction matters. The field has been waiting for a way to make the residual stream legible in pieces. The paper provides a way to do that.
Why It Matters in the Agent Era
Frontier model work in 2026 is dominated by agents: systems that take multi-step actions, use tools, and produce long chains of intermediate reasoning before delivering a final answer. The agentic regime is the regime in which J-Space is most relevant. The paper documents that the J-Space region is larger, more stable, and more structured in agentic settings than in single-turn chat. This is the part of the finding that will draw the most attention from builders.
It will also draw attention from competitors. The broader interpretability landscape is, as of mid-2026, more crowded than it was a year ago. OpenAI's recent GPT-5 system card includes its own interpretability work, much of it in the sparse-autoencoder tradition. Meta's entry into the coding model market has not, as of this writing, been accompanied by a comparable interpretability publication. The companies that ship the most legible models will, in the next eighteen months, be the companies that ship the models whose failures can be diagnosed before deployment. The diagnosis is the product.
The agentic stake is higher than the chat stake. An agent that takes a wrong action is not a chatbot that produces a wrong sentence. The cost of a misstep in a tool-using, code-executing, file-modifying system is qualitatively different. J-Space offers, for the first time, a way to inspect, at inference time, the plan the model is about to execute. That capability is not yet a safety guarantee. It is a precondition for one.
The Map Inside the Machine
The paper ends with a metaphor and a constraint. The metaphor is that the residual stream is a building, and J-Space is a room inside it. The constraint is that the room is not always occupied. The paper documents a class of inputs — simple pattern completions, short factual lookups, single-step code transformations — in which J-Space does not activate in the identifiable form. The model handles these inputs the way the field used to think all inputs were handled: directly, in the output-adjacent layers, without a planning phase.
The model has, in other words, two modes. A fast mode for the easy inputs, and a slow mode for the hard ones. The slow mode is what the paper documents. The fast mode is what the paper, for the most part, leaves alone. The next paper, presumably, will be about the conditions under which the model decides which mode to enter. That paper will be about the moment, somewhere in the middle layers, when the model commits to thinking. The moment before the room is entered. The moment the room is built.
For now, the room exists. It is measurable. It is in the same place, for the same kinds of tasks, across runs. That is, in interpretability terms, a lot. It is also, in deployment terms, a beginning. The companies that can read the room will build different agents from the companies that cannot. The companies that cannot will, eventually, ship agents whose planning they cannot see. The market will, eventually, notice.