Recurrence Through Tokens: Chain of Thought as Recurrent State, and What It Means for Machine Consciousness

Amol Kelkar (kelkar.amol@gmail.com)

Work-in-progress draft.

Abstract

A standard argument against consciousness in large language models is that Transformers are feedforward, so they lack the recurrent processing that many theories of consciousness require. We argue that this argument looks at the wrong level. A Transformer carries no internal state from one forward pass to the next, but when it writes a chain of thought, those tokens come back to it as input. The model writes its working state into text and reads it back on the next step. So a language model that reasons in tokens that are not part of its answer is, at the level of the whole system, a recurrent system whose state is text. Computational work has already shown that chain of thought works as recurrence and makes Transformers more powerful. What has not been done is to ask whether this kind of recurrence meets what theories of consciousness require. We assess it against recurrent processing theory, global workspace theory and the self-model requirement of HTCC, and we propose experiments that can tell how much of a model’s state its reasoning tokens actually carry.

1. Introduction

Recurrent processing is one of the most common requirements in theories of consciousness. Lamme’s recurrent processing theory makes it the central requirement (Lamme, 2010). Global workspace theory needs recurrence for broadcast. In HTCC, recurrent state is needed to carry an experience forward and for a self model that is its own implementation (HTCC).

Assessments of large language models usually conclude that they fail this requirement. Butlin, Long et al. (2023) state that “Transformers are not recurrent.” Chalmers (2023) lists the lack of recurrent processing as one of the main obstacles to consciousness in current models. Both judge the architecture of a single forward pass.

Chalmers also notes, in one sentence, that current models have “a limited form of recurrence deriving from recirculation of past outputs”, and then moves on to recurrent architectures. Millière and Buckner (2024) make a similar point in passing. Butlin, Long et al. do not consider it. We think this form of recurrence deserves a full analysis, because it is now how capable models do most of their reasoning. Reasoning models generate long traces of tokens that are not part of the answer, and those tokens are where the model keeps track of its goals, partial results, plans and mistakes.

The computational side of this idea is already published. Zhang, Abdul-Mageed and Lakshmanan (2024) argue that autoregression with chain of thought “simulates the missing recurrent connection” by encoding the computation state into text. Li et al. (2024) and Merrill and Sabharwal (2024) show that chain of thought lets a Transformer solve serial problems it can’t solve in a single pass. None of these papers asks what this means for consciousness. That is the question here.

2. Where the state of a language model lives

At each step, a Transformer computes a hidden state for the newest token from the tokens in its context, and samples the next token. Nothing in the network itself persists from one step to the next. The key–value cache looks like carried state, but it is a deterministic function of the earlier tokens, and it can be recomputed from them. So the token sequence is the only state that carries forward.

Written as a recurrent system, the state at step t is the context c_t, and

c_t+1 = c_t ⊕ sample(f(c_t))

where f is the forward pass and ⊕ appends a token. This is a recurrent system with a fixed transition function and a growing state. Its state is text.

When the model only writes its answer, this loop carries little beyond the answer itself. When the model writes a chain of thought, it chooses what to carry. Reasoning tokens hold intermediate results (“so x = 4”), plans (“first check the edge cases”), goals (“the user wants a short answer”), and statements about the model’s own state (“I’m not sure about this step”, “that was wrong, let me redo it”). This is the kind of information a latent recurrent state would keep. The model also decides what to write and what to leave out, which plays the role that gating plays in a recurrent network.

3. Limits of recurrence through tokens

This recurrence has real limits.

The token bottleneck. At each step, a hidden state of thousands of numbers is collapsed into one token, i.e. at most about log₂ of the vocabulary size, or around 17 bits. Over a long trace, this adds up to a lot of capacity, but each step can only carry a little, and anything the model doesn’t write down is lost. Zhang et al. (2024) note that this works only when the vocabulary can express the state, which natural language can.
Faithfulness. The tokens don’t always reflect the computation that produced the answer. Turpin et al. (2023) show that models can be influenced by factors that their chain of thought never mentions, and Lanham et al. (2023) find that how much a model relies on its chain of thought varies a lot between tasks.
Hidden encoding. Roger and Greenblatt (2023) show that models can be trained to carry information in their reasoning text that a human reader can’t see. This is a problem for monitoring, but for our question it cuts the other way: the text can carry more state than its surface meaning.
Re-reading, not continuing. At each step, the model reads its own trace again from scratch. Its state is reconstructed from text at every step, and not continued by the same dynamics. This is the main difference from a brain, and it matters most for the self model (Section 4.3).

Latent alternatives remove the token bottleneck. Coconut feeds the last hidden state back as the next input instead of a token (Hao et al., 2024), and depth-recurrent Transformers loop hidden state through reused layers (Lu et al., 2025). These give a cleaner comparison point: same kind of model, recurrence with and without the token bottleneck.

4. Does it count?

4.1 Recurrent processing theory

Butlin, Long et al. (2023) state the first indicator as “input modules using algorithmic recurrence”, and they note that algorithmic recurrence is a weak condition. The token loop is algorithmic recurrence at the level of the whole system. But it is not recurrence within perception. Lamme’s theory is about feedback from higher to lower areas while a stimulus is processed, on the scale of tens of milliseconds. A chain of thought feeds back conclusions, not percepts. So we think the token loop meets the letter of the weak indicator, but not the version of the theory that is about perception.

