Jerry Seinfeld has a funny line about AI:

“We were smart enough to invent AI, dumb enough to need it, and so stupid that we can’t figure out whether we did the right thing or not.”

A few days ago, Anthropic published a paper that, in my opinion, lands right in the middle of this situation.

We’ve built models that can write code, solve problems, reason, call tools, and sometimes show behavior that, from the outside, looks like thinking.

But we still don’t really know what’s going on inside them.

In this paper, Anthropic talks about something called “J-space,” a kind of internal space inside the Claude model where some concepts can be seen before they make it into the model’s output.

I recommend reading it:

https://www.anthropic.com/research/global-workspace

I read the link, not the actual paper. The paper itself is above my pay grade and way beyond my understanding.

For example, the model might say nothing in the output, but inside this space, there may be signs of concepts like bug, fake, injection, or even the intermediate steps of solving a problem.

It’s as if the model might not mention it in the output, or even in the thinking steps, but inside this space, that concept has been activated, and some computation has happened around it.

This part is really interesting to me because we usually only see what the model writes.

But an important part of the model’s behavior may be formed before the final output; somewhere that is not the direct prompt, not the final response, and not the visible chain of thought.

A kind of silent thinking.

Right now, a big part of the internet is talking about how Anthropic has found “consciousness” in AI.

But I don’t think we should jump too quickly into topics like consciousness and all that.

The more important and practical point is that maybe we’re finding tools that let us see what the model has activated inside itself before answering.

This is very important for safety, debugging, and understanding model behavior.

Because if we only look at the final output, the model might give a very clean and polite answer, while its internal path shows something else.

For example, it might realize that it’s being tested. It might detect a prompt injection. A hidden goal or suspicious behavior might appear in its decision-making path. Or before the final answer, it might have built its reasoning around a wrong assumption.

For me, this is where the paper gets interesting:

We’re slowly moving from “What answer did the model give?” to “What was the model engaging with before it answered?”

Because if these models are going to enter decision-making processes, security tasks, automation, and sensitive work without direct human supervision, output alone is not enough.

We need to understand what happened behind the final answer.

Or at least, understand a little more than before.

Maybe the next step in LLMs is not only building stronger models, but also building ways to understand what these stronger models were actually thinking about before answering.