Equilibrium Reasoners: Learning Attractors Enables Scalable Reasoning — part 1/7

Cleaned-text code points [0, 15593). Bibliography omitted here; source.md includes it.

# Equilibrium Reasoners: Learning Attractors Enables Scalable Reasoning

###### Abstract

Scaling test-time compute by iteratively updating a latent state has emerged as a powerful paradigm for reasoning. Yet, the internal mechanisms that enable these iterative models to generalize beyond memorized patterns remain fundamentally unclear. We hypothesize that such generalizable reasoning arises from learning task-conditioned attractors : a latent dynamical system where stable fixed points correspond to valid solutions.

We formalize this process by introducing Equilibrium Reasoners (EqR) . EqR enables test-time scaling without relying on external verifiers or task-specific priors. Instead, our models scale internal dynamics along two axes: depth by running more iterations and breadth by aggregating stochastic trajectories from multiple initializations. Empirically, performance gains from scaling test-time compute are tightly coupled with better convergence to attractors.

This attractor perspective allows neural networks to adaptively allocate test-time compute based on task difficulty. While simple cases converge within 1 to 5 iteration steps, the hardest cases benefit from massive test-time scaling. By unrolling up to an equivalent of 40,000 layers, this scalable latent reasoning boosts accuracy from 2.6% for feedforward models to over 99% on Sudoku-Extreme. We hope our attractor perspective sheds light on scalable reasoning.

###### Keywords:

CMU https://github.com/locuslab/EqR

## 1 Introduction

Scaling is a defining pattern of modern AI systems: accuracy improves with training data, model capacity, and, increasingly, test-time compute . Across settings ranging from search-based game agents ( Silver et al., 2018 ) to chain-of-thought reasoning ( Wei et al., 2022 ) , systems often spend additional inference compute to improve performance.

Yet the opposite can be true, where more test-time compute may yield diminishing returns or even worse performance ( Pipis et al., 2025 ; Ghosal et al., 2025 ; Fu et al., 2026 ; Chen et al., 2025 ) . This suggests that improving reasoning via test-time scaling requires specific internal mechanisms. It raises a basic question: what internal mechanisms enable scalable and generalizable reasoning?

In this work, we study this problem on controlled, structured reasoning benchmarks, where memorization can be separated from generalization. Recent iterative reasoning models, such as HRM and TRM ( Wang et al., 2025 ; Jolicoeur-Martineau, 2025 ) , repeatedly apply a learned module to update latent states and achieve strong results on algorithmic reasoning tasks such as Sudoku and Maze. This repeated update naturally defines a learned dynamical system in latent space for reasoning.

We argue that test-time scaling is effective when a model’s internal attractor landscape aligns with the task-metric landscape: trajectories that achieve stronger convergence should also decode to lower-error answers. Under this view, training then seeks to shape the attractor landscape into a differentiable surrogate aligned with the task metric. This amortizes intrinsically complex reasoning into a finite-capacity network, while leaving adaptive computation to inference. Consequently, inference acts as an adaptive search: scaling up test-time compute reliably drives the latent state toward favorable attractors. In this aligned regime, finding stable fixed points (attractors) is implicitly solving the task, suggesting that stronger convergence yields better performance. The learned dynamics effectively close the capacity-complexity gap, enabling scalable reasoning that generalizes beyond memorization, even with limited data, model capacity, and training budgets.

We view these models as learned fixed-point dynamical systems (akin to a DEQ-style perspective ( Bai et al., 2019 ) ) whose trajectories evolve in latent space toward attractors. This extends the usual fixed-point view from asking whether a state converges to asking what attractor landscape the learned dynamics induce: which attractors exist, whether they are reachable from plausible initializations, and whether they align with the task metric. Under this lens, correct solutions correspond to favorable attractors and failures correspond to spurious attractors; scaling works when additional iterations or restarts guide trajectories into basins of favorable attractors.

Building on this view, we first perform a systematic study of training-time and inference-time design choices for iterative reasoning on controlled tasks, starting from the transition from feedforward computation to weight-tied iteration and then analyzing the training and inference choices that shape the learned attractor landscape. Across Sudoku-Extreme and Maze-Unique, we quantify convergence via the fixed-point residual ∥ f θ ​ ( 𝐳 , 𝐱 ) − 𝐳 ∥ \lVert f_{\theta}(\mathbf{z};\mathbf{x})-\mathbf{z}\rVert and show that lower residual tightly tracks lower prediction error (Fig. 1 ), identifying the key factors that activate generalizable reasoning.

This framing suggests concrete, task-agnostic diagnostics: fixed-point convergence (a.k.a. ∥ f θ ​ ( 𝐳 , 𝐱 ) − 𝐳 ∥ \lVert f_{\theta}(\mathbf{z};\mathbf{x})-\mathbf{z}\rVert ) and how it co-varies with prediction error. It also predicts a characteristic depth–breadth interaction: breadth (more restarts) becomes effective only after sufficient depth enables trajectories to meaningfully explore and settle into attractors, a pattern we observe in Fig. 3 .

