Equilibrium Reasoners (EqR)

Equilibrium Reasoners (EqR) are introduced in the paper Equilibrium Reasoners: Learning Attractors Enables Scalable Reasoning, submitted to arXiv on 20 May 2026 by Benhao Huang, Zhengyang Geng, and Zico Kolter. The work studies a specific research question. Why does extra test-time computation improve some iterative reasoning systems while producing little benefit or even worse results in others?

The authors frame the answer around task-conditioned attractors. Instead of treating a model as a single forward pass, EqR repeatedly updates a hidden state. The update process is intended to move that state toward stable outcomes that decode to valid solutions. More computation can then mean more steps along one trajectory or more trajectories from different initial states.

The reported numbers are controlled benchmark results, not a claim that a general chatbot has acquired a new universal reasoning ability. The paper evaluates structured tasks, including Sudoku-Extreme and Maze-Unique. Its exact comparison reports 99.8% for EqR on Sudoku and 93.0% on Maze, while its abstract describes improvement from a 2.6% feedforward baseline to over 99% on Sudoku-Extreme after scaling. Those results should be read with the task, evaluation metric, and inference budget in view.

This guide follows the arXiv record, the paper HTML, and the ICML 2026 poster page. Readers interested in adjacent systems can also see the site's Agent JIT compilation guide and AI voice agents guide.

What You'll Learn

• How EqR treats iterative latent-state updates as a reasoning process.
• What task-conditioned attractors, depth scaling, and breadth scaling mean.
• Which Sudoku-Extreme and Maze-Unique results are reported by the paper.
• Why a controlled research benchmark is not the same as a production model or general proof of reasoning.

What Are Equilibrium Reasoners (EqR)?

Equilibrium Reasoners are iterative neural models described in the 2026 paper by Huang, Geng, and Kolter. A conventional feedforward model maps an input to an output through a fixed sequence of transformations. An iterative reasoner maintains a latent state and applies a learned update rule repeatedly.

In simplified form, the paper describes an update in which the next latent state is produced from the current state and the input. After a number of steps, a decoder turns the final state into a task answer. The same learned update block can be reused across steps. This weight-tied structure allows inference to spend more computation without adding a separate set of parameters for every step.

EqR is not a named consumer application. It is a framework for studying how learned dynamics behave when inference is extended. The paper's contribution is the proposed connection between useful test-time scaling and convergence toward solution-aligned attractors. That connection is evaluated on structured reasoning problems where exact answers can be checked.

The distinction between a latent state and a visible explanation is important. The paper studies internal dynamics and decoded task accuracy. It does not establish that EqR produces a faithful natural-language explanation of how it reached an answer.

What Is a Task-Conditioned Attractor?

An attractor is a stable outcome toward which repeated updates can move a system. In EqR, the relevant outcome depends on the input task. A Sudoku instance can create one set of useful states, while a maze instance can create another. The model is trained so that states associated with valid solutions become reachable and stable under the update process.

The word task-conditioned means that the dynamics depend on the problem being solved. The model does not use one fixed answer for every input. Instead, the input influences the update rule's trajectory through latent space. If the trajectory settles in a state that decodes to a correct solution, the attractor is useful for that example.

The paper also allows a weaker interpretation of convergence. A finite trajectory may approach a fixed point, remain in a stable region, or enter a bounded recurrent pattern. The article therefore avoids saying that every useful run reaches one exact mathematical fixed point. The central observation is about stable behavior and its relationship to task error.

A useful analogy is repeated refinement of a candidate solution, but the analogy has limits. EqR does not necessarily expose a list of candidate answers or run an external checker. The model's internal update creates a sequence of hidden states, and a decoder evaluates the resulting output against the benchmark target.

How EqR Scales Compute at Test Time

The paper defines two main inference axes. Depth is the number of update steps applied to one trajectory. Breadth is the number of stochastic trajectories started from different initialisations. Increasing depth gives a trajectory more opportunities to settle. Increasing breadth gives inference more attempts to reach a useful basin of states.

These controls are complementary. More steps do not automatically help if a trajectory is moving toward a wrong stable outcome. More initialisations do not automatically help if the update dynamics have not learned a state that corresponds to a valid solution. The reported gains occur when additional compute improves the chance of reaching a useful attractor and reduces the task error.

