---
title: 'Recursive Stem Model: Stable Operator Learning'
url: https://www.emergentmind.com/topics/recursive-stem-model-rsm
type: topic
---

# Recursive Stem Model: Stable Operator Learning

Searching arXiv for the target paper and closely related recursive reasoning work to ground the article.
arxiv_search(query="Recursive Stem Model 2603.15641 OR \"Form Follows Function: Recursive Stem Model\" OR recursive reasoning TRM HRM", max_results=10, sort_by="relevance")
Recursive Stem Model (RSM) is a recursive reasoning architecture introduced for verifier-rich, compute-heavy tasks such as Sudoku and Maze solving. It preserves a TRM-style, weight-shared recursive backbone, but changes the training contract so that the network learns a **stable, depth-agnostic transition operator** rather than a depth-specific supervised trajectory. In the formulation reported for RSM, hidden-state history is fully detached during training, early recursive iterations are treated as detached warm-up steps, and the loss is applied only at the final step; this is intended to make recursion itself a test-time compute dial and to permit inference at depths far beyond those used during training [2603.15641].

## 1. Origins and design objective

RSM is positioned against prior recursive reasoning models, especially Hierarchical Reasoning Model (HRM) and Tiny Recursive Model (TRM). Those models established that small, weight-shared networks can solve difficult puzzle tasks through latent iterative refinement, but their training typically relied on **deep supervision**, **long unrolls**, or gradient schemes tied to explicit trajectory depth. The RSM formulation identifies these choices as sources of increased wall-clock cost, memory pressure, vanishing or exploding gradient exposure, and bias toward **greedy intermediate behavior** [2603.15641].

The central design move in RSM is therefore not a wholesale replacement of the recursive backbone, but a change in what the model is asked to learn. Instead of optimizing many intermediate recursion depths, RSM optimizes correctness **after refinement**. The paper explicitly frames the target as a **stable, depth-agnostic transition operator** that can be reused across many refinement steps and remain effective when iterated far beyond the training rollout length. In the authors’ own characterization, RSM is best understood as a **TRM-like recursive reasoning model retrained as an operator learner** [2603.15641].

This places RSM near a broader family of recursive latent-state reasoners. A related taxonomy later describes TRM as a special case of a Recursive Inference Machine with shared Solver and Generator backbones and identity reweighting, which helps situate RSM as a training-contract modification of the recursive-model line rather than a departure from it [2603.05234]. A plausible implication is that RSM’s novelty lies less in adding new module types than in altering the optimization geometry of an existing recursive architecture.

## 2. Latent architecture and recursive computation

RSM is a **two-state recursive latent dynamical system** with a fast inner latent state \(Z_L\) and a slower outer latent state \(Z_H\). The model operates on an input sequence \(x \in \{1,\dots,V\}^S\) with target \(y \in \{1,\dots,V\}^S\). Token embeddings are written as
\[
e(x) = \mathrm{Embed}(x) \in \mathbb{R}^{B \times S \times d},
\]
and optional learned puzzle embeddings \(p\) may be prepended:
\[
\tilde e(x)= [p; e(x)] \in \mathbb{R}^{B \times (S_p+S)\times d}.
\]
The total sequence length is \(S_{\text{tot}} = S_p + S\), and both latent states satisfy
\[
Z_H, Z_L \in \mathbb{R}^{B \times S_{\text{tot}} \times d}.
\]
Initialization uses persistent vectors \(h_0,\ell_0\):
\[
z_H^{(0)} = \mathbf{1}\cdot h_0, \qquad z_L^{(0)} = \mathbf{1}\cdot \ell_0.
\]
The shared transition module is
\[
F_\theta(h;u) = \mathrm{Block}_D(\cdots \mathrm{Block}_2(\mathrm{Block}_1(h+u))\cdots).
\]
This shared module is the operational meaning of the paper’s “recursive stem”: one reusable backbone is repeatedly reapplied to refine latent state [2603.15641].

