The Loop Inside the Model

Why This Matters

A language model receives a graph and a question: can node $A$ reach node $H$? The shortest path has five edges. A system that propagates information one edge per serial step cannot answer in two steps, however confident its output looks. It needs five serial updates. It needs depth.

The usual way to give a Transformer depth is to build it in: a 48-layer model applies 48 differently parameterized blocks. A second way is a longer written chain of thought: decode a token, condition on it, decode the next. A third way is less visible. Apply the same neural block repeatedly to an evolving continuous state before producing another word. That is recurrent depth.

The attraction is direct. The model spends more computation on a hard input without a new parameter set for every extra step, and if the intermediate state stays continuous, it never has to translate a tentative update into a word.

The temptation is to call the result a model "thinking in neuralese". That phrase is evocative and underspecified. A hidden vector is not automatically a language. Repeating a block is not automatically reasoning. A larger tensor is not automatically a higher-capacity channel in the information-theoretic sense. "Neuralese" has no standard technical definition; this page uses it only to name the slogan it declines to endorse.

The claim that survives scrutiny is narrower. Recurrent depth creates an inference-time scaling axis. A continuous latent state may be a better interface than discrete tokens for some serial computations. The controlled comparison that would decide the "better" has not yet been run. The mechanism is established; general superiority over token reasoning is open.

This page is the long-form companion to Latent Reasoning, which surveys the method family. Here the focus is the recurrence itself: what goes around the loop, what the loop can forget, who stops it, and what evidence would move the open claim either way.

Reported, not confirmed

On September 2, 2026, The Information reported, citing one source, that OpenAI's next model, referred to as Astra, uses recurrent depth: reasoning carried in the model's activations rather than in readable text. OpenAI has published no description of the architecture, and its August 5, 2026 report on ten mathematical results does not use the name. This page records Astra as reported, with the architecture claim unknown. Nothing below depends on the report. If it is accurate, the mechanism is the one described here, and the question it raises about monitoring a model that no longer writes its reasoning down is taken up in the closing section.

There are three loops, not one

Discussion of "recurrent reasoning" switches silently between three mechanisms.

The depth loop. Inside one model evaluation, a state passes through the same block several times:

$$S_0 \xrightarrow{R_\theta} S_1 \xrightarrow{R_\theta} S_2 \xrightarrow{R_\theta} \cdots \xrightarrow{R_\theta} S_T .$$

The parameters $\theta$ are tied. Each extra iteration adds executed FLOPs and serial latency but not unique parameters in the recurrent core. This is recurrent depth in the narrow sense.

The token loop. An autoregressive model predicts a token, appends it, and predicts another:

$$z_t \sim p_\theta(z_t \mid x, z_{<t}).$$

A written chain of thought uses this loop as an explicit scratchpad. A pause-token model uses extra positions without assigning them a readable meaning (Goyal et al., ICLR 2024). The same parameters are reused at every token step. This is also serial computation, but the state topology and the interface between steps differ from a fixed-state depth loop.

The agent loop. An agent acts, observes, updates persistent state, and calls the model again:

$$a_t \sim \pi_\theta(g, s_t, o_t), \qquad s_{t+1} = U(s_t, a_t, o_{t+1}).$$

The environment can change between iterations. The persistent state can be text, files, database rows, a plan, tool output, or a neural memory. This is system-level recurrence.

A future system can nest all three: an agent action loop around a token loop around a latent depth loop. When someone says a model "thinks longer", the first question is which loop received the extra compute.

Watch Out

Recurrent depth is not the agent loop

Neural depth recurrence, autoregressive token recurrence, and agent-environment recurrence run at different levels with different state and different interfaces. An agent that re-plans every step has system-level recurrence even when its model is a plain fixed-depth Transformer. A recurrent-depth model can run inside a single policy call with no agent loop at all. Calling both "iteration" hides which resource grew.

Ordinary depth and recurrent depth

A conventional $L$-layer Transformer computes

$$H^{(0)} = E(x), \qquad H^{(\ell+1)} = B_{\theta_\ell}\big(H^{(\ell)}\big), \quad \ell = 0, \ldots, L-1 .$$

