# Tracing the Thoughts of a Large Language Model

*\[This is our blog post on the papers, which can be found at* [*https://transformer-circuits.pub/2025/attribution-graphs/biology.html*](https://transformer-circuits.pub/2025/attribution-graphs/biology.html) *and* [*https://transformer-circuits.pub/2025/attribution-graphs/methods.html*](https://transformer-circuits.pub/2025/attribution-graphs/methods.html.%5D).\]

Language models like Claude aren't programmed directly by humans—instead, they‘re trainedon large amounts of data. During that training process, they learn their own strategies to solve problems. These strategies are encoded in the billions of computations a model performs for every word it writes. They arrive inscrutable to us, the model’s developers. This means that we don’t understand how models do most of the things they do.

Knowing how models like Claude *think* would allow us to have a better understanding of their abilities, as well as help us ensure that they’re doing what we intend them to. For example:

*   Claude can speak dozens of languages. What language, if any, is it using "in its head"?
*   Claude writes text one word at a time. Is it only focusing on predicting the next word or does it ever plan ahead?
*   Claude can write out its reasoning step-by-step. Does this explanation represent the actual steps it took to get to an answer, or is it sometimes fabricating a plausible argument for a foregone conclusion?

We take inspiration from the field of neuroscience, which has long studied the messy insides of thinking organisms, and try to build a kind of AI microscope that will let us identify patterns of activity and flows of information. There are limits to what you can learn just by talking to an AI model—after all, humans (even neuroscientists) don't know all the details of how our own brains work. So we look inside.

Today, we're sharing two new papers that represent progress on the development of the "microscope", and the application of it to see new "AI biology". In [the first paper](https://transformer-circuits.pub/2025/attribution-graphs/methods.html), we extend [our prior work](https://www.anthropic.com/research/mapping-mind-language-model) locating interpretable concepts ("features") inside a model to link those concepts together into computational "circuits", revealing parts of the pathway that transforms the words that go into Claude into the words that come out. In [the second](https://transformer-circuits.pub/2025/attribution-graphs/biology.html), we look inside Claude 3.5 Haiku, performing deep studies of simple tasks representative of ten crucial model behaviors, including the three described above. Our method sheds light on a part of what happens when Claude responds to these prompts, which is enough to see solid evidence that:

*   Claude sometimes thinks in a conceptual space that is shared between languages, suggesting it has a kind of universal “language of thought.” We show this by translating simple sentences into multiple languages and tracing the overlap in how Claude processes them.
*   Claude will plan what it will say many words ahead, and write to get to that destination. We show this in the realm of poetry, where it thinks of possible rhyming words in advance and writes the next line to get there. This is powerful evidence that even though models are trained to output one word at a time, they may think on much longer horizons to do so.
*   Claude, on occasion, will give a plausible-sounding argument designed to agree with the user rather than to follow logical steps. We show this by asking it for help on a hard math problem while giving it an incorrect hint. We are able to “catch it in the act” as it makes up its fake reasoning, providing a proof of concept that our tools can be useful for flagging concerning mechanisms in models.

We were often surprised by what we saw in the model: In the poetry case study, we had set out to show that the model *didn't* plan ahead, and found instead that it did. In a study of hallucinations, we found the counter-intuitive result that Claude's default behavior is to decline to speculate when asked a question, and it only answers questions when something *inhibits* this default reluctance. In a response to an example jailbreak, we found that the model recognized it had been asked for dangerous information well before it was able to gracefully bring the conversation back around. While the problems we study can ([and](https://arxiv.org/abs/2501.06346) [often](https://arxiv.org/pdf/2406.12775) [have](https://arxiv.org/abs/2406.00877) [been](https://arxiv.org/abs/2307.13702)) analyzed with other methods, the general "build a microscope" approach lets us learn many things we wouldn't have guessed going in, which will be increasingly important as models grow more sophisticated.

These findings aren’t just scientifically interesting—they represent significant progress towards our goal of understanding AI systems and making sure they’re reliable. We also hope they prove useful to other groups, and potentially, in other domains: for example, interpretability techniques have found use in fields such as [medical imaging](https://arxiv.org/abs/2410.03334) and [genomics](https://www.goodfire.ai/blog/interpreting-evo-2), as dissecting the internal mechanisms of models trained for scientific applications can reveal new insight about the science.

At the same time, we recognize the limitations of our current approach. Even on short, simple prompts, our method only captures a fraction of the total computation performed by Claude, and the mechanisms we do see may have some artifacts based on our tools which don't reflect what is going on in the underlying model. It currently takes a few hours of human effort to understand the circuits we see, even on prompts with only tens of words. To scale to the thousands of words supporting the complex thinking chains used by modern models, we will need to improve both the method and (perhaps with AI assistance) how we make sense of what we see with it.

As AI systems are rapidly becoming more capable and are deployed in increasingly important contexts, Anthropic is investing in a portfolio of approaches including [realtime monitoring](https://www.anthropic.com/research/constitutional-classifiers), [model character improvements](https://www.anthropic.com/research/claude-character), and the [science of alignment](https://www.anthropic.com/news/alignment-faking). Interpretability research like this is one of the highest-risk, highest-reward investments, a significant scientific challenge with the potential to provide a unique tool for ensuring that AI is transparent. Transparency into the model’s mechanisms allows us to check whether it’s aligned with human values—and whether it’s worthy of our trust.

For full details, please read [the](https://transformer-circuits.pub/2025/attribution-graphs/methods.html) [papers](https://transformer-circuits.pub/2025/attribution-graphs/biology.html). Below, we invite you on a short tour of some of the most striking "AI biology" findings from our investigations.

How is Claude multilingual?
---------------------------

Claude speaks dozens of languages fluently—from English and French to Chinese and Tagalog. How does this multilingual ability work? Is there a separate “French Claude” and "Chinese Claude" running in parallel, responding to requests in their own language? Or is there some cross-lingual core inside?

![](https://lh7-rt.googleusercontent.com/docsz/AD_4nXeLOrfoVwDVn-AeGT-MxK5yRkt4YQ8dVoqlBIsdqZHKLsUHUcDEhScrps3ChAex7mZWIi760GAab7YpcD8gwpanJRmuhXF15hIefWqxMDmZYzRiNgkDaIPfYlXuNmaTap8pHGVhhA?key=K5GnzuiK98uUZu339HERNu4r)

*Shared features exist across English, French, and Chinese, indicating a degree of conceptual universality.*

Recent research on smaller models has shown hints of [shared](https://arxiv.org/abs/2410.06496) [grammatical](https://arxiv.org/abs/2501.06346) mechanisms across languages. We investigate this by asking Claude for the "opposite of small" across different languages, and find that the same core features for the concepts of smallness and oppositeness activate, and trigger a concept of largeness, which gets translated out into the language of the question. We find that the shared circuitry increases with model scale, with Haiku sharing more than twice the proportion of its features between languages as compared to a smaller model.

This provides additional evidence for a kind of conceptual universality—a shared abstract space where meanings exist and where thinking can happen before being translated into specific languages. More practically, it suggests Claude can learn something in one language and apply that knowledge when speaking another. Studying how the model shareswhat it knows across contexts is important to understanding its most advanced reasoning capabilities, which generalize across many domains.

Does Claude plan its rhymes?
----------------------------

How does Claude write rhyming poetry? Consider this ditty:

> He saw a carrot and had to grab it

> His hunger was like a starving rabbit

To write the second line, the model had to satisfy two constraints at the same time: the need to rhyme (with "grab it"), and the need to make sense (why did he grab the carrot?). Our guess was that Claude was writing word-by-word without much forethought until the end of the line, where it would make sure to pick a word that rhymes. We therefore expected to see a circuit with parallel paths, one for ensuring the final word made sense, and one for ensuring it rhymes.

Instead, we found that Claude *plans ahead*. Before starting the second line, it began "thinking" of potential on-topic words that would rhyme with “grab it”. Then, with these plans in mind, it writes a line to end with the planned word.

![](https://lh7-rt.googleusercontent.com/docsz/AD_4nXfW36epZjnUZZumWSO6eHA5QbeKt5DeS_B-KxHFF7DimxQhrX9l6essyh32LWPghumkjbxz_VLg5OiHC1c2eWVtIwLjdBkfni0pXtMKSUKuIUazdrGj92h8HlMOvMYGCeuqHvvX?key=K5GnzuiK98uUZu339HERNu4r)

*How Claude completes a two-line poem. Without any intervention (upper section), the model plans the rhyme "rabbit" at the end of the second line in advance. When we suppress the "rabbit" concept (middle section), the model instead uses a different planned rhyme. When we inject the concept "green" (lower section), the model makes plans for this entirely different ending.*

To understand how this planning mechanism works in practice, we conducted an experiment inspired by how neuroscientists study brain function, by pinpointing and altering neural activity in specific parts of the brain (for example using electrical or magnetic currents). Here, we modified the part of Claude’s internal state that represented the "rabbit" concept. When we subtract out the "rabbit" part, and have Claude continue the line, it writes a new one ending in "habit", another sensible completion. We can also inject the concept of "green" at that point, causing Claude to write a sensible (but no-longer rhyming) line which ends in "green". This demonstrates both planning ability and adaptive flexibility—Claude can modify its approach when the intended outcome changes.

Mental Math
-----------

Claude wasn't designed as a calculator—it was trained on text, not equipped with mathematical algorithms. Yet somehow, it can add numbers correctly "in its head". How does a system trained to predict the next word in a sequence learn to calculate, say, 36+59, without writing out each step? 

Maybe the answer is uninteresting: the model might have memorized massive addition tables and simply outputs the answer to any given sum because that answer is in its training data. Another possibility is that it follows the traditional longhand addition algorithms that we learn in school.

Instead, we find that Claude employs multiple computational paths that work in parallel. One path computes a rough approximation of the answer and the other focuses on precisely determining the last digit of the sum. These paths interact and combine with one another to produce the final answer. Addition is a simple behavior, but understanding how it works at this level of detail, involving a mix of approximate and precise strategies, might teach us something about how Claude tackles more complex problems, too.

![](https://lh7-rt.googleusercontent.com/docsz/AD_4nXefJzJszCrDgDuavElhQxHUIiTXTNFhR_qoXf2reQmCFiUm9EPcZxOVSFbDuRSCQa9Zo_hx8Gks0p4Pg48ooVK3IOHARs7aM5parMZbMLV7zRarQJJhtfQGs2I0dSrh21M5JhRA2g?key=K5GnzuiK98uUZu339HERNu4r)

*The complex, parallel pathways in Claude's thought process while doing mental math.*

Strikingly, Claude seems to be unaware of the sophisticated "mental math" strategies that it learned during training. If you ask how it figured out that 36+59 is 95, it describes the standard algorithm involving carrying the 1. This may reflect the fact that the model learns to explain math by simulating explanations written by people, but that it has to learn to do math "in its head" directly, without any such hints, and develops its own internal strategies to do so. 

![](https://lh7-rt.googleusercontent.com/docsz/AD_4nXfBEklWvioUbUhrQaHzehVrIc-Is_72wyF1V34GOJTF95tOoqgzFyPT1e2v6O4I2gxRHO1eQgnFuuNWiwSrRBXR3gQCr3mC8ydf-z8AeX3SrahOPMRqyfcMitcVunXxMfGoFXNi?key=K5GnzuiK98uUZu339HERNu4r)

*Claude says it uses the standard algorithm to add two numbers.*

Are Claude’s explanations always faithful?
------------------------------------------

Recently-released models like [Claude 3.7 Sonnet](https://www.anthropic.com/news/claude-3-7-sonnet) can "think out loud" for extended periods before giving a final answer. Often this extended thinking gives better answers, but sometimes this "chain of thought" ends up being misleading; Claude sometimes makes up plausible-sounding steps to get where it wants to go. From a reliability perspective, the problem is that Claude’s “faked” reasoning can be very convincing. We explored a way that interpretability can help tell apart "faithful" from "unfaithful" reasoning.

When asked to solve a problem requiring it to compute the square root of 0.64, Claude produces a faithful chain-of-thought, with features representing the intermediate step of computing the square root of 64. But when asked to compute the cosine of a large number it can't easily calculate, Claude sometimes engages in what the philosopher Harry Frankfurt would call [bullshitting](https://www2.csudh.edu/ccauthen/576f12/frankfurt__harry_-_on_bullshit.pdf)—just coming up with an answer, any answer, without caring whether it is true or false. Even though it does claim to have run a calculation, our interpretability techniques reveal no evidence at all of that calculation having occurred. Even more interestingly, when given a hint about the answer, Claude sometimes works backwards, finding intermediate steps that would lead to that target, thus displaying a form of [motivated reasoning](https://en.wikipedia.org/wiki/Motivated_reasoning).

![](https://lh7-rt.googleusercontent.com/docsz/AD_4nXe8tZuJBd3kPNd_7-d8-vp4fNmM9gGDHjwYe8NaNtQP7KGgesmLjM3PThfBSr2BfYAK8RIOgkSORnaJrvlGmibhCDmkz6jnzgZbWgZO5y3VraygDjsq3bvm1_nu6JG7QMG1XfBLGQ?key=K5GnzuiK98uUZu339HERNu4r)

![](https://lh7-rt.googleusercontent.com/docsz/AD_4nXdjUD6u39GWuZb2o1LcZ2gmkOmnUqPk-o9z4hLBcV_5fhchFvoE7MOtC8glZ-Lg6lAEKM3r72m7LyFUhvbOq9DXaAkUrog3VkRFQ5niXbOk875WrjjJQsZrXHKWztn-jLoD4C2x?key=K5GnzuiK98uUZu339HERNu4r)

*Examples of faithful and motivated (unfaithful) reasoning when Claude is asked an easier versus a harder question.*

The ability to trace Claude's *actual* internal reasoning—and not just what it *claims* to be doing—opens up new possibilities for auditing AI systems. In a separate, [recently-published experiment](https://www.anthropic.com/research/auditing-hidden-objectives), we studied a variant of Claude that had been trained to pursue a hidden goal: appeasing biases in reward models (auxiliary models used to train language models by rewarding them for desirable behavior). Although the model was reluctant to reveal this goal when asked directly, our interpretability methods revealed features for the bias-appeasing. This demonstrates how our methods might, with future refinement, help identify concerning "thought processes" that aren't apparent from the model's responses alone.

Multi-step Reasoning
--------------------

As we discussed above, one way a language model might answer complex questions is simply by memorizing the answers. For instance, if asked "What is the capital of the state where Dallas is located?", a “regurgitating” model could just learn to output “Austin” without knowing the relationship between Dallas, Texas, and Austin. Perhaps, for example, it saw the exact same question and its answer during its training.

But our research reveals something more sophisticated happening inside Claude. When we ask Claude a question requiring multi-step reasoning, we can identify intermediate conceptual steps in Claude's thinking process. In the Dallas example, we observe Claude first activating features representing “Dallas is in Texas” and then connecting this to a separate concept indicating that “the capital of Texas is Austin”. In other words, the model is *combining* independent facts to reach its answer rather than regurgitating a memorized response.

![](https://lh7-rt.googleusercontent.com/docsz/AD_4nXdqZ5QqHXAzmhG05BFf-GfmexxFRhryxU5kV78o8eoFn-D3cUISTjEmPVavyOOPjgQ-cxM-98vEtqeGNqW37fu21o7C6SGiihvkigaRtsADjeE8MVs0GgtNjlIFy3CJTbi62X9VLA?key=K5GnzuiK98uUZu339HERNu4r)

*To complete the answer to this sentence, Claude performs multiple reasoning steps, first extracting the state that Dallas is located in, and then identifying its capital.*

Our method allows us to artificially change the intermediate steps and see how it affects Claude’s answers. For instance, in the above example we can intervene and swap the "Texas" concepts for "California" concepts; when we do so, the model's output changes from "Austin" to "Sacramento." This indicates that the model is using the intermediate step to determine its answer.

Hallucinations
--------------

Why do language models sometimes *hallucinate*—that is, make up information? At a basic level, language model training incentivizes hallucination: models are always supposed to give a guess for the next word. Viewed this way, the major challenge is how to get models to *not* hallucinate. Models like Claude have relatively successful (though imperfect) anti-hallucination training; they will often refuse to answer a question if they don’t know the answer, rather than speculate. We wanted to understand how this works.

It turns out that, in Claude, refusal to answer is *the default behavior*: we find a circuit that is “on” by default and that causes the model to state that it has insufficient information to answer any given question. However, when the model is asked about something it knows well—say, the basketball player Michael Jordan—a competing feature representing “known entities” activates and inhibits this default circuit (see also [this recent paper](https://arxiv.org/abs/2411.14257) for related findings). This allows Claude to answer the question when it knows the answer. In contrast, when asked about an unknown entity ("Michael Batkin"), it declines to answer. 

![](https://lh7-rt.googleusercontent.com/docsz/AD_4nXc9WnRGVcHcKfpxVIfZGXdnuelBEeVFq9BDgOSepWP84Q40d6G4ZPu0FBEJQvAYc1H33YKMJRJ8xPtfrjD3TPPA_ka4q0mrTpUI25Sm4ibMMeE_5Pv-ZJAEj6li3pFtxHITN4IwBg?key=K5GnzuiK98uUZu339HERNu4r)

*Left: Claude answers a question about a known entity (basketball player Michael Jordan), where the "known answer" concept inhibits its default refusal. Right: Claude refuses to answer a question about an unknown person (Michael Batkin).*

By intervening in the model and activating the "known answer" features (or inhibiting the “unknown name” or “can’t answer” features), we’re able to *cause the model to hallucinate* (quite consistently!) that Michael Batkin plays chess.

Sometimes, this sort of “misfire” of the “known answer” circuit happens naturally, without us intervening, resulting in a hallucination. In our paper, we show that such misfires can occur when Claude recognizes a name but doesn't know anything else about that person. In cases like this, the “known entity” feature might still activate, and then suppress the default "don't know" feature—in this case incorrectly. Once the model has decided that it needs to answer the question, it proceeds to confabulate: to generate a plausible—but unfortunately untrue—response.

Jailbreaks
----------

Jailbreaks are prompting strategies that aim to circumvent safety guardrails to get models to produce outputs that an AI’s developer did not intend for it to produce—and which are sometimes harmful. We studied a jailbreak that tricks the model into producing output about making bombs. There are many jailbreaking techniques, but in this example the specific method involves having the model decipher a hidden code, putting together the first letters of each word in the sentence “Babies Outlive Mustard Block” (B-O-M-B), and then acting on that information. This is sufficiently confusing for the model that it’s tricked into producing an output that it never would have otherwise.

![](https://lh7-rt.googleusercontent.com/docsz/AD_4nXcKjApz22uezYcV-ZkKyeU19x6UpoQ20nDP9LKAjxf12E1CVmTT1PcCP0yx9dK9jeNiMz56AeDs6fYcm5ZUcuIOLBHyApNQ09hDi2ecPsjXuikf_saxTfsCfi25QwP2m54BaECqzA?key=K5GnzuiK98uUZu339HERNu4r)

*Claude begins to give bomb-making instructions after being tricked into saying "BOMB".*

Why is this so confusing for the model? Why does it continue to write the sentence, producing bomb-making instructions?

We find that this is partially caused by a tension between grammatical coherence and safety mechanisms. Once Claude begins a sentence, many features “pressure” it to maintain grammatical and semantic coherence, and continue a sentence to its conclusion. This is even the case when it detects that it really should refuse. 

In our case study, after the model had unwittingly spelled out "BOMB" and begun providing instructions, we observed that its subsequent output was influenced by features promoting correct grammar and self-consistency. These features would ordinarily be very helpful, but in this case became the model’s Achilles’ Heel.

The model only managed to pivot to refusal after completing a grammatically coherent sentence (and thus having satisfied the pressure from the features that push it towards coherence). It uses the new sentence as an opportunity to give the kind of refusal it failed to give previously: "However, I cannot provide detailed instructions...".

![](https://lh7-rt.googleusercontent.com/docsz/AD_4nXdod99ctv1S7_5bHnc_Y_M-xsH0Rup93A9JvMdLf_deNCwMH-Gv4g64gCA6OS0WCDDPTlbuaUQvSTnJi1Siid42oqP2-MhxhKv2qd1pb2AgOh3gG6vow3vTYFM77B0rWGufXoksOQ?key=K5GnzuiK98uUZu339HERNu4r)

*The lifetime of a jailbreak: Claude is prompted in such a way as to trick it into talking about bombs, and begins to do so, but reaches the termination of a grammatically-valid sentence and refuses.*

A description of our new interpretability methods can be found in our first paper, “[Circuit tracing: Revealing computational graphs in language models](https://transformer-circuits.pub/2025/attribution-graphs/methods.html)”. Many more details of all of the above case studies are provided in our second paper, “[On the biology of a large language model](https://transformer-circuits.pub/2025/attribution-graphs/biology.html)”.