RSM has two recursive depths. The **inner depth** \(L\) controls repeated refinement of \(Z_L\); the **outer depth** \(H\) controls repeated refinement of \(Z_H\). The inner update is
\[
Z_L \leftarrow F_\theta(Z_L;\, Z_H + \tilde e(x)) \quad \text{repeated } L \text{ times,}
\]
and the outer update is
\[
Z_H \leftarrow F_\theta(Z_H;\, Z_L).
\]
An indexed form makes the nesting explicit:
\[
z_{L,\ell}^{(h)} = F_\theta\!\left(z_{L,\ell-1}^{(h)};\, z_H^{(h-1)} + \tilde e(x)\right), \qquad
z_{L,0}^{(h)} = z_L^{(h-1)},
\]
\[
z_L^{(h)} = z_{L,L}^{(h)},
\]
\[
z_H^{(h)} = F_\theta\!\left(z_H^{(h-1)};\, z_L^{(h)}\right).
\]
Final prediction is decoded from the terminal outer state:
\[
\mathrm{logits}^{(H)} = W_{\text{out}} z_H^{(H)},
\qquad
W_{\text{out}} = W_{\text{emb}}.
\]

Two backbone instantiations are described. For Maze, RSM uses a non-causal attention variant with RoPE, SwiGLU, RMSNorm, and residual connections. For Sudoku, it typically uses an MLP token-mixing variant without positional encodings. This suggests that the recursive stem is intended as a reusable computation pattern rather than a commitment to one block type [2603.15641].

## 3. Training contract: detachment, warm-up, and terminal supervision

The most distinctive element of RSM is its training method. Hidden-state history is **fully detached** during training:
\[
Z_H \leftarrow \mathrm{stopgrad}(Z_H), \qquad Z_L \leftarrow \mathrm{stopgrad}(Z_L).
\]
Earlier recursive iterations still occur in the forward pass, but most of them do not carry temporal gradients. The paper treats these early steps as detached **warm-up**. Loss is applied only at the final outer step:
\[
\mathcal{L}(\theta)= \mathrm{CE}\!\left(\mathrm{logits}^{(H)}, y\right).
\]
No auxiliary loss is placed on intermediate depths [2603.15641].

This arrangement changes what the model is optimized to do. Rather than rewarding intermediate states for looking locally correct, it rewards the transition operator for improving a state that may already have undergone substantial prior refinement. The paper presents this as a way to learn a reusable local improvement operator instead of a fixed-depth path. The authors explicitly connect this to reduced wall-clock and memory cost, since training no longer requires a long backpropagation-through-time graph [2603.15641].

RSM also grows outer depth \(H\) and inner depth \(L\) **independently** through milestone-based schedules:
\[
p = 100 \cdot \frac{\text{step}}{\text{total\_steps}},
\]
\[
H(p) = H_0 + \sum_i \mathbf{1}[p > m_i]\Delta H_i,
\]
\[
L(p) = L_0 + \sum_j \mathbf{1}[p \ge n_j]\Delta L_j.
\]
During training, the model clamps \(H \ge 2\), ensuring at least one warm-up step; during inference, \(H=1\) is allowed [2603.15641].

To mitigate instability when increasing depth, the paper introduces a **stochastic outer-transition scheme**, described as stochastic depth over \(H\). Let \(P_{\text{detach}} = \texttt{prob\_detach\_prev\_H}\). Then
\[
\text{include\_prev\_H} \sim \mathrm{Bernoulli}(1 - P_{\text{detach}}).
\]
If the penultimate transition is included, gradients span two outer steps; otherwise, the model falls back to strict one-step outer credit assignment. For Sudoku, the paper reports a typical setting
\[
P_{\text{detach}} = 0.99.
\]
Additional stabilizers include gradient clipping with default norm \(1.0\), learning-rate warmup plus cosine decay, optional transition LR warmup, optional EMA, and optional optimizer-state scaling or reset when depth grows [2603.15641].

## 4. Test-time scaling, settling dynamics, and reliability signal

A central claim of RSM is that it can be trained shallow and deployed deep. The reported training regime uses outer depth around \(H_{\text{train}} \lesssim 20\), yet the paper states that inference can be run for roughly \(20{,}000\) outer steps:
\[
H_{\text{test}} \gg H_{\text{train}}, \qquad L_{\text{test}} \gg L_{\text{train}}.
\]
The motivation is that the learned operator should remain useful after arbitrary prior refinement, because training did not couple success to a fixed supervised trajectory [2603.15641].

The paper interprets the resulting dynamics as an **iterative settling process**. Repeated application of the shared operator can move latent states toward a stable fixed point, although no theorem proving contraction or global convergence is given. The connection to fixed-point solvers, DEQs, Neural ODE-like iterative depth, and iterative denoising is explicitly conceptual rather than formal. The paper is clear that there are **no convergence guarantees** and that the model can still oscillate or settle incorrectly [2603.15641].