Every block may carry its own parameters; more depth usually means more parameter sets and more computation.

Definition

Recurrent-depth architecture$prelude,sharedcore,coda$

A recurrent-depth model separates into an optional prelude $P_\phi$, a shared core $R_\theta$ applied $T$ times, and a coda $C_\psi$:

$$S_0 = P_\phi(x), \qquad S_{t+1} = R_\theta(S_t; M_x), \quad t = 0, \ldots, T-1, \qquad p(y \mid x) = \operatorname{softmax}\big(W\, C_\psi(S_T)\big).$$

$M_x$ is an optional memory of the prompt that the core can read at every iteration. The executed depth is the number of core applications $T$; it can be chosen at inference and need not equal any depth seen in training.

Proposition

Executed Depth Decouples From Unique Parameters

Statement

Under the assumptions, the number of unique parameters is $|\phi| + |\theta| + |\psi|$ and does not depend on $T$, while inference compute is $C_{\mathrm{prelude}} + T\, C_{\mathrm{core}} + C_{\mathrm{coda}}$ and grows linearly in $T$. Executed depth and unique parameter count are therefore independent quantities: the first is an inference-time choice, the second is fixed at training time.

Intuition

The same learned transformation acts as a reusable program. Running it four times or twenty times changes how much work is done, not how many weights exist. An unshared stack ties the two together because every extra layer is a new parameter set.

Proof Sketch

Count parameters: the tuple $(\phi, \theta, \psi)$ is fixed before inference, and $T$ indexes how many times $\theta$ is used, not how many copies exist. Count compute: each of the $T$ core applications costs $C_{\mathrm{core}}$ by the fixed-shape assumption, and the prelude and coda are applied once. Sum.

Why It Matters

This is the whole case for an inference-time depth dial. It is also the whole reason "more iterations helped" is not by itself evidence for latent reasoning: more iterations are also more FLOPs, and any comparison has to control for that.

Failure Mode

The fixed-shape assumption fails for appended-latent designs, where every step adds a position and attention cost grows with $t$. Training an unrolled recurrence stores $T$ sets of activations, so training memory does grow with $T$ even though parameters do not. Cache reuse, prelude and coda size, and parallelism all move the real cost away from the linear model. The proposition counts resources; it says nothing about accuracy at any $T$.

report a correction →

The idea predates current reasoning models. Adaptive Computation Time gave recurrent networks a differentiable halting mechanism in 2016 (Graves, 2016). Universal Transformers refined token representations with shared self-attention and transition blocks, optionally letting different positions halt at different depths (Dehghani et al., ICLR 2019). PonderNet formulated learned halting as a probability distribution regularized toward a compute prior (Banino et al., 2021). Looped Transformer constructions showed how repeated shared blocks can execute iterative algorithms (Giannou et al., ICML 2023).

The new question is not whether recurrence is possible. It is whether recurrence becomes a useful test-time scaling axis for language models.

Weight sharing is not the whole idea

A model can share parameters across layers and still run exactly the same fixed number of operations on every input. ALBERT used cross-layer sharing to cut the parameter count of a pretrained encoder (Lan et al., ICLR 2020). That is weight tying; it is not adaptive recurrence.

Three properties should be kept apart:

1. Shared parameters. Several depth positions use the same weights.
2. Iterative state. The output of one application is the input to the next.
3. Variable compute. The number of applications changes with budget or input.

A system can have any two without the third. The most ambitious recurrent proposals combine all three.

Watch Out

Cross-layer weight sharing is not recurrent depth

ALBERT-style sharing fixes the executed depth and only reduces the parameter count. A recurrent-depth model adds the second and third properties: the state feeds back, and the iteration count is a free variable at inference. A paper that reports parameter savings from sharing has shown property 1 alone.

What goes around the loop?

The symbol $S_t$ can hide several incompatible designs.

The whole residual stream. The model repeatedly refines a matrix $S_t \in \mathbb{R}^{n \times d}$, one vector per prompt or latent position. This is close to Universal-Transformer depth recurrence.

A small bank of latent slots. A fixed set of working-state vectors cross-attends to prompt memory at every step, which separates immutable evidence from mutable computation:

$$C_{t+1} = R_\theta(C_t; M_x), \qquad C_t \in \mathbb{R}^{k \times d}.$$

An appended continuous thought. The model creates a new latent position at every step. Earlier prompt and thought positions stay in the attended prefix. Sequence length grows, but no discrete token is selected between latent steps. Coconut is the prominent example (Hao et al., COLM 2025).

A fixed recurrent memory. The model overwrites or updates a bounded memory state. This bounds memory use and forces compression. Recurrent Memory Transformer (Bulatov et al., NeurIPS 2022) and Block-Recurrent Transformers (Hutchins et al., NeurIPS 2022) carry a state across context segments; their objective is long-context memory rather than deeper computation before each answer, but the topology is the same question.

These choices set compute, memory, prompt access, and drift. "Feed the hidden state back" is not enough detail to evaluate an algorithm.

Token reasoning is not a total reset

A popular cartoon draws token chain of thought as

$$\text{hidden state} \rightarrow \text{one token} \rightarrow \text{new hidden state},$$

and declares the token an extreme bottleneck. The cartoon is incomplete.

During cached decoding the model keeps continuous keys and values for the prompt and every previous position (see KV cache). At step $t$ the newly selected token is discrete, but the model also attends to a continuous history:

$$(K_{\le t}, V_{\le t}, z_t) \longrightarrow (K_{\le t+1}, V_{\le t+1}, z_{t+1}).$$

So a written chain of thought does not compress the model's whole internal condition into one vocabulary symbol per step. It commits the newly externalized step to a token while preserving a richer continuous history.

Watch Out

Chain of thought does not discard the continuous state

The KV cache persists across decoded tokens. What the token loop discretizes is the new public symbol, not the model's history. The real contrast between the interfaces is narrower than "words versus vectors": token reasoning adds a discrete, language-shaped position to a growing context; appended latent reasoning adds a continuous position; fixed-state recurrent depth refines a bounded state without growing the context. The existence of continuous internal state is not unique to latent-reasoning models.

Coconut: replacing a token with a continuous thought

In ordinary autoregressive reasoning a hidden vector is projected to vocabulary logits, $p_t = \operatorname{softmax}(W h_t)$, a token $z_t$ is selected, and its embedding $E[z_t]$ is fed back.

Coconut removes the projection-and-lookup step at designated thought positions. In simplified form,

$$c_t = h_\theta\big([x, c_{<t}]\big)_{\mathrm{last}},$$

and $c_t$ is used directly as the embedding at the next latent position. The model later switches back to ordinary language generation for the answer (Hao et al., COLM 2025).

Two things matter here. The intermediate vector is not constrained to equal one vocabulary embedding, so it can hold graded combinations and directions that correspond to no word. And training stays differentiable through the latent thoughts: Coconut uses a curriculum that starts from explicit reasoning traces and progressively replaces portions of them with continuous states. The written rationale scaffolds a latent computation.

The paper reports its clearest gains on planning-style problems, with more mixed results elsewhere. Its analysis section reads the continuous thoughts as holding several candidate next steps before committing to one. That is evidence for delayed branch commitment on those tasks, not proof of a general private-language advantage.

Coconut also shows why taxonomy matters. Its latent thoughts are appended positions, not a fixed tensor overwritten by the same core $T$ times. Attention state and sequence length still grow.

Recurrent-depth language models: a direct inference dial

A recurrent-depth language model places a shared Transformer core between ordinary input and output layers, randomizes the number of core applications during training, and lets the user raise the iteration count at inference. The Huginn work is the clearest direct study of this design in a language model (Geiping et al., 2025). It shows that a model can learn a repeated latent computation whose accuracy on some reasoning tasks changes systematically with inference depth.

The compute is added inside the model's latent processing, not by producing a longer visible rationale or by sampling more complete answers. That is the result. What the experiment does not isolate is an ingredient called "neuralese": extra iterations are also extra FLOPs. A fair reading is that recurrent-depth models show a workable parameter-sharing route to test-time scaling; they do not yet show that shared latent recurrence is the best use of those FLOPs.

The follow-up comparison has to separate four effects: more executed block applications; shared versus unique weights; continuous versus discrete intermediate interfaces; fixed-state refinement versus context growth.