The paper describes simple examples converging within 1 to 5 iteration steps, while harder examples benefit from much larger test-time budgets. The abstract says that the models can be unrolled up to an equivalent of 40,000 layers. The detailed HTML explains that training is capped at 16 iterations in one analysis while test-time trajectories generalise to over 1,024 iterations. These are paper-specific experimental settings, not a recommended budget for every model.

Test-time scaling should therefore be treated as a measured inference strategy. A deployment would need to choose an accuracy target, a compute budget, a stopping signal, and a way to handle uncertain or incorrect outputs.

What the Paper Reports on Sudoku-Extreme

Sudoku-Extreme is a structured constraint-satisfaction benchmark used in the paper. The task provides a Sudoku instance and evaluates whether the decoded answer is exactly correct. This type of evaluation is useful for separating a right answer from a plausible explanation because a single incorrect cell can make the complete solution wrong.

The paper reports a 2.6% accuracy figure for a 64-layer feedforward baseline in its comparison table. EqR reaches 99.8% exact accuracy on Sudoku in that table. The paper notes that the main text uses Sudoku as shorthand for Sudoku-Extreme in the reported comparison. The abstract gives the same story as a rise from 2.6% for feedforward models to over 99% after scalable latent reasoning.

These figures do not mean that EqR solves all Sudoku instances or all reasoning tasks at 99.8%. They describe the stated benchmark, model configuration, training procedure, and inference setting. The evaluation is valuable because the paper reports exact task accuracy, but it remains a controlled research comparison.

What the Paper Reports on Maze-Unique

Maze-Unique is the second named benchmark in the paper's main comparison. The paper describes it as a uniquely solvable variant of Maze-hard-1k designed to remove ambiguity caused by multiple shortest paths. That design makes it easier to interpret whether the predicted path matches the unique target solution.

EqR reaches 93.0% exact accuracy on Maze in the paper's comparison table. The paper uses Maze as shorthand for Maze-Unique in that section. Other iterative baselines have lower reported results in the same table, but those values depend on the exact evaluation and model settings. This article does not present the table as a ranking of all current reasoning systems.

The difference between the Sudoku and maze results also shows why a single headline number can mislead. Tasks may differ in structure, difficulty, data generation, and error sensitivity. A model that performs well on one controlled benchmark still requires separate testing on different tasks, domains, and distributions.

Why Attractor Convergence Matters

The paper measures a fixed-point residual based on the distance between the current latent state and the state produced by the update rule. Lower residual means the state is changing less under the next update. In the paper's experiments, lower residual is closely associated with lower prediction error in the studied settings.

This gives the researchers a diagnostic that is available during inference even when the correct answer is not known. A trajectory that is still moving rapidly may need more steps. A trajectory with a small residual may have settled. However, a low residual can also correspond to a stable wrong answer. The residual is therefore a signal for analysis and compute allocation, not a universal correctness certificate.

The attractor view also explains why more compute can have different outcomes. If the learned update has a broad basin around a correct solution, depth can refine the trajectory. If correct and incorrect attractors coexist, breadth can help by trying more initial states. If no reachable attractor decodes to a correct solution, more computation may not solve the task.

How Training Shapes the EqR Dynamics

The paper studies a construction path from feedforward predictors to iterative reasoners. It examines weight-tied parameters, truncated gradients, hierarchical iterations, segmented online training, and adaptive computation. These components affect how the update rule is trained and how inference allocates repeated computation.

Two interventions receive particular attention. Randomised state initialisation improves coverage across possible starting states. Noise injection introduces variation into trajectories. The purpose is not to add an external solver or a hand-written search heuristic. It is to shape the learned update so that useful attractors become easier to reach.

Training also has to manage the cost of long trajectories. Backpropagating through every repeated step can increase memory use and create difficult optimisation conditions. The paper studies truncated gradients with detached carry and segmented supervision as ways to keep training manageable while still shaping intermediate states.

The result is a research programme about the relationship between training dynamics and inference-time scaling. It is not a claim that one intervention will transfer unchanged to every architecture.

