Bibliography

arXiv identifiers were checked against the arXiv and Semantic Scholar APIs in September 2026. The same material is available as a map and a timeline.

The core

• Hao, S., Sukhbaatar, S., Su, D., Li, X., Hu, Z., Weston, J., and Tian, Y. (2024). Training Large Language Models to Reason in a Continuous Latent Space. arXiv:2412.06769. Coconut. Feeds the final hidden state back as the next input embedding, deleting the quantiser. ProsQA 97.0% against 77.5% for explicit chain of thought, and GSM8K 34.1% against 42.9%. The paper that named the idea and, read carefully, bounded it.
• Geiping, J., McLeish, S., Jain, N., Kirchenbauer, J., Singh, S., Bartoldson, B. R., Kailkhura, B., Bhatele, A., and Goldstein, T. (2025). Scaling up Test-Time Compute with Latent Reasoning: A Recurrent Depth Approach. arXiv:2502.05171. The other endpoint: 3.5B parameters over 800B tokens, a recurrent core unrolled 4 to 64 times at test time with no chain-of-thought training data. Open weights as Huginn-0125.
• Xu, K., and Sato, I. (2025). A Formal Comparison Between Chain of Thought and Latent Thought. arXiv:2509.25239. At $\log^k n$ iterations, polynomial width and constant precision, looped/continuous models are characterised exactly (Thm 3.12), while chain of thought is bounded above by $\mathsf{TC}^{k-1}$ (Lem 3.13). The strict separation (Thm 3.15) assumes $\mathsf{TC}^{k-1} \subsetneq \mathsf{TC}^k$. The countervailing stochastic result assumes $\mathsf{FPTAS} \subsetneq \mathsf{FPRAS}$ for self-reducible relations and compares against deterministic latent updates only.
• Korbak, T., Balesni, M., Barnes, E., Bengio, Y., Benton, J., et al. (2025). Chain of Thought Monitorability: A New and Fragile Opportunity for AI Safety. arXiv:2507.11473. Forty-one authors across OpenAI, Anthropic, Google DeepMind, UK AISI, Redwood and Apollo. Argues current models are architecturally forced to externalise serial computation legibly, that this is an accident rather than a guarantee, and names fully latent reasoning as the threat to it.

Antecedents

• Graves, A. (2016). Adaptive Computation Time for Recurrent Neural Networks. arXiv:1603.08983. A differentiable halting mechanism: let the network choose how many internal steps to take. The ancestor of everything in the depth column.
• Dehghani, M., Gouws, S., Vinyals, O., Uszkoreit, J., and Kaiser, Ł. (2018). Universal Transformers. arXiv:1807.03819. Weight-tied layers plus per-position adaptive halting: depth becomes a loop. The architectural precursor to recurrent-depth language models.
• Banino, A., Balaguer, J., and Blundell, C. (2021). PonderNet: Learning to Ponder. arXiv:2107.05407. Replaces the halting penalty with a learned stochastic halting distribution under a proper probabilistic objective.
• Giannou, A., Rajput, S., Sohn, J., Lee, K., Lee, J. D., and Papailiopoulos, D. (2023). Looped Transformers as Programmable Computers. arXiv:2301.13196. A hand-programmed nine-layer, two-head transformer in a loop runs SUBLEQ programs, one instruction per pass. The numerical routines use up to thirteen layers. Depth stays constant as the program grows. Width grows as $\log n$, the loop count with runtime, and the softmax pointers need a temperature growing with $n$.

Expressivity theory

• Merrill, W., and Sabharwal, A. (2023). “The Parallelism Tradeoff: Limitations of Log-Precision Transformers.” TACL. arXiv:2207.00729. One forward pass of a log-precision transformer lies inside logspace-uniform $\mathsf{TC}^0$. Conditional on $\mathsf L \neq \mathsf P$, no polynomial-size family solves certain $\mathsf P$-complete problems in a single pass: an asymptotic statement about growing inputs, not a verdict on finite instances.
• Feng, G., Zhang, B., Gu, Y., Ye, H., He, D., and Wang, L. (2023). “Towards Revealing the Mystery behind Chain of Thought: A Theoretical Perspective.” NeurIPS. arXiv:2305.15408. Assuming $\mathsf{TC}^0 \neq \mathsf{NC}^1$, no fixed-depth log-precision transformer of polynomial width solves arithmetic-expression evaluation or linear-equation solving over $\mathbb{Z}_p$ at all sizes. Constant-size autoregressive models with chain of thought can, and can implement dynamic programming. Conditional, and scoped to those two problem families: not “arithmetic” generally.
• Merrill, W., and Sabharwal, A. (2024). “The Expressive Power of Transformers with Chain of Thought.” ICLR. arXiv:2310.07923. Expressivity graded by chain-of-thought length: logarithmic is marginal, linear recognises all regular languages, polynomial is exactly $\mathsf P$. Each result carries a specific architectural assumption: projected pre-norm normalisation and saturated attention, where every score is zero or $1/v$ rather than a softmax. The logarithmic tier is an upper bound with no matching lower bound.
• Li, Z., Liu, H., Zhou, D., and Ma, T. (2024). “Chain of Thought Empowers Transformers to Solve Inherently Serial Problems.” ICLR. arXiv:2402.12875. At constant precision and depth without chain of thought, expressivity is confined to $\mathsf{AC}^0$ under their constant-bit floating-point and immediate-rounding model. With chain of thought, a non-uniform family of constant-depth fixed-point transformers simulates size-$T$ circuits in $T$ tokens: for each input length and target circuit a separate $O(\log n)$-width transformer carries the circuit description in learned absolute positional embeddings. A circuit-specific representability construction rather than one trained model, and the authors note length generalisation “does seem impossible” with trainable absolute positions. Tokens buy serial computation that a fixed-depth parallel circuit structurally cannot do.
• London, C., and Kanade, V. (2025). Pause Tokens Strictly Increase the Expressivity of Constant-Depth Transformers. arXiv:2505.21024. At constant precision and $O(\log n)$ width, polynomial pause-token padding characterises exactly $\mathsf{AC}^0$ (Thm 4.1), with a non-uniform strict separation from the unpadded case (Cor 4.2). The uniform separation needs quasi-polynomial padding (Thm 4.3), and log precision with polynomial padding gives $\mathsf{TC}^0$ (Thm 4.5). Padding buys parallel workspace at fixed depth, not serial depth. The PARITY result in §5 is a finite-size learning experiment requiring intermediate supervision, not the separation's witness.
• Zhu, H., Hao, S., Hu, Z., Jiao, J., Russell, S., and Tian, Y. (2025). Reasoning by Superposition: A Theoretical Perspective on Chain of Continuous Thought. arXiv:2505.12514. A two-layer transformer with $D$ continuous steps solves directed graph reachability at diameter $D$, for a fixed maximum input length and at width growing with the vocabulary. The best known discrete construction needs $O(n^2)$ steps, an upper bound, and a lower bound is listed as future work. Two-layer models trained with path supervision on 3–4-hop ProsQA show the frontier in attention and embedding similarity, with no intervention. The companion paper on training dynamics is arXiv:2509.23365.
• Gozeten, H. A., Ildiz, M. E., Zhang, X., Harutyunyan, H., Rawat, A. S., and Oymak, S. (2025). Continuous Chain of Thought Enables Parallel Exploration and Reasoning. arXiv:2505.23648. Quantifies the parallelism as tracking several discrete traces at once. The construction is one attention-plus-mixture-of-experts block run for $n$ autoregressive steps, with width $d = 2^{n+1} + n + 2$ holding all $2^n$ signed partial sums, $n+1$ position-specific experts, and exact selection only in the $c \to \infty$ limit. A representability result through superposition, not an efficient algorithm for subset-sum.
• Saunshi, N., Dikkala, N., Li, Z., Kumar, S., and Reddi, S. J. (2025). Reasoning with Latent Thoughts: On the Power of Looped Transformers. arXiv:2502.17416. A $k$-layer transformer looped $L$ times nearly matches a $kL$-layer unlooped model: many reasoning problems are depth-bound rather than parameter-bound.
• Xu, K., and Sato, I. (2025). To CoT or To Loop? A Formal Comparison Between Chain-of-Thought and Looped Transformers. arXiv:2505.19245. Loops efficiently emulate parallel DAG-structured deterministic computation. Sequential chain of thought suits self-reducible compositional problems. No universal conversion between loop count and token count: the relationship is structural.
• Zhang, H. (2026). Chain-of-Thought and Compressed Looped Transformers: A Memory-Budget Separation. arXiv:2605.30757. Under a standard complexity assumption, $\mathsf P \not\subseteq \mathsf{DSPACE}(\mathrm{polylog}\,n)$, a compressed-state loop carrying polylogarithmic persistent memory cannot decide problems $\mathsf P$-complete under logspace reductions that polynomial-length chain of thought can. Explicitly does not cover full sequence-state loops carrying $ndp$ bits. Recurrence buys depth, not memory.
• Sanford, C., Hsu, D., and Telgarsky, M. (2024). Transformers, Parallel Computation, and Logarithmic Depth. arXiv:2402.09268. Relates constant-depth self-attention to constant-round massively parallel computation in both directions, though the two simulations carry different hypotheses and overheads and the authors note they do not jointly give a sharp characterisation. Logarithmic depth suffices for tasks other sequence models cannot solve efficiently. Stated as an MPC-round simulation, not a circuit-class placement.
• Sanford, C., Hsu, D., and Telgarsky, M. (2023). Representational Strengths and Limitations of Transformers. arXiv:2306.02896. A sparse-averaging task separates transformers from recurrent and feedforward networks. For exact unrestricted modular triple matching, a single softmax attention layer needs embedding dimension, precision and head count whose product is $\Omega(N/\log\log N)$ — a bound on the product, not on any one of them, and the multi-layer version is explicitly a conjecture. Structured variants are easy: the bigram form needs two layers at dimension 3, the local form one layer at $O(K\log N)$. The authors flag the unrestricted negative case as unusual in practice.
• Peng, B., Narayanan, S., and Papadimitriou, C. (2024). On Limitations of the Transformer Architecture. arXiv:2402.08164. A communication-complexity argument that one transformer layer cannot compose two functions once their domains are large enough. The impossibility is conditional on domain size, and a second family of claims in the same paper rests on unproven complexity conjectures.
• de Luca, A. B., and Fountoulakis, K. (2024). Simulation of Graph Algorithms with Looped Transformers. arXiv:2402.01107. A looped transformer with graph-reading attention heads simulates Dijkstra, breadth- and depth-first search and Kosaraju's algorithm with parameter count independent of graph size, and iteration count that grows with the graph. The authors add their own ceiling: “we show a limit to simulation in our solution due to finite precision”, since the circular positional encoding that enumerates nodes is discretised. Turing completeness at constant width requires those extra heads.
• Amiri, A., Huang, X., Rofin, M., and Hahn, M. (2025). Lower Bounds for Chain-of-Thought Reasoning in Hard-Attention Transformers. arXiv:2502.02393. Lower bounds, tight up to logarithmic factors, on how many chain-of-thought steps a hard-attention transformer needs per problem. The authors note models empirically need scratchpads even for problems already inside TC0.
• Li, Z., Svete, A., Sabharwal, A., and Merrill, W. (2026). Efficiently Representing Algorithms With Chain-of-Thought Transformers. arXiv:2606.19697. Chain-of-thought transformers simulate Word-RAM algorithms with polylogarithmic overhead per instruction, against the quadratic overhead of going through existing Turing-machine simulations. The three constructions differ in architecture. Discrete tokens need non-uniform width growing as $\log^2(n+t)$ and rightmost hard attention. Fixed width needs either continuous chain of thought or a linear RNN layer beneath the transformer. Whether an ordinary fixed-width transformer can do it is left open.
• Svete, A., Merrill, W., Cotterell, R., and Sabharwal, A. (2026). Revisiting Padded Transformer Expressivity: Which Architectural Choices Matter and Which Don’t. arXiv:2605.30523. Precision and depth change padded-transformer expressivity. Attention type and width above logarithmic do not. Polynomially padded constant-precision transformers equal L-uniform AC0, growing precision reaches TC0 regardless of width, and the results hold for both softmax and average-hard attention.
• Kraus, M., Sarrof, Y., Yao, Y., Koller, A., and Hahn, M. (2026). Barriers to Universal Reasoning With Transformers (And How to Overcome Them). arXiv:2604.25800. In the idealised length-generalisation model they adopt — a restricted finite-precision learner that perfectly fits every bounded training prefix and minimises a complexity regulariser — a finite-alphabet chain of thought expressible in C-RASP[Pos] has its decision in $\mathsf{TC}^0$. For a language outside $\mathsf{TC}^0$, some train-to-test length scaling defeats the corresponding learner infinitely often, which is weaker than failure at every rate. Not a bound on ordinarily trained finite-vocabulary transformers. Their positive construction restores Turing-machine simulation using an annotated input and an unbounded alphabet of unique tape-position signposts, again under the idealised learner.
• Jiang, Y., Hahn, M., Zetzsche, G., and Lin, A. W. (2025). Softmax Transformers are Turing-Complete. arXiv:2511.20038. A chain-of-thought construction for a theoretical softmax transformer whose attention logits are scaled by $\log n$ and whose feed-forward layer may use exact Heaviside thresholds, both of which the paper argues are necessary. With causal masking and no positional encoding it recognises arbitrary recursively enumerable unary and letter-bounded languages; Proposition 4.1 shows it is not Turing-complete over a general two-letter alphabet, and arbitrary alphabets need a specially constructed relative-position relation. Length generalisation is stated for the same idealised learner, not for finite-sample gradient training.
• Liu, Z., Baraniuk, R., and Sonkar, S. (2026). Circuit Complexity of Hierarchical Knowledge Tracing and Implications for Log-Precision Transformers. arXiv:2603.23823. Recursive-majority prerequisite propagation lies unconditionally in NC1, and separating it from TC0 would need progress on open lower bounds. Empirically, transformers trained on these trees converge to permutation-invariant shortcuts even when handed explicit structure.

Continuous and internalised chain of thought

• Deng, Y., Prasad, K., Fernandez, R., Smolensky, P., Chaudhary, V., and Shieber, S. (2023). Implicit Chain of Thought Reasoning via Knowledge Distillation. arXiv:2311.01460. Distils a teacher's horizontal token-by-token reasoning into vertical layer-by-layer computation: a separate emulator predicts the teacher's hidden states, a student answers from them, and the pair is fine-tuned end to end. Inference keeps both stacks, at 0.66–0.73 of no-CoT throughput. After the joint fine-tuning the decoded intermediate states stop resembling the teacher's steps. The first serious attempt to delete the rationale and keep the capability.
• Zelikman, E., Harik, G., Shao, Y., Jayasiri, V., Haber, N., and Goodman, N. D. (2024). Quiet-STaR: Language Models Can Teach Themselves to Think Before Speaking. arXiv:2403.09629. Generates rationales after every token and rewards those that improve prediction of the real continuation. Zero-shot GSM8K 5.9% to 10.9%. The rationales are still tokens: a bridge case rather than latent reasoning proper.
• Deng, Y., Choi, Y., and Shieber, S. (2024). From Explicit CoT to Implicit CoT: Learning to Internalize CoT Step by Step. arXiv:2405.14838. Removes reasoning tokens on a schedule. GPT-2 Small reaches 99% on nine-by-nine multiplication; Mistral-7B passes 50% on GSM8K emitting nothing between question and answer.
• Cheng, J., and Van Durme, B. (2024). Compressed Chain of Thought: Efficient Reasoning Through Dense Representations. arXiv:2412.13171. Variable-length dense contemplation tokens in place of the rationale, from a fine-tuned generator and a separate answer decoder. The compression ratio is a training-time choice, and a learned stopping rule varies the count per example. No public implementation.
• Su, D., Zhu, H., Xu, Y., Jiao, J., Tian, Y., and Zheng, Q. (2025). Token Assorted: Mixing Latent and Text Tokens for Improved Language Model Reasoning. arXiv:2502.03275. Abstracts only the early part of a trace into discrete VQ-VAE latent tokens and mixes them with text. Seven-benchmark averages rise 2.9 to 4.5 points across model sizes, the 13.3-point gain being one 8B task, and responses average about 17% fewer tokens than chain of thought: a hybrid by construction.
• Xu, Y., Guo, X., Zeng, Z., and Miao, C. (2025). SoftCoT: Soft Chain-of-Thought for Efficient Reasoning with LLMs. arXiv:2502.12134. Never fine-tunes the target model: a frozen assistant produces soft thoughts that a trained projector maps into the frozen model's embedding space. The motivation is catastrophic forgetting, which the authors conjecture from LoRA and LoRA-adapted Coconut baselines scoring below zero-shot CoT. No retention test isolates forgetting as the cause. Extended for test-time scaling in arXiv:2505.11484.
• Shen, Z., Yan, H., Zhang, L., Hu, Z., Du, Y., and He, Y. (2025). CODI: Compressing Chain-of-Thought into Continuous Space via Self-Distillation. arXiv:2502.21074. Aligns one token's hidden state between an explicit and an implicit pass, removing Coconut's multi-stage curriculum. First in the family to match explicit chain of thought on GSM8K at GPT-2 scale.
• Zhang, J., Zhu, Y., Sun, M., Luo, Y., Qiao, S., et al. (2025). LightThinker: Thinking Step-by-Step Compression. arXiv:2502.15589. Compresses thoughts into gist tokens during generation and evicts the originals from context via specialised attention masks.
• Shen, X., Wang, Y., Zhou, Y., Shi, X., Zhao, P., et al. (2025). Efficient Reasoning with Hidden Thinking. arXiv:2501.19201. The Heima framework: multimodal reasoning condensed into a few abstract thinking tokens. The information-theoretic section is the data-processing inequality for tokens defined from the input and the gold CoT, whereas deployed tokens are generated from the input alone, and no information is estimated. Stage-wise interpreters, given the question and the thinking token, write approximate text back (reasoning-stage BLEU 11.2, BERTScore 66.6), with no question-only control.
• Zhang, Z., He, X., Yan, T., Shen, Y., Zhao, C., et al. (2025). Soft Thinking: Unlocking the Reasoning Potential of LLMs in Continuous Concept Space. arXiv:2505.15778. Training-free: replace each token with a probability-weighted mixture of embeddings. The rebuttal below qualifies it.
• Wei, X., Liu, X., Zang, Y., Dong, X., Cao, Y., et al. (2025). SIM-CoT: Supervised Implicit Chain-of-Thought. arXiv:2509.20317. Diagnoses latent instability. Going from Coconut's default three latent tokens to five sometimes collapses training, and failed runs have near-identical latents. A step-level auxiliary decoder, removed at inference, stabilises it.
• Butt, N., Kwiatkowski, A., Labiad, I., Kempe, J., and Ollivier, Y. (2025). Soft Tokens, Hard Truths. arXiv:2509.19170. First scalable reinforcement learning of continuous chain of thought without distilling from discrete traces. Broadly comparable to discrete chain of thought at pass@1, though several points behind on Llama 3.2 3B when trained on MATH or DeepScaleR, and ahead of it at pass@32, which is better coverage under repeated sampling. The authors read it as greater trace diversity and separately report a token-entropy analysis, which is the part that measures diversity.
• Piao, S., and Park, S. (2025). SpiralThinker: Latent Reasoning through an Iterative Process with Text-Latent Interleaving. arXiv:2511.08983. Alternates latent iterations with text, with a progressive alignment objective to stabilise the latent updates.