A useful middle ground: soft tokens

Hard tokens and unconstrained hidden vectors are not the only options. A model can feed back a probability-weighted token embedding,

$$\tilde{e}_t = E^{\top} \operatorname{softmax}(W h_t / \tau),$$

which avoids an argmax decision and stays differentiable but is confined to the vocabulary embedding geometry: with a probability vector, it lies in the convex hull of token embeddings.

Soft chain-of-thought methods supply this control (Xu et al., 2025). If an unconstrained latent vector beats a hard token but not a soft token, the useful ingredient is delayed discrete commitment rather than a non-linguistic representational space. CODI distills an explicit chain of thought into continuous states so that rationale generation can be reduced or removed at inference (Shen et al., 2025); that tests whether the function of a learned textual rationale can be compressed, which is a different proposition again. These variants manipulate different parts of the interface and should not be collapsed into one leaderboard category.

More dimensions do not prove more useful bandwidth

A token from a vocabulary of size $|V|$ carries at most $\log_2 |V|$ bits as a discrete index. A hidden vector holds thousands of finite-precision values. It is tempting to multiply dimensions by bits per float and declare victory. The argument fails for five reasons.

Nominal storage is not mutual information. Activations are correlated, normalized, noisy, and confined to a learned manifold. A downstream network may decode only a small number of task-relevant degrees of freedom.

A rationale is a sequence. A chain of thought uses many tokens; its code space grows exponentially with length, even though grammar and the model's own probabilities make much of that space unusable.

The attention cache stays continuous. Token generation does not reduce the history to the latest token id.

A rich channel can be badly used. A 4,096-dimensional vector can carry irrelevant variation, unstable features, or redundant encodings. Capacity is not computation.

Discreteness can help. A language-like bottleneck can create stable abstractions, force decomposition, support error correction, and make intermediate states supervisable and checkable.

The defensible claim is geometric and computational, not a bit count: a continuous interface can postpone a hard symbolic commitment and preserve graded or superposed alternatives in a task-optimized representation. Whether that advantage survives equal-compute controls is empirical.

A sharp test progressively quantizes the latent state. If performance is unchanged when the vector is replaced by a small codebook, the high-bandwidth story has been overstated. If performance degrades smoothly with representational restriction, after retraining, the continuous channel is doing essential work.

Does recurrence forget the original prompt?

Consider a state-only update $S_{t+1} = R_\theta(S_t)$. Every fact about the task must survive inside the evolving state. After many iterations, distinctions can fade, explode, oscillate, or collapse toward an attractor. The sensitivity of the final state to the initial state is governed locally by a product of Jacobians:

$$\frac{\partial S_T}{\partial S_0} = J_{T-1} J_{T-2} \cdots J_0 .$$

Directions repeatedly contracted are forgotten; directions repeatedly amplified become unstable.

Residual updates $S_{t+1} = S_t + G_\theta(S_t)$ add an identity path, which supports signal preservation. They do not guarantee that the model keeps the semantically right information, and layer normalization controls scale, not meaning.

A safer topology keeps prompt memory available at every step, $S_{t+1} = R_\theta(S_t; M_x)$ with $M_x = E(x)$, so the recurrent state can cross-attend to immutable prompt encodings. Another design reinjects the initial state, $S_{t+1} = R_\theta(S_t, S_0)$. Coconut-style appended thoughts keep the prompt in the attended prefix. Ordinary autoregressive decoding keeps prompt K/V entries in cache. Agents can store the objective and constraints verbatim outside the mutable plan.

None of these mechanisms guarantees correct use. They guarantee access, not attention, retrieval, or obedience. That is the resolution of the original worry: recurrent computation can forget a prompt when the prompt survives only through a repeatedly overwritten state, and it need not when every iteration can reread a protected representation of the task. The drift lab above shows the mechanism on a declared toy system; it is not a measurement of any trained model.

Training the loop

A fixed-depth recurrent model is trained by unrolling $T$ applications and backpropagating through them. The gradient contains products of recurrent Jacobians, so long unrolls inherit vanishing- and exploding-gradient risk, and training memory grows with the stored activations.