EqR Compared With Feedforward and Iterative Models

In the paper's controlled table, feedforward models use distinct layers and do not create the same repeated update trajectory. Iterative models reuse parameters over multiple steps and can continue computation after the initial state has been produced. EqR is analysed within this iterative family and adds an attractor-based interpretation of why scaling can work.

The comparison table reports a 64-layer feedforward Sudoku accuracy of 2.6%, EqR Sudoku accuracy of 99.8%, and EqR Maze accuracy of 93.0%. It also reports earlier iterative baselines, including TRM at 84.8% on Sudoku and 44.9% on Maze. These numbers are included here only to explain the paper's own comparison. They should not be treated as a current leaderboard.

The relevant distinction is not simply shallow versus deep. A model can have more layers and still fail to generalise if repeated computation does not produce useful state transitions. EqR focuses on the dynamics of those transitions and on whether convergence is aligned with the task metric.

What the EqR Results Do Not Prove

The results do not prove that EqR is a general-purpose replacement for large language models, external tools, symbolic solvers, or verification systems. The paper studies controlled structured tasks. It does not show that the same accuracy holds for open-ended writing, current-events research, software maintenance, or unstructured visual reasoning.

The results also do not show that a low residual guarantees a correct response. A model can settle into a spurious attractor. They do not establish that longer inference is always better, because additional computation can be wasted or can amplify an incorrect path. The experiments support a narrower conclusion about when test-time scaling can work in the studied setting.

Finally, the reported equivalent-of-40,000-layers figure is a compute-unrolling description, not a claim that a deployed system contains 40,000 separately trained layers. The paper reuses an update mechanism across iterations. This distinction prevents the headline number from being confused with parameter count or model size.

Could EqR Become a Production Architecture?

EqR could inform future research into models that allocate more inference compute to harder examples, but the paper does not by itself establish a production system. A practical implementation would need engineering for latency, memory, batching, failure handling, monitoring, and cost. It would also need evaluation outside the two controlled benchmarks.

A deployment would need to decide how many iterations to allow, when to stop, how to compare multiple trajectories, and what to do when the output is uncertain. If no trusted external verifier is available, the internal residual may help monitor convergence but cannot replace task-specific correctness checks for safety-critical use.

The linked EqR project page is a useful place to check for code and updates. This article does not claim that a repository automatically provides a supported product, a hosted API, or a guarantee of reproducible benchmark results.

How Researchers Should Evaluate Similar Systems

A fair evaluation should state the task, data split, metric, model configuration, training budget, inference budget, and stopping rule. Exact-match tasks need clear definitions of what counts as correct. If multiple trajectories are aggregated, the evaluation should explain the aggregation method and the number of initialisations.

Researchers should also compare compute rather than only accuracy. More inference steps can improve a score while increasing latency and energy use. Reporting accuracy alongside the number of update evaluations makes it easier to compare systems with different scaling strategies.

Convergence diagnostics should be reported with task error when possible. A residual can be informative even when labels are unavailable, but it should be calibrated against known outcomes. Tests on shifted tasks are also needed to determine whether the system generalises beyond the generation process used to create the benchmark.

Bottom Line on Equilibrium Reasoners

Equilibrium Reasoners provide a research lens for understanding scalable iterative reasoning. The paper proposes that task-conditioned attractors can make extra test-time computation useful. Depth adds iterations to a trajectory. Breadth adds stochastic starting points. Lower residual and lower task error are linked in the reported controlled experiments.

The paper reports 99.8% exact accuracy on Sudoku-Extreme and 93.0% on Maze-Unique, with a 2.6% feedforward baseline in the stated comparison. It also describes unrolling up to an equivalent of 40,000 layers. These figures are meaningful within the paper's evaluation setup and should not be converted into a universal claim about deployed AI systems.

The practical takeaway is narrower and more useful. Test-time scaling needs dynamics that improve with additional computation. Measuring whether a latent trajectory settles is one way to study that behaviour. Whether the same approach transfers to a new model or task remains an empirical question. For related systems context, readers can also review the site's MCP guide, Agent JIT compilation guide, and AI voice agents guide. These articles cover different systems and do not validate EqR's benchmark results.