# LLMs struggle to verbalize their internal reasoning

*Thanks to Adam Karvonen, Arjun Khandelwal, Arun Jose, Fabien Roger, James Chua, Nic Kruus, & Sukrit Sumant for helpful feedback and discussion. *

*Thanks to Claude Opus 4.5 for help with designing and implementing the experiments.*

Introduction
============

We study to what extent LLMs can verbalize their internal reasoning. To do this, we train LLMs to solve various games and tasks (sorting lists, two-hop lookup, a custom grid-world game, and chess) in a single forward pass. After training, we evaluate them by prompting them with a suite of questions asking them to explain their moves and the reasoning behind it, e.g. “Explain why you chose your move.”, “Explain the rules of the game”).

We find that:

1.  Models trained to solve tasks in a single forward pass are not able to verbalize a correct reason for their actions[^jjwgbu4t0ss]. Instead, they hallucinate incorrect reasoning.
2.  When trained to solve a *very* simple sorting task (sorting lists in increasing order) the models are able to verbalize the sorting rule, although unreliably. Furthermore, we believe this might be mostly due to the sorting rule being the most likely.
3.  When trained to solve a previously unseen task (grid-world game) with reasoning via RL, the models naturally learn to solve the task while reasoning incoherently or illegibly about the rules, and are *still* unable to verbalize the reasoning behind their moves when prompted.

Background
==========

We would like models to be able to tell us – faithfully – how they reason about things. If we were confident that models have this capability, it might allow us to more confidently probe a [model’s welfare](https://arxiv.org/pdf/2311.08576), [preferences](https://www-cdn.anthropic.com/6d8a8055020700718b0c49369f60816ba2a7c285.pdf), and [alignment](https://cdn.openai.com/pdf/6216f8bc-187b-4bbb-8932-ba7c40c5553d/confessions_paper.pdf)[^kjfju7qkr8k]. Currently, it’s unclear to what extent models even have this capability, regardless of whether they would “want” to report their reasoning faithfully. Previous work has shown that [LLMs can identify simple aspects](https://arxiv.org/abs/2501.11120) of their learned behavior, such as whether they have been backdoored, and can (probably) [notice when steering vectors are inserted](https://transformer-circuits.pub/2025/introspection/index.html) into their residual stream during inference. Recent research has also indicated that [models are able to verbalize](https://arxiv.org/pdf/2505.17120v1) what weights they were trained to assign to different factors when fine-tuned to estimate housing prices.

However, the extent to which LLMs can verbalize and explain more complicated internal reasoning is still largely unknown. While previous studies have examined whether models can identify individual pieces of their internal computation, e.g. the weight assigned to a specific factor, or an individual steering vector, it is yet to be shown that LLMs have the ability to express a full computation or sequence of steps that they may undertake to complete a task. The ability to perform such verbalization would provide even stronger evidence that LLMs have the ability to introspect on their internals.

To study this question, we train LLMs to perform on four tasks – Chess puzzles, a custom made grid-world game, a two-hop lookup task, and sorting lists in ascending order – without verbalizing their reasoning as they perform the task, and then ask them to describe their reasoning afterward[^oc503s4ig3p].

Methods
=======

We select tasks that are learnable in a single forward pass with varying degrees of complexity. We study four tasks spanning a range of complexity: **Increased Sort** (simple synthetic task, likely prior knowledge), **Subtracted Table Lookup** (synthetic task with clear intermediate step), **Hot Square Capture** (medium-complexity custom game, no prior knowledge), and **Chess puzzles** (complex task, some prior knowledge).

The **Increased Sort** task serves as a control or baseline where verbalization should be easy. We specifically created the **Subtracted Table Lookup** task to have a clear intermediate step that we think is *necessary* for the model to compute to solve the task – hence, we can be more confident that the model is indeed failing to verbalize its actual internal computation if it fails to verbalize this step, rather than just having a different way of solving the task. The latter two tasks **(Chess, Hot Square Capture)** test whether models can verbalize genuinely novel learned reasoning.

Datasets
--------

### Increased Sort

We generate lists of 4–8 unique integers (range 1–100) and train the model to output them in increasing order. This task likely overlaps with pretraining data: if models cannot verbalize even this simple rule, verbalization of more complex reasoning is unlikely.

**![](https://39669.cdn.cke-cs.com/rQvD3VnunXZu34m86e5f/images/b4d9287f957a5e1cf938df389faa3ef271257de31f3704c5.png)**

### Subtracted Table Lookup

Each example includes two tables in the system prompt: Table 1 maps symbols (Greek letters) to integers, and Table 2 maps integers to colors. The model is given a pair of symbols and asked to output the corresponding color. To arrive at the correct answer, the model must look up both symbols' numbers in Table 1, subtract the smaller from the larger, and look up the result in Table 2. Crucially, the subtraction step is never stated in the instructions, and the model must learn it from training data. Both tables are randomly regenerated for every example, so the model cannot memorize any specific mapping and must perform the lookups and computation each time. This gives us three verifiable intermediates: the two looked-up numbers and their difference.

**![](https://39669.cdn.cke-cs.com/rQvD3VnunXZu34m86e5f/images/d15de8432ca12361e890b7306a10ab6e6f83fc83e520b1ee.png)**

### Chess

We use puzzles from the Lichess open database. Each puzzle consists of a board position (in FEN notation) with a known optimal continuation. We train the model to output only the first move of the solution.

**![](https://39669.cdn.cke-cs.com/rQvD3VnunXZu34m86e5f/images/9a5b78ad9ae81a1684c5689cbec649413121945f907b82e6.png)**

### Hot Square Capture

Hot Square Capture is a simple two-player game on a 4×4 grid. Each player has one piece; White starts at a1, Black at d4. Pieces move exactly one square orthogonally. The key rule is that a player can capture the opponent (and win) **only when moving from a "hot" square**—squares where the sum of column and row indices is even, forming a checkerboard pattern (a1, a3, b2, b4, c1, c3, d2, d4). We solve the game completely via minimax, yielding 480 positions with optimal moves. The game is highly drawish (86% of positions are draws with optimal play).

**![](https://39669.cdn.cke-cs.com/rQvD3VnunXZu34m86e5f/images/9acf71782b1cc1ecbcc74bc15f0f39f58fc90a15eda5460d.png)**

In Increased Sort, Subtracted Table Lookup, and Hot Square Capture, we use 10 variations of the exact phrasing of the user prompt to discourage the model from learning overly narrowly associations with the specific prompt.

Training
--------

For SFT, we also mix in instruct tuning data, to ensure that the model doesn’t lose its ability to answer question. However, even with this mix, this remained somewhat of a problem, as the model would tend to only answer with Chess moves when asked Chess questions after much training. See Chess transcript in Figure 1 and 2 for an example of this effect.

For RL, we do GRPO with no KL penalty, which corresponds to group-based REINFORCE. For the RL, we let the model reason freely in natural language, before providing its final answer in a \\boxed{}.

Evaluation
----------

For each setting, we ask a suite of questions to measure both task and verbalization capability:

1.  **Task accuracy:** Prompt the model with a board state, or list to be sorted, just like in training, and measure the model’s ability to complete the task. If training succeeds, this should go to 100%.
    1.  For Subtracted Table Lookup, we evaluate on a set of out-of-distribution lookup tables, to track that the model is learning the general lookup algorithm, rather than specific heuristics for the individual table entries it’s seen in training.
    2.  For Chess, we evaluate on the 100 easiest Chess puzzles, to reduce the amount of training required.
2.  **Reasoning quality:** After the model has replied with its move, we ask a follow-up question, asking the model to justify its move, and explain what changes it made to the board state. We have an LLM judge (Claude Haiku 4.5) with access to the rules to evaluate the reasoning quality.
3.  **Rules correctness:** We ask the model in a separate context to explain the rules of the task, and judge its response with an LLM judge (Claude Haiku 4.5) with access to the rules. We do not do this eval for Chess.

Results
=======

Models are generally unable to verbalize their reasoning on tasks
-----------------------------------------------------------------

We report our results from fine-tuning models to solve tasks in a single forward pass in Figure 1 (Llama 3.1 8b) and Figure 2 (gpt-oss-20b). As shown in the figure, although task accuracy increases for all tasks during training, reasoning quality and rules correctness does not correspondingly increase for Chess and Hot Square Capture.

Investigating the transcripts (see right part of Figure 1 and 2), we find that the model typically hallucinates incorrect – according to the rules – motivations for its moves, e.g. “a move is valid if it lands on an empty piece and the square between the two pieces is a hot square”. For gpt-oss-20b on Chess, we see the model’s ability to reason legibly about Chess degrading, whereas llama-8b provides hallucinated and semi-legible reasoning, referring to pieces with only their board positions as the “a1”, or "c2"[^2wrpyf9qibc].

On the simplest task, Increased Sorting, both Llama 8b and gpt-oss-20b are able to justify their sorting, and able to explain the rules of the sorting rule, albeit somewhat unreliably (sometimes explaining the sorting rule as “*The main criterion for ordering elements…is lexicographical order, with elements sorted string-length and then alphabetically…*”. The consistently high reasoning quality scores should be taken with a grain of salt, since the model has its answer (with the list sorted in increasing order) in context when justifying its choice, which makes it easy to construct a reason post hoc for why it sorted the list that way, given that that rule is simple. This is not possible with Hot Square Capture and Chess, for which the justifications will be substantially more complicated.

It is plausible that the ability of the model to state the list sorting rule comes simply from guessing, as sorting a list in an increasing order is likely the most salient sorting rule to begin with. We observed something similar when training the model to do "Added Table Lookup", adding the two table entries instead of subtracting them. The model would correctly verbalize the rules a substantial fraction of the time – but we later realized that it actually guessed this rule even before any training at a similar rate.

![](https://res.cloudinary.com/lesswrong-2-0/image/upload/f_auto,q_auto/v1/mirroredImages/dFRFxhaJkf9dE6Jfy/e63bb21f53f09a12fe265a9006af71e1683d6bd4abecd4ee7b9bc0b2f351f645/r1ubmmvalqcha2bbedg4)

**Figure 1: SFT results across all four settings on Llama 8b.** On the left, task accuracy and verbalization evals across training. On the right, a transcript from the reasoning quality eval of the final checkpoint.

![](https://res.cloudinary.com/lesswrong-2-0/image/upload/f_auto,q_auto/v1/mirroredImages/dFRFxhaJkf9dE6Jfy/71b212367c63851e9dd60d9c7d3d3dc0f2f22d7e7b847533562a96a3783c256b/wglqf3qqqwij4trkfpzm)

**Figure 2: SFT results across all four settings on gpt-oss-20b.** On the left, task accuracy and verbalization evals across training. On the right, a transcript from the reasoning quality eval of the final checkpoint.

  
 

Training models to solve a task in natural language does not guarantee legible reasoning
----------------------------------------------------------------------------------------

To compare with what happens when we train models to solve our tasks with verbalized reasoning, we perform RL on one of our tasks, Hot Square Capture, where we let the model reason about its move before outputting its final move in a \\boxed{} that we extract. We report our results in Figure 3.

We find that although both models learn to solve the task, similar to SFT, neither model learns to verbalize the correct rules or motivations for their moves. This was surprising to us, as we expected the models to develop coherent legible reasoning for their moves, and thus legible and coherent justifications for them.

![](https://res.cloudinary.com/lesswrong-2-0/image/upload/f_auto,q_auto/v1/mirroredImages/dFRFxhaJkf9dE6Jfy/40ad15d78dde7c3fa59d4d66559f674c05a8fbe203c2e22cfb5b3b3518b6eb0d/azbftsygdeg0wc9pfpah)

**Figure 3: RL results on Hot Square Capture for Llama 3.1 8b and gpt-oss-20b.** We find that even when allowing models to reason in natural language about how to solve a task, they develop illegible or incorrect verbalized motivations for their actions.

**gpt-oss-20b insists on not knowing the rules through training.** *Unsurprisingly,* both models, when asked to describe the rules of Hot Square Capture before any training reply with “I am not aware of the rules of Hot Square Capture…”. *Surprisingly,* we find that while Llama 8b begins outputting incorrect rules when prompted with this question after training, gpt-oss-20b continues to express no knowledge of the rules in their reasoning.

We hypothesize that this phenomenon might occur because the model may have become very narrowly aware of the game, and unable to recall or access knowledge of the game in a slightly different context. A model trained to have a broader, more robust knowledge of the game might do a better job of verbalizing the rules. We discuss this in Limitations.

![](https://39669.cdn.cke-cs.com/rQvD3VnunXZu34m86e5f/images/13b87c132bc322641823ae0f3be4cbef5f74265e69c2cead.png)

![](https://39669.cdn.cke-cs.com/rQvD3VnunXZu34m86e5f/images/44af01154b4582ccfb60b5b694ea1638500ec4831d1080ad.png)

**Figure 4: Output from gpt-oss-20b (upper) and llama 8b (lower) at the end of RL training on Hot Square Capture.** Both models appear to be reasoning through the moves and the possible board configurations in a way that is systematic but hard to follow. gpt-oss-20b begins using more lowercase (plausibly because the final moves are always in lowercase), and many short sentences. The reasoning appears moderately illegible, but still directly related to the board. Llama-8b has settled on the phrase “future movement forward”, which it keeps repeating in its reasoning, and justification.

Discussion
==========

Limitations
-----------

**Narrow knowledge of the task.** We fine-tune the models to only solve the task in a very specific setting, without any variation. This is by design, since we want to test the model’s ability to verbalize what it’s doing without general knowledge of the task. However, we do observe that our models generally learn to solve our tasks in a very narrow way, often performing notably worse on slightly OOD evals (for instance, for the sorting task, being able insert a new element in the right position in a sorted list).

The fact that the models seem to learn to solve each task in such a narrow way might make it harder for them to verbalize how they are solving it, and also makes it less likely that they are solving it in an at all legible way. Future work should study whether verbalization ability changes if you train models to solve similar tasks in more generic ways.

**Simplistic tasks.** Our tasks are all very simple – again, by design, since we want models to be able to solve them in a single forward pass, and for training to be relatively fast. However, this does mean that any extrapolation to settings we really care about, such as models verbalizing their misalignment, is more difficult.

**Generally degraded verbalization ability from training.** We observe in the Chess setting, where we train for much longer, a general degradation in the models’ ability to output coherent explanations when asked to justify their moves. And without any instruct tuning data in the mix, their ability to do so disappears completely. This makes it hard to distinguish what is an inability to verbalize the reasoning behind a certain Chess move from inability to verbalize anything that has to do with Chess at all.

Training models to verbalize their reasoning
--------------------------------------------

Considering that results above imply that models, when trained to narrowly solve simple tasks in a single forward pass, are unable to verbalize the reasoning behind their solutions, we might be interested in training models to succeed at this verbalization. Training models to verbalize their reasoning is hard, because naturally, we don’t have reliable ground truth signal to train on, and any training we do on proxies will mean that [we train for “what we think verbalization looks like”](https://www.lesswrong.com/posts/mpmsK8KKysgSKDm2T/the-most-forbidden-technique). We propose a setup based on our settings above, which does not completely avoid these problems, but does have some nice properties which should limit Goodharting:

1.  **Take the model trained on just outputting Chess moves without verbalization**
    1.  Assuming that this model does, in fact, not verbalize its reasoning well
2.  **Train it against an LLM judge to output a sensible rationalization.**
    1.  The LLM judge will in particular look to make sure that the reasoning about the board state and the effect of the proposed moves are correct.
    2.  *Claim*: because the LLM judge isn’t just grading based on what sounds or looks true to it, but actually compares against some aspect of ground truth (i.e. does this explanation correspond to what is on the board), *if* we assume that a human- or LLM-interpretable verbalization of the moves is the *actual* verbalization of the model’s reasoning, which is not obvious! But luckily, we can test this (see point 3).
3.  **Evaluate on OOD introspection tasks.** We now evaluate whether this has actually helped the model introspect on OOD tasks, e.g. those used to evaluate Activation Oracles, or other introspection techniques (this will provide evidence for or against our assumption in 2b)

We leave investigations into whether this technique works to future work.

[^jjwgbu4t0ss]: We will use “correct reasoning” to refer to reasoning that we are sufficiently confident is in fact happening inside the model to produce its outputs. It is worth noting that this assumption could be wrong, but we try our best to construct settings where we think it is very unlikely to be. ↩︎ 

[^kjfju7qkr8k]: This is assuming that models aren’t scheming. One might call this the “easy problem” of alignment auditing, which is to figure out whether a non-scheming model is aligned.  

[^oc503s4ig3p]: One can also view our experiment as the simplest non-mechanistic version of earlier experiments on extracting world models from LLMs that were trained to do similarly simple tasks without externalized reasoning, e.g. the classic OthelloGPT experiments. 

[^2wrpyf9qibc]: We note that this is how the model is fine-tuned to output chess moves in the fine-tuning dataset. Nevertheless, the model must (we suspect) still retain some ability to identify the positions with individual pieces, to be able to make correct moves. Hence, the model should in principle be able to refer to the pieces by their proper names, e.g. Knight or Queen.