Practical techniques: residual or gated updates; gradient clipping; activation checkpointing; randomized training depths; intermediate readout losses; curricula that raise latent depth; truncated backpropagation with the approximation disclosed; and fixed-point or implicit-differentiation methods when convergence is the objective, as in deep equilibrium models (Bai, Kolter, Koltun, NeurIPS 2019).

Randomized depth matters most for an inference-time dial. A model trained only at $T = 8$ can learn that iteration eight is where answers are assembled; sampling $T$ during training pushes it to hold useful states at several depths. That still does not guarantee extrapolation to $T = 64$. Extra recurrence can give diminishing returns or "overthinking", where a correct state is revised into an incorrect one. Behaviour beyond the training-depth range has to be measured, not assumed.

Who decides when to stop?

The simplest answer is the user: choose $T$ from a compute budget.

A learned system predicts a halting probability from the current state, $p_t = \sigma(w^{\top} S_t + b)$. Adaptive Computation Time accumulates halting mass and penalizes excess pondering (Graves, 2016). PonderNet defines an explicit distribution over halt times,

$$P(T = t) = \lambda_t \prod_{j < t} (1 - \lambda_j),$$

and regularizes it toward a prior (Banino et al., 2021).

The hard part is not producing a stop probability. It is teaching that probability to estimate the expected value of one more computation step. Confidence is insufficient: a model can be confidently wrong. Apparent difficulty is insufficient: a long prompt may be easy and a short proof may need a rare insight. Labels for "one more step would help" are expensive and counterfactual.

A halting system should therefore be evaluated on more than mean accuracy and mean steps. It should report the compute-accuracy frontier, regret relative to an oracle halt, calibration of the predicted marginal gain, correlation with controlled algorithmic depth, the overthinking rate, and behaviour beyond the training-depth distribution. Learned halting is an established mechanism. Reliable value-of-computation estimation at frontier scale is open.

What current evidence establishes

The literature forms a ladder. Each rung supports a stronger claim; none supports all of them.

Repeated shared computation is feasible. Adaptive Computation Time, Universal Transformers, PonderNet, looped Transformers, and deep equilibrium models establish that weight-tied iterative computation can be trained, halted, or solved to equilibrium (Graves, 2016; Dehghani et al., ICLR 2019; Banino et al., 2021; Giannou et al., ICML 2023; Bai, Kolter, Koltun, NeurIPS 2019).

Additional inference computation can improve results. Pause-token training shows that extra positions can help without a prescribed natural-language rationale, provided the model was trained with them (Goyal et al., ICLR 2024). Quiet-STaR learns tokenized rationales during language modelling (Zelikman et al., 2024). Test-time search and budget allocation show that sampling, ranking, and verification can give strong compute-accuracy tradeoffs on selected tasks (Snell et al., 2024). Budget forcing and reinforcement-trained reasoning models add token-level evidence (Muennighoff et al., 2025; DeepSeek-AI, 2025). See Test-Time Compute and Search for that axis on its own.

Continuous intermediate computation can work. Coconut reports task-specific gains from feeding hidden states into later latent positions (Hao et al., COLM 2025). CODI and SoftCoT probe compression and differentiable intermediate interfaces (Shen et al., 2025; Xu et al., 2025).

Recurrent depth can be scaled after training. Huginn-style recurrent-depth models directly test raising a shared core's inference iterations (Geiping et al., 2025).

What remains unestablished. The reviewed evidence does not show that latent recurrent reasoning generally dominates a deeper ordinary Transformer, an equally well trained token-CoT model, trained pause tokens, a soft-token interface, sample-and-rank or verifier-guided search, tool use, or a hybrid that allocates compute among all of them. The missing object is not another isolated benchmark score. It is a controlled frontier comparison.

Where the claim could be wrong

A useful theory names the results that would count against it.

It may just be extra FLOPs. If recurrent-depth gains vanish against equal-inference-compute pause, token, or unshared-depth controls, recurrence is an implementation route, not a better substrate.

Shared weights may be a handicap. Unique layers can specialize by depth. A recurrent core saves parameters at a possible cost in representational flexibility.