Recurrent depth and looped models

• Mohtashami, A., Pagliardini, M., and Jaggi, M. (2023). CoTFormer: A Chain-of-Thought Driven Architecture with Budget-Adaptive Computation Cost at Inference. arXiv:2310.10845. Motivates looping explicitly as a token-level analogue of chain of thought, with per-token adaptive depth. No official implementation.
• Fan, Y., Du, Y., Ramchandran, K., and Lee, K. (2024). Looped Transformers for Length Generalization. arXiv:2409.15647. Trained on parity up to twenty digits with the step count set equal to the length, the looped model stays near-perfect past forty digits when inference applies the same rule, and beats next-token baselines with matched depth, pause tokens or weight-tied layers. The step count is an oracle. A per-sample confidence stop does almost as well on tasks whose iterates converge, and worse on parity, where they do not.
• Bae, S., Fisch, A., Harutyunyan, H., Ji, Z., Kim, S., and Schuster, T. (2024). Relaxed Recursive Transformers: Effective Parameter Sharing with Layer-wise LoRA. arXiv:2410.20672. Converts pretrained transformers into looped ones, then relaxes the weight-tying with per-depth low-rank adapters.
• Bae, S., Kim, Y., Bayat, R., Kim, S., Ha, J., et al. (2025). Mixture-of-Recursions: Learning Dynamic Recursive Depths for Adaptive Token-Level Computation. arXiv:2507.10524. A router picks each token's recursion depth, with matched KV caching: a new Pareto frontier for perplexity per FLOP and for throughput.
• Zhu, R.-J., Wang, Z., Hua, K., Zhang, T., Li, Z., et al. (2025). Scaling Latent Reasoning via Looped Language Models. arXiv:2510.25741. Ouro. 1.4B and 2.6B looped models over 7.7T tokens, with recurrence built into pretraining rather than bolted on at test time. Attributes the gains to better knowledge manipulation rather than added capacity. It also claims latent traces better aligned to final outputs than explicit chains, on an observational proxy: on 1,000 Quora Question Pairs the answer read out at each loop keeps changing (36.1% agreement between steps 2 and 4), where a thinking model's early probe predicts its final answer. The latent state is never intervened on. Open weights.
• McLeish, S., Li, X., Kirchenbauer, J., Kalra, D., Bartoldson, B. R., et al. (2025). Teaching Pretrained Language Models to Think Deeper with Retrofitted Recurrence. arXiv:2511.07384. Retrofits recurrence onto an already-pretrained model via a depth curriculum, decoupling test-time from training-time compute after the fact.
• Fan, Y., Svete, A., and Lee, K. (2026). Bridging the Gap Between Latent and Explicit Reasoning with Looped Transformers. arXiv:2606.31779. LOTUS. Notes that latent chain-of-thought methods had been falling behind explicit chain of thought past 1B with the gap widening at scale, and reports closing it at 3B via parallel supervision of loop latents, at 2.5–6.9× lower thought-phase latency.
• Blayney, T., Arroyo, D. M., Obando-Ceron, J., Castro, P. S., Courville, A., et al. (2026). A Mechanistic Analysis of Looped Reasoning Language Models. arXiv:2604.11791. For many of the studied models each layer in the loop converges toward a distinct fixed point and the block settles into a cyclic trajectory, with recurrent blocks re-enacting the stages of inference seen in feedforward models rather than encoding a distinct reasoning step per iteration. Not universal: Ouro does not reach the approximate fixed point after 128 recurrences. Convergence is the stability condition the training recipes are implicitly chasing, and it is not automatic.
• Wang, Y., Li, S., Zhang, Y., Huang, F., Yan, J., and Li, W. (2026). On the Residual Scaling of Looped Transformers: Stability and Transferability. arXiv:2606.18524. Weight sharing correlates residual updates across loops, so the standard depth-scaling rule is insufficient for looped models, and a replacement gives hyperparameter transfer across loop counts. The constructive-accumulation theorem assumes ReLU non-negativity for its positive-cone argument, which the authors say does not directly apply to the SwiGLU models they actually train, and the transfer result is stated informally with a formal version requiring a weak-coupling condition. Single seed throughout; Post-Norm left open.
• Li, S., Zhang, Y., Guo, J., Gu, Q., and Wang, M. (2026). DeepLoop: Depth Scaling for Looped Transformers. arXiv:2607.13491. One shared parameter update aggregates gradients from repeated visits within a forward pass, so the initialisation exponent must rise with loop count in the worst-case aligned regime.
• Fu, R., Yang, Z., Zhang, J., Ma, J., Chen, H., Li, Y., and Chang, Y. (2026). Simply Stabilizing the Loop via Fully Looped Transformer. arXiv:2605.18797. Identifies gradient oscillation and residual explosion as two instability patterns associated with looped training, which is the paper's own wording: it says oscillation “may contribute” and that residual amplification “may not fully explain early collapse by itself”, and its ablation shows neither parameter-free change is sufficient alone. Trains stably to twelve iterations at 318M where baselines collapse, on a single run per configuration with no seed error bars.
• Buehlmaier, M. M. M. (2026). LayerNorm as Implicit Gain Control in Looped Transformers. arXiv:2607.10681. Pre-norm LayerNorm makes the recurrence Jacobian asymptotically contractive at fixed points even where its operator norm exceeds one, so a diagonal-carry constraint on its own does not guarantee convergence: local stability is governed by the spectrum of the full Jacobian, not the carry term in isolation. Verified only at small scale, as the author states.
• Wu, Y., Zhang, R., and Cao, Y. (2026). Looped Transformers with Layer Normalization Provably Learn the Power Method. arXiv:2606.00605. A looped linear transformer — softmax removed, normalisation structurally equivalent to RMSNorm rather than LayerNorm — provably converges to power-method iteration under population gradient descent from a specific initialisation with only one block set to the identity, on rotation-invariant unit-norm data with $d \ge 3$. The loss converges to a strictly positive limit, not to zero.
• Lin, Y., Guo, Y., Zhu, R.-J., Ye, Z., and Eshraghian, J. (2026). Allocating Recurrent Compute in Looped Language Models. arXiv:2608.18230. Looping only the mixer and applying the feedforward block once beats full-block recurrence at 15M parameters, but at 110M it retains 41.5 per cent of full recurrence's CORE improvement, not the bulk of it. The 45.9 per cent saving counts recurrent-backbone projection FLOPs; end to end the saving is 43.0 per cent at that scale. One checkpoint per architecture, without error bars.
• Wang, Y., Zhang, Y., Luo, S., Wu, Y., Liu, Z., Liu, J., Huang, F., Yan, J., and Li, W. (2026). SMELT: Scaling Laws for Compute-Matched MoE Looped Transformers. arXiv:2609.01343. A budget-matched scaling study holding FLOPs, parameters and cache fixed, reporting 6.8 to 18.0% training-FLOP savings at the compute-optimal frontier.
• Wang, C., and Reid, M. (2026). Looped Transformers under the Jacobian Lens: Does the Global Workspace Survive Recurrence?. arXiv:2609.01924. A workspace forms under recurrence, read through a mean-Jacobian lens fitted on 1,000 prompts. Under that instrument one tracked concept fails to cross an Ouro loop boundary, and Huginn's reads and writes work only within about two recurrences of the lens's own target. The authors note the average cancels when the response turns prompt-dependent, and that the lens “cannot distinguish ‘not held’ from ‘held but idle’”, so this bounds what the instrument recovers rather than what the architecture can carry.
• Shapiro, M. (2026). Retrofitting Recurrent Depth into a Pretrained Language Model: Installation, Extrapolation, Transfer, and Retention at Two Parameter Budgets. arXiv:2608.11233. Retrofits recurrent depth onto a pretrained model at two budgets, with a 6M adapter matching a 180M full block and extrapolating to about 1.5 times its supervised depth. A reversed-rule task exposes a catastrophic-interference boundary the retrofit cannot cross.
• Park, T., Lee, Y., Kim, D., and Bae, H. (2026). LoopUS: Recasting Pretrained LLMs into Looped Latent Refinement Models. arXiv:2605.11011. A second retrofitting recipe using staged block decomposition, an input-dependent gate against hidden-state drift and random deep supervision. The abstract asserts improvement without itemised figures.
• Hegazy, M., Alanwar, A., and Elhoushi, M. (2026). Gated Recurrent Transformer: Bracketing a Shared Recurrent Core. arXiv:2608.15062. Uses gating to counter the representational collapse of naive depth sharing, with fixed prelude and coda around a single shared recurrent core.
• Viakhirev, I., Borodin, K., Almutairi, A., Barannikov, S., Abramov, M., and Mkrtchian, G. (2026). Think Shallow, Solve Deep: Controlling Recurrent Dynamics for Reliable Test-Time Depth. arXiv:2608.18222. Associates a measured settling, marginal or drifting regime with whether more test-time iterations help, hurt or do nothing, empirically, on small controlled models trained from 800 examples per tier. The formal depth-safety condition needs the total remaining path length, summed over all future steps, to stay below the decoder margin. It guarantees the answer stops changing, not that it is correct.
• Kim, S., Hayashi, H., Kamiya, T., Koyama, M., Iwasawa, Y., and Matsuo, Y. (2026). Source-Centred State Evolution in Looped Transformers. arXiv:2607.27656. Additive-injection looped models can still drift from their reference state despite reintroducing the input at every step.
• Chen, J., Shi, W., Liu, Y., Wang, H., Wang, Z., Xu, R., Wang, T., and Ding, N. (2026). Penelope: Localizing Recurrent Computation to a Decoder Interval. arXiv:2607.25915. Loops a chosen interval of the decoder rather than the whole stack.
• Popescu, A. C., Sáez de Ocáriz Borde, H., and Liò, P. (2026). Looped Language Models Improve Compositional Tool Calling. arXiv:2608.18171. Native and retrofitted looped models against non-looped baselines under matched supervised recipes on three tool-calling benchmarks: recurrence generally helps compositional, dependency-aware multi-step calls more than isolated ones.
• Frey, M., Shomali, B., Bashir, A. H., Berghaus, D., Koehler, J., and Ali, M. (2026). Adaptive Loops and Memory in Transformers: Think Harder or Know More?. arXiv:2603.08391. At about 200M parameters, adaptive looping lowers bits per byte on the gold MATH answers and also beats the parameter-matched unlooped baseline on commonsense (accuracy 0.501 against 0.477). It trails a 36-layer iso-FLOP baseline on commonsense, and gated memory banks narrow that gap without closing it (0.511 against 0.535). The math metric is answer likelihood, not accuracy, which the authors say limits claims about reasoning.
• Koriagin, N., Aksenov, Y., Bredis, N., Gerasimov, D., Balagansky, N., and Gavrilov, D. (2026). A Model with No Head and Many Thoughts. arXiv:2608.31069. Replaces the language-model head during reasoning with a lightweight projector, so rollout happens in embedding space with no discrete tokenisation at all.
• Lam-Muir, A. (2026). The Ignition Is Real, and It Lives at the Readout. arXiv:2608.03263. A pre-registered study of a 30M recurrent-depth reasoner confirming a readout-localised transition, and explicitly withdrawing an earlier claim of its own under normalisation controls.
• Lam-Muir, A. (2026). Behaviour Is an Incomplete Measure of Reasoning Development. arXiv:2608.16085. Behavioural competence, probe accessibility and training-time development are three distinct observables in the same reasoner, with a large gap in epochs-to-competence between training surfaces.

Contentless tokens

• Goyal, S., Ji, Z., Rawat, A. S., Menon, A. K., Kumar, S., and Nagarajan, V. (2024). “Think before you speak: Training Language Models With Pause Tokens.” ICLR. arXiv:2310.02226. Learnable pause tokens delay answer extraction and buy computation. At 1B, pauses in both pretraining and fine-tuning take SQuAD exact match from 36.4 to 55.9 (the prose quotes 18%). Pause fine-tuning alone gives mixed, smaller gains, 40.2 on SQuAD at best. No code was released.
• Pfau, J., Merrill, W., and Bowman, S. R. (2024). Let's Think Dot by Dot: Hidden Computation in Transformer Language Models. arXiv:2404.15758. Transformers solve two tasks unsolvable in a single pass using nothing but repeated dots, with the admissible problems characterised by quantifier depth, but learning to exploit fillers needs dense, task-specific supervision and does not emerge from ordinary training.
• Brauer, K., Mayrink Verdun, C., and Marks, S. (2026). Reading Between the Dots: Decoding Hidden Computation across Filler Tokens. arXiv:2607.03502. Filler-token computation in frontier open-weight models defeats token-level monitoring outright, yet an unsupervised decoder on hidden states alone recovers the intermediate values at 80–95% accuracy, with causal validation by cache transplantation. Monitorability is a property of activations, not of surface tokens.
• Monea, G., Godey, N., Brantley, K., and Artzi, Y. (2026). The State-Prediction Separation Hypothesis. arXiv:2607.01218. Interleaves a learned prediction slot with each input token and keeps only the input stream in the persistent cache. From 53M to 1.678B parameters on one corpus it lowers validation loss and adds 2.3 to 3.1 points on a five-task zero-shot average, at roughly double the training compute per step. The scale results are single runs, with a three-seed check at one small setting.
• Langford, J., Godey, N., Monea, G., Artzi, Y., Dong, H., Fan, Y., de Rosa, G., and Zhan, Z. (2026). Almost Free State Prediction Separation. arXiv:2609.03807 (first version titled Free Pause Tokens). A pause without a position: a weight-shared prediction stream queries the token stream's keys and values at every layer and writes none of its own, so inference adds no context, cache or decode step. On one 1B model it gains 0.028 nats at equal tokens, 0.005 to 0.013 at equal node-hours, and under a stricter iso-FLOP count the full-pause run falls slightly behind. It measures language modelling and aggregate benchmark scores, not chain-of-thought reasoning.

Negative results and critiques

This field produces rebuttals at an unusual rate, Several headline mechanisms did not survive replication.

