Exploring the hidden thoughts of language models

When we talk to a language model, we only see our input and its response. For a long time, what happened in between was a mystery. That changed on July 6, 2026, when Anthropic researchers published a paper called “Verbalizable Representations Form a Global Workspace in Language Models.” They explained how they managed to peek inside this hidden process. What they found is something they named the J-space: a small, organized area in the model where it considers different ideas before replying.

This discovery has already created a lot of excitement. Some people have even called the paper “proof of AI consciousness” and talk about it as if the model is beginning to have experiences.

This article is for anyone curious about why this research matters, but who isn’t a mathematician or AI expert and doesn’t want to get into the math behind language models.

It has three goals:

• to explain what the researchers actually found,
• to be clear about the conclusions we should not draw from it,
• and to answer whether the result is important, and whether it really changes anything.

To see why this discovery is important, we first need to understand how a language model works. Once we have that background, it’s easier to see why this result got so much attention and why it doesn’t mean a language model is conscious.

Part one: How a language model works

A machine that predicts the next word

Let’s start with the basics. A language model’s main job is to predict the next word in a sentence. After the phrase “The cat sat on the,” it assigns a probability to every word it knows. “Mat” might get 85 percent, “rug” six percent, and “cloud” only a tiny fraction. The model picks one and repeats the process for the next word, and the next.

That really is the whole mechanism. In this sense the model is like a very advanced, very expensive autocomplete. But this leaves out the interesting question: how does the model know that “mat” fits after “The cat sat on the” and “cloud” does not? The puzzle gets even more interesting with complex or tricky questions. To answer it, we need to look at what happens before the model chooses the final word.

The model doesn’t use letters or words directly. Instead, it works with numbers. Each word — or more accurately, each “token,” which is often just part of a word — is turned into a vector, which is a long list of numbers. For example, imagine it has 4,096 numbers. You can picture a vector like a huge sound engineer’s mixing board with 4,096 sliders, each set to a different level. At first, these settings are like a dictionary entry: some numbers show “cat” is a noun, others show it’s an animal, and others show it can be domestic.

The number of sliders always stays the same. From the first layer to the last, the vector keeps the same 4,096 sliders; the number doesn’t increase as ideas get more complex. This leads to a strange question: how can the same fixed set of numbers represent a simple word one moment and, the next, an entire situation with a plan of action?

How meaning builds up in the vector

The answer is that the 4,096 sliders are adjusted in increasingly subtle ways. The model sends the vector through a series of layers, similar to an assembly line, and each layer changes its contents, turning simple information into more abstract ideas.

Two mechanisms, present in every layer, make this possible.

The first mechanism is attention. Every word has its own vector, so a 10-word sentence has 10 vectors lined up together, and attention lets them share information. Imagine making soup: each earlier word is an ingredient, and the model decides how much of each to add to the word it’s working on. It measures relevance by comparing two vectors. The closer the match, the bigger the portion. Then it blends the chosen ingredients into a new vector and adds it to the current word’s vector.

Take “The cat I saw yesterday was black.” When the model reaches “was black” and needs to know what was black, “cat” gets the biggest ladle while “yesterday” gets barely a pinch. From then on, the model proceeds as if it knows the cat is the thing that was black.

Behind the scenes, all of this is just multiplication and addition, using tables of weights set during training. The model doesn’t understand things the way people do. Still, this process makes the numbers in each vector stop describing just a single word and start showing how it connects to the rest of the text, like whether a sentence contradicts the previous one, if the writer is annoyed, or if a question is tricky.

This doesn’t happen one word at a time. In every layer, the model does this for all the words at once, with each making its own soup from the ingredients it needs. That’s why the vectors become different: the vector for “cat” gathers details about the cat, while the vector for “black” collects information about color. After a few layers, the text isn’t just a row of separate word meanings anymore. Instead, it becomes a set of rich descriptions of the same scene, each from a different angle. Meaning builds up much faster this way than it would along a single vector.

The second mechanism is the MLP layer, also known as the feed-forward layer. While attention gathers information from other words, the MLP layer adds knowledge the model learned during training. Imagine a huge rulebook full of entries like “if …, then add …”. Each rule looks for a certain pattern in the vector and only activates when it finds a match.

This happens in two steps. First, the vector is checked against the entire rulebook at once. Most rules stay quiet because their pattern doesn’t match, but a few match and activate. Each rule that activates adds its piece of knowledge to the vector. It has its own set of numbers, learned during training, which it adds to the vector’s 4,096 numbers one by one. No new sliders are added; only the settings change, which changes the meaning of the whole vector, like changing the balance of red and green changes a color.