The latent state may become unstable. More iterations can move the model outside its training distribution, erase prompt information, or amplify errors.

Language may be an effective code. Discrete steps can stabilize abstractions, expose errors, support external verification, and make search easy.

The advantage may be limited to branching problems. Continuous states may help mainly when several candidate paths should coexist before commitment. That is valuable and narrower than "better reasoning".

The curriculum may explain the result. Rationale supervision, staged replacement, or randomized depth may matter more than whether the intermediate state is continuous.

Halting may not track useful compute. A stop head can learn surface difficulty cues rather than the expected gain from another step.

Hidden computation may be harder to audit. An opaque state can be effective and still be unfaithful to the explanation later generated in text.

These are not objections from outside the idea. They are the experiment plan.

The experiment that would matter

The obvious proposal, hold parameters and FLOPs fixed across four models, is harder than it sounds. Weight tying, width, sequence growth, and training dynamics couple the budgets. Narrowing a model to match parameters changes optimization; adding unique layers changes training compute; token reasoning grows KV memory; a fixed-state loop does not. The right design uses several iso-budget frontiers.

Systems. (A) ordinary unshared depth; (B) shared recurrent depth; (C) token chain of thought and trained pauses; (D) unconstrained continuous latent recurrence; (E) soft-token feedback; (F) sampling and search with a verifier.

Budgets. Equal unique parameters, comparing accuracy against inference FLOPs; equal inference FLOPs, comparing accuracy against parameters; equal training tokens and total training FLOPs; equal wall-clock latency and peak memory on the same hardware; all repeated across model scales.

Tasks. Problems whose serial depth can be controlled and whose answers can be verified: graph reachability and pointer chasing; shortest-path planning; SAT and CSP with certificates; program execution with controlled loop depth; formal theorem proving checked by a kernel; symbolic mathematics checked by a computer algebra system; long-horizon agents with immutable goals and logged state transitions.

Primary outcome. Verified success against total inference compute, as a curve. One chosen budget is not a result.

Critical ablations. Prompt-anchored versus state-only recurrence; append-latent versus fixed-state update; continuous versus soft-token versus hard-token interface; shared versus unique weights at the same executed depth; semantic chain of thought versus meaningless trained pauses; fixed versus randomized training depth; fixed versus learned halt; latent-state quantization; preserved versus compressed prompt memory.

A falsifiable broad claim. Before training, preregister that latent recurrent reasoning must: improve a prespecified aggregate across at least three task families; win on both parameter-matched and inference-compute-matched analyses; keep its gains beyond the training-depth range; avoid a material penalty under distribution shift; and replicate across two model scales and independent implementations. If it fails, the conclusion is not that recurrent depth is useless. It is that its advantage is conditional rather than general.

What this has to do with agents

An agent already has recurrence at the system level: it observes, acts, and updates state. That does not mean its model has recurrent depth.

A production-safe agent state separates into three parts: an immutable block (original goal, constraints, authorization boundaries), a persistent block (verified facts, tool outputs, source references), and a mutable block (current hypothesis, plan, working notes, next action). Each action is then chosen from the goal, the persistent evidence, and the working state, $a_t \sim \pi_\theta(g, c, m_t, o_t)$. This addresses prompt drift structurally: the agent never has to remember its objective only through a summary of its previous summary.

Recurrent depth could live inside each policy invocation, giving the model several latent iterations before it emits an action. Token reasoning could live around those iterations. Search or verification could live around the token trace. Tool interaction supplies the outer loop. That leads to a more useful allocation problem than "words or neuralese": given one more unit of inference compute, should the system take another latent step, emit another reasoning token, sample another path, call a tool, retrieve evidence, or verify its current answer? The best architecture may be a controller that allocates compute among all of these.

Auditing a loop that does not write

A written chain of thought is the surface that current monitoring reads. It is not guaranteed faithful to the computation that produced the answer, and Chain of Thought and Reasoning covers that limit; but a text trace can at least be read, searched, and compared against the final answer by a person or a second model. A latent loop removes that surface. If the intermediate state never passes through the vocabulary, there is no readable step to check, and the only remaining evidence of what the model did is the answer plus whatever probes can recover from activations.