Guided by these diagnostics, we introduce two lightweight training interventions, randomized state initialization and path stochasticity via noise injection, to make favorable attractors easier to reach. The resulting dynamics can be scaled along two explicit inference axes: depth ( D D ), the per-trajectory number of unrolled steps, and breadth ( B B ), the number of stochastic trajectories from independent initializations. With two-axis scaled inference and convergence-based selection, EqR substantially outperforms prior iterative reasoning models on these controlled benchmarks, reaching 99.8 % 99.8\% exact accuracy on Sudoku and 93.0 % 93.0\% on Maze 1 1 1 For simplicity, we refer to Sudoku-Extreme as Sudoku and Maze-Unique as Maze throughout the paper. . We hope these analyses help advance a mechanistic understanding of iterative latent reasoning models and how their internal dynamics support scalable reasoning.

## 2 Background and Problem Formulation

We study iterative reasoning models that carry out multi-step computation through iterative updates of a latent state. Given an input 𝐱 ∈ 𝒳 \mathbf{x}\in\mathcal{X} , the model maintains a state 𝐳 k ∈ ℝ n \mathbf{z}_{k}\in\mathbb{R}^{n} and applies a parameterized update operator 𝐳 k + 1 = f θ ​ ( 𝐳 k , 𝐱 ) , \mathbf{z}_{k+1}=f_{\theta}(\mathbf{z}_{k};\mathbf{x}), (1) where k k denotes the iteration index, and θ \theta denotes the model parameters. This update-rule perspective is common in neural networks with iterative computation ( Bai et al., 2019 ; Dehghani et al., 2019 ; Zhu et al., 2025 ; Wang et al., 2025 ; Jolicoeur-Martineau, 2025 ; Hao et al., 2025 ) . These approaches share a common view of test-time scaling through additional applications of the same learned update rule. Starting from an initial state 𝐳 0 ∼ μ 0 ( ⋅ ∣ 𝐱 ) \mathbf{z}_{0}\sim\mu_{0}(\cdot\mid\mathbf{x}) , the model runs K K updates and decodes the final state into a prediction 𝐲 ^ K \hat{\mathbf{y}}_{K} . The task supplies a metric comparing 𝐲 ^ K \hat{\mathbf{y}}_{K} with the target 𝐲 \mathbf{y} . In this work, we focus on iterative reasoning models with fixed-size latent states. Hierarchical Reasoning Models ( Wang et al., 2025 ) and Tiny Recursive Models ( Jolicoeur-Martineau, 2025 ) implement multi-step reasoning by iteratively updating high- and low-level latent states in a nested-loop schedule. For our analysis, the essential commonality is a weight-tied latent dynamical system whose extra computation unfolds in state space.

## 3 From Feedforward Predictors to Iterative Reasoners

We study how a feedforward model can be turned into an iterative model ( Wang et al., 2025 ; Jolicoeur-Martineau, 2025 ) with feedback loops under controlled data and compute, and use this path to analyze the key design choices for training strong iterative models. We ablate the main design axes used by prior works as follows.

#### Weight-tied structure.

The weight-tied design reuses parameters across model layers, replacing additional distinct layers with repeated iterations of the same update block.

#### Truncated gradients.

Full backpropagation through long weight-tied trajectories is costly and multiplies many recurrent Jacobians, which can make the backward dynamics poorly conditioned and the gradient signal unstable. Truncated gradients with detached carry keep the length of forward trajectory but cut the backward graph at segment boundaries. Therefore, each update is optimized through a local trajectory window.

#### Hierarchical iterations.

We then compare single-stream iteration against hierarchical iterations, where two latent states are updated at different frequencies. This separates the effect of weight-tied iteration from the additional two-timescale structure used in HRM/TRM-style models.

#### Supervision placement and optimization schedule.

After choosing the gradient window, one must decide where losses are placed and when parameters are updated. Given a K K -step trajectory { 𝐳 k } k = 1 K \{\mathbf{z}_{k}\}_{k=1}^{K} from iterative models, we compare three schedules: 1) Vanilla , which computes the loss only after the final iteration and updates the parameters once per full trajectory; 2) Trajectory Supervision , which places losses at multiple iterations but accumulates them into a single update at the end of the trajectory; and 3) Segmented Online Training , which splits the trajectory into segments, supervises the end of each segment, and takes an optimizer step immediately. The next segment starts from the current latent state with detached carry, but under the updated parameters. Thus, SOT changes not only where supervision is applied, but also the optimizer time scale: the model is updated along the evolving trajectory rather than only after the full rollout has completed. From an optimization viewpoint, this can be seen as an alternating approximation to an attractor-learning problem: latent updates seek a reachable low-residual state under the current operator, while parameter updates reshape the operator so that these reachable states decode to correct solutions. These schedules can differ substantially in optimization fidelity, training stability, and efficiency. We include detailed discussions in Appendix A.2 .