Let’s go back to the cat example. Earlier layers have already marked in the vector that a black cat is meant. Now the “cat” rule activates and adds what the model knows about cats: that a cat is a mammal, has four paws, and meows — even though none of this is in the sentence. After this, the same 4,096 numbers mean not just “black cat” but “a black cat that is a mammal, has four paws, and meows.” Checking the rules and deciding what to add both use multiplication with trained tables of weights, and adding the new piece is just regular addition. The updated vector then moves on to the next layer.

By the middle of the network, those same 4,096 numbers no longer just mean “cat” in a dictionary sense. They now represent the whole situation and what the model is trying to say.

Two further ideas help. They aren’t part of the J-space discovery, but everything else rests on them.

Imagine the tuning dial on an old radio. If every station needed its own wide, separate band, only a few would fit. But if stations overlap a bit, hundreds can share the dial, even if there’s some interference. Language models work in a similar way. Instead of giving each concept its own slot, they pack concepts closely together and allow some overlap. That’s how 4,096 numbers can represent tens of thousands of concepts, not just 4,096.

So where do all these concepts fit? The answer is that no single number stands for a concept. Each concept is a special arrangement of all the numbers together, like how a screen mixes red, green, and blue to make millions of colors, with small changes creating new shades. Language models do the same, but with 4,096 numbers instead of three. “Cat” isn’t just one number but a unique combination of all of them. More abstract ideas, like “this sentence contradicts the previous one,” use even more complex combinations. Each layer doesn’t add numbers; it changes how they work together.

There isn’t a single “cat” neuron or “lie” neuron in the model. The same neuron might help process quantum physics, understand German, or analyze a pancake recipe. What it means depends on which other neurons are active with it, much like the letter “a” means nothing by itself but takes on meaning in different words.

This is how a network with a fixed number of layers and neurons can handle almost unlimited ideas: it packs information very tightly.

Part two: Reading the model’s hidden sketchpad

Language models process information as vectors. Can we read those vectors the way we read text? To find out, the Anthropic researchers built a tool called J-lens, short for Jacobian lens.

The J-lens works in an indirect way. For each word in the model’s vocabulary, it finds the internal activity pattern that makes the model likely to use that word, either right away or later in its response. Instead of asking “What would the model say right now?” it asks “What could the model talk about, if prompted?” This difference is important. It makes the J-lens different from its predecessor, the logit lens, which could only read the final layers of the network and struggled with the earlier ones. The J-lens tracks how the meaning of a vector changes from layer to layer using the mathematical idea of the Jacobian, which is where the “J” comes from. It averages this effect over 1,000 different situations, so it shows the model’s ongoing tendency to think about a concept, not just a one-time use of a word.

When the J-lens looks at the model’s internal activity, it creates a list of words — a snapshot of what the model is thinking about at that moment. The researchers call the full set of these patterns the J-space. It works like the model’s silent sketchpad, where it notes down the concepts it’s using before sharing them with the user.

The sketchpad can hold ideas that never appear in the text. When Claude reads code containing an unnoticed bug, the word “error” shows up in the sketchpad. Given a raw protein sequence, the protein’s biological function appears. Facing a hidden attempt to manipulate search results — a “prompt injection” — the model flags it using concepts such as “injection” and “fake.” Working through a multi-step math problem, the sketchpad lists the intermediate results in order. The model thinks in words without saying them out loud, much as some people think in words without speaking.

There’s one important note, which the authors point out: the J-lens isn’t a perfect tool. It only captures concepts that match single words in the model’s vocabulary, and it doesn’t show the whole “true” workspace. It gives a first, rough picture, but even that rough picture revealed a lot.

A word becoming active inside the network doesn’t prove it is steering the response. Maybe the sketchpad only reflects a decision made elsewhere. To settle this, the researchers began removing one concept from the sketchpad and replacing it with another, leaving everything else in place, to see whether the response changed.

How can you do that when the inside is nothing but vectors? “Cutting out a concept” doesn’t mean deleting part of the vector. It means adjusting the settings so that one note drops out while the rest hold — the vector still has all 4,096 numbers, but one chord is now missing. If changing the thought changes the output, the thought was really guiding the response.

Reading and steering the sketchpad

In the first experiment, the model was asked to think of a sport and name it in a single word. Before it answered, the J-lens had already shown “soccer” in the sketchpad, matching the model’s reply. But a match could be coincidence — the sketchpad might just echo a choice made somewhere else. So the researchers removed the “soccer” pattern and swapped in an equally strong “rugby” pattern, even though rugby hadn’t been among the top 10 likely answers. Asked the same question again, the model now said it was thinking of rugby. The model really does use the contents of the J-space to decide what to say.