This is the cost side of the interface question, and it is the reason the interface is not a free choice. Two responses are available. The first is interpretability tooling: causal probes and decoders that read the recurrent state directly. These are research methods, not deployed guarantees, and "continuous recurrence is more interpretable because it never generates words" is false as stated: it is generally less directly inspectable. The second is to change what is checked. Instead of reading the model's reasoning, require the model to emit intermediate claims that a checker can verify: a proof step a kernel accepts, a program a test suite runs, a certificate a solver confirms. Verification of outputs does not depend on the reasoning being legible.

The matched-budget experiment above should therefore carry one more column: for each system, what fraction of its intermediate work is checkable by something other than the model itself. A system that wins the compute-accuracy frontier and loses that column has traded a monitoring surface for FLOPs. That trade may be worth making; it should be made in the open.

The open possibility

The case for recurrent depth is not that language is bad or that vectors are intelligent. It is that a fixed stack of unique layers is one way to organize computation, not the only one.

A shared recurrent core can act like an iterative algorithm. A continuous state can avoid premature symbolic commitment. Prompt memory can stay available at every step. A halt rule can, in principle, allocate depth by difficulty. And the same learned parameters can be reused for more computation at inference. Those are concrete mechanisms.

The unresolved question is whether they combine into a better system under fair controls. Current work has moved that question from speculation to experiment, not yet to conclusion. "Neuralese" may one day be a useful metaphor for structured internal communication. For now the rigorous description is enough:

$$\boxed{\;\text{fixed learned program} \;+\; \text{variable recurrent computation} \;+\; \text{continuous working state}\;}$$

The loop is real. What it buys remains measurable.

Exercises

ExerciseCore

Problem

In the reachability lab, a local update propagates reachability one edge per application. The shortest $A$ to $H$ path has five edges. (a) State the minimum executed depth $T$ at which a fixed-state recurrent model can certify that $H$ is reachable, and explain why no choice of parameters can lower it. (b) Under the lab's schematic accounting, a written trace costs $18 + 10T$ context tokens and latent recurrence costs $18$. At $T = 5$, how many extra context tokens does the token interface consume, and which resource does the latent interface consume instead?

Hint

Reveal Solution

ExerciseAdvanced

Problem

Design the quantization ablation from the bandwidth section. A trained recurrent-depth model is modified so that, between core applications, the latent state is replaced by its nearest entry in a codebook of size $K$, and the model is retrained at each $K$. Say what pattern of verified accuracy as a function of $K$ would support the claim that the continuous channel does essential work, what pattern would undermine it, and name two confounds that would make either pattern uninterpretable without further controls.

Hint

Reveal Solution

References

Registry ids in monospace resolve in data/content/sources.json. All 18 arXiv records were re-checked by identifier on 2026-09-02.

Recurrent depth and shared computation:

• Graves, A. "Adaptive Computation Time for Recurrent Neural Networks." arXiv:1603.08983 (2016). The halting unit and the ponder cost. graves-2016-adaptive-computation-time
• Dehghani, M., Gouws, S., Vinyals, O., Uszkoreit, J., Kaiser, L. "Universal Transformers." ICLR 2019, arXiv:1807.03819. The shared recurrent transition and per-position dynamic halting. dehghani-2019-universal-transformers
• Bai, S., Kolter, J. Z., Koltun, V. "Deep Equilibrium Models." NeurIPS 2019, arXiv:1909.01377. The fixed-point formulation and implicit differentiation. bai-2019-deep-equilibrium-models
• Lan, Z., Chen, M., Goodman, S., Gimpel, K., Sharma, P., Soricut, R. "ALBERT: A Lite BERT for Self-supervised Learning of Language Representations." ICLR 2020, arXiv:1909.11942. Cross-layer parameter sharing at fixed executed depth. lan-2020-albert
• Banino, A., Balaguer, J., Blundell, C. "PonderNet: Learning to Ponder." arXiv:2107.05407 (2021; ICML 2021 AutoML workshop). The halting distribution and its KL prior. banino-2021-pondernet
• Giannou, A., Rajput, S., Sohn, J., Lee, K., Lee, J. D., Papailiopoulos, D. "Looped Transformers as Programmable Computers." ICML 2023, arXiv:2301.13196. The constructive simulation of iterative programs by a looped block. giannou-2023-looped-transformers
• Geiping, J., McLeish, S., Jain, N., Kirchenbauer, J., Singh, S., Bartoldson, B. R., Kailkhura, B., Bhatele, A., Goldstein, T. "Scaling up Test-Time Compute with Latent Reasoning: A Recurrent Depth Approach." arXiv:2502.05171 (2025). The prelude-core-coda architecture, randomized training depth, and accuracy against iteration count. geiping-2025-recurrent-depth
• Darlow, L., Regan, C., Risi, S., Seely, J., Jones, L. "Continuous Thought Machines." arXiv:2505.05522 (2025). An internal-time recurrence separate from sequence position; adjacent architecture, not an LLM chain-of-thought replacement. darlow-2025-continuous-thought-machines

