Anthropic's J++ Lens: A Cleaner Jacobian Lens for Reading What Claude-Style Models Think Between Layers

Anthropic's interpretability team has published an upgrade to its Jacobian lens. In the October 2026 Circuits update, it introduces the J++ lens: a version of the lens that clusters internal activations, fits one Jacobian per cluster, and throws away the clusters that give bad readouts. It remains a single linear map at each layer, so Anthropic says it can be swapped in for the original.

This is a research note, not a product launch, and Anthropic frames it that way. This post explains what the lens is, what J++ changes, what has been released, and what we cannot tell from the short update alone.

First, what the Jacobian lens is #

Language models process text through a stack of layers. At any layer, the model holds a vector (the residual stream) at each token position. A long-standing question is: what does the model "have in mind" at a middle layer, before it produces its answer?

The Jacobian lens (J-lens) is Anthropic's answer, introduced in its global workspace paper, "Verbalizable Representations Form a Global Workspace in Language Models." The reference code's README describes it this way: it reads out what an internal activation is disposed to make the model say. It linearly transports a residual-stream vector at any layer and position into the final-layer basis, then decodes it with the model's own unembedding into a ranked list of vocabulary tokens. The transport is the average input-output Jacobian over a text corpus. The README gives the formula as lens_l(h) = unembed(J_l @ h), with J_l the expected derivative of the final hidden state with respect to the layer-l state, averaged over prompts, source positions and all current and future target positions in a generic web-text corpus.

The README includes a memorable example: in an ASCII-face prompt, selecting the nose character shows the lens reading out "nose" at mid layers, although the word never appears in the prompt.

For the fuller story of what that revealed about Claude, see our earlier explainers: what the J-lens is and Anthropic's J-space global workspace finding. Those cover the July 2026 results; this post only covers what is new.

The problem J++ targets #

The original J-lens builds its transport by averaging Jacobians over a large number of source token positions, each weighted equally. Anthropic's update says that in practice some of those positions contribute very noisy gradients that corrupt the average.

That is a familiar statistics problem: a plain mean is only as good as its worst contributors. If a minority of positions produce junk, the single averaged map used at a layer is pulled away from what it should be, and the tokens it reads out become less trustworthy.

What changed in J++ #

According to the Circuits update, the J++ lens changes four things:

1. Cluster the activations at each layer. Instead of one average over everything, the activations are grouped.
2. Fit a separate Jacobian per cluster. Each cluster gets its own transport.
3. Combine them with learned weights. In practice, Anthropic says, the weights mostly serve to discard the clusters that produce poor readouts.
4. Borrow the R-lens improvement and add filtering. The R-lens used layerwise relevance propagation when performing backward passes to compute the Jacobians. J++ includes that, plus post-hoc filtering of spurious readout tokens.

The important engineering property: the result is still a single linear map at each layer. Downstream tools that expected a J-lens do not need changes, which is why Anthropic calls it a drop-in replacement.

The headline claim: across Anthropic's evaluations, the J++ lens more reliably surfaces the intermediate latent variables a model uses for its reasoning than either the J-lens or the R-lens. An intermediate latent variable here means a concept the model computes along the way, such as a bridging fact in a multi-step question, that never appears in the output.

Three columns of nodes joined by lines with a few green nodes, standing for a J++ lens reading intermediate latent variables layer by layer

A worked way to picture it: ask a model "What is the capital of the country where the Eiffel Tower stands?" The answer, Paris, needs a bridging step, France, that the prompt never states. A lens that reads mid-layer activations should show "France" ranking highly in the middle of the network and then give way to "Paris" near the end. If the lens is noisy, "France" competes with unrelated tokens and the bridge is hard to see. That example is our illustration of what "intermediate latent variable" means, not one of Anthropic's reported experiments.

What was released #

Anthropic says the full post contains more details and experiments, and that it has released its code and lenses along with an interactive demo hosted on Neuronpedia (the update points to code at safety-research/jpp_lens and lenses at koayon/jpp-lenses on Hugging Face; the demo runs on qwen3.6-27b). The project came out of the Anthropic Fellows Program, led by Kola Ayonrinde, working with Jack Lindsey.

Neuronpedia, the open-source interpretability platform, lists the Jacobian lens as a featured tool and lists an October 15 blog post titled "J++ Lens and Drift Calibrator (UI Research)", described as a better Jacobian lens and a community collaboration with MIT Media Lab. Its tools page also lists a "J++ Lens" paper dated October 2026 under author names (Fraser-Taliente, Kantamneni, Ong et al.) that differ from the Circuits update's credits. We could not open the full details of either from the pages available to us, so we do not claim how those items relate; check the Neuronpedia pages directly for the demo and the paper.

The earlier Anthropic repository is explicit about its status: "Reference implementation. Not maintained and not accepting contributions." It fits the lens on open-weights decoder transformers and renders a layer-by-position view; its examples use Qwen, and it says other Hugging Face decoders adapt cleanly. So you can try the J-lens family on open models without any Claude access.

Why this matters #

Interpretability tools live or die on trust. A readout is only useful if you can believe it. A lens that gives a clean answer on some prompts and a polluted one on others is hard to use for safety work, where the interesting cases are often the odd ones. Pruning noisy contributors is a direct attempt at making the readout more dependable.

It is a sign the method is still moving. The first J-lens paper came out in July. By October, a fellows project had shipped a measurable improvement. For readers following Anthropic's interpretability line, including natural language autoencoders, the pattern is a fast-moving toolbox, not a fixed method.

It connects to claims about model "thinking." Work built on the J-lens has been used in discussions of whether models have something like a workspace, which we looked at in our J-space and Claude consciousness explainer. A better lens does not settle those debates, but it does change how much weight a readout can carry.

What we cannot tell from the update #

Anthropic's own caveat is blunt: treat these results like a colleague sharing preliminary experiments at a lab meeting rather than a mature paper. In that spirit:

• No numbers in the summary. The update says J++ is "more reliable" across its evals but the short summary does not give figures. The full post is where the experiments are; we have not been able to read its contents, so we do not quote any scores.
• Which models and layers. The summary does not say on which models the evaluations ran.
• Limits inherited from the J-lens. In our coverage of the original work, Anthropic noted that the J-lens only approximately captures the workspace and identifies concepts mappable to single tokens. We have no indication J++ changes that, since it still decodes through vocabulary tokens.
• Independent replication. The J-lens was replicated independently on open models in the summer, as discussed in our earlier posts. For J++, there is no independent result yet that we found.

How to try it, in practice #

1. Open the Circuits update and follow the link to the full J++ post for the experiments.
2. Use the Neuronpedia demo for the interactive view rather than fitting your own lens.
3. If you want to fit a lens yourself on an open decoder model, start from the jacobian-lens repository and its walkthrough notebook; for J++, use the released code and lenses Anthropic references.
4. Compare readouts from the J-lens and J++ on the same prompt. If J++ is doing what Anthropic describes, the noisy tokens should thin out and the bridging concept should rank higher.

Where it sits in the wider interpretability picture #

A quick map for orientation:

If you want the theory side, our post on why AI works from a mechanistic-interpretability view and the SAE additivity work from Wisconsin place lenses next to sparse autoencoders.

Related reading #

Primary sources: Anthropic, Circuits Updates, October 2026 · anthropics/jacobian-lens on GitHub · Neuronpedia.