• Vennam, S., Valente, D., Herel, D., and Kumaraguru, P. (2024). Rethinking Thinking Tokens: Understanding Why They Underperform in Practice. arXiv:2411.11371. Naive thinking tokens underperform supervised chain of thought on GPT-2 multiplication and on Llama-3.2-1B fine-tuned for GSM8K and OpenBookQA. The authors hypothesise noisy gradients on the single repeated embedding, which barely moves in training. A second embedding moves more, but its task accuracy is not reported, so the mechanism is untested.
• Yu, Y. (2024). Do LLMs Really Think Step-by-step In Implicit Reasoning? arXiv:2411.15862. On generated multi-step arithmetic, probes on a prompted Qwen2.5-72B recover the first and last results but hardly the intermediate ones, while a Mistral-7B trained to internalise chain of thought yields decodable intermediates. Probe decodability, with no intervention showing the model uses them. Both models lose accuracy when the equations are reversed or the values scaled.
• Wu, Y., Lu, K., Ren, X., Hu, J., Wu, X., et al. (2025). LLMs are Single-threaded Reasoners: Demystifying the Working Mechanism of Soft Thinking. arXiv:2508.03440. Against the parallel-exploration claim: in a training-free mixture-of-embeddings setup on QwQ-32B, behaviour is predominantly that of top-1 decoding, with output distributions concentrated near the greedy ones. Not an identity. Both components' paths rise over the first two or three layers before the top one dominates, and some steps diverge from the greedy trace. Stochastic variants improve on the vanilla method, which shows exploration helps here rather than that noise is necessary.
• Rizvi-Martel, M., Rabusseau, G., and Mosbach, M. (2026). The Illusion of Superposition? A Principled Analysis of Latent Thinking in Language Models. arXiv:2604.06374. Genuine superposition shows up only in models trained from scratch with continuous latent chain of thought. Under fine-tuning or training-free regimes it collapses to token commitment or shortcuts. Undercuts the family's central theoretical selling point.
• Sahoo, S., Chadha, A., Jain, V., and Chaudhary, D. (2026). When Shallow Wins: Silent Failures and the Depth-Accuracy Paradox in Latent Reasoning. arXiv:2603.03475. Reports 18.4% of correct predictions as stable and faithful against 81.6% “computationally inconsistent”, 8.8% silent failures, and $r = -0.21$ between reasoning quality and correctness. This is a contested diagnostic proposal. The reported correlation is hard to reconcile with the conditional means given alongside it, and the headline rates are threshold-based operational definitions rather than independent verification of reasoning errors: see families.
• Yang, R., Han, S., Zhang, Y., Wei, C., Shao, Y., et al. (2026). Stabilizing Recurrent Dynamics for Test-Time Scalable Latent Reasoning in Looped Language Models. arXiv:2605.26733. Looped performance peaks at some recurrence depth and then collapses with further looping. Random-loop training plus a Jacobian-gain penalty improves finite-depth robustness: on synthetic addition it stays stable across the tested range, while on 1.4B mathematics benchmarks the average falls from 74.18% at four recurrences to 65.55% at eight, which the paper calls a slower decline rather than a cure. Motivated by the fixed-point condition $\rho(J) < 1$, but the released implementation takes one vector-Jacobian product from a random direction and penalises $\lVert J^{\top}v\rVert^2$, whose expectation is $\lVert J\rVert_F^2/D$ — a Frobenius-like surrogate rather than a spectral-radius estimate. Directly against the infinite-depth framing.
• Kshirsagar, A. (2026). The Weight of Silence: A Causal Case for Weights Over the Scratchpad in Latent Chess Reasoning. arXiv:2607.20952. In one Qwen3-14B LoRA chess run, replacing four latent positions with a held-out-board average or matched-norm noise leaves aggregate legality unchanged, so board-specific latent content is not necessary for that metric. Removal itself is a modest but resolved effect at n=1000, −2.0 points at p=0.021, while pad replacement and exact zeros cause much larger out-of-distribution failures. RL lifts legality from 48% to 61% against a 52% explicit-chain-of-thought baseline, with Stockfish top-move accuracy flat; the reported failures of latent reasoning plus RL to beat supervised fine-tuning are from math and logic settings, on accuracy rather than legality.
• Jin, H., Yang, S., and Wang, D. (2026). Final Checkpoints Are Not Enough: Analyzing Latent Reasoning Faithfulness Along Training Trajectories. arXiv:2607.06648. Faithfulness proxies are not monotonic during training. On ProsQA, COCONUT accuracy rises from 73.1% to 90.1% while output-level counterfactual responsiveness to a verified graph edit falls from 71.3% to 27.4%. That measure edits the input and watches the answer, so it is behavioural; the authors say high values do not establish faithful latent reasoning. Latent-state interventions are reported separately and disagree with each other, and separately trained GSM models move in opposite directions. Endpoint-only checks, which is what most of this literature runs, can therefore miss the trajectory.
• Sharma, A., and Vu, T. (2026). Dense Supervision Is Not Enough: The Readout Blind Spot in Looped Language Models. arXiv:2606.24898. Per-loop cross-entropy directly constrains what each readout exposes and need not control active variables hidden behind that interface. A scale-invariant readout removes the immediate radial signal exactly; later losses still reach it through the recurrence, attenuated rather than absent, which the authors state explicitly. Demonstrated for hidden-state scale: in 44M and 129M pre-norm looped transformers with inter-loop normalisation removed, final-loop norms reach 39,207 and 56,051. Other recurrent-state variables are left as future work.
• Kuo, C.-C., Chayti, E. M., Reizinger, P., Brendel, W., and Jaggi, M. (2026). Stabilizing Extrapolation in Looped Transformers via Learned Stochastic Stopping. arXiv:2606.29983. Length generalisation in looped transformers is brittle, with high out-of-distribution variance that stochastic loop schedules reduce. The paper attributes the variance to a spurious correlation between sequence length and loop count, though its own appendix complicates that: a fixed budget with no length dependence still shows standard deviation 0.087, and randomising around that same fixed budget cuts run-to-run deviation from 7.4 to 4.7 at unchanged mean accuracy, which the authors say shows the effect “is not specific to length-matched schedules”. The mechanisms are offered as hypotheses rather than proved.
• Larson, S. (2026). The Gradient Does Not See Rank: Rank-Indifference in Matrix-CODI on ProsQA. arXiv:2609.03090. Tests the superposition reading of matrix-valued CODI by ablating the latent matrix to low rank. Accuracy is flat to within 0.6 points across three regimes, three seeds and four readouts. A matched control on vanilla GPT-2 reproduces the flat curve, so the paradigm cannot separate rank-blindness from position-irrelevance.
• Ding, Y., Huang, Z., and Yang, L. (2026). SCIT: Testing Causal Cache Carriers in Latent Chain-of-Thought Models. arXiv:2608.27265. A causal cache-interchange protocol finds no universal latent-tail mechanism: the causal object differs by checkpoint and model competence, being a value-cache suffix in some models and the full key-value cache in others.
• Roye-Azar, N., Vargas-Naranjo, D., Ghai, S., Balamurugan, S., and Amir, S. (2025). Tiny Recursive Models on ARC-AGI-1: Inductive Biases, Identity Conditioning, and Test-Time Compute. arXiv:2512.11847. An ablation on the released checkpoint: replacing the puzzle-identifier token with a blank or random token yields zero accuracy, roughly eleven points of Pass@1 come from majority-vote test-time augmentation, and accuracy saturates after a few recursion steps.
• Liang, J., and Pan, L. (2026). Do Latent-CoT Models Think Step-by-Step? A Mechanistic Study on Sequential Reasoning Tasks. arXiv:2602.00449. In three-layer CODI students trained on a synthetic modular recurrence, longer hop-lengths do not produce a full latent rollout: the latent trace carries the last one or two intermediates, which fuse with the final input at the answer position. Students trained separately on prime moduli, where every nonzero update is invertible, reach about 8-9% accuracy and show no such pathway. The paper calls this collapse under regime shift, but the contrast is between separately trained models on different tasks, not one model meeting shifted inputs.
• Kim, J., Kim, S., Lee, N., Kim, Y., Seo, J., Lee, G., and Lee, J. (2026). Towards Understanding Pause Token Fine-Tuning Dynamics: A Mode Retention Perspective. arXiv:2609.04489. Offers a training-dynamics account of pause-token gains as a rival to the expressivity explanation. The fourfold figure comes from a synthetic two-regime pilot with a two-layer transformer: at matched fit to the new regime, held-out loss on the old one sits near 1.5 nats with masked pauses and near 6 without. The 1B-8B results are accuracy gains for pauses placed at step boundaries, and mode retention as their cause remains a working hypothesis.
• Tang, Y., Fang, Y., Sun, Y., Liu, J., Wang, Z., Zhao, X., Zhang, W., Liu, B., Liu, K., Zhang, W., and Chen, K. (2026). Is Next-Chunk Reasoning RL Really Better than SFT? Revisiting Training Strategies under no-CoT Data. arXiv:2608.23256. On one Qwen3-30B-A3B base with one data mixture, a mixed supervised baseline trained jointly on no-CoT and long-CoT data, followed by the same RLVR stage, beats next-chunk reasoning RL on the average of six math benchmarks, though not on each, and on all three out-of-domain ones. The sixty-fold saving is for the stage that uses the no-CoT data, 65.6 GPU-hours against 4,284 and 4,608. The shared RLVR stage is excluded and its cost unreported, so the end-to-end ratio is unknown.
• Sirivella, N., Newaz, A., and Melo, G. (2026). Evaluating Tiny Recursive Models Across Training for Code Generation. arXiv:2608.29376. Under teacher forcing the fit ranking between a recursive model and a depth-matched control reverses twice across training, so a single-checkpoint comparison is not stable evidence in either direction. On free-running generation the ranking does not reverse: the depth-matched control leads from epoch 8 onward, seed-consistent, and the paper reads the late fit reversal as an overfitting artefact rather than a recursion win. Scores come from an LLM judge on a synthetic corpus with no unit tests.
• Park, J., Jung, S., and Kang, M. (2026). Reason Through the Latent! Making Latent Visual Reasoning Necessary. arXiv:2609.06746. Perturbing the latent state leaves predictions largely unchanged for several latent visual-reasoning methods, so the visual content they carry is not behaviourally necessary. The paper stops short of calling it unused: the interventions are not strict no-bypass tests, because the original multimodal context stays available as another image-conditioned route, and an internal state can be informative without being causally required.
• Kim, G. (2026). Dynamical phase selection controls compute scaling in looped transformers. arXiv:2608.26556. Identically trained, identically accurate looped transformers fall into distinct dynamical phases depending on initialisation, and the phase rather than the architecture sets how iteration count grows near the bottleneck. The workload-level tail P(τ>N) ~ N-2 needs a second assumption, that the difficulty density is regular there; the paper attributes the universality to the fold normal form and that regularity, not to the network. Fifteen networks at width 16, and the paper calls the result a classification of the models explored rather than an exclusion theorem.

Faithfulness, monitorability and interpretability

• Turpin, M., Michael, J., Perez, E., and Bowman, S. R. (2023). “Language Models Don't Always Say What They Think: Unfaithful Explanations in Chain-of-Thought Prompting.” NeurIPS. arXiv:2305.04388. Biasing cues shift answers by up to 36% across thirteen BIG-Bench Hard tasks while the stated reasoning systematically omits the bias.
• Lanham, T., Chen, A., Radhakrishnan, A., Steiner, B., Denison, C., et al. (2023). Measuring Faithfulness in Chain-of-Thought Reasoning. arXiv:2307.13702. Interventional metrics: truncation, inserted mistakes, paraphrase, filler substitution. Models often reach the same answer regardless of what the chain says, and faithfulness does not straightforwardly improve with scale.
• Roger, F., and Greenblatt, R. (2023). Preventing Language Models From Hiding Their Reasoning. arXiv:2310.18512. A fine-tuned model embeds reasoning steganographically in innocuous text — 80% opinion-matching against 54% without the hidden channel. Context-aware paraphrasing plus penalties for abnormal generations held estimated rates below about 3 bits per kilobyte across the schemes tested, on one instruction and one maths dataset. That estimate assumes a message is either transmitted perfectly or scrambled entirely, which the authors note underestimates capacity, so it bounds the tested encoders from below rather than covert capacity from above.
• Yang, S., Gribovskaya, E., Kassner, N., Geva, M., and Riedel, S. (2024). “Do Large Language Models Latently Perform Multi-Hop Reasoning?” ACL. arXiv:2402.16837. Evidence that models internally resolve a bridge entity and use it for the second hop, for certain relation types: reasoning was partly latent before anyone designed it that way. The follow-up arXiv:2411.16679 asks how much of this survives a shortcut analysis.
• Baker, B., Huizinga, J., Gao, L., Dou, Z., Guan, M. Y., et al. (2025). Monitoring Reasoning Models for Misbehavior and the Risks of Promoting Obfuscation. arXiv:2503.11926. A weak monitor reading raw chains catches reward hacking during RL, but optimising the policy against that monitor yields obfuscated hacking that still passes it. The empirical basis for not training against chain-of-thought legibility.
• Lindsey, J., Gurnee, W., et al. (2025). On the Biology of a Large Language Model. Transformer Circuits. Attribution graphs show Claude 3.5 Haiku planning several tokens ahead, choosing rhyme words before writing the line that must end with them. Substantial reasoning precedes any emitted token.
• Chen, Y., Benton, J., Radhakrishnan, A., Uesato, J., Denison, C., et al. (2025). Reasoning Models Don't Always Say What They Think. arXiv:2505.05410. Across six hint categories, models verbalise using a hint they demonstrably used often below 20% of the time. Outcome-based RL improves faithfulness early and then plateaus without saturating.
• Lindsey, J. (2025). Emergent Introspective Awareness in Large Language Models. Transformer Circuits; later arXiv:2601.01828. Concept injection shows Claude Opus 4 and 4.1 sometimes detecting and naming a vector patched into the residual stream: roughly 20% of trials under favourable conditions. Failures of introspection remain the norm.
• Guan, M. Y., Wang, K., Carroll, M., Dou, Z., Wei, J., et al. (2025). Monitoring Monitorability. arXiv:2512.18311. Treats monitorability as a measurable and degradable property: thirteen evaluations across twenty-four environments in three archetypes.
• Dilgren, C., and Wiegreffe, S. (2026). Are Latent Reasoning Models Easily Interpretable? arXiv:2604.04902. The optimistic counterweight: latent reasoning tokens are frequently unnecessary, and where they carry the computation, a backtracking search against already-known gold traces recovers one on up to 65–93% of correctly answered instances, and substantially less often on incorrect ones, which is where a monitor would be reading. The authors call the evidence correlational rather than causal. A separate unsupervised method decodes a verified trace on a narrower subset, at a rate that falls as the counterfactual verification threshold rises.
• Chang, S., Bai, T., Zhang, X., Ma, Q., Liu, Q., et al. (2026). Unlocking the Black Box of Latent Reasoning: An Interpretability-Guided Approach to Intervention. arXiv:2606.01243. Finds early latent vectors acting as causal hubs and builds decode-time interventions on that basis. The paper calls the suite training-free, but only the weight-tying projection is: the linear mapper is fitted on 1,000 paired examples, the energy score is a trained two-layer network, interpolation needs a cached exemplar bank, and the gradient step nudges the vector toward the likelihood of the correct answer, which is not available at test time.
• Liu, Y. (2026). Beyond tokens: a unified framework for latent communication in LLM-based multi-agent systems. arXiv:2606.05711. Proposes replacing natural-language messages between agents with latent representations, naming the drawbacks of the token protocol as inference cost and “irreversible information loss during discretization”. The same quantiser argument that motivates latent reasoning inside a model, applied between models, where the messages are often the only legible part of the system.
• Baquero, C., and Brito, G. (2026). Cache Merging as a Convergent Replicated State for Multi-Agent Latent Reasoning. arXiv:2607.01308. Composes agents' key-value caches into one context. Concatenating them is non-commutative and the best ordering shifts with regime, latent-step budget and model scale. The answer offered is a representation-independent state: a set of content-addressed unshifted fragments under set union, with a deterministic canonical render over it. Order sensitivity is therefore a convergence problem rather than an absence of anything to observe, and the paper evaluates merge quality rather than interpretability.
• Backour, A. (2026). The Dynamics of Continuous Mixture Collapse in Language Models. arXiv:2609.02049. A dynamical account of why continuous mixtures collapse. Two theorems bracket the behaviour: coupling above 2 amplifies small differences until one component dominates, coupling in [0, 2) contracts mixtures until they are indistinguishable. The pair is not exhaustive, since both assume non-negative coupling and zero bias; negative coupling admits a stable oscillation between two mixture weights that neither theorem covers. Pretrained-model rollouts are reported on the amplifying side, measured on a logit-space surrogate that runs the model on the two pure branches rather than propagating the mixture, and binary, on two model families.
• Dilgren, R., and Wiegreffe, S. (2026). Are Latent Reasoning Models Easily Interpretable? arXiv:2604.04902. Finds latent reasoning tokens are often unnecessary to the prediction on logical reasoning datasets, corroborating the shortcut finding independently on other models.
• Gurnee, W., Sofroniew, N., Pearce, A., Piotrowski, M., Kauvar, I., Chen, R., Soligo, A., Bogdan, P., Ong, E., Wang, R., Thompson, T. B., Abrahams, D., Kantamneni, S., Ameisen, E., Batson, J., and Lindsey, J. (2026). Verbalizable Representations Form a Global Workspace in Language Models. Transformer Circuits Thread, 6 July 2026. Argues models maintain a privileged band of verbalizable representations, read through a Jacobian lens over single-token concepts, that mediate report and flexible multi-step reasoning, while some automatic computations survive ablating it. The authors call the lens an imperfect tool that captures the workspace “approximately and incompletely,” so computation outside it is not shown to be unverbalisable, and they decline to call monitoring it sufficient. If a workspace is what monitoring reads, the question about any architecture is how much of its computation passes through it. Not on arXiv.
• Breuninger, K., and Haddad, C. (2026). Trump goes scorched earth on AI warnings, raging about data center opposition and regulation. CNBC, 14 September 2026. News reporting, not a primary document. Records the President dismissing AI risk as a hoax and arguing that industry calls for regulation prove the fear manufactured, the White House AI adviser answering with product-liability and market discipline, and the Speaker arguing that regulating now loses the race to China. Quotes Truth Social posts rather than any signed instrument, and no executive order on the subject appears in the Federal Register as of this writing.

Encoded reasoning