#### Adaptive computation time (ACT).

We also study adaptive computation via a learned halting mechanism ( Graves, 2017 ) . Let q ^ k = f ϕ ​ ( 𝐳 k ) \hat{q}_{k}=f_{\phi}(\mathbf{z}_{k}) be a halting score and τ = min ⁡ { k ≤ K : q ^ k > δ } , \tau=\min\{k\leq K:\hat{q}_{k}>\delta\}, with τ = K \tau=K if no halt is triggered. We compare different variants, including fixed-depth iteration, oracle halting, and learned halting with an ACT head. The main distinction is whether the halting signal is only predicted or is actually used to allocate variable compute. In the latter case, solved examples leave the batch early while unresolved examples receive further refinement, so ACT acts as a difficulty-aware compute allocation mechanism.

#### Overview.

Together, these axes define the construction path studied in Sec. 6.1 : 1) weight-tied structure converts distinct layers into repeated application of a shared update block; 2) hierarchical iterations test whether two-timescale latent updates add benefits beyond single-stream iteration; 3) truncated gradients stabilize optimization through long weight-tied trajectories by keeping the backward graph local while also reducing memory and compute costs; 4) segmented online training changes where supervision and optimizer updates enter the trajectory; and 5) adaptive computation reallocates iteration budget across examples by difficulty. The main text reports the compact construction path, and we defer full details, results and diagnostics to Appendix A.2 .

## 4 Iterative Models as Attractor Dynamics

This section develops the conceptual framework used by the rest of the paper. We first relax exact fixed-point convergence into an attractor view of iterative inference, then use the resulting landscape modes to explain when depth and breadth scaling should help and what training must shape.

### 4.1 From Fixed-Point Convergence to Attractors

Prior iterative reasoning work already points toward a convergence interpretation: HRM describes its nested latent updates through hierarchical convergence , while TRM cautions that literal fixed-point convergence is too strong because latent residuals can remain nonzero even as they decrease during training ( Wang et al., 2025 ; Jolicoeur-Martineau, 2025 ) . By contrast, we argue that iterative models do converge in a weaker attractor sense: repeated application of the update operator often reduces the residual ‖ f θ ​ ( 𝐳 , 𝐱 ) − 𝐳 ‖ \|f_{\theta}(\mathbf{z};\mathbf{x})-\mathbf{z}\| and improves performance, as illustrated in Fig. 1 . The key point is that this behavior need not be exact fixed-point convergence. Under finite computation, a trajectory may approach a fixed point, settle into a stable region, or enter a bounded recurrent set; when nearby states are drawn toward such a set under repeated updates, it acts as an attractor. We therefore use attractor to describe stable long-run outcomes of the learned dynamics, generalizing the equilibrium perspective used in Deep Equilibrium Models ( Bai et al., 2019 ) .

This attractor view keeps the core convergence claim without requiring convergence to a single exact fixed point: test-time compute is useful when trajectories move toward favorable attractors and lower-residual states within a well-structured internal landscape . A favorable basin suffices.

In this view, the learned trajectory is part of the prediction mechanism: when successive states become more task-consistent as their residuals fall, additional iterations can refine the answer instead of simply adding compute. Feedforward models do not induce such refinement trajectories; in our controlled comparison, they generalize substantially worse than iterative alternatives in Tab. 1 .

Formally, for a data example ( 𝐱 , 𝐲 ) ∼ 𝒟 (\mathbf{x},\mathbf{y})\sim\mathcal{D} , inference induces a trajectory { 𝐳 k } k ≥ 0 \{\mathbf{z}_{k}\}_{k\geq 0} by iterating an update operator f θ ​ ( ⋅ , 𝐱 ) f_{\theta}(\cdot;\mathbf{x}) from the initialization 𝐳 0 ∼ μ 0 ( ⋅ ∣ 𝐱 ) \mathbf{z}_{0}\sim\mu_{0}(\cdot\mid\mathbf{x}) . We write 𝒵 θ ∗ ​ ( 𝐱 ) \mathcal{Z}^{*}_{\theta}(\mathbf{x}) for the stable long-run outcomes of these dynamics (e.g., fixed points or small recurrent sets).

The collection 𝒵 θ ∗ ​ ( 𝐱 ) \mathcal{Z}^{*}_{\theta}(\mathbf{x}) is the model’s attractor landscape . This landscape matters through two axes: task alignment and reachability. Task alignment asks whether the reached attractors decode to correct solutions rather than spurious ones. Reachability asks which attractor a trajectory reaches, and how reliably it does so under different initializations or perturbations. We summarize reachability using breadth and depth : broad attractors are easy to reach from many initial states, while deep attractors are stable once reached.