Continuous, soft, and pause interfaces:

• Hao, S., Sukhbaatar, S., Su, D., Li, X., Hu, Z., Weston, J., Tian, Y. "Training Large Language Models to Reason in a Continuous Latent Space." COLM 2025, arXiv:2412.06769. The continuous-thought feedback, the staged curriculum, and the branching analysis. hao-2025-coconut
• Xu, Y., Guo, X., Zeng, Z., Miao, C. "SoftCoT: Soft Chain-of-Thought for Efficient Reasoning with LLMs." ACL 2025, arXiv:2502.12134. The soft thought representation as an interface control. xu-2025-softcot
• Shen, Z., Yan, H., Zhang, L., Hu, Z., Du, Y., He, Y. "CODI: Compressing Chain-of-Thought into Continuous Space via Self-Distillation." arXiv:2502.21074 (2025). The self-distillation objective that compresses a learned rationale. shen-2025-codi
• Goyal, S., Ji, Z., Rawat, A. S., Menon, A. K., Kumar, S., Nagarajan, V. "Think before you speak: Training Language Models With Pause Tokens." ICLR 2024, arXiv:2310.02226. Pause-augmented pretraining and finetuning; inference-only pauses do not help. goyal-2024-pause-tokens
• Zelikman, E., Harik, G., Shao, Y., Jayasiri, V., Haber, N., Goodman, N. D. "Quiet-STaR: Language Models Can Teach Themselves to Think Before Speaking." arXiv:2403.09629 (2024). Parallel rationale generation with a REINFORCE-style objective. zelikman-2024-quiet-star

Token-level test-time compute (the competing route):

• Snell, C., Lee, J., Xu, K., Kumar, A. "Scaling LLM Test-Time Compute Optimally can be More Effective than Scaling Model Parameters." arXiv:2408.03314 (2024). Compute-optimal allocation across sampling, search, and revision. snell-2024-test-time-compute
• Muennighoff, N., Yang, Z., Shi, W., Li, X. L., Fei-Fei, L., Hajishirzi, H., Zettlemoyer, L., Liang, P., Candès, E., Hashimoto, T. "s1: Simple test-time scaling." arXiv:2501.19393 (2025). Budget forcing on a small curated set. muennighoff-2025-s1
• DeepSeek-AI. "DeepSeek-R1: Incentivizing Reasoning Capability in LLMs via Reinforcement Learning." arXiv:2501.12948 (2025). The reinforcement-learning recipe that elicits long token traces. deepseek-2025-r1

Recurrent memory across segments (topology, not depth):

• Bulatov, A., Kuratov, Y., Burtsev, M. S. "Recurrent Memory Transformer." NeurIPS 2022, arXiv:2207.06881. Memory tokens carried across segments. bulatov-2022-recurrent-memory-transformer
• Hutchins, D., Schlag, I., Wu, Y., Dyer, E., Neyshabur, B. "Block-Recurrent Transformers." NeurIPS 2022, arXiv:2203.07852. A recurrent cell carried along the sequence in blocks. hutchins-2022-block-recurrent-transformers

Press report, recorded as reported:

• The Information via Techmeme, "OpenAI's Astra model uses recurrent depth" (September 2, 2026; single-source press report, no primary architecture description), https://www.techmeme.com/260901/p61