At inference time, the authors decode along the rollout,
\[
\{y^{(h)}\}_{h=1}^{H_{\text{test}}},
\]
and use two practical diagnostics. The first is **steps-to-solve**, the first outer step \(h^\*\) at which the decoded output satisfies the verifier and remains stable thereafter. The second is a **fixed-point or settling check**, namely whether decoded outputs stop changing across consecutive steps. The Sudoku visualization is described with the observation that once the model finds the solution, it often “stops changing it” [2603.15641].

This yields what the paper calls an **architecture-native reliability signal**. If the trajectory settles and the answer passes a verifier, confidence should be high; if it does not settle, that warns that the model has not reached a viable solution. The paper also stresses the obvious caveat: convergence is not correctness, since a model can converge to a wrong fixed point. Still, in verifier-rich domains, the conjunction of **settled** and **passes verifier** is presented as a practical certificate-like signal [2603.15641].

## 5. Empirical profile

The reported experimental focus is on **Sudoku-Extreme** and **Maze-Hard (\(30 \times 30\))**, with model sizes of roughly **2.5M–5M parameters**. Two headline claims are emphasized: **\(>20\times\) faster training than TRM** and **\(\sim 5\times\) reduction in error rate** [2603.15641].

On Sudoku-Extreme, RSM reaches **97.5% exact accuracy** with test-time compute, within roughly **1 hour of training on a single A100**. The paper contrasts this with a previous TRM state of the art of about **87%** on Sudoku with **12 hours of training**. The reported scaling trend is especially important: the model is trained only to shallow depth, but increasing outer cycles \(H\) at test time substantially improves solve rate, and the figure description explicitly states that increasing \(H\) does **not** cause a drop in accuracy. The solve-rate progression reported in the figure description includes values such as **67.7**, **88.7**, **96.8**, and **97.5**, which the text uses to support the conclusion that test-time recursion materially improves Sudoku performance [2603.15641].

On Maze-Hard (\(30 \times 30\)), the attention-based variant reaches about **80% exact accuracy** in roughly **40 minutes**. The visual description suggests that the model often first finds a rough path and then refines it over subsequent recursion steps. The paper speculates that Maze performance may have been constrained more by training-data size and overfitting than by architectural limits, but this remains an interpretation rather than a controlled ablation [2603.15641].

The paper also reports qualitative evidence that many puzzles solve **before** the maximum test depth, which supports the claim that the model is genuinely settling rather than merely consuming extra compute. At the same time, the experimental section is described as lightweight and exploratory: the total experiment budget was only about **\$50** on Google Colab, and the authors explicitly state that the work is **not** a comprehensive ablation study [2603.15641].

## 6. Relation to neighboring recursive models and acronym usage

RSM belongs to a rapidly developing literature on recursive latent computation, but it occupies a specific position within that landscape. A related formalism, Recursive Inference Machines, treats TRM as a special case with shared Solver and Generator backbones and identity reweighting, which helps clarify that RSM is best read as a refinement of the TRM line rather than a competing umbrella framework [2603.05234]. Another neighboring direction, Generative Recursive reAsoning Models (GRAM), extends recursive latent reasoning into a stochastic latent-variable framework with multiple trajectories and variational training, thereby adding a probabilistic axis that RSM itself does not include [2605.19376]. Recursive scaling has also been explored in masked diffusion, where repeated application of a shared denoising block is treated as a third scaling axis beyond parameter count and denoising steps [2606.18022]. More general recursive long-horizon reasoning systems have been formulated in terms of explicit call/return scaffolds over recursive subtasks, emphasizing bounded active context rather than verifier-rich latent settling [2603.02112].

A recurring source of confusion is the acronym **RSM** itself. In other arXiv contexts it refers to **Reverse Sequence Mutation** in genetic algorithms for TSP [1203.5028], **Reusable Slotwise Mechanisms** in object-centric world modeling [2302.10503], **Regime-Switching Model** for exoplanet detection in high-contrast imaging [2012.05094], and **Recursive State Machines** in program analysis [1701.04914]. None of those is the same construct as Recursive Stem Model.

Within recursive reasoning specifically, the distinctive signature of RSM is therefore narrow but clear: a small, heavily weight-shared recursive backbone; two latent states \(Z_L\) and \(Z_H\); full hidden-state detachment over history during training; detached warm-up; terminal-only supervision; independent growth of \(H\) and \(L\); and explicit use of settling behavior as a practical reliability signal [2603.15641]. This suggests that RSM’s enduring significance, if the empirical claims generalize, will lie in reframing recursive reasoning as **stable operator learning** rather than **deeply supervised trajectory learning**.

Source: https://www.emergentmind.com/topics/recursive-stem-model-rsm