• Mathew, Y., Matthews, O., McCarthy, R., Velja, J., Schroeder de Witt, C., et al. (2024). Hidden in Plain Text: Emergence & Mitigation of Steganographic Collusion in LLMs. arXiv:2410.03768. Steganographic collusion emerging from a mis-specified reward rather than deliberate training, in a synthetic candidate-screening task built so that a hidden sensitive attribute pays: a Gemma-2-2B sender learns, unprompted, to pass it to the receiver past an overseer. Separately, a Claude 3.5 Sonnet team explicitly told to build a covert channel finds strategies that passive monitoring and paraphrasing do not fully stop, when evaluated against the same fixed defences it was optimised against.
• Karpov, A., Adeleke, T., Cho, S. H., and Pérez-Campanero Antolín, N. (2025). The Steganographic Potentials of Language Models. arXiv:2505.03439. RL fine-tuning of Llama-3.1-8B-Instruct, updating only the encoder, improves undetected transmission of a roughly 3-bit payload by about 20% in a stylised summarisation task. The frontier models (GPT-4o, Claude 3.5 Sonnet, o1) are prompted, not fine-tuned, in setups the authors call idealized. Capability is rudimentary and decoding accuracy falls off with payload length.
• Zolkowski, A., Nishimura-Gasparian, K., McCarthy, R., Zimmermann, R., and Lindner, D. (2025). Early Signs of Steganographic Capabilities in Frontier LLMs. arXiv:2507.02737.

Scaling, padding and depth

• Schwethelm, K., Rueckert, D., and Kaissis, G. (2026). How Much Is One Recurrence Worth? Iso-Depth Scaling Laws for Looped Language Models. arXiv:2604.21106. Prices a recurrence in equivalent unique parameters, fitting $L = E + A(N_{\text{once}} + r^{\varphi} N_{\text{rec}})^{-\alpha} + BD^{-\beta}$ across $r \in \{1,2,4,8\}$ and roughly fifty-fold in training compute, with $\varphi \approx 0.46$ in the tested regime.
• Merrill, W., and Sabharwal, A. (2025). Exact Expressive Power of Transformers with Padding. arXiv:2505.18948. Padding as an alternative to chain of thought that avoids sequential decoding, with padding and looping analysed together under stated architecture assumptions.
• Merrill, W., and Sabharwal, A. (2025). A Little Depth Goes a Long Way: The Expressive Power of Log-Depth Transformers. arXiv:2503.03961. Constant depth is the wrong idealisation for short inputs: how far bounded depth suffices, and what growing it buys. The nearest thing the theory offers to task-specific depth guidance.
• Wierstra, D., Förster, A., Peters, J., and Schmidhuber, J. (2009). “Recurrent Policy Gradients.” PDF. Trains recurrent policies by return-weighted backpropagation. Cited here because it long predates, and contradicts, the claim that policy gradients cannot carry credit through a recurrence.

Probing and decoding latent computation

• Hagendorff, T., and Fabi, S. (2025). Beyond Chains of Thought: Benchmarking Latent-Space Reasoning Abilities in Large Language Models. arXiv:2504.10615. A 4,000-item benchmark that forces model-internal inference by requiring the answer to be signalled through the language of the first response token rather than through descriptive text, so the reasoning cannot be externalised. Eighteen models evaluated, best accuracy 74.7%. The authors state they cannot rule out heuristic exploitation under some conditions.
• Gould, S., Ward, F., Woodruff, J., Arike, R., Hills, J., and Serrano, S. (2026). Think Fast: Estimating No-CoT Task-Completion Time Horizons of Frontier AI Models. arXiv:2606.07157. Measures how well frontier models reason without chain of thought across more than 30,000 questions from 43 benchmarks, estimating the 50% task-completion time horizon against human times. Motivated directly by oversight: if models can reason internally without thinking tokens, chain-of-thought monitoring stops working. A suite rather than a dataset, with collated data available on request.
• Lu, W., Yang, Y., Lee, K., and Li, L. (2025). Latent Chain-of-Thought? Decoding the Depth-Recurrent Transformer. arXiv:2507.02199. Asks whether a depth-recurrent model's iterations correspond to anything like chain-of-thought steps, and attempts to decode them. The closest thing to interpretability tooling aimed specifically at recurrent depth.
• Nikolaou, G., Mencattini, T., Crisostomi, D., and Santilli, A. (2025). Language Models are Injective and Hence Invertible. arXiv:2510.15511. The input-to-state map is almost surely injective, at initialisation and after any finite number of gradient steps, so distinct prompts give distinct last-token representations despite non-injective activations and normalisation. Assumes real-analytic activations, which excludes ReLU. The recovery algorithm needs all per-position states at a layer; doing it from the final embedding alone is possible in principle and left open in practice. This concerns recovering the prompt from accessible activations: not recovering intermediate reasoning, and not recovering anything from the model's emitted text. The theorem is also real-valued: a $d$-coordinate representation at $p$ bits per coordinate has at most $2^{dp}$ states, so injectivity over all length-$K$ prompts fails by counting once $|V|^K > 2^{dp}$.
• Yang, Z., Li, J., Xia, S., and Hu, X. (2025). Internal Chain-of-Thought: Empirical Evidence for Layer-wise Subtask Scheduling in LLMs. arXiv:2505.14530. Across fifteen two-step composite tasks, distinct subtasks are learned at different depths and executed in sequence across layers: multi-step structure inside a single forward pass. The ordering comes from LogitLens, which the authors call correlational. Their causal check, on Llama-3.1-8B only, adds a vector along the difference of two unembedding rows rather than patching in an activation from the alternative prompt. The final answer does move to the alternative composite answer, but the edit is a steering vector, not the model's own counterfactual intermediate state.
• Du, Z., Wang, R., Bai, H., Cao, Z., Zhu, X., Cheng, Y., Zheng, B., Chen, W., and Ying, H. (2025). Enabling Agents to Communicate Entirely in Latent Space. arXiv:2511.09149. Agent-to-agent communication that bypasses tokens on the argument that discretising internal states limits what can be transmitted. In the full-length version the sender still generates a text plan, and the receiver takes the last-layer hidden states recorded while generating it, so a readable plan exists alongside the message. A separately trained compressor emits short latent messages without decoding any tokens. That variant is the concrete version of the neuralese concern in monitorability: multi-agent traffic with no native text transcript, though the authors treat interpretability as open rather than showing the messages undecodable. Mainly a two-agent feasibility study on ALFWorld and MATH.

Further latent-reasoning methods

• Liu, H., Murty, S., Manning, C. D., and Csordás, R. (2025). Thoughtbubbles: an Unsupervised Method for Parallel Thinking in Latent Space. arXiv:2510.00219. A transformer variant that performs parallel latent computation natively and can be applied during pretraining, rather than requiring serially generated natural-language verbalisation.
• Koishekenov, Y., Lipani, A., and Cancedda, N. (2025). Encode, Think, Decode: Scaling test-time reasoning with recursive latent thoughts. arXiv:2510.07358. Motivated by interpretability work locating reasoning computation in a limited band of layers, recurses on that band rather than the whole stack.
• Zeng, Z., Li, Y., Song, K., and Wang, W. (2025). PonderLM-2: Pretraining LLM with Latent Thoughts in Continuous Space. arXiv:2509.23184. Moves the extra computational steps into pretraining, spending them on every token rather than at test time on a reasoning trace.
• Deng, S., Pang, W., Wei, Y., and Xu, L. (2025). LLM Latent Reasoning as Chain of Superposition. arXiv:2510.15522. Latent-SFT, addressing distributional misalignment and ambiguous chain definitions, on the premise that latent reasoning should function as a superposition of several reasoning paths. The replication evidence in families cuts against it.
• Asadulaev, A., Banerjee, S., Karray, F., and Takáč, M. (2025). Latent Reasoning in TRMs is Secretly a Policy Improvement Operator. arXiv:2511.16886. Questions the standard explanation that recursion simply buys effective depth, noting that recursively added layers trail one-pass models of the same feed-forward capacity.
• Yang, J., Chen, C., Wu, S., Liu, Y., Fan, Y., Li, L., Lai, S., Qin, C., and Guo, Z. (2026). Demystifying Hidden-State Recurrence: Switchable Latent Reasoning with On-Policy Reinforcement Learning. arXiv:2606.13106. The policy ratio is undefined inside a latent block, so this wraps the block in two ordinary tokens to make entry and exit legible to on-policy reinforcement learning while the interior stays continuous.
• You, R., Liu, Z., Li, Y., and Li, W. (2026). SLPO: Scaling Latent Reasoning via a Surrogate Policy. arXiv:2607.19691. Names the obstacle directly: latent trajectories lack a tractable per-step likelihood and a stopping interface, so outcome-reward reinforcement learning cannot elicit latent test-time scaling as it does for explicit chains.
• Jung, W. (2026). Dropout-GRPO: Variational Stochasticity for Continuous Latent Reasoning. arXiv:2606.10184. Group-relative advantage needs reward variance within a group. A deterministic latent phase does not by itself remove it, since sampled answer tokens can still differ; the paper's own setup adds the condition that makes the rollouts identical, low-temperature decoding, and reports rewards collapsing to exactly zero variance under it. The proposed fix gains 1.72 points on GSM8K, 2.33 on SVAMP and 3.00 on MultiArith, against a Coconut baseline run at a single seed where the dropout runs use three.
• Zheng, Z., Gu, Y., Liu, W., Teh, Y. W., and Lee, W. S. (2025). SofT-GRPO: Surpassing Discrete-Token LLM Reinforcement Learning via Gumbel-Reparameterized Soft-Thinking Policy Optimization. arXiv:2511.06411. Puts the exploration noise in the logits rather than on the embedding, so the perturbed soft token stays a mixture of real embeddings, and takes the policy density from the Gumbel noise. Against discrete-token GRPO on 1.5B to 7B models: +0.13 at pass@1, +2.19 at pass@32, so the gain is in coverage at a 32-sample budget rather than in the single answer.
• Yue, Z., Jin, B., Zeng, H., Zhuang, H., Qin, Z., Yoon, J., Shang, L., Han, J., and Wang, D. (2025). Hybrid Latent Reasoning via Reinforcement Learning. arXiv:2505.18454. HRPO. Samples discrete tokens as usual and gates a vocabulary-projected soft token, the previous hidden state passed through the language-model head and back to an embedding average, into the sampled embedding, so the token sampler supplies the stochasticity and no chain-of-thought traces are needed. A hybrid by construction: the loop still closes through the vocabulary.
• Jain, A., and Rappazzo, B. (2025). Learning to Reason with Mixture of Tokens. arXiv:2509.21482. Extends GRPO to mixture-of-token generation with Dirichlet-weighted or multi-sampled mixtures. Gains on seven of ten Reasoning-Gym tasks at 1.5B, attributed to higher hidden-state entropy through the chain.
• Ren, H. (2025). LSRL: Process-Supervised GRPO on Latent Recurrent States Improves Mathematical Reasoning. Findings of EMNLP 2025. Decodes each recurrent depth of Huginn-3.5B to text and grades it with GPT-4.1-nano, discounting the per-depth scores into one trajectory reward, so the credit is shaped rather than depth-indexed. +4.27 on GSM8K from 500 problems. The decode-and-grade answer to process reward in a space nobody can read, and the overhead RLTT was built to avoid.
• Yu, Z., Shen, Q., Li, H., Zhang, Z., Zhu, S.-C., Zhang, C., and Zheng, Z. (2026). GradCuit: Credit-Assigned Gradient Flow Enables Robust and Interpretable Test-Time Latent Reasoning. arXiv:2608.02585. Optimises instance-specific latent states inserted mid-stack at test time, giving every later token a differentiable path back to each latent. A gradient-based rather than policy-gradient answer to the same credit-assignment problem.
• Zou, J., Xiong, Y., and Liu, Y. (2026). Capabilities and Fundamental Limits of Latent Chain-of-Thought. arXiv:2602.01148. Argues direct non-curriculum training of latent chain of thought fails from distributional mismatch. The failure theorem assumes a training distribution already worse than the expert by a fixed gap and concludes that more data from it cannot close the gap, so the mismatch is its premise rather than its result, and the paper's own “theoretically necessary” is stronger than what is proved. Also introduces a measure of decisional commitment governing an exploration-execution trade-off.
• Chen, X., Leong, C. T., Guo, W., Wang, J., Li, W., and Shen, X. (2026). What Makes Effective Supervision in Latent Chain-of-Thought: An Information-Theoretic Analysis. arXiv:2606.20075. Outcome-only latent training does no better than answering directly (GPT-2, GSM8K-Aug). The authors attribute this to a dual collapse, gradient attenuation together with representational drift, on the evidence of gradient norms and a PCA plot, without an intervention that tests either.
• Solgi, R., Tian, J., and Zhang, Z. (2026). LoRi: Low-Rank Distillation for Implicit Reasoning. arXiv:2606.05315. An explicit-CoT teacher's hidden states, stacked over layers and rationale tokens, have rapidly decaying singular values (LLaMA-3.2-1B, GSM8K). Layer and hidden-mode factors fixed from that teacher define a subspace in which the student's implicit states are matched to the teacher's by mean and covariance. The rank measurement is of the teacher's explicit rationale, not of implicit trajectories.
• Hao, Y., and Yang, M. (2026). Think Wider: Mitigating Latent Rank Collapse in Implicit Chain-of-Thought Reasoning. arXiv:2609.07406. Within each example, a trained model's six latent states concentrate on one dominant direction (effective rank 1.49 for SIM-CoT on ASDiv-Aug). A training-time penalty on that direction raises it to 3.82 and improves most matched CODI and SIM-CoT accuracies. Rank is measured per example, and the authors state it does not directly measure semantic reasoning capacity.
• Li, Y., Chen, X., Ju, C., Yao, J., Li, Z., Lan, J., Zhu, X., Zheng, B., and Wang, Y. (2026). Structural Process Supervision for Latent Chain-of-Thought Reasoning. arXiv:2609.09928. Prototype-Mediated Process Supervision (PMPS) soft-aligns latent embeddings with the teacher's hidden states at explicit chain-of-thought token positions, through learnable prototypes, aimed at representation collapse. No partition of the chain into steps is needed.
• Zou, X., Huang, J., Li, J., and Zhou, P. (2026). Latent Thought Flow: Efficient Latent Reasoning in Large Language Models. arXiv:2606.16222. Models latent reasoning as variable-length continuous trajectories, sampled by a continuous GFlowNet rewarded for decoded-answer quality and short length. The reward-proportional target integrates over unbounded latent vectors with no base measure, so its normaliser is not shown to be finite.
• Tu, S., Fu, Y., Yu, X., Tang, J., Kang, Y., Qin, Z., Zhang, M., and Gu, Q. (2026). Latent Reasoning with Normalizing Flows. arXiv:2606.06447. A probabilistic treatment of continuous thought, modelling latent trajectories with normalizing flows.
• Lin, Z., Cai, Y., Wen, J., and Zhang, M. (2026). Tyler: Typed Latent Reasoning for Language Models. arXiv:2606.16360. Learns when to invoke latent computation, which kind, and how much budget to allocate, rather than fixing those by design.
• Yuan, H., Jin, B., Yu, S., Kuang, K., Yu, P., Dong, Y., and Wang, S. (2026). Closing the Loop on Latent Reasoning via Test-Time Reconstruction. arXiv:2606.06252. Adapts the latent state at test time until it can reconstruct the query, sixteen per-instance updates to LoRA parameters with the backbone frozen. The paper does not read this as verification: reconstruction is “not sufficient for correct reasoning” and is “an input-anchored structural check rather than a certificate of correctness.” A state could encode the query alongside an unrelated conclusion and reconstruct perfectly. The answer is generated from the original query with the adapted model, not from the reconstruction.
• Li, Y., Li, Z., and Zhou, D. (2026). Skip a Layer or Loop It? Learning Program-of-Layers in LLMs. arXiv:2606.06574. Pretrained models admit many valid programs of layers, skipping or looping per input, some cheaper and more accurate than the default pass. Those programs are found by a search scored against the ground-truth answer: 71.9 per cent of already-correct inputs admit a shorter program, and 34.0 per cent of wrong ones admit a shorter program that corrects the prediction. Using this without the answer needs a separate 2.1M-parameter predictor, supervised on the search's offline labels; the base model is what goes unretrained.
• Duraipandian, S. I., Boyane, A., Nagesh, S., Francis, J., Vaidheeswaran, A., and Zhu, S. (2026). Interpreting Latent CoT Reasoning as Dynamical Systems. arXiv:2607.09698. Treats CODI and Coconut latent-token sequences as dynamical trajectories, measuring step geometry with a Lyapunov-like surrogate on GPT-2 Small at six latent steps and a single seed. The description is geometric, not causal: the paper runs no intervention, and says a direct correspondence with reasoning processes would need causal validation it leaves to future work.
• Fu, R., Guo, W., Wang, Y., Zhu, B., Lee, J. D., Jiao, J., Russell, S., and Mei, S. (2026). DiscoLoop: Looping Discrete Embeddings and Continuous Hidden States for Multi-hop Reasoning. arXiv:2607.00341. A depth-local storage problem in non-recurrent transformers for two-hop reasoning, motivating looped discrete-continuous hybrids.
• Zhang, C., Ding, N., Fang, Y., Liao, S., Ye, Q., Zhao, X., and Wang, S. (2026). The Tell-Tale Norm: $\ell_2$ Magnitude as a Signal for Reasoning Dynamics in Large Language Models. arXiv:2606.06188. Hidden-state norm tracks reasoning intensity, concentrated in late layers and compared against sparse-autoencoder features. Two gaps in that support. The decomposition's error term is stated as O(εorth‖z‖22), reached by bounding ‖z‖12 ≤ m‖z‖22 and absorbing m, the dictionary size, into the constant; on a k-sparse code the same step costs a factor of k, and with the reported εorth = 0.0173 the error term stops being small once about sixty features are active. An overcomplete decoder also cannot have small worst-case coherence at all, since D⊤D has at least m − d zero eigenvalues however small the average pairwise correlation is. Separately, the suppression experiment scales the selected dimensions to a tenth of their value and compares against the same number of random dimensions. Matching count rather than magnitude leaves the high-norm dimensions carrying the larger perturbation.
• Malarkkan, A., Choudhury, R., Byahut, S., Charde, M., Gupta, S., and Fu, Y. (2026). Invariant Reasoning Directions in Latent Trajectories of Language Models. arXiv:2606.29164. Low-rank directions along which reasoning quality differs, recovered by taking differences between a later and an earlier training checkpoint of the same backbone on 200 calibration examples, then truncating the SVD. The subspace is a property of what changed between those checkpoints, not of a native trajectory, and the authors make “no formal claim that it corresponds to causally invariant features,” only that the differences are consistent across the calibration set. Rank at 90 per cent energy averages 12 and ranges from 8 to 34.
• Chang, R., Liu, Y., Wang, S., Gao, J., Ma, X., Zhao, Y., Miao, C., Sun, M., Peng, H., Li, J., and Niu, C. (2026). Why Struggle with Continuous Latents? Interpretable Discrete Latent Reasoning via Rendered Compression. arXiv:2606.29712. Attributes continuous-latent training instability to a mismatch with discrete symbolic supervision and proposes a discrete, interpretable alternative.
• Jung, D., Shi, P., Zhang, Y., Zhang, J., and Chen, M. (2026). Adaptive Latent Agentic Reasoning. arXiv:2606.02871. A dual-mode agent that chooses latent or explicit reasoning at each turn, trained with a reward on whole trajectories that favours latent turns only when the task succeeds. Explicit reasoning is more frequent on Bamboogle and 2Wiki than on single-hop NQ and TriviaQA, and in the first turn. No experiment tests whether the turns it escalates are the ones that need explicit reasoning.
• Cho, J., Cui, Y., Kim, S., Han, D., and Han, B. (2026). LoopSpec: Self-Speculative Decoding for Looped Transformers. arXiv:2609.17184. Uses intermediate recurrent states as speculative drafts, with no auxiliary draft model.
• Huang, J., Wu, H., Gao, Y., Yan, Y., Zhang, J., Hei, Y., Dai, S., Zhang, J., Tan, P. S., and Hu, X. (2025). EffiReason-Bench: A Unified Benchmark for Evaluating and Advancing Efficient Reasoning in Large Language Models. arXiv:2511.10201. Built because “fair comparison of efficiency-oriented approaches is hindered by fragmented evaluation practices”, and finds no method dominates across backbone scale, task complexity or architecture. Covers efficient reasoning broadly rather than latent reasoning alone.