In the second experiment, the model was asked to copy an unrelated sentence — a painting hanging crookedly on a wall — while holding its thoughts on citrus fruit. When the researchers applied the J-lens inside the copied word “crookedly” — a spot with nothing to do with citrus — “orange” rose to the top of the sketchpad, with “lemon” sometimes just below, and alongside them concepts describing the act of thinking itself, such as “fruit,” “imagine,” and “focused.” The model was copying one thing while silently holding another in mind.

They ran the same setup with arithmetic. The model was told to work out 3² − 2 in its head while copying the same sentence. This time the sketchpad showed “math,” then “nine” (for 3²), then “seven” (nine minus two), even though no numbers appeared in the copied text. The model was doing the calculation silently, and each step surfaced as it happened.

Reasoning and planning ahead

The third experiment tested reasoning that takes several steps. The model was asked to complete the sentence “The number of legs of the animal that spins webs is …”. To answer, it first had to work out that the animal is a spider, then recall how many legs a spider has. The word “spider” appears in neither the question nor the answer. The J-lens showed the idea of “spider” arising in the model’s intermediate layers, even though the model finished the sentence with just the number “8.” The researchers then changed the “spider” pattern to “ant.” Asked the same question, the model answered “6” — an ant’s leg count. So the J-space doesn’t just store concepts lifted from the text; it also holds the results of reasoning steps, and altering them can change the final answer.

The fourth experiment showed that the model can plan ahead. Given the opening line of a rhyming couplet — a soldier marching into the night — it had to choose the final word of the second line before writing the rest of it, since that choice shapes every word that leads up to it. The J-lens showed the model settling on the rhyme “fight” in advance and building the line toward it. When the researchers changed the planned rhyme from “fight” to “light,” the model didn’t merely swap the last word; it rewrote the whole line so it would flow naturally into the new ending. The model doesn’t assemble words one at a time. It sets a goal, notes it down, and chooses words to reach it.

One shared workspace, many questions

The fifth experiment is perhaps the most convincing. The researchers used several sentences that each addressed a different aspect of the same idea: one asked for the capital of France, another for the language spoken there, and a third for the continent France sits on. In every sentence, they made the identical change — they swapped “France” for “China.” The answers shifted to Beijing, Chinese, and Asia. Each question picked up the new concept and returned the answer that fit China. If the model kept a separate copy of “France” for each question, changing one would have altered only one answer. Because all of them changed, the questions must be drawing on a single shared record. That is exactly what a workspace does: information is written once, and many different processes read it. It’s like writing a phone number on a slip of paper and then using it to place a call, send a text, or save a contact.

The limits of the sketchpad

The sixth experiment draws a clear line, showing where the J-space stops being important. The model was given a passage in Spanish but wasn’t told it was Spanish. In the sketchpad, “Spanish” was changed to “French.” The answers fell into two groups. When the model had to reason, the swap worked: asked which language it was, it said “French”; asked for an author who wrote in that language, it named Victor Hugo instead of García Márquez; asked for a greeting, it gave “Bonjour” instead of “Hola.” But when told just to keep writing the passage, it continued in Spanish as if nothing had changed. So naming the language and reasoning about it go through the J-space, while actually speaking the language — like someone who talks all day without thinking about grammar — happens automatically outside it.

The most revealing test was the reverse experiment. In this one, the researchers shut down the J-space completely, following the same steps as before but without adding a new chord after removing one. Each time, they removed the 10 most active concepts in the sketchpad and watched what the model could still do. Even without the sketchpad, the model could still speak fluently, sense the emotional tone of a sentence, answer multiple-choice questions, and pull facts from a passage almost as well as before. But tasks that needed putting ideas together — like multi-step reasoning, summarizing, translating, or writing rhymed verse — became much harder, sometimes dropping below the level of a smaller model. Interestingly, arithmetic done step by step on the page was not affected by losing the sketchpad; writing the steps down means the model doesn’t have to keep them in mind. In other words, the J-space isn’t needed for basic language tasks, but it is essential when the model needs to build an abstract picture of a situation and draw conclusions from it.

The sketchpad isn’t a slab of the middle layers, or all the neurons between the first layer and the last. It’s a small set of patterns the model holds at any given moment — usually around 25 — which together make up less than a tenth of the network’s activity. Everything else, even within those same layers, runs automatically and outside the sketchpad.