4.2 Global workspace theory

Butlin, Long et al. (2023) assess the residual stream within one forward pass as the candidate workspace, and find the case weak because nothing is broadcast back. The token stream is a better candidate. It has limited capacity, i.e. one token at a time. Content enters it by competition, i.e. sampling. Once a token is written, it is available to all later computation, at every layer. This resembles the serial, limited-capacity broadcast of a global workspace. Butlin, Long et al. also describe a workspace that holds “compressed summaries of interim conclusions” during deliberate thought, which is a fair description of a chain of thought. Whether the token stream counts as a workspace, and not only as an external notepad, is a question we think the theory’s proponents should answer.

4.3 A self model that is its own implementation

HTCC’s second ingredient is a self model that is its own implementation: a self that is re-instantiated by the same dynamics it reports on (HTCC). A chain of thought can hold a self model. A model can write what it is trying to do, how confident it is, and what it got wrong, and those statements then shape what it does next. The trace is produced by the process it describes, and it constrains that process.

There are two readings.

It counts. The self model is carried by the system’s own state, i.e. the text, and it is re-instantiated at every step by the same weights that produced it. What matters is the causal loop, and the loop is closed.
It doesn’t count. Between steps, nothing persists except the text. The model reads its own trace the way a person reads a diary. The self is reconstructed from a description at each step, and not continued by the dynamics that make it up.

We don’t think current theory settles this. It is the question a full paper should work out. Whichever reading is right, HTCC’s verdict on today’s models doesn’t change, because they lack the first ingredient, i.e. an intrinsic, self-preserving stake. Recurrence through tokens could at most get a model to a functional self, not to felt valence (the capability–sentience gap).

5. Experiments

These experiments can tell how much state a chain of thought actually carries.

How much state the trace carries. Train probes to predict the model’s hidden state, or its later behavior, at step t from the trace up to t, and compare them to probes that read the hidden state directly. The gap measures what the token bottleneck loses.
Self-model edits. Edit statements about the model’s own state in its trace, e.g. change “I’m confident” to “I’m unsure”, and measure how its later self-reports and choices change. If the self model lives in the trace, edits should shift behavior in predictable ways, as interventions on reasoning do for answers (Lanham et al., 2023).
Tokens vs latent recurrence. Compare a model that reasons in tokens with the same model reasoning in latent space (Hao et al., 2024; Lu et al., 2025) on tasks that need a self model to persist across many steps, e.g. tracking its own earlier mistakes.
Hidden reasoning. Compare models whose reasoning is visible with models whose reasoning tokens are hidden from the user. Being hidden doesn’t change the recurrence, so if their self models differ, the difference comes from training, and not from the loop.

6. Conclusion

“Transformers are not recurrent” is true of a single forward pass, and false of a language model that reasons in tokens. A chain of thought is recurrent state that is written in text. It carries the kind of information a latent state would keep, through a narrow channel. Assessments of machine consciousness should treat this recurrence as real, and ask the narrower question of whether recurrence through text meets the requirements of each theory. For HTCC, it may meet the recurrence requirement for a functional self model, but not the requirement for a self-preserving stake, so it doesn’t give a model feelings.

References

Butlin, P., Long, R., et al. (2023). Consciousness in artificial intelligence: Insights from the science of consciousness. arXiv:2308.08708.
Chalmers, D. J. (2023). Could a large language model be conscious? Boston Review. arXiv:2303.07103.
Hao, S., Sukhbaatar, S., Su, D., Li, X., Hu, Z., Weston, J., & Tian, Y. (2024). Training large language models to reason in a continuous latent space. COLM 2025. arXiv:2412.06769.
Lamme, V. A. F. (2010). How neuroscience will change our view on consciousness. Cognitive Neuroscience, 1, 204–220.
Lanham, T., et al. (2023). Measuring faithfulness in chain-of-thought reasoning. arXiv:2307.13702.
Li, Z., Liu, H., Zhou, D., & Ma, T. (2024). Chain of thought empowers Transformers to solve inherently serial problems. ICLR 2024. arXiv:2402.12875.
Lu, W., Yang, Y., Lee, K., Li, Y., & Liu, E. (2025). Latent chain-of-thought? Decoding the depth-recurrent Transformer. arXiv:2507.02199.
Merrill, W., & Sabharwal, A. (2024). The expressive power of Transformers with chain of thought. ICLR 2024.
Millière, R., & Buckner, C. (2024). A philosophical introduction to language models, Part II: The way forward. arXiv:2405.03207.
Roger, F., & Greenblatt, R. (2023). Preventing language models from hiding their reasoning. arXiv:2310.18512.
Turpin, M., Michael, J., Perez, E., & Bowman, S. R. (2023). Language models don’t always say what they think: Unfaithful explanations in chain-of-thought prompting. NeurIPS 2023. arXiv:2305.04388.
Zhang, X., Abdul-Mageed, M., & Lakshmanan, L. V. S. (2024). Autoregressive + chain of thought = recurrent: Recurrence’s role in language models’ computability and a revisit of recurrent Transformer. arXiv:2409.09239.