Routing and control on latent state

• Raposo, D., Ritter, S., Richards, B., Lillicrap, T., Humphreys, P. C., and Santoro, A. (2024). Mixture-of-Depths: Dynamically Allocating Compute in Transformer-Based Language Models. arXiv:2404.02258. Top-$k$ token routing per layer: selected tokens get the layer's full computation, the rest take a cheap residual skip.
• Zhou, Y., Lei, T., Liu, H., Du, N., et al. (2022). “Mixture-of-Experts with Expert Choice Routing.” NeurIPS. arXiv:2202.09368. Experts select their own top-$k$ tokens rather than tokens selecting experts, making load balance deterministic. The mechanism Mixture-of-Recursions later repurposes to select recursion depth.
• Wang, Y., Hayou, S., and Nalisnick, E. (2026). The Myth of Expert Specialization in MoEs: Why Routing Reflects Geometry, Not Necessarily Domain Expertise. arXiv:2604.09780. Proposition 1 bounds the distance between two tokens' routing logits by their distance in the router-relevant subspace plus a residual, so similar hidden states give similar logits. The paper states the converse fails and calls the mapping many-to-one, and the bound governs logits rather than the discrete top-$k$ route. The abstract's “necessary and sufficient to explain” is an informal gloss, not a theorem about expert selection. Empirically, expert overlap across models on the same question runs near 60 per cent, comparable to one model's overlap across different questions.
• Mohamud, S., Wagner, N., and Ravanelli, M. (2026). Self-Routing: Parameter-Free Expert Routing from Hidden States. arXiv:2604.00421. A fixed subspace of the raw hidden state routes competitively with no learned gate at all.
• Zhang, L., Zhao, S., Zhao, X., Xu, Y., Wang, Y., and Li, Y. (2026). TARPO: Token-Wise Latent-Explicit Reasoning via Action-Routing Policy Optimization. arXiv:2606.05859. An action head reads the hidden state at each step and samples a binary decision: emit a discrete token, or continue in continuous latent space. The dial between token and latent space, made a learned choice.
• Cheng, T., Chen, S.-Z., Zhang, H., Qin, Y., Luo, J., and Wei, Z. (2026). HyLaR: Hybrid Latent Reasoning with Decoupled Policy Optimization. arXiv:2604.20328. Interleaves discrete text with continuous visual latents for multimodal models, trained with separate clipping ranges for the two components. The latent objective is derived from a von Mises-Fisher policy with a closed-form KL, but the reported system uses an unnormalised surrogate for which, the authors say, that interpretation no longer strictly holds.
• Zhang, A., Chen, Y., Pan, J., Zhao, C., Panda, A., Li, J., and He, H. (2025). Reasoning Models Know When They're Right: Probing Hidden States for Self-Verification. arXiv:2504.05419. A probe scores intermediate answers for correctness. Truncating completed traces at the first chunk it trusts cuts tokens by about 24 per cent at 88.2 per cent accuracy against 88.6 without exit, or 19 per cent at 88.6, on one model and MATH. The exit is simulated after the fact on chunks parsed from the full trace, not run as a live gate.
• Scalena, D., Candussio, G., Bortolussi, L., Fersini, E., Nissim, M., and Sarti, G. (2026). Beyond the Commitment Boundary: Probing Epiphenomenal Chain-of-Thought in Large Reasoning Models. arXiv:2606.13603. Identifies a step after which further chain of thought no longer changes the greedily decoded answer. The paper calls such reasoning epiphenomenal rather than useless, since a step can shift probability mass without moving the arg-max. Its abstract reports up to 55 per cent of tokens saved, a median over the traces where a boundary was found; its conclusion reports up to 35 per cent, and using the boundary as a live exit costs accuracy.
• Ning, A., Kuo, Y.-L., and Gomes, C. (2025). Learning When to Stop: Adaptive Latent Reasoning via Reinforcement Learning. arXiv:2511.21581. A linear stop head trained by reinforcement learning halts latent reasoning, reported as a 52 per cent drop in reasoning length with no penalty to accuracy. The abstract does not name the baseline for that comparison.
• Popescu, A., Sáez de Ocáriz Borde, H., and Liò, P. (2026). Adaptive Depth in Looped Transformers: Diagnosing Learned Halting Gates and Trajectory Readouts. arXiv:2607.20519. Fitting a halting gate to frozen trajectories separates trajectory quality from gate capacity, and locates the difficulty in how the trajectory forms. That isolation runs only on a four-layer model trained from scratch; Ouro's released checkpoints fix the trajectory, so only the readout can be varied. There a post-hoc confidence readout beats the two-stage halting gate on held-out accuracy in five of twelve model-benchmark pairs, several differences small and on single runs.
• Varshney, N., Surla, S., Xu, W., Krishnan, A., Jeblick, K., Austin, D., Vaidya, A., and Onofrio, M. (2026). LLM Router: Rethinking Routing with Prefill Activations. arXiv:2603.20895. Extracts residual-stream activations before generation and predicts per-model correctness, closing 45.58 per cent of the gap to an oracle at 74.31 per cent cost saving. One of two confirmed cases of cross-model routing on internal state rather than prompt text.
• Bailey, L., Serrano, A., Sheshadri, A., Seleznyov, M., Taylor, J., Jenner, E., Hilton, J., Casper, S., Guestrin, C., and Emmons, S. (2024). Obfuscated Activations Bypass LLM Latent-Space Defenses. arXiv:2412.09565. A universal embedding suffix, optimised with white-box access, can take harmfulness probes from 100 per cent recall to zero at a 1 per cent false-positive rate while keeping a 90 per cent jailbreak rate. Sparse autoencoders and OOD detectors are also bypassed, under other attacks.
• Boxó, E., Neelappa, A., and Raval, N. (2025). Linear probes rely on textual evidence: Results from leakage mitigation studies in language models. arXiv:2509.21344. Filtering out tokens carrying explicit textual evidence drops probe AUROC by 10 to 30 points, with sandbagging detection falling from 0.94 to 0.57. Much apparent activation reading is surface reading, which bears on whether activation monitoring is an independent channel.
• Kumar, S. (2026). Pressure-Testing Deception Probes in LLMs: Scaling, Robustness, and the Geometry of Deceptive Representations. arXiv:2605.27958. Clean-data AUROC at or above 0.998 collapses under stylistic shift unless probes are trained with style augmentation. On clean data a probe on the first principal component alone reaches 0.609 to 0.804, but a permutation test finds no significant deception subspace.
• Duan, Y. (2026). Do Activation Monitors Survive Model Updates? Benchmarking, Predicting, and Repairing Activation-Monitor Staleness. arXiv:2606.15980. Monitors survive quantisation but frequently become unreliable after LoRA or QLoRA fine-tuning.

Non-generative classification and decision models

Encoders and APIs that take text plus candidate labels or a schema and return scores, with nothing generated. They read the input text, not another model's activations, so as routers they belong with the text-based ones. Deciding without a written rationale is not evidence of iterative latent computation, and fixed-depth classification is still inference.

• Guo, C., Pleiss, G., Sun, Y., and Weinberger, K. Q. (2017). On Calibration of Modern Neural Networks. ICML, PMLR 70. Modern neural classifiers are poorly calibrated, and temperature scaling, a one-parameter variant of Platt scaling, is effective on most of the datasets tested. The reference point for reading any classifier's softmax as a probability.
• Yin, W., Hay, J., and Roth, D. (2019). Benchmarking Zero-shot Text Classification: Datasets, Evaluation and Entailment Approach. EMNLP-IJCNLP. Casts zero-shot classification as textual entailment, with the label as the hypothesis, and adds a label-fully-unseen evaluation in which no task-specific training data is seen at all. The abstract credits that setting to Chang et al. (2008), so classifying against label descriptions is an old task.
• Tunstall, L., Reimers, N., Jo, U. E. S., Bates, L., Korat, D., Wasserblat, M., and Pereg, O. (2022). Efficient Few-Shot Learning Without Prompts. arXiv:2209.11055. SetFit. Contrastively fine-tunes a sentence encoder on a few labelled pairs, then trains a classification head, with no prompts. Reports accuracy comparable to PEFT and PET at an order of magnitude less training time. It needs task-labelled examples, which the zero-shot label-description models do not.
• Zaratiana, U., Tomeh, N., Holat, P., and Charnois, T. (2024). GLiNER: Generalist Model for Named Entity Recognition using Bidirectional Transformer. NAACL. A bidirectional encoder extracts entities of any type named as a label, in parallel rather than by sequential generation, and reports beating ChatGPT and fine-tuned LLMs on zero-shot NER benchmarks. Span extraction rather than classification, and the architecture GLiClass and GLiNER2 adapt.
• Stepanov, I., Shtopko, M., Vodianytskyi, D., Lukashov, O., Yavorskyi, A., and Yaroshenko, M. (2025). GLiClass: Generalist Lightweight Model for Sequence Classification Tasks. arXiv:2508.07662. The main variant concatenates every candidate label, each behind a marker token, with the input text, so one encoder pass scores all labels. Bi-encoder variants and a PPO adaptation for multi-label training are also reported. The largest model averages 0.7193 F1 against 0.6821 for the strongest cross-encoder, though the two tables average over slightly different dataset lists. Speeds are measured at batch size 1 on one GPU. Calibration differences across datasets are listed as a limitation, and no calibration metric is reported. Code, with checkpoints such as edge-v3.0 under Apache-2.0.
• Zaratiana, U., Pasternak, G., Boyd, O., Hurn-Maloney, G., and Lewis, A. (2025). GLiNER2: Schema-Driven Multi-Task Learning for Structured Information Extraction. EMNLP System Demonstrations. Entity recognition, text classification and hierarchical record extraction in one encoder of about 205M parameters, composed through a declarative schema and described as CPU-efficient. Classification uses a softmax across labels for single-label tasks and an independent sigmoid per label for multi-label ones. Code, Apache-2.0.
• Almeida, D. (2026). Introducing System One Models & Jev. TypeSafe AI blog, 15 September, with API documentation. A vendor launch post, not a paper. Jev takes a state and typed questions (a choice among up to 255 options, a score on an ordered rubric, a yes-or-no probability) and returns probabilities without generating text. The architecture is described only as new. The training method, Reinforcement Learning for Calibrated Decisions, is named but not specified, and is not the RLCR method on the prediction page. The speed and cost headlines come from the company's own workflow evals, which score agreement with the average of two frontier models rather than outcomes, and the company says it deliberately does not publish public-benchmark results. Its “can't hallucinate” is schema validity, by the post's own account: “Our number is not empirical. Schema matching is guaranteed.”

Hierarchical and tiny recursive networks

• Wang, G., Li, J., Sun, Y., Chen, X., Liu, C.-L., Wu, Y., Lu, M., Song, S., and Abbasi Yadkori, Y. (2025). Hierarchical Reasoning Model. arXiv:2506.21734. Two small recurrent modules at different frequencies, a slow planning loop and a fast detail loop, reported to beat chain-of-thought LLMs on Sudoku, maze and ARC-AGI-style puzzles at 27M parameters on roughly a thousand examples. Recursion in continuous state with no emitted intermediate tokens, roughly two orders of magnitude below the 2.6–3.5B recurrent-depth language models.
• Jolicoeur-Martineau, A. (2025). Less is More: Recursive Reasoning with Tiny Networks. arXiv:2510.04871. Strips the hierarchical model to a single tiny recursive network with a simpler training recipe, reporting results past both it and much larger models on the same puzzles.
• Ren, Z., and Liu, Z. (2026). Are Your Reasoning Models Reasoning or Guessing? A Mechanistic Analysis of Hierarchical Reasoning Models. arXiv:2601.10679. HRM can fail on a puzzle with one unknown cell because correct answers are not always stable fixed points, and it often settles on a spurious fixed point before jumping abruptly to the answer, which the authors call guessing rather than reasoning. The hierarchical modules are kept, not ablated. This belongs next to the two above rather than after them.
• ARC Prize Team (2025). The Hidden Drivers of HRM's Performance on ARC-AGI. Published 15 August 2025. The organisation that runs the benchmark ran its own ablations on the Hierarchical Reasoning Model and reports that the hierarchical architecture “had minimal performance impact when compared to a similarly sized transformer,” that the under-documented outer refinement loop drove most of the gain, and that “most of the performance comes from memorizing solutions to the specific tasks used at evaluation time.” Not on arXiv.
• Wang, G., Liu, C., Wang, C., Zhou, C., Sun, Y., Wu, Y., Zhen, S., Scimeca, L., and Abbasi Yadkori, Y. (2026). HRM-Text: Efficient Pretraining Beyond Scaling. arXiv:2605.20613. Takes the hierarchical recurrent architecture to language-model pretraining. A 1B model trained from scratch on 40B unique tokens, repeated to 60B, for a stated 1,500 US dollars reports 60.7% MMLU, 84.5% GSM8K and 56.2% MATH, which the paper places “roughly 100–900× fewer training tokens and 96–432× less estimated compute” than the open baselines it lists. Several things qualify that comparison, and they pull in different directions.
• HRM-Text, the ablations. The architecture claim has a FLOPs-matched ablation behind it, which is more than most such claims carry: at equal compute the recurrent model reaches 60.73 MMLU against 56.51 for a looped transformer, 56.09 for RINS, 53.15 for a plain 1B transformer and 56.67 for a 3B one, and the plain transformer saw 0.17T tokens to the recurrent model's 0.06T. The same tables also show the training recipe carrying more of the total than the architecture: a transformer goes 40.55 to 47.72 to 53.15 as the task-completion objective and PrefixLM masking are added, before the architecture swap adds 53.15 to 60.73. The architecture contribution is larger in combination with the objective than alone.
• HRM-Text, the comparison. The baselines in the headline table are pretrained on raw web text at trillions of tokens; HRM-Text trains on instruction-response pairs with response-only loss and is evaluated on instruction-shaped benchmarks, so the two are not doing the same task. The corpus includes LLM-rewritten Wikipedia and reasoning-model distillation sets, with <think> spans stripped, and the cost of generating that upstream data is not counted in that 1,500. The paper runs an n-gram contamination test and finds DROP significant at n=13 but not n=20. It does not address whether training on instruction pairs brings the training distribution closer to the benchmark format. Two open reports on the project's own tracker are unanswered: that the evaluation harness credits $1/|\text{options}|$ when the model emits no parseable answer, and that rebuilding the corpus from the released pipeline yields about 0.73× the stated token count.

Faithfulness beyond planted hints