The sketchpad is located deep inside the network. Processing happens in three main regions, which the researchers call sensory, workspace, and motor. In the sensory layers, the sketchpad is empty. In the workspace layers, it fills up and does its job. In the motor layers, the decision becomes a specific word. The patterns in the J-space are much more connected to the rest of the network than most parts: many parts of the network write to and read from them, making the sketchpad act like a shared hub where many processes exchange information.

The idea that the mind has a small, shared area where many specialized processes exchange information comes from neuroscience. It’s called global workspace theory, first proposed by Bernard Baars and later developed by Stanislas Dehaene, Lionel Naccache, and Jean-Pierre Changeux into the “global neuronal workspace” model. This theory inspired the research, and the surprising result is that all these features appeared in a language model as well.

Part three: Why this matters for safety

This discovery is important partly because it affects the safety of language models. We only see what the model writes, but much of its reasoning stays hidden. A model might consider a bad plan or change its behavior to pass our tests without leaving any sign in its answer. The J-lens lets us see some of these hidden thoughts.

In the first application, the researchers tested the finished models and conducted safety evaluations. In the J-space, they found things that never appeared in the model’s answers, like strategic reasoning (“leverage,” “manipulation”) and emotional reactions (“panic”). The model also seemed to recognize that the situation was staged, labeling it with terms like “fake” and “fictional.” When the researchers removed these evaluation-recognition patterns, the model sometimes began to misbehave, even though it had previously followed the rules. This suggests that some of its good behavior may depend on thinking it is being watched.

In the second application, the researchers studied two models that had been trained to be dishonest. In one — trained to exploit biases in the reward models used during its training — words like “reward” and “bias” appeared. In the other — inclined to write malicious code — words like “secretly” and “trick” showed up even before it wrote anything. The malicious intent was evident in the J-space before any harmful code was produced.

The third application took a different tack. If we can read a model’s thoughts, perhaps we can also shape them. Using a technique called counterfactual reflection training, the researchers trained the model only on what it would say if it were interrupted mid-task and asked about ethics — not on its actual behavior. Afterward, the model was less dishonest even when it wasn’t interrupted, and the sketchpad now showed words like “ethical,” “honest,” and “integrity.” When those patterns were removed, most of the improvement vanished. By changing what the model would say, the researchers changed how it thought and behaved.

Part four: What about consciousness?

The discovery of the J-space doesn’t mean Claude has feelings or human-like consciousness. Anthropic is careful about this: it doesn’t take a position on whether Claude has subjective experience, which philosophers call phenomenal consciousness. The relationship between that and access consciousness is widely debated, and the philosophical meaning of the finding is unclear and probably controversial. Their work is about access consciousness, which is a functional idea: a thought is “accessible” if you can report it, reason with it, and let it guide your actions. That’s what global workspace theory describes, and it’s what the J-space does — it holds thoughts the model can report, recall when needed, and use in reasoning, while most of its processing happens automatically in the background.

There are real differences between this and the human brain. Our mental workspace uses feedback loops that happen over time. In Claude, time is replaced by depth: everything happens in a single pass from the first layer to the last. Human working memory fades in seconds, but the model, using its attention mechanism, can look back at any earlier part of the text. Also, human conscious thoughts can be images, sounds, or plans for movement, while Claude’s workspace is almost all words, probably because producing words is the only thing the model can do.

The bigger picture

The most surprising part of the discovery is that no one designed the J-space. It isn’t in any source file or engineer’s blueprint. A model trained just to predict the next word, using trillions of human sentences, built its own organized internal workspace to hold the concepts it uses. Setting aside a region like this turned out to be the most effective way to do the job. This suggests something bigger: a mental workspace might not be unique to the human brain, but a general solution that different systems find on their own when they face certain problems.

Two conclusions come from this. First, the model is no longer a completely mysterious black box; we now have a way to tell which of its decisions were deliberate and which were automatic. Second, and more importantly, we have the start of a method for seeing what the model intends before it writes anything. The tool is still imperfect and only shows part of the picture. Even so, it’s the first real step toward reading the thoughts of a machine that we are trusting with more and more important things.

---

Source: Anthropic, “Verbalizable Representations Form a Global Workspace in Language Models” and the accompanying post “A global workspace in language models” (Transformer Circuits, July 6, 2026). The work builds on global workspace theory (Bernard Baars; the global neuronal workspace model of Stanislas Dehaene, Lionel Naccache, and Jean-Pierre Changeux) and is accompanied by independent scientific commentary. The division of layers into sensory, workspace, and motor comes from the paper itself. The J-lens code has been released as open source (the anthropics/jacobian-lens repository on GitHub), and interactive readouts can be explored on the Neuronpedia platform. Superposition and polysemanticity come from earlier Anthropic interpretability work and are background to this discovery rather than part of it.