# How Language Models Use Ideas Before Putting Them Into Words

> To understand how a model can use an intermediate result without writing it down, follow what it represents, how later computation uses it, and what changes when it becomes language.

Published: 2026-10-25 · Lumisonde (https://lumisonde.com/reports/internal-thought-workspace/)
Citations JSON (per-claim receipts): https://lumisonde.com/reports/internal-thought-workspace/citations.json
Serial: Inside Language Models (https://lumisonde.com/serials/model-activations-to-language/)
Role in this serial: Understand the work before the words — Builds the foundation: how numerical representations remain accessible and become inputs to layers, attention and additional latent steps.
Next in recommended reading order: https://lumisonde.com/reports/model-activations-to-language/

## The brief

**Question:** How do language models maintain and work with information they have not yet put into words?

**Stake:** An answer or explanation is only the visible part of a model’s processing. Understanding the work behind it helps us ask what the model has actually represented and used.

**Answer:** Language models can use unspoken information because their numerical states can supply inputs to later computation before any word is selected. Layers transform those states, while attention lets a new position draw on information from earlier ones; specially trained systems can add further steps without choosing a word each time. Experiments that change an intermediate and observe a changed answer show that some internal content matters to later work, though a readable state or an extra processing step alone does not establish that connection. Once words are generated, they become context for further processing, so a model’s explanation may draw on both internal information and what it has already said.

Ask a model how many legs belong to the animal that spins webs. It can answer “8” without ever saying “spider.” The missing word poses an interesting question: did the model use an internal representation of the animal on its way to the answer, or did it arrive at the number by some other route? A July 2026 study of Claude models tests this directly. Changing an internal spider-associated representation to an ant-associated one changes the leading answer from 8 to 6. An unspoken intermediate can influence what the model does next. [1]

Here, an “unfinished idea” means information represented in the model’s numerical activity that can be useful to further computation: an inferred identity, an association, an intermediate quantity, or a possible destination for a sentence. It need not already have the form of a sentence. The central question is how that information becomes an input to another operation.

The answer connects three processes. Layers transform a current state, while attention makes information from earlier positions available to it. A later operation can use an intermediate as an argument or a constraint. [1] Eventually, an output head produces vocabulary scores from which a token is selected; that token then provides context for more computation. Specially trained systems can also extend processing without selecting a word at each step, by feeding numerical states into new positions [3] or repeatedly applying a processing block. [4]

Following these connections gives us a way to distinguish an internal representation, continued work on a problem, and a verbal explanation of that work. They can interact closely without being the same thing. First we need to understand what a readable internal state tells us; then how it remains usable, how models can spend additional silent steps on it, and what changes when the result becomes language.

## An intermediate is more than its readable label

A transformer processes text at token positions, where a token may be a word, a word fragment, or a punctuation mark. At each position, layers read and update a numerical vector often called the residual stream. [1] An intermediate computed by one layer can therefore supply information to later layers before a next token has been selected.

The Claude study introduces the Jacobian lens, or J-lens, to inspect some of that information. It estimates how changes in numerical activity would affect present and future vocabulary outputs, averaged across contexts. This links directions in the state to tokens the model is disposed to verbalize under suitable conditions. In the animal example, *spider* and *ant* label two such directions that researchers can inspect and change. The labels interpret numerical content; they do not mean the state consists of those words or must output them next. The authors call sparse combinations of these vocabulary-linked directions the J-space. [1]

In the animal experiment, researchers swap the amounts assigned to the spider and ant directions—the lens coordinates—across token positions over a layer range, leaving components outside the two directions’ span unchanged. They then let computation continue, and the leading answer shifts from 8 to 6. They also compare changing the intermediate with changing the answer itself: intermediate swaps become effective earlier in depth. [1] These observations support the interpretation that the inferred animal supplies an argument to a later property lookup, and weigh against explaining the result solely as a disguised injection of the desired number.

This is a stronger claim than finding that a probe can predict the animal from an activation. It connects the candidate representation to a downstream operation. Its transfer across models is nevertheless uneven. In his Anthropic-commissioned review on LessWrong, Neel Nanda reports Qwen3.6-27B experiments conducted with his collaborators. He reports that some multilingual and typo-related effects replicated, but, when comparing answer and intermediate swaps on their multihop dataset, writes that “swapping the answer turned out to strictly dominate.” He suggests that the facts the smaller model could answer might permit simpler associations. [5] The Claude result therefore demonstrates a usable intermediate in those experiments, rather than establishing that every apparent two-step answer uses the same mechanism.

Even a correct concept label leaves out an important part of an idea: its organization. Consider the illustrative facts “Alice lives in Paris” and “Bob lives in Rome.” A list containing Alice, Bob, Paris and Rome cannot tell us who lives where. A useful state must preserve the associations as well as the items.

Feng and Steinhardt study this problem in controlled entity–attribute tasks, principally with LLaMA-30B. Their evidence supports a binding mechanism in which an entity and its associated attribute carry matching identifier components. Applied to the illustration, the proposed mechanism would link Alice to Paris through a shared identifier, and Bob to Rome through another. A query about Alice could then retrieve the city with her matching identifier. The intervention observations are distinct: changing the identifier components on the entity side reverses the associations; changing the attribute side also reverses them; changing both restores them. Random directions of the same magnitude do not reproduce the effect. The interventions hold other context activations fixed [6], isolating stored associations rather than allowing the altered context to be reconstructed.

The binding study does not map those identifiers into Claude’s J-space. Taken together, the findings instead clarify what an account of unfinished content needs to explain: both what is represented and how its parts are related. A readable collection of words can expose useful ingredients while leaving their arrangement unseen. [1]

## Keeping content available means providing a route to use it

So far, we have followed later layers processing the same token position. When the model generates another token, it processes a new position. Information from earlier positions can reach that new computation through attention.

In ordinary full-attention, causally masked decoding, each attention layer produces keys and values for processed positions. The current position’s query determines how strongly to weight those keys, and the corresponding values contribute to its current representation. A key–value cache stores the earlier keys and values so their computation need not be repeated at every decoding step. New positions add new entries; future tokens do not retroactively revise the old causal representations. Sliding-window caches can discard older entries, so this append-only account applies to the ordinary full-context setting. [2]

The cache thus supplies material for a new computation to consult. [2] It does not independently keep calculating while the model waits to emit the next token. The current forward computation must select and combine what it reads. Nor does finding similar content at successive positions settle whether a previously inferred intermediate was carried forward or reconstructed from the still-accessible prompt. The workspace experiments demonstrate continuity, interventions and relay routes without isolating those two explanations.

The workspace study identifies attention heads whose weight transformations preferentially relay J-space directions while preserving their labels. Removing these heads disrupts the lens contents and reporting of an injected concept more than removing equally many layer-matched random heads. [1] This connects a proposed route to a downstream effect, rather than inferring communication from attention weights alone.

Reporting a passage’s language and continuing that passage can use information differently. In another experiment, the model reads a Spanish passage and researchers replace its Spanish-associated lens direction with a French-associated one. Its explicit language report changes, as do answers to flexible questions about the language. Its continuation nevertheless remains Spanish, and its detection of an out-of-place foreign-language sentence largely survives. [1] The same readable label is present across these tasks, but the tested direction matters to some operations and not others.

This makes “keeping an idea available” more precise. Storage preserves possible inputs; a current representation makes selected information usable; a downstream computation determines what role that information plays. A model need not route every use of the same information through one shared, readable variable.

The information being used can also describe a destination rather than an established fact. In a 2025 study of Claude 3.5 Haiku, researchers identified prospective rhyme-ending features before the model wrote the corresponding line. Suppressing *rabbit*-related features shifted the phrasing toward *habit*. [7] When researchers resampled the whole line after steering the planning features, its construction changed toward the steered ending. They detected planned-word features in about half the poems investigated, a rate that could reflect both incomplete detection and variation in strategy. In the demonstrated cases, the unspoken ending helps organize words that come before it.

An intermediate can therefore supply either something to calculate from or something to construct toward. What makes it operationally useful is the route by which later computation receives it.

## Additional silent work needs another computational step

A normal forward pass already performs many transformations before selecting a token. Extending that work requires an implemented route for another transformation. Two research systems make the alternatives concrete.

Coconut feeds the final hidden state at one position directly into the next position as its input embedding during a marked latent interval. Ordinary language generation instead selects a vocabulary token and feeds that token’s embedding into the subsequent position. Coconut’s new positions can attend to the earlier question and latent positions, so the process need not depend only on its immediately preceding vector. Its training curriculum gradually replaces early written reasoning steps with continuous states, while training the model to predict the remaining text. Each additional latent position requires another sequential forward computation. [3]

The recurrent-depth model Huginn adds steps along a different axis. A prelude transforms the input into an embedding; a shared core repeatedly receives that embedding together with the preceding latent state; a coda converts the resulting state into output probabilities. Reusing the core adds depth without requiring a separately parameterized block for every iteration. The model is pretrained for this arrangement, including variable recurrence counts. Its gains from additional recurrence saturate differently across tasks and contexts. [4]

The distinction is where the next transformation occurs: another sequence position in Coconut, another iteration through a shared block in Huginn. Both require training that makes the route useful, and both spend additional computation. A preserved state, an extra step and a useful operation are separate ingredients.

That separation matters when interpreting success on a reasoning task. Coconut’s original paper describes continuous states as supporting a breadth-first-search-like process on ProsQA, a synthetic graph-proof task. Its evidence includes decoding distributions over possible concepts at successive latent stages. These readouts suggest how alternatives might be represented, but do not by themselves establish that each decoded alternative is used to expand a search frontier. In the paper’s GPT-2 experiments, Table 1 reports ProsQA accuracy of 96.6 ± 0.8% for pause-as-thought and 97.0 ± 0.3% for Coconut. [3] The pause-as-thought variant uses the same multi-stage training curriculum as Coconut. [3] Continuous feedback does not uniformly outperform written reasoning across the tested tasks. These comparisons leave training as a material contributor.

An independent October 2026 preprint asks directly what the latent chain contributes. Across 21 model–task configurations using GPT-2 and Llama-3.2-1B-Instruct, it deletes latent slots and separately replaces their supplied vectors with norm-matched noise, a dataset-mean vector, or states from another problem. Replacement retains the slots, with later states recomputed and the question still accessible. This distinguishes losing processing opportunities from changing the information supplied through them. [8]

On a frozen set of 300 ProsQA problems, the tested GPT-2 Coconut checkpoint scores 97.3% both intact and with its latent chain deleted; no individual answer changes. [8] On GSM8k arithmetic, the corresponding Coconut arrangement falls from 33.3% to 10.3% after deletion, and replacing states with another problem’s vectors lowers intact accuracy by 30.7 percentage points. [8] The feedback route can therefore carry dispensable states in one tested setting and behaviorally consequential content in another.

The study finds a third pattern on ProsQA with a Llama model trained with supervision at each latent step. Removing the chain sharply hurts performance, but none of the tested content replacements changes an answer. The authors call this a placeholder signature. Because the question remains available, later computation may still obtain problem information elsewhere. Dependence on the slots does not establish dependence on the particular problem-specific vectors fed into them. [8]

These results separate an opportunity to process from dependence on the content supplied through it. Keeping the slots while replacing their vectors tests that distinction with the question still accessible and later states recomputed. In these settings, the behavioral effects help connect supplied content to later work without tracing every operation of the intact computation. A moving or readable state alone cannot make that connection.

## Becoming words changes the next computation

At a language-generation step, a learned output head maps the final hidden state to vocabulary scores. A softmax turns these scores into probabilities, and a decoding rule selects a token. The selected token’s embedding becomes an input at the next position. [3] This is the handoff that Coconut bypasses during its latent interval. Selecting one token exposes one discrete continuation, while attention can still give later positions access to earlier contextual representations.

Words can consequently do two jobs: communicate a result and supply an intermediate for more work. A written chain of thought places statements into the context from which subsequent processing proceeds. Whether the model actually relies on those statements is experimentally testable.

Lanham and colleagues truncate chains, introduce mistakes, paraphrase passages and replace reasoning with filler tokens. Their 2023 experiments, mainly on a 175B RLHF assistant across eight multiple-choice tasks, find substantial task-dependent reliance on the written chain. Changing or removing it can redirect the answer in some tasks while having little effect in others. Paraphrasing largely preserves performance, suggesting that the useful contribution in those experiments need not depend on the exact phrasing. [9]

The words themselves are not the only possible resource. In a deliberately trained 34M-parameter transformer, Pfau and colleagues show that repeated filler tokens can provide useful hidden computation on synthetic 3SUM and transformed-2SUM tasks. [10] Learning this behavior requires particular supervision; filler-only and serial-reasoning training ablations fail to teach comparable use. Repeated dots do not verbally explain a solution, but their positions can host numerical representations that help produce one. [10]

Language therefore does not mark a clean boundary between computing and communicating. Generating a meaningful sentence can make an intermediate available for further calculation; generating an uninformative token can also create another computational position when training has taught the model to use it. The visible text alone does not identify which contribution produced the answer.

## Reporting an internal state is another task

A verbal explanation adds a further demand: the model must produce words about its own processing. The workspace study finds positive links between internal directions and reports under elicited conditions. In its injected-concept experiment, the researchers prefill a claim that the model detected an injected thought. Injecting a concept into the user-turn activations then makes that concept reportable at the requested location, without forcing it into every earlier assistant position. This supports selective reportability, rather than an unconditional tendency to emit the injected word. [1]

In a preliminary first-party report on his personal GitHub Pages site, Garcia describes a response-order experiment. It uses Qwen3.6-27B with thinking disabled, deterministic decoding, 20 one-word factual tasks and concept injections during prompt processing. Garcia reports that, across 1,560 positive-strength trials per response order, injections steer the factual answer to the target 450 times when the answer comes before the report and 454 times when the report comes first. [11] He reports 322 exact target reports after the answer and zero before it. [11] Every exact after-answer report follows a steered answer. [11]

The response-order pattern is consistent with a model using its already-generated answer as evidence for the later report, but does not prove answer-based reconstruction. This single-model experiment is not a direct replication of the Claude study’s prefilled reporting protocol. Its substantive lesson is that influencing an answer and reporting the influential content can come apart. Output order changes what information is available when the model explains itself. [11]

This closes the loop between internal state and expression. A report may draw on an internal representation, on earlier generated words, or on both. A chain can influence an answer without describing every influence on it. Establishing causal use answers a different question from establishing a complete verbal account of the computation.

## Conclusion

Language models can work with unspoken information because selecting a word is only one use of a numerical state. An inferred identity can supply a property lookup; a binding can preserve who has which attribute; a prospective ending can constrain the construction of a sentence. Layers and attention provide routes through which later computations can receive such information. Trained feedback or recurrence can add further transformations before language readout.

The useful connection is an unfinished result becoming an input to further work. Reading a concept from a state, preserving access to information, spending another processing step and verbally explaining the result each reveal a different part of that connection. Keeping those parts separate makes both the positive interventions and the latent-chain failures intelligible.

The next mechanism question is how models select, organize and refresh the intermediates that later operations actually consume. Answering it requires more than a better-looking internal readout: it requires tracing what changes, what survives, and what downstream computation does differently because of it.

## Limitations

This account concerns functional mechanisms in the studied transformers and specially trained latent systems, using evidence available through October 24, 2026. It does not establish subjective experience or a universal internal language. Vocabulary-linked lenses recover only part of a state, and concept lists leave relational organization unresolved. The binding results do not establish that Claude uses the same identifiers. Nanda’s LessWrong review reports uneven transfer in his team’s Qwen experiments. [5]

Across-position continuity remains incompletely explained: the workspace evidence does not isolate carrying a naturally inferred intermediate forward from reconstructing it using available context. Nor do the latent-system studies settle a general advantage over genuinely compute-matched alternatives. The October chain interventions concern small backbones and tested replacements; they neither identify every intact computation nor establish how larger frontier systems use latent steps. Reporting experiments remain sensitive to elicitation and cannot certify a complete internal transcript.

## References

[1] Gurnee, Sofroniew, Lindsey et al. *Verbalizable Representations Form a Global Workspace in Language Models*. Transformer Circuits, July 6, 2026. Research article — https://transformer-circuits.pub/2026/workspace/index.html
[2] Hugging Face. *How caching works*. Transformers documentation, current unversioned capture. Documentation — https://huggingface.co/docs/transformers/en/cache_explanation
[3] Hao et al. *Training Large Language Models to Reason in a Continuous Latent Space*. arXiv:2412.06769v4, revised August 23, 2026. Version 4 — https://arxiv.org/abs/2412.06769v4
[4] Geiping et al. *Scaling up Test-Time Compute with Latent Reasoning: A Recurrent Depth Approach*. arXiv:2502.05171v2, February 17, 2025. Version 2 — https://arxiv.org/abs/2502.05171v2
[5] Neel Nanda. *A Review of Anthropic’s Global Workspace Paper*. LessWrong, July 6, 2026; Anthropic-commissioned review including his team's Qwen experiments. Review and experiments — https://www.lesswrong.com/posts/zFJ3ZdQwrTWE9jT5S/a-review-of-anthropic-s-global-workspace-paper
[6] Feng and Steinhardt. *How do Language Models Bind Entities in Context?* 2023; ICLR 2024. Full text — https://ar5iv.labs.arxiv.org/html/2310.17191
[7] Lindsey et al. *On the Biology of a Large Language Model*. Transformer Circuits, March 27, 2025, “Planning in Poems.” Research article — https://transformer-circuits.pub/2025/attribution-graphs/biology.html
[8] Qiu et al. *Does Latent Chain-of-Thought Actually Reason? A Single, Unifying Taxonomy for Latent Reasoning*. Preprint, arXiv:2610.21182v1, October 15, 2026. Version 1 — https://arxiv.org/abs/2610.21182v1
[9] Lanham et al. *Measuring Faithfulness in Chain-of-Thought Reasoning*. arXiv:2307.13702v1, July 17, 2023. Version 1 — https://arxiv.org/abs/2307.13702v1
[10] Pfau, Merrill and Bowman. *Let’s Think Dot by Dot: Hidden Computation in Transformer Language Models*. 2024. Paper — https://arxiv.org/abs/2404.15758
[11] Garcia. *When (and when not) LLMs can verbalize awareness of J-Space concept injections — Initial results*. Preliminary first-party report on personal GitHub Pages, 2026. Report — https://e-m-garcia.github.io/research/j-lens-awareness/

---
Every [N] marker above is verifiable: fetch the citations JSON, match the marker id, and check the extraction (summary and key facts) plus placements against the source URL. Verification guide: https://lumisonde.com/for-agents/