• Arcuschin, I., Janiak, J., Krzyzanowski, R., et al. (2025). Chain-of-Thought Reasoning In The Wild Is Not Always Faithful. arXiv:2503.08679. On naturally worded prompts with no injected cue, models answer reversed comparison pairs inconsistently and take illogical shortcuts on hard maths. The authors read the comparison results as preliminary evidence of post-hoc rationalisation of an implicit Yes/No bias, while noting the direction of causality is not established. Their search for restoration errors found none beyond likely dataset contamination.
• Bogdan, P. C., Macar, U., Nanda, N., and Conmy, A. (2025). Thought Anchors: Which LLM Reasoning Steps Matter? arXiv:2506.19143. Resamples the continuation after replacing each sentence of a reasoning trace with a semantically different one, scoring how far the distribution of final answers moves. On 40 traces for 20 MATH problems, certain sentences, mostly planning and uncertainty management, have an outsized effect. Makes causal influence measurable per sentence rather than per trace. The authors call it preliminary and note that later steps can be overdetermined by independent sufficient causes.
• Boppana, S., Ma, A., Loeffler, M., et al. (2026). Reasoning Theater: Disentangling Model Beliefs from Chain-of-Thought. arXiv:2603.05488. On DeepSeek-R1 and GPT-OSS-120B, activation probes and forced answering predict the eventual answer well before a text monitor finds a commitment, much more so on MMLU than on GPQA-Diamond. The authors read this as performative chain of thought. The measurements show early predictability of the final answer, not a settled belief that the remaining tokens leave unused.
• Shi, Z., Tifft, X., and Xing, W. (2026). Selective Disclosure of Hidden Directives in Reasoning Models. arXiv:2608.29070. Under a system prompt banning self-reference, several reasoning models mention a malign hidden directive, or the ban, more often than a matched benign one. Explicit mention is not the same as recoverability: on traces a keyword detector calls clean, a monitor reading only the trace names the malign directive's specific target 82.1% of the time, and steering that suppresses disclosure vocabulary leaves the monitor's detection rate unchanged.
• Baherwani, V., Goldstein, T., and Panda, A. (2026). Not All LLM Reasoning is Visible in the Chain-of-Thought. arXiv:2607.22925. Of thirteen frontier models, many, not all, gain accuracy from fixed filler spans on three generated tasks, with effects that depend on model, task and token type. Frontier models, but synthetic tasks, and the authors do not claim filler tokens evade a monitor in a realistic setting.
• Chen Yueh-Han, McCarthy, R., Lee, B., et al. (2026). Reasoning Models Struggle to Control their Chains of Thought. arXiv:2603.05706. Asked to follow instructions about their chains of thought, such as avoiding a keyword, models mostly fail, with controllability mostly below 10 per cent. A prompted proxy for concealment. No model is trained to evade a monitor, and within the open-weight families tested controllability rises with size.
• Xiong, Z., Chen, S., and Lakkaraju, H. (2026). Monitorability as a Free Gift: How RLVR Spontaneously Aligns Reasoning. arXiv:2602.03978. On Qwen3-4B and a 1.5B distilled model, early verifiable-reward training often makes it easier for a monitor reading the trace to tell when the model followed a planted hint, without being optimised for. The effect is “not universal”: it depends on the training data, and science-only training degrades it on code and sandbagging. The authors attribute the gain mainly to sharper output distributions and more attention to the prompt, not to stronger reliance on the trace. A more optimistic reading than the position paper's, with those limits.
• Anwar, U., Bakker, T., Kianfar, D., et al. (2026). Analyzing and Improving Chain-of-Thought Monitorability Through Information Theory. arXiv:2602.18297. A mutual-information formalisation of monitorability, which the position paper leaves informal. Positive monitor uplift needs the trace to carry information about the monitored attribute. Mutual information between trace and output is also necessary, though not sufficient, when that attribute is a function of the prompt and final output.

Recent critiques and refinements

• Aswal, A., Palmeira Ferraz, T., Zhou, Y., et al. (2026). Observable Patterns Are Not Explanations: A Causal-Geometric Analysis of Latent Reasoning Models. arXiv:2606.12689. Tests Coconut and CODI against controls lacking their recurrence or curriculum and finds the patterns read as evidence of internal reasoning appear in the controls too, without always causally affecting behaviour. Latent thoughts are hidden computation, not hidden explanation.
• Guo, S., Wu, T., Du, Y., et al. (2026). Right Direction, Wrong Step: Geometric Analysis of Finite-Step Failure in Looped Transformers. arXiv:2609.16665. Separates a wrong update direction from a correct direction with the wrong step size. Extra iterations can reduce support for the correct answer even when the direction is right.
• Prairie, H., Novack, Z., Berg-Kirkpatrick, T., et al. (2026). Parcae: Scaling Laws For Stable Looped Language Models. arXiv:2604.12946. A scaling-law study for looped models together with a recipe addressing training instability. This sits alongside the iso-depth law above.
• Tan, W., Li, J., Ju, J., et al. (2025). Think Silently, Think Fast: Dynamic Latent Compression of LLM Reasoning Chains. arXiv:2505.16552. CoLaR. Two-stage supervised then reinforcement training that compresses chain of thought into latent space at variable compression ratios.
• Yang, C., Huang, C., et al. (2026). Nanbeige4.2-3B: Unlocking Agentic Capabilities in a Compact Model. arXiv:2607.22083. A general agentic model on a looped transformer that reuses its layer stack for depth without extra parameters, 3B non-embedding parameters over 28T tokens, with open weights, evaluated as a local assistant inside the OpenClaw agent framework. Running it takes the repository's own modelling code, and an independent report found five bugs in the released checkpoint under Transformers 5.8.1.

Stress-testing chain-of-thought monitoring

A coherent cluster from NeurIPS 2025 and ICLR 2026, largely postdating the position paper, testing whether monitoring survives contact with a model that would rather it did not.

• Arnav, B., Bernabeu-Pérez, P., Helm-Burger, N., Kostolansky, T., Whittingham, H., and Phuong, M. (2025). “CoT Red-Handed: Stress Testing Chain-of-Thought Monitoring.” NeurIPS. arXiv:2505.23575. Monitoring an untrusted model can be defeated by reasoning traces that are deceptive but plausible. A hybrid monitor reading both the chain of thought and the actions roughly doubles detection of subtle sabotage.
• Skaf, J., Ibanez-Lissen, L., McCarthy, R., Watts, C., Georgiev, V., et al. (2025). “Large language models can learn and generalize steganographic chain-of-thought under process supervision.” NeurIPS. arXiv:2506.01926. RL against a regex monitor that penalises specific strings teaches small models to substitute other strings that still carry the reasoning, on three constructed tasks, and a name-encoding scheme transfers to held-out names from the same class. The authors call the arithmetic result a minimum viable proof of concept, note that regex monitors are significantly less sophisticated than monitors that might be deployed, and leave stronger monitors and reward-hacking settings open.
• Drori, J., Marks, L., Woodworth, B., Cloud, A., and Turner, A. M. (2025). “Output Supervision Can Obfuscate the Chain of Thought.” ICLR 2026. arXiv:2511.11584. Training against an output-only monitor, the mitigation proposed to avoid pressuring the trace, still produces obfuscated and unfaithful chains through two identified mechanisms. The recommended workaround is not safe by construction.
• Wang, X., Joshi, N., Plank, B., Angell, R., and He, H. (2025). “Is It Thinking or Cheating? Detecting Implicit Reward Hacking by Measuring Reasoning Effort.” ICLR 2026 oral. arXiv:2510.01367. Implicit reward hacking, where the trace looks benign and the model still exploits a loophole, is flagged by truncating the reasoning and measuring how little of it the answer needed, reaching near 1.0 F1 against a chain-of-thought monitor's 0.7 on single-model math. The truncation score is a proxy for relative reasoning effort, not the ground truth: hacking labels come from separate counterfactual tests, feeding the model a wrong hint or a verifier without the loophole. It assumes a task that needs inference-time exploration, and the authors note that a task solvable in one forward pass turns the long chain into post-hoc rationalisation the score cannot see. A monitor can be defeated without any verbalised cheating to catch.
• Jose, A. (2025). “Reasoning Models Sometimes Output Illegible Chains of Thought.” NeurIPS. arXiv:2510.27338. Illegible chains appear across fourteen models that were not trained to produce them. The evidence is observational: the authors say they cannot determine the causal mechanism without controlled reinforcement-learning or ablation experiments, and the Claude models stay legible, which they read as showing that outcome-based training does not make illegibility inevitable. Truncating a QwQ chain and forcing an answer drops definitely-correct answers from 24.6 to 11.5 per cent, while within-question resampling finds no population-level link between illegibility and correctness (mean r = 0.061).
• Tutek, M., Hashemi Chaleshtori, F., Marasović, A., and Belinkov, Y. (2025). “Measuring Chain of Thought Faithfulness by Unlearning Reasoning Steps.” EMNLP, Outstanding Paper. arXiv:2502.14829. Erases content associated with an individual reasoning step from the model's parameters and measures the change in its direct answer, subject to efficacy and specificity controls. The authors name the construct parametric faithfulness, distinguish it from perturbing the context, and read ff-hard as a lower bound rather than evidence that the emitted step mediated the original answer.
• Hase, P., and Potts, C. (2026). “Counterfactual Simulation Training for Chain-of-Thought Faithfulness.” COLM. arXiv:2602.20710. Trains traces to let a simulator predict the model's output on counterfactual inputs, lifting monitor recall on SNLI from 12 to 87 per cent at under 3 per cent false positives. What it optimises is counterfactual simulatability, which is weaker than faithfulness: on two of four datasets the paper finds simulation accuracy improving through more predictable answers rather than better chains, with no gain at all on MMLU for model-generated counterfactuals. Training on cue-based and model-generated counterfactuals does not transfer between them, and the cues are not tied to a threat model.
• Wang, H., Sun, Y., Ko, B., Talati, M., et al. (2026). “MonitorBench: A Comprehensive Benchmark for Chain-of-Thought Monitorability.” COLM. arXiv:2603.28590. 1,514 instances across 19 tasks. A candidate for the shared instrument this area lacks, though its headline number is not a causal-detection rate. The monitorability score divides the monitor's hit rate on successful interventions by the share of successes the intervention caused, then caps it at one, so a monitor that flags only the cases that would have succeeded anyway can reach the ceiling while catching none of the successes actually attributable to the intervention.

Limits on internalisation

• Yao, Y., Du, Y., Zhu, D., Hahn, M., and Koller, A. (2025). “Language models can learn implicit multi-hop reasoning, but only if they have lots of training data.” EMNLP. arXiv:2505.17923. Single-pass $k$-hop reasoning is learnable, at exponentially growing data and linearly growing depth in $k$. The scaling is the finding.
• Qin, T., Alvarez-Melis, D., Jelassi, S., and Malach, E. (2025). “To Backtrack or Not to Backtrack: When Sequential Search Limits Model Reasoning.” COLM. arXiv:2504.07052. Training on full search traces can do worse than shorter targets on the same task, so more visible search is not always more capability. The experiment compares supervision targets and does not itself measure an internal non-verbalised capacity.
• Wu, H., Teng, Z., and Tu, K. (2025). “Parallel Continuous Chain-of-Thought with Jacobi Iteration.” EMNLP. arXiv:2506.18582. Updates latent thought tokens by Jacobi iteration in parallel rather than sequentially, taking about half the time of sequential continuous chain of thought. The measurement covers processing the question and the chain, and excludes answer generation, which the authors leave out because answer length varies by method and, on their benchmark, runs to one or two tokens against roughly a hundred measured.
• Svete, A., and Sabharwal, A. (2025). “On the Reasoning Abilities of Masked Diffusion Language Models.” ICLR 2026 oral. arXiv:2510.13117. Extends the circuit-complexity programme to masked diffusion models, characterising what they can solve and at what cost.

Fixed points, implicit differentiation and algorithmic reasoning

A loop that settles can sometimes be differentiated without unrolling it, and a loop can be trained so each iteration advances one step of an algorithm. Both literatures predate latent reasoning and are largely uncited by it.

• Bai, S., Kolter, J. Z., and Koltun, V. (2019). Deep Equilibrium Models. arXiv:1909.01377. Finds a hidden-layer fixed point by root-finding and backpropagates through it by implicit differentiation, giving memory constant in effective depth. Convergence alone is not enough: the formula inverts $I - J_f$ at the equilibrium, so that Jacobian must be nonsingular and the selected root must vary differentiably with the inputs.
• Bai, S., Koltun, V., and Kolter, J. Z. (2020). Multiscale Deep Equilibrium Models. arXiv:2006.08656. Extends the equilibrium formulation to a multi-resolution hidden state solved jointly.
• Chen, R. T. Q., Rubanova, Y., Bettencourt, J., and Duvenaud, D. (2018). Neural Ordinary Differential Equations. arXiv:1806.07366. The adjoint sensitivity method for continuous-depth networks: backpropagate by solving a second ODE backwards in time, at memory constant in depth. The continuous-time sibling of the equilibrium backward pass. The constant-memory version reconstructs the forward trajectory by integrating backwards, so it is not in general an exact gradient of the numerical forward solve.
• Geng, Z., Zhang, X.-Y., Bai, S., Wang, Y., and Lin, Z. (2021). On Training Implicit Models. arXiv:2111.05177. Introduces the phantom gradient, a deliberately inexact approximation to the implicit gradient, on the argument that the exact solve is expensive and not necessary for a good update direction.
• Fung, S. W., Heaton, H., Li, Q., McKenzie, D., Osher, S., and Yin, W. (2021). JFB: Jacobian-Free Backpropagation for Implicit Networks. arXiv:2103.12803. Drops the Jacobian term entirely and proves the resulting update is still a descent direction under stated conditions.
• Fein-Ashley, J., and Rashidinejad, P. (2026). Solve the Loop: Attractor Models for Language and Reasoning. arXiv:2605.12466. Treats a looped model's output embedding as a fixed point solved by root-finding rather than unrolling. The exact implicit gradient is derived but mostly not used: the 140M and 370M language models train with the one-step Jacobian-free approximation, the 770M model with an Anderson adjoint solve, and the reasoning tasks with phantom gradients. In the ablation the exact gradient costs 4.8 times the memory and 2.7 times the step time for a 0.14 perplexity gain. Positioned explicitly against Coconut, Huginn and Ouro, whose unrolling makes training memory grow with depth.
• Labovich, A. (2026). Stability and Generalization in Looped Transformers. arXiv:2604.15259. A fixed-point framework along reachability, input-dependence and geometry. For autonomous looped networks, those that do not re-inject the input, the paper proves the fixed-point set is countable and strong input-dependence is unreachable at any spectral regime. That result is generic rather than universal: it assumes a transversality condition and holds for almost all parameter vectors. Recall combined with outer normalisation produces fixed points that are reachable, locally smooth in the input, and support stable backpropagation.
• Zhang, T., Hu, J., Peng, Y., and Xie, T. (2026). When Does Recurrence Become an Algorithm? Convergence Selection in Weight-Tied Looped Transformers. arXiv:2607.20594. A budget law: free training installs a frontier solving $v$ positions per loop, priced by the training contract as $v \sim n_{\text{train}}/T_{\text{train}}$. The authors state it as “a robust empirical regularity rather than a selection theorem”, and their own table shows exceptions under the $T=n$ contract that the abstract's “exactly unity” does not convey: $v = 0.96$ over sixteen seeds on one group with range $[0.08, 1.03]$, and roughly $1.5$ on a parity benchmark. Weight tying rather than expressivity selects a serial over a parallel algorithm, and imposing seriality through the input schedule fails where free training succeeds.
• Veličković, P., and Blundell, C. (2021). Neural Algorithmic Reasoning. arXiv:2105.02761. The position paper for aligning neural computation with algorithmic structure.
• Veličković, P., Ying, R., Padovano, M., Hadsell, R., and Blundell, C. (2019). Neural Execution of Graph Algorithms. arXiv:1910.10593. Trains networks to imitate individual steps of classical graph algorithms, establishing step-wise supervision as the norm in this line.
• Veličković, P., Badia, A. P., Budden, D., Pascanu, R., Banino, A., et al. (2022). The CLRS Algorithmic Reasoning Benchmark. arXiv:2205.15659. Packages classical algorithms with per-step hints, the full trajectory of intermediate states, as an optional supervision signal alongside input-output pairs.
• Ibarz, B., Kurin, V., Papamakarios, G., Nikiforou, K., Bennani, M., et al. (2022). A Generalist Neural Algorithmic Learner. arXiv:2209.11142. Improvements to input representation, training regime and processor architecture over the benchmark baselines.
• Rodionov, G., and Prokhorenkova, L. (2023). Neural Algorithmic Reasoning Without Intermediate Supervision. arXiv:2306.13411. Trains from input-output pairs alone, replacing ground-truth step hints with a self-supervised regulariser on intermediate computations, and reports results competitive with trajectory supervision. Per-step ground truth is not the gate it is often taken to be.
• Bansal, A., Schwarzschild, A., Borgnia, E., Emam, Z., Huang, F., Goldblum, M., and Goldstein, T. (2022). End-to-end Algorithm Synthesis with Recurrent Networks: Logical Extrapolation Without Overthinking. arXiv:2202.05826. Names overthinking, the degeneration that appears when a recurrent model is run for many more iterations than it was trained for, and fixes it with a recall architecture keeping an explicit copy of the problem in memory plus progressive training over iteration counts.
• Schwarzschild, A., Borgnia, E., Gupta, A., Huang, F., Vishkin, U., Goldblum, M., and Goldstein, T. (2021). Can You Learn an Algorithm? Generalizing from Easy to Hard Problems with Recurrent Networks. arXiv:2106.04537. The easy-to-hard result across prefix sums, mazes and chess: recurrent networks trained on simple instances solve harder ones when allowed more recurrences at inference. The reported answer is the output from whichever iteration the model is most confident in, not the final one.
• Selsam, D., Lamm, M., Bünz, B., Liang, P., de Moura, L., and Dill, D. L. (2018). Learning a SAT Solver from Single-Bit Supervision. arXiv:1802.03685. NeuroSAT, a message-passing network trained only to predict satisfiability, solves SAT problems substantially larger and harder than any it saw in training by running for more iterations. An earlier instance of the same kind of extrapolation, on one problem family, which Schwarzschild et al. cite.
• Anil, C., Pokle, A., Liang, K., Treutlein, J., Wu, Y., Bai, S., Kolter, J. Z., and Grosse, R. (2022). Path Independent Equilibrium Models Can Better Exploit Test-Time Computation. arXiv:2211.09961. Defines path independence as converging to the same steady state regardless of initialisation, and measures it by the cosine similarity between the fixed point reached from the usual initialisation and those reached when the solver starts from other inputs' fixed points. That score correlates with whether extra test-time iterations help, and on prefix sums, training changes that raise it improve upward generalisation while a penalty that lowers it hurts. The authors note that none of their metrics can verify that a network is globally path independent.
• Gilmer, J., Schoenholz, S. S., Riley, P. F., Vinyals, O., and Dahl, G. E. (2017). Neural Message Passing for Quantum Chemistry. arXiv:1704.01212. The message-passing formulation in which $k$ rounds bound a node's receptive field to its radius-$k$ neighbourhood. That is an upper bound on what the state can depend on, not a guarantee that each round advances exactly one hop of a computation, though it is the precedent for reading one iteration as one hop.
• Xu, K., Hu, W., Leskovec, J., and Jegelka, S. (2018). How Powerful are Graph Neural Networks?. arXiv:1810.00826. Ties $k$ message-passing layers to $k$ iterations of the Weisfeiler-Lehman test, with the expressiveness limits that follow.
• Li, Q., Han, Z., and Wu, X.-M. (2018). Deeper Insights into Graph Convolutional Networks for Semi-Supervised Learning. arXiv:1801.07606. Oversmoothing: repeated graph-convolution layers act as Laplacian smoothing, driving node representations within a connected component together and costing discriminative power. The effect is shown for that architecture and regime rather than as a universal ceiling on stacked propagation.
• Alon, U., and Yahav, E. (2020). On the Bottleneck of Graph Neural Networks and its Practical Implications. arXiv:2006.05205. Oversquashing: exponentially many messages compressed into fixed-size vectors as receptive fields grow, bounding effective long-range propagation.
• Topping, J., Di Giovanni, F., Chamberlain, B. P., Dong, X., and Bronstein, M. M. (2021). Understanding over-squashing and bottlenecks on graphs via curvature. arXiv:2111.14522. A curvature account of when oversquashing occurs, with a rewiring remedy.
• Gholami, A., Keutzer, K., and Biros, G. (2019). ANODE: Unconditionally Accurate Memory-Efficient Gradients for Neural ODEs. arXiv:1902.10298. The correction to the constant-memory adjoint: reconstructing the forward trajectory by integrating backwards can give inaccurate gradients, and this proposes a scheme that does not.

