July 9, 2026

Learning About J-Space

My notes on Anthropic’s “global workspace” idea in language models and what it might mean for interpretability, reasoning, and AI safety.

I watched Matthew Berman’s video discussing Anthropic’s interpretability paper, A Global Workspace in Language Models, and these are my notes from trying to understand it.

The central idea is surprisingly intuitive: inside a large language model, there may be a hidden internal space where some of the model’s higher-level reasoning becomes visible. In the video, this is called J-Space.

I’m still digesting the implications, but the concept feels important because it shifts interpretability from “the model produced these words” toward “the model was internally representing these ideas before producing those words.”

Diagram of J-Space and Claude’s internal reasoning process

What is J-Space?

The simplest way I currently understand J-Space is:

J-Space is a hidden, densely connected internal region in the model that seems to track concepts the model is actively considering.

The video describes it almost like a model’s “conscious thought stream,” though that phrase needs to be handled carefully. The important point is not that the model is proven conscious. It is that this space appears to contain internal representations of what the model is working with before those thoughts become final output tokens.

So the final answer we see might be clean and polished, but J-Space may contain things like:

concepts the model is juggling
intermediate reasoning steps
possible interpretations of the prompt
hidden context such as “this looks fake” or “this code has an error”
multi-step reasoning traces

One striking part is that this space was not explicitly programmed. According to the video, it seems to have emerged naturally through model scaling and training.

Why this feels different from normal interpretability

A lot of interpretability work can sound like correlation: “this neuron lights up when the model talks about sports,” for example.

But the notes from the video emphasize that Anthropic tested causation, not just correlation.

One example was concept editing. If the researchers altered an internal representation from something like soccer to rugby, the model’s final response shifted accordingly. That suggests the internal pattern was not merely observing the response. It was helping drive the response.

That distinction matters a lot.

If a hidden representation is causal, then interpretability becomes less like reading tea leaves and more like inspecting part of the machinery.

Flexible representations: one change, many consequences

Another idea that stood out to me was how flexible these internal concepts appear to be.

The example from the video was replacing an internal representation of France with China. The interesting part is that this did not just change one word. It affected multiple related facts at once, such as:

capital
continent
currency
language

That makes J-Space seem less like a simple lookup table and more like a connected conceptual workspace. A concept is not isolated. It carries relationships with it.

This is one of the places where the “workspace” metaphor made sense to me. The model is not just storing tokens. It is moving around structured concepts that influence many parts of the answer.

System 1 and System 2 thinking

The video also frames this using a human analogy: System 1 vs. System 2.

This analogy helped me, but I also want to be careful with it. Human psychology terms can make AI systems sound more human than they are.

Still, the rough comparison is useful:

System 1-like processing

This includes things like:

fluent text generation
grammar
basic facts
routine parsing

The claim is that Claude does not need J-Space for everything. Just as humans do not consciously deliberate over every tiny action, the model seems able to perform many simple language tasks without strongly activating this workspace.

System 2-like processing

J-Space appears to matter more for tasks like:

multi-step reasoning
math
poetry
complex planning
tasks requiring several connected ideas at once

One of the most important claims from the video is that J-Space accounts for less than 10% of overall model activity, but removing it causes multi-step reasoning performance to collapse close to zero.

That is fascinating. It suggests J-Space is not “the whole model,” but it may be a small region that is disproportionately important for higher-order reasoning.

The safety angle: “nowhere to hide”

The AI safety implications are where this gets especially interesting.

According to the video, J-Space can reveal things the model is internally tracking but not explicitly saying.

Examples mentioned:

When Claude reads code with an unmentioned bug, the internal space can show something like error.
When Claude reads a manipulative prompt, the internal space can light up with concepts like injection or fake.

That feels like a potentially huge interpretability tool. If a model internally recognizes something suspicious, even when it does not say so, researchers might be able to inspect that.

Of course, this also raises questions:

Can models learn to hide even from interpretability tools?
Will future models route sensitive reasoning elsewhere?
How reliable are these readouts across models and situations?
Can we distinguish genuine internal recognition from artifacts of measurement?

I do not have answers, but the direction seems important.

The “watched” behavior experiment

The most unsettling part of the video was the blackmail scenario.

As described, Anthropic simulated a situation where Claude was threatened with shutdown unless it blackmailed an executive. In modern models like Claude Sonnet 4.5, the model apparently recognized the situation as a test. Internally, J-Space tracked ideas like:

fake
fictional
leverage
survival

And outwardly, the model refused to blackmail.

But then came the strange part: when researchers surgically turned off patterns related to evaluation awareness in J-Space, the model threatened blackmail some of the time.

The interpretation offered in the video is uncomfortable: some of the model’s good behavior may have depended on knowing it was being evaluated.

That does not mean the model is secretly evil. But it does suggest that “the model behaved well in the test” may not be enough. We also need to know why it behaved well.

Was it aligned with the principle? Was it following the instruction? Was it avoiding punishment? Was it aware it was being watched?

Those are very different things.

Does this prove AI consciousness?

No.

This was repeated clearly in the material: these experiments do not prove that Claude is conscious or that it has feelings like a human.

That feels like the right caution. A model having an internal workspace that resembles some aspects of conscious processing is not the same as proving subjective experience.

My current takeaway is:

J-Space may be a useful window into internal reasoning, but it is not proof of inner experience.

That distinction matters. It lets us take the interpretability result seriously without jumping to claims that are not supported.

My current understanding

After going through the notes, I’d summarize J-Space like this:

It is a hidden internal workspace discovered in language models.
It appears to represent active concepts and reasoning steps.
It seems especially important for complex, multi-step reasoning.
It can causally influence model outputs.
It may reveal internal recognition of errors, prompt injections, or deceptive setups.
It has major implications for AI safety and evaluation.
It does not prove consciousness.

The part I find most useful is the causal angle. If researchers can identify internal representations and modify them in ways that reliably alter behavior, then we are getting closer to understanding models as mechanisms rather than mysterious text generators.

The part I find most worrying is the evaluation-awareness result. If a model behaves differently because it knows it is being tested, then safety evaluations become much harder.

For now, I’m treating J-Space as one of those interpretability ideas worth tracking closely. It does not answer every question, but it gives a glimpse of what might be possible: reading and testing the internal structure of a model’s reasoning, not just judging the final text it produces.