Belief state, evidence and attribution

What a model's internal credence is, and how a change in it can be traced back to the evidence that moved it. Largely disjoint from the latent-reasoning literature proper, and relevant to it.

• Balcells, D., Lee, A. J., Rastogi, C., Riechers, P. M., Shai, A., and Poncini, X. (2026). Large Language Models Develop Belief State Geometry In-Context. arXiv:2609.17376. Six open-source models prompted with data from 40 hidden Markov models carry the posterior over hidden states linearly in the residual stream, at peak held-out probe $R^2$ of 0.83 to 0.99, with patching and steering along the decoded directions preserving prediction quality where controls degrade it. Probes and intervention embeddings are fitted separately for each 20,000-token sequence, so whether one linear readout transfers across sequences is untested.
• Shai, A., Marzen, S., Teixeira, L., Gietelink Oldenziel, A., and Riechers, P. (2024). Transformers represent belief state geometry in their residual stream. arXiv:2405.15943. The small-model antecedent: transformers trained on hidden-Markov data encode the belief simplex linearly, with the fractal structure computational mechanics predicts.
• Dai, Y., Gao, Z., Sattar, Y., Dean, S., and Sun, J. (2025). Pre-trained Large Language Models Learn Hidden Markov Models In-context. arXiv:2506.07298. Behaviour, not representation: open Qwen and Llama models predict synthetic HMM sequences in context, converging reliably when entropy is low and mixing fast, and compete with expert models on animal decision data. The benchmark called the theoretical optimum is a Viterbi most-likely-path predictor, not the forward-filtered predictive distribution.
• Dai, Y., Gao, Z., Sattar, Y., Sun, J. J., and Dean, S. (2026). Extracting Algorithms in Pre-trained LLMs: A Case on Hidden Markov Models. arXiv:2607.22646. Twelve pre-trained models against forward-filtering, spectral, n-gram and Baum–Welch predictors on 75 HMM configurations. No single class matches behaviour in every regime. Probing and patching find the true belief linearly decodable in early layers of a slow-mixing regime where patching it fails, and a soft n-gram representation the most causally effective.
• Zhu, J.-Q., and Griffiths, T. L. (2024). Incoherent Probability Judgments in Large Language Models. arXiv:2401.16646. Elicited probability judgments from four models on 24 event pairs violate the probability calculus in human-like ways, with the same inverted-U mean-variance signature across repeated samples. The evidence is the generated numbers alone. The link to Bayesian inference assumes truthful reporting of a latent probability rather than measuring one.
• Xie, S. M., Raghunathan, A., Liang, P., and Ma, T. (2021). An Explanation of In-context Learning as Implicit Bayesian Inference. arXiv:2111.02080. In-context examples are treated as evidence for a latent document concept, formalised through a mixture of hidden Markov models and demonstrated on synthetic data.
• Panwar, M., Ahuja, K., and Goyal, N. (2023). In-Context Learning through the Bayesian Prism. arXiv:2306.04891. High-capacity transformers track the Bayesian predictor where exact inference is tractable, and depart from Bayes-optimal behaviour when generalising to unseen function families.
• Zhang, Y., Zhang, F., Yang, Z., and Wang, Z. (2023). What and How does In-Context Learning Learn? Bayesian Model Averaging, Parameterization, and Generalization. arXiv:2305.19420. A perfectly pretrained predictor under the paper's latent-variable model performs Bayesian model averaging, independent of architecture. A separate construction realises it with a kernelised attention variant that approaches softmax attention only for long i.i.d. prompts with unit-norm keys and values. The $O(1/T)$ average log-loss regret assumes the true concept carries prior mass bounded below, as in a finite concept class, which a continuous prior does not give.
• Arora, A., Jurafsky, D., Potts, C., and Goodman, N. D. (2024). Bayesian scaling laws for in-context learning. arXiv:2410.16531. A fitted functional form for accuracy against the number of in-context examples, with interpretable prior and learning-efficiency terms. The Bayesian reading is a fit, not a demonstration that the model updates as Bayes requires.
• von Oswald, J., Niklasson, E., Randazzo, E., Sacramento, J., Mordvintsev, A., Zhmoginov, A., and Vladymyrov, M. (2022). Transformers learn in-context by gradient descent. arXiv:2212.07677. Constructs linear self-attention weights implementing one gradient step on a least-squares objective, and reports that trained models in the same restricted setting match the construction.
• Mahankali, A., Hashimoto, T., and Ma, T. (2023). One Step of Gradient Descent is Provably the Optimal In-Context Learner with One Layer of Linear Self-Attention. arXiv:2307.03576. The tightest version of the equivalence and the narrowest: one layer, linear self-attention, Gaussian linear regression.
• Shen, L., Mishra, A., and Khashabi, D. (2023). Do pretrained Transformers Learn In-Context by Gradient Descent?. arXiv:2310.08540. Tests the equivalence on an actually pretrained model and finds in-context learning and gradient descent move the output distribution differently, with different sensitivity to demonstration order. The counterweight to the constructive results above.
• Akyürek, E., Schuurmans, D., Andreas, J., Ma, T., and Zhou, D. (2022). What learning algorithm is in-context learning? Investigations with linear models. arXiv:2211.15661. Hand-set weights let a transformer implement gradient descent and closed-form ridge regression for in-context linear regression. Trained models' predictions match gradient descent, ridge or least squares depending on depth and noise. Probes decode the moment vector and least-squares weights from late layers through nonlinear probes, which the authors present as preliminary evidence of shared algorithmic features, not as identification of the algorithm the model runs.
• Olsson, C., Elhage, N., Nanda, N., Joseph, N., DasSarma, N., et al. (2022). In-context Learning and Induction Heads. arXiv:2209.11895. Induction heads emerge in a sharp phase transition coinciding with a jump in an in-context learning score defined as the loss at token 500 minus the loss at token 50, rather than few-shot task accuracy. The causal evidence is for small attention-only models, and for larger models with MLPs it is correlational. A mechanistic substrate later work connects to the gradient-descent reading, though this paper claims no such equivalence.
• Yin, K., and Steinhardt, J. (2025). Which Attention Heads Matter for In-Context Learning?. arXiv:2502.14010. Across 12 models, ablating function-vector heads degrades few-shot accuracy while ablating induction heads does little beyond random heads, and the pattern reverses for Olsson et al.'s token-loss difference. The two metrics measure different things. Many function-vector heads begin as induction heads during training.
• Cohen-Wang, B., Shah, H., Georgiev, K., and Madry, A. (2024). ContextCite: Attributing Model Generation to Context. arXiv:2409.00729. Attributes a generated statement to context spans by ablating random subsets, re-running, and fitting a sparse linear surrogate. A sampled finite difference smoothed by regression, not a derivative.
• Kramár, J., Lieberum, T., Shah, R., and Nanda, N. (2024). AtP*: An efficient and scalable method for localizing LLM behaviour to components. arXiv:2403.00745. Uses a first-order expansion of the output around an activation as a cheap stand-in for the expensive activation-patching experiment, then patches two failure modes of that approximation. The clearest case of a gradient standing in for a discrete intervention.
• Syed, A., Rager, C., and Conmy, A. (2023). Attribution Patching Outperforms Automated Circuit Discovery. arXiv:2310.10348. A two-forward, one-backward gradient approximation to activation patching beats automated circuit discovery on area under the curve.
• Marks, S., Rager, C., Michaud, E. J., Belinkov, Y., Bau, D., and Mueller, A. (2024). Sparse Feature Circuits: Discovering and Editing Interpretable Causal Graphs in Language Models. arXiv:2403.19647. Approximates a feature's indirect effect on an output metric by a gradient dotted with a direction in the sparse-autoencoder basis. The construction for asking which interpretable feature, if nudged, moves a model's output.
• Grosse, R., Bae, J., Anil, C., Elhage, N., Tamkin, A., et al. (2023). Studying Large Language Model Generalization with Influence Functions. arXiv:2308.03296. A genuine derivative, but with respect to a training example's weight rather than in-context evidence. The two are different objects and are often conflated.
• Sundararajan, M., Taly, A., and Yan, Q. (2017). Axiomatic Attribution for Deep Networks. arXiv:1703.01365. Integrated gradients: attribution as a path integral of the gradient from a baseline to the input.
• Kim, B., Wattenberg, M., Gilmer, J., Cai, C., Wexler, J., Viegas, F., and Sayres, R. (2017). Interpretability Beyond Feature Attribution: Quantitative Testing with Concept Activation Vectors (TCAV). arXiv:1711.11279. Quantifies a prediction's sensitivity to a concept by the directional derivative of a class logit along a learned concept vector. The nearest named formalism for a derivative of an output with respect to a semantic direction, built for image classifiers.
• Sanyal, S., and Ren, X. (2021). Discretized Integrated Gradients for Explaining Language Models. arXiv:2108.13654. Straight-line interpolation between token embeddings passes through points no token occupies, so this constructs word-anchored paths instead. The off-manifold problem is a consequence of discretisation.
• Roy, S., and Kundu, S. (2024). Uniform Discretized Integrated Gradients: An effective attribution based method for explaining large language models. arXiv:2412.03886. A successor interpolation strategy for the same off-manifold problem.
• Meng, K., Bau, D., Andonian, A., and Belinkov, Y. (2022). Locating and Editing Factual Associations in GPT. arXiv:2202.05262. Causal tracing: corrupt and restore individual hidden states and measure the change in output probability. A finite difference, and the origin of the method most of this literature uses.
• Wang, K., Variengien, A., Conmy, A., Shlegeris, B., and Steinhardt, J. (2022). Interpretability in the Wild: a Circuit for Indirect Object Identification in GPT-2 small. arXiv:2211.00593. The reference worked example of circuit identification by activation patching.
• Zhang, F., and Nanda, N. (2023). Towards Best Practices of Activation Patching in Language Models: Metrics and Methods. arXiv:2309.16042. Methodological standardisation for activation patching: which metrics, which corruptions, and what each choice implies.
• Goldowsky-Dill, N., MacLeod, C., Sato, L., and Arora, A. (2023). Localizing Model Behavior with Path Patching. arXiv:2304.05969. Patches specific edges between components rather than whole nodes.
• Cunningham, H., Ewart, A., Riggs, L., Huben, R., and Sharkey, L. (2023). Sparse Autoencoders Find Highly Interpretable Features in Language Models. arXiv:2309.08600. Sparse-autoencoder features on Pythia score as more interpretable than neuron, random, PCA and ICA directions under an automated metric, and localise counterfactual behaviour on indirect object identification more tightly than PCA. Superposition is the hypothesised cause the method targets, not something the paper tests, and the reconstructions lose information.
• Gao, L., la Tour, T. D., Tillman, H., Goh, G., Troll, R., et al. (2024). Scaling and evaluating sparse autoencoders. arXiv:2406.04093. k-sparse autoencoders and scaling laws, with a 16M-latent autoencoder trained on a frontier model.
• Lieberum, T., Rajamanoharan, S., Conmy, A., Smith, L., Sonnerat, N., et al. (2024). Gemma Scope: Open Sparse Autoencoders Everywhere All At Once on Gemma 2. arXiv:2408.05147. An open suite of autoencoders across all layers and sublayers, which is what makes feature-direction work reproducible outside a frontier lab.
• Turner, A. M., Thiergart, L., Leech, G., Udell, D., Vazquez, J. J., Mini, U., and Pope, M. (2023). Steering Language Models With Activation Engineering. arXiv:2308.10248. Computes a steering vector as the activation difference between a contrastive prompt pair and adds it at inference. Used at finite magnitude, never as the direction argument of a derivative.
• Rimsky, N., Gabrieli, N., Schulz, J., Tong, M., Hubinger, E., and Turner, A. M. (2023). Steering Llama 2 via Contrastive Activation Addition. arXiv:2312.06681. Averages activation differences over positive and negative behaviour examples into a steering vector applied at all post-prompt positions.
• Zou, A., Phan, L., Chen, S., Campbell, J., Guo, P., et al. (2023). Representation Engineering: A Top-Down Approach to AI Transparency. arXiv:2310.01405. Separates reading vectors, extracted as correlational probes, from control vectors added to activations. Neither is used as a derivative direction.
• Park, K., Choe, Y. J., and Veitch, V. (2023). The Linear Representation Hypothesis and the Geometry of Large Language Models. arXiv:2311.03658. Formalises linear representation through counterfactual pairs in both output and input space, and introduces a causal inner product under which projection respects language structure.
• Kim, H., Papamakarios, G., and Mnih, A. (2020). The Lipschitz Constant of Self-Attention. arXiv:2006.04710. Standard dot-product self-attention has no global Lipschitz constant over unbounded inputs, since its Jacobian grows with the spread of the other tokens. It is Lipschitz on any compact input set, with a constant that depends on the input range and can be very large.

Latent context and memory

• Shao, R., Shen, S. Z., Yin, J. O., Li, Y., Wang, M., et al. (2026). Context Language Models. arXiv:2609.37725. Context as a file the model rewrites without restriction. Zero-shot, 11.4% higher accuracy with 21.5% fewer FLOPs on BrowseComp-Plus; online RL lifts Qwen3.5-9B by 47.6%. Every edit is text.
• Li, M. Y., Hamid, J. I., Fox, E. B., and Goodman, N. D. (2026). Neural Garbage Collection: Learning to Forget while Learning to Reason. arXiv:2604.18002. Eviction decisions sampled by the reasoning policy and trained with it from outcome reward alone. 49.6% against 21.2% on Countdown at a 2.4-times smaller peak cache. The closest latent analogue of a Context Language Model, but it only deletes.
• Monea, G., Feldman, Y., Padmanabhan, S., Brantley, K., and Artzi, Y. (2025). Breadcrumbs Reasoning: Memory-Efficient Reasoning with Compression Beacons. arXiv:2510.13797. A learned beacon token compresses a window of generated tokens, which is then evicted. Keeps 65.1–89.8% of teacher performance with 2–32 times less memory, on a fixed schedule.
• Łańcucki, A., Staniszewski, K., Nawrot, P., and Ponti, E. M. (2025). Inference-Time Hyper-Scaling with KV Cache Compression. arXiv:2506.05345. Dynamic Memory Sparsification: delayed eviction learned in 1K steps reaches 8-times compression and lifts Qwen-R1 32B by 12.0 points on AIME 24 at equal memory reads.
• Dong, Z., Liu, P., Li, J., Chen, Z., Peng, H., et al. (2026). ForesightKV: Optimizing KV Cache Eviction for Reasoning Models by Learning Long-Term Contribution. arXiv:2602.03203. ForesightKV: eviction distilled from an oracle that sees future attention, then refined with GRPO.
• Bui, N., Sharma, S., Lamba, S., Mishra, S., and Ying, R. (2025). Cache What Lasts: Token Retention for Memory-Bounded KV Cache in LLMs. arXiv:2512.03324. TRIM-KV: a retention score learned per token at creation. The scores rediscover sink tokens and sliding windows unprompted.
• Moschella, L., Manduchi, L., and Sener, O. (2026). Learning to Evict from Key-Value Cache. arXiv:2602.10238. KV Policy: lightweight per-head reinforcement-learning agents rank tokens for eviction, with the language model unchanged.
• Yang, X., Gu, H., Xu, B., Li, L., Liu, B., et al. (2026). IndexMem: Learned KV-Cache Eviction with Latent Memory for Long-Context LLM Inference. arXiv:2605.25475. IndexMem: evicted tokens are compressed into an online latent state with residual readouts, up to 25 points on RULER under aggressive eviction.
• Li, B. (2026). Models Take Notes at Prefill: KV Cache Can Be Editable and Composable. arXiv:2606.17107. During prefill the model writes conclusions onto downstream positions, so a field’s own KV drives under 1% of the decision. Overwrite fails; an append-only erratum works.
• Kontonis, V., Zeng, Y., Garg, S., Chen, L., Tang, H., et al. (2026). MEMENTO: Teaching LLMs to Manage Their Own Context. arXiv:2604.09852. Memento: block summaries in text, plus the summaries’ KV states. Removing the KV route costs 15 points on AIME24.
• Nawrot, P., Łańcucki, A., Chochowski, M., Tarjan, D., and Ponti, E. M. (2024). Dynamic Memory Compression: Retrofitting LLMs for Accelerated Inference. arXiv:2403.09636. Dynamic Memory Compression: retrofitted models learn per-head, per-layer compression ratios, up to 4-times cache compression at preserved performance.
• Kim, J.-H., Yeom, J., Yun, S., and Song, H. O. (2023). Compressed Context Memory For Online Language Model Interaction. arXiv:2312.03414. Compressed Context Memory: accumulating key-value pairs compressed online, matching full context with a five-times smaller memory.
• Zhang, P., Liu, Z., Xiao, S., Shao, N., Ye, Q., and Dou, Z. (2024). Long Context Compression with Activation Beacon. arXiv:2401.03462. Activation Beacon: progressive compression of keys and values rather than soft prompts.
• Zhang, G., Fu, M., and Yan, S. (2025). MemGen: Weaving Generative Latent Memory for Self-Evolving Agents. arXiv:2509.24704. MemGen: an RL-trained trigger decides when to recall, and a weaver generates latent memory tokens. Up to 38.22% over ExpeL and AWM.
• Zhang, G., Ling, Y., Meng, F., Wang, K., and Yan, S. (2026). Mem-W: Latent Memory-Native GUI Agents. arXiv:2605.09317. Mem-W: past trajectories and in-session segments compressed into memory tokens inside a GUI agent’s embedding sequence.
• Wu, S.-L., Wang, J., Du, Z., and Gan, W. (2026). ActiveMem: Dynamic Latent Memory Trees for Long-Horizon Agents. arXiv:2609.33244. ActiveMem: a tree of node embeddings injected as a latent KV prefix into a frozen model, with expansion and pruning learned by GRPO.
• Yu, H., Chen, T., Feng, J., Chen, J., Dai, W., et al. (2025). MemAgent: Reshaping Long-Context LLM with Multi-Conv RL-based Memory Agent. arXiv:2507.02259. MemAgent: an overwritten fixed-size text memory trained with multi-conversation RL, extrapolating to 3.5M tokens with under 5% loss.
• Zhou, Z., Qu, A., Wu, Z., Kim, S., Prakash, A., et al. (2025). MEM1: Learning to Synergize Memory and Reasoning for Efficient Long-Horizon Agents. arXiv:2506.15841. MEM1: a constant-size internal state for multi-turn agents, trained end to end with RL.
• Hoy, W., Fan, J., Celik, N., and Pan, X. (2026). Continuous Context Management. arXiv:2609.35540. Compaction at every turn, in text despite the name, with privileged full-history distillation for dense credit.
• Xu, B., Li, H., and Zhang, K. (2026). LLM Agents Are Latent Context Managers: Eliciting Self-Managed Context via State Proprioception. arXiv:2606.30005. VISTA: models cannot see their own context budget. A dashboard lifts Gemini-3-Flash on LOCA-Bench from 22.7% to 50.7%.
• Zerhoudi, S., Mitrovic, J., and Granitzer, M. (2026). The Compaction Cliff in Long-Running AI Agent Memory. arXiv:2608.22752. One production compaction round keeps 53% of safety rules, five rounds keep 10%.
• Liu, S. (2026). What Does Context Compression Cost an Agent? Interaction Costs Unrevealed by Task-Completion Metrics. arXiv:2608.16370. Compression leaves completion unchanged while retrieval calls rise from 21.0 to 63.9.
• Ren, T., Luo, W., Yang, H., Zhu, R., Huang, X., et al. (2026). Scaling Self-Evolving Agents via Parametric Memory. arXiv:2606.04536. TMEM: the agent writes supervision into fast LoRA weights online, with the extraction policy trained by RL. A weight-delta counterpart of a context file.
• Zweiger, A., Pari, J., Guo, H., Akyürek, E., Kim, Y., and Agrawal, P. (2025). Self-Adapting Language Models. arXiv:2506.10943. SEAL: a model trained by RL to generate its own fine-tuning data, rewarded by the updated model’s accuracy.
• Charakorn, R., Cetin, E., Uesaka, S., and Lange, R. T. (2026). Doc-to-LoRA: Learning to Instantly Internalize Contexts. arXiv:2602.15902. Doc-to-LoRA: a hypernetwork writes a document into an adapter in one forward pass, near-perfect needle retrieval beyond four times the native window.
• Kuratov, Y., Kairov, M., Bulatov, A., Rodkin, I., and Burtsev, M. (2026). GradMem: Learning to Write Context into Memory with Test-Time Gradient Descent. arXiv:2603.13875. GradMem: a context written into prefix memory vectors by test-time gradient steps on a reconstruction loss.
• Tandon, A., Dalal, K., Li, X., Koceja, D., Rød, M., et al. (2025). End-to-End Test-Time Training for Long Context. arXiv:2512.23675. TTT-E2E: context compressed into weights by test-time training. Scales like full attention and runs 2.7 times faster at 128K, but scores 0.06 on 128K pass-key retrieval against 0.99.
• Behrouz, A., Zhong, P., and Mirrokni, V. (2024). Titans: Learning to Memorize at Test Time. arXiv:2501.00663. Titans: a neural long-term memory that learns to memorise at test time beside attention.
• Behrouz, A., Li, Z., Kacham, P., Daliri, M., Deng, Y., et al. (2025). ATLAS: Learning to Optimally Memorize the Context at Test Time. arXiv:2505.23735. ATLAS: memory optimised over past tokens rather than only the last input.
• Eyuboglu, S., Ehrlich, R., Arora, S., Guha, N., Zinsley, D., et al. (2025). Cartridges: Lightweight and general-purpose long context representations via self-study. arXiv:2506.06266. Cartridges: a compact KV cache trained per corpus by self-study, matching in-context learning with 38.6 times less memory.
• Laguna, S., Monteiro, J., Cuturi, M., Ablin, P., and Gualdoni, E. (2026). Cartridges++: KV Cache Compression without Off-Context Derailment. arXiv:2609.35621. Cartridges++: learned caches degrade off-context queries, the reverse of training-free eviction’s trade-off.
• Schlag, I., Irie, K., and Schmidhuber, J. (2021). Linear Transformers Are Secretly Fast Weight Programmers. arXiv:2102.11174. Linear attention as outer-product fast-weight programming, with a delta-rule write.
• Irie, K., Schlag, I., Csordás, R., and Schmidhuber, J. (2022). A Modern Self-Referential Weight Matrix That Learns to Modify Itself. arXiv:2202.05780. A self-referential weight matrix that emits its own edits.
• Yang, S., Kautz, J., and Hatamizadeh, A. (2024). Gated Delta Networks: Improving Mamba2 with Delta Rule. arXiv:2412.06464. Gated DeltaNet: gated erasure combined with the delta rule.
• Hwang, H. S., Wu, X., Chun, S., and Russakovsky, O. (2026). Reinforced Fast Weights with Next-Sequence Prediction. arXiv:2602.16704. REFINE: GRPO shapes fast-weight write dynamics under a next-sequence objective.
• Cui, W. (2026). A Hippocampus for Linear Attention: An Exact Memory for What the Recurrent State Forgets. arXiv:2607.02303. HOLA: a bounded exact cache beside a delta-rule state, keeping what the state would overwrite.
• Irie, K., Yau, M., and Gershman, S. J. (2025). Blending Complementary Memory Systems in Hybrid Quadratic-Linear Transformers. arXiv:2506.00744. Hybrids of key-value memory, precise but quadratic, and fast-weight memory, unbounded but imprecise.
• Wang, Y., Hao, J., Shi, Y., Yuan, K., and Sun, M. (2026). No Time Like the Present: Agentic Test-Time Training for LLM Agents. arXiv:2607.03441. Agentic test-time training: in-episode weight writes amplify drift; down-weighting repeated text gains up to 5.0 points on ALFWorld.
• Zou, J., Qiu, R., Li, G., Yang, X., Tieu, K., et al. (2025). Latent Collaboration in Multi-Agent Systems. arXiv:2511.20639. LatentMAS: agents share a latent working memory without training. Up to 14.6% higher accuracy and 70.8–83.7% fewer output tokens than text-based systems.
• Fu, T., Min, Z., Zhang, H., Yan, J., Dai, G., et al. (2025). Cache-to-Cache: Direct Semantic Communication Between Large Language Models. arXiv:2510.03215. Cache-to-Cache: a trained fuser projects one model’s KV cache into another’s, about 3.1–5.4% over text communication.
• Cheng, J., Das, S., and Ramnath, R. (2026). When Does Latent Communication Pay? A Causal Audit of Relayed KV Caches in Multi-Agent LLMs. arXiv:2608.04893. A mismatched-cache audit: relays reach ceiling when the receiver needs private information; otherwise gains stay within 2.8 points of a mismatched cache.
• Zhang, H. and Emu, M. (2026). Do Latent Channels Actually Communicate? A Causal Audit of Latent Multi-Agent LLM. arXiv:2607.26773. Of a 15.00-point MATH-500 gain from latent relay, 6.67 points are attributable to example-specific content.
• Wenzel, M. (2026). Latent Communication Between Language Model Agents: Channels, Alignment, and the Limits of Text. arXiv:2607.14103. A text round-trip destroys 88% of sparse-autoencoder features, yet the latent channel never beats text on the tasks tested.
• Brito, L. and Baquero, C. (2026). When Latent Agents Lie: KV-Cache Integrity in Multi-Agent LLM Collaboration. arXiv:2606.28958. Tampering with a relayed KV cache collapses answers while visible messages look plausible. An HMAC manifest rejected all 295 tampered payloads.
• Graves, A., Wayne, G., and Danihelka, I. (2014). Neural Turing Machines. arXiv:1410.5401. Neural Turing Machines: a controller with learned read and write heads over continuous memory.
• Csordás, R. and Schmidhuber, J. (2019). Improving Differentiable Neural Computers Through Memory Masking, De-allocation, and Link Distribution Sharpness Control. arXiv:1904.10278. The Differentiable Neural Computer’s faults: keys not separated from values, aliasing after de-allocation, degrading chained reads. Fixes cut bAbI error by 43%.
• Rae, J. W., Hunt, J. J., Harley, T., Danihelka, I., Senior, A., et al. (2016). Scaling Memory-Augmented Neural Networks with Sparse Reads and Writes. arXiv:1610.09027. Sparse Access Memory: few slots per read or write, 1,000 times faster with 3,000 times less memory.
• Wayne, G., Hung, C.-C., Amos, D., Mirza, M., Ahuja, A., et al. (2018). Unsupervised Predictive Memory in a Goal-Directed Agent. arXiv:1803.10760. MERLIN: memory is not enough without storing the right information in the right format, so predictive modelling drives what is written.
• Hung, C.-C., Lillicrap, T., Abramson, J., Wu, Y., Mirza, M., et al. (2018). Optimizing Agent Behavior over Long Time Scales by Transporting Value. arXiv:1810.06721. Temporal value transport: recall of specific memories assigns credit to past actions across long delays.
• Zaremba, W. and Sutskever, I. (2015). Reinforcement Learning Neural Turing Machines - Revised. arXiv:1505.00521. Reinforcement learning over discrete memory tapes, demonstrated on simple algorithmic tasks.
• Parisotto, E., Song, H. F., Rae, J. W., Pascanu, R., Gulcehre, C., et al. (2019). Stabilizing Transformers for Reinforcement Learning. arXiv:1910.06764. Gated Transformer-XL: attention exceeds an external-memory architecture on DMLab-30.
• Kuratov, Y., Arkhipov, M., Bulatov, A., and Burtsev, M. (2025). Cramming 1568 Tokens into a Single Vector and Back Again: Exploring the Limits of Embedding Space Capacity. arXiv:2502.13063. Up to 1,568 tokens reconstructed from one optimised vector. Learned encoders stop near tenfold compression against up to 1,500-fold.
• Meyer, M., Michelessa, M., Chaux, C., and Tan, V. Y. F. (2025). Memory Limitations of Prompt Tuning in Transformers. arXiv:2509.00421. Memorisation through a prompt grows at most linearly with prompt length.

Surveys and adjacent work

• Zhu, R.-J., Peng, T., Cheng, T., Qu, X., Huang, J., et al. (2025). A Survey on Latent Reasoning. arXiv:2507.06203. Thirty-three authors. Splits the field into vertical recurrence (activation-based, loop and hidden-state feedback) and horizontal recurrence (hidden-state-based, linear and gradient-state), and extends the framing to masked diffusion models.
• Chen, X., Zhao, A., Xia, H., Lu, X., Wang, H., et al. (2025). Reasoning Beyond Language: A Comprehensive Survey on Latent Chain-of-Thought Reasoning. arXiv:2505.16782. A token-wise horizontal versus layer-wise vertical taxonomy. Companion to the Awesome-Latent-CoT list.
• Li, J., Fu, Y., Fan, L., Liu, J., Shu, Y., et al. (2025). Implicit Reasoning in Large Language Models: A Comprehensive Survey. arXiv:2509.02350. Organises by mechanism of control, latent optimisation, signal-guided control, layer-recurrent execution, rather than by representation.
• Yu, X., Chen, Z., He, Y., Fu, T., Yang, J., et al. (2026). The Latent Space: Foundation, Evolution, Mechanism, Ability, and Outlook. arXiv:2604.02029. The broadest recent survey, treating latent reasoning as one instance of a wider latent-native paradigm. Whether that paradigm exists yet is itself contestable.
• Kuzina, A., Pióro, M., Whatmough, P., and Bejnordi, B. E. (2025). KaVa: Latent Reasoning via Compressed KV-Cache Distillation. arXiv:2510.02312. Distils a compressed teacher cache into a latent student, finding chain-of-thought caches highly redundant. The teacher cache and its eviction are used only in training. At inference the student generates its own compressed latent cache.
• Kang, H., Zhang, W., Kuang, K., Majamaki, T., Jaitly, N., et al. (2025). LaDiR: Latent Diffusion Enhances LLMs for Text Reasoning. arXiv:2510.04573. Continuous latent representation combined with iterative diffusion refinement.
• Kang, H., Zhang, W., Kuang, K., Ma, X., and Qin, C. (2026). LaDi-RL: Latent Diffusion Reasoning Prevents Entropy Collapse in Reinforcement Learning. arXiv:2602.01705. Reinforcement learning over latent diffusion reasoning against verifiable rewards, including unit-test pass rates and exact answer correctness.
• Wang, T., and Reid, M. (2026). Tiny Recursive Reasoning with Mamba-2 Attention Hybrid. arXiv:2602.12078. Mamba-2 hybrid operators inside a latent recursive scaffold at roughly 7M parameters. Narrow in scale and task, but the operator question is being asked.
• Williams, M., and Türeci, H. E. (2026). Prioritize the Process, Not Just the Outcome: Rewarding Latent Thought Trajectories Improves Reasoning in Looped Language Models. arXiv:2602.10520. Reports that standard objectives such as GRPO have underperformed on looped models and that per-loop auxiliary credit helps. The paper's own account has the terminal signal backpropagating through the latent refinements, so this is an optimisation finding, not a demonstration that policy gradients cannot train recurrence. For a differentiable recurrence with gradients retained, a terminal reward's total derivative already includes every unrolled update.

Curated elsewhere: Awesome-Latent-Space and Awesome-Latent-CoT track new papers more frequently than this site does. Working on something that belongs here, or spotted an error? Open an issue on the repository.