The Given and the Found: What Test-Time Reasoning Amortizes, and What It Cannot

1. Three Things the Field Conflates

When an iterative reasoner solves a puzzle, three distinct objects are in play, and most discussion runs them together.

The first is the correctness condition: what makes an answer right. For Sudoku it is the constraint that every row, column and box be a permutation of the digits. For a maze it is that the path is a valid shortest route. For a reinforcement-learning agent it is a reward, and for an energy-based model a scalar energy. The condition is a fact about the task, prior to any network.

The second is the landscape: the learned dynamical system. Its stable states, the attractors, are supposed to coincide with answers that satisfy the condition. Training produces the landscape. Equilibrium Reasoners state the ideal precisely: test-time scaling works when the model’s internal attractor landscape aligns with the task-metric landscape, so that descending the internal one, by running more iterations, also moves toward a correct solution. The internal landscape is an imperfect surrogate for the condition.

The third is the search: the trajectory the system actually follows through the landscape at inference, including any restarts. The iteration count and the number of parallel runs pay for the search.

The correctness condition is what we want. The landscape is a trained approximation to it, and the search is a procedure for traversing the approximation. The iteration acts on the landscape and the search; the condition comes from somewhere else. Most interesting questions about these systems concern the seams between the three. Where does the condition come from? How faithfully does the landscape approximate it? When does traversing the landscape find answers to the condition rather than to its surrogate?

2. The Spectrum of Givenness

The architectures differ most sharply in how much of the correctness condition is guaranteed by construction, and how much is approximated by a trained surrogate that is trustworthy only in distribution. This one axis orders the field and predicts its failure modes.

At one end sit genuine energy-based models. Inference is descent on a scalar energy that someone wrote down, and the fixed point is a minimum of a known objective. “Correctness”, in the weak sense of optimizing that objective, is structural. Energy descent has a Lyapunov function by construction, so convergence is a theorem, not a hope. Energy Transformers and their relatives anchor this end of the spectrum; we take them as given and do not develop them here.

One step in from that end is the Lattice Deduction Transformer (LDT). It is the most instructive case in the cluster, because it pins correctness architecturally and leaves everything else to training. LDT is built on abstract interpretation, the framework Cousot and Cousot introduced for sound approximate reasoning. Information states are elements of a lattice. Its top element \top represents no information, with every solution still possible. Its bottom element \bot represents inconsistency, with no solution left. For Sudoku, the abstract domain assigns each cell the set of digits still viable. \top gives every cell all nine digits, and any cell whose set becomes empty is \bot. Deduction descends the lattice: it can only remove candidates. The operator is sound by design but incomplete. A step may fail to derive a true fact, but it never derives a false one.

The concrete domain (sets of full solutions) and the abstract domain (per-cell candidate sets) are linked by an abstraction map \alpha and a concretization map \gamma that form a Galois connection. The most precise sound deduction operator for an instance p is \mathit{ded}_p(a) = \alpha(\gamma(a) \cap \lVert p\rVert): refine the state to keep only the candidates that survive in at least one valid solution. LDT trains a recurrent transformer to approximate \mathit{ded}_p from solution samples. It encodes the lattice as a tensor (729 binary sigmoids for 9\times9 Sudoku, one per candidate) and projects the latent state to and from that tensor between forward passes. What matters is the division of labor. The architecture guarantees the form of soundness: the dynamics live on a lattice and can only remove candidates, so the model returns a correct answer or abstains, never a wrong one. Training supplies only the strength of the deduction, meaning how many candidates each step can soundly eliminate. Correctness is architectural; competence is trained.

A step further in sits MuZero, which is easy to overstate. Its correctness condition is given, since the environment supplies reward. The idealized Bellman operator it targets is a contraction with a unique fixed point, which makes the whole thing look principled. But MuZero does not plan with the true Bellman backup. It plans with a learned, value-equivalent model, trained to predict reward, value and policy rather than to reconstruct the environment’s transitions. The analysis “What model does MuZero learn?” shows what that buys and what it costs. The learned model is generally not accurate enough for policy evaluation, and its accuracy decays as the evaluated policy drifts from the policy that collected the data. It is faithful where MuZero already plays and unreliable off-policy. Planning is rescued by the policy prior in Monte Carlo Tree Search, which biases search toward actions where the model is accurate and so keeps the search where the surrogate holds. MuZero’s condition is given, but the landscape it searches is a local surrogate. A given reward plus an in-principle contraction does not add up to a globally trustworthy operator. Again, the trustworthiness holds only in distribution.

At the far end are the pure learned-dynamics reasoners: Equilibrium Reasoners, HRM, TRM, Attractor Models and GRAM. Here the update f_\theta need not be the gradient of any potential. There is no energy, no contraction, no Galois connection and no guarantee. Equilibrium Reasoners are explicit about the loosening. They relax exact fixed-point convergence to the weaker notion of an attractor: a state, stable region or “bounded recurrent set” toward which nearby trajectories are drawn. Literal fixed points are too much to ask of a learned operator whose residual never reaches zero. At this end, training carries the whole burden of shaping the landscape so that its attractors coincide with solutions. Nothing at construction time backs it up.

Moving down the spectrum, correctness migrates out of the architecture and into a trained surrogate. The surrogate’s guarantees weaken from “theorem” to “holds where we trained it”. Each failure mode in the rest of the essay follows from where a system sits on this spectrum.

3. Convergence Is Not Self-Certifying

In a real energy-based model, a low-energy state is a good state by definition, because the convergence signal is the objective. Replace the energy with a learned surrogate and that identity breaks. The break is the most useful epistemic fact about these systems.

Equilibrium Reasoners measure convergence by the fixed-point residual \lVert f_\theta(z;x) - z\rVert, which is how far the next iteration would still move the state. In well-trained models, lower residual tracks lower prediction error tightly, and that licenses convergence as a signal for stopping and for selecting among runs. But the tracking is earned. In a baseline without landscape shaping, a falling residual can instead mean convergence to a spurious attractor: a stable, low-residual state that decodes to the wrong answer. There, picking the best-converged of several restarts underperforms a simple majority vote across them. That inversion is the sharp diagnostic, and it is more alarming than it first sounds. If the residual were a good per-instance signal of correctness, the lowest-residual run would win. That it loses means the residual says nothing about which answers are right, even when aggregate accuracy is high enough to invite trust. The dangerous regime is not low accuracy. It is deployable accuracy paired with a confidence signal that cannot be read. In the paper’s words, the convergence measure is “a learned proxy whose reliability depends on the attractor landscape”, not a task-agnostic certificate.

Shaping means something specific here, and it is not simply more training. It consists of two changes to the training procedure: a randomized initial state for each trajectory, and path noise injected at each step. Both act on the geometry of the landscape. They widen the basins of correct attractors and loosen premature trapping in wrong ones. They help at a fixed training budget (on the maze task, accuracy rises from 44.9% to 82.2% at equal compute), which shows that the lever is geometry rather than duration. The paper’s taxonomy of four regimes explains what the geometry is correcting. The first three are distinct reasons for convergence and correctness to come apart:

• In (a), no reachable attractor decodes to a correct answer. The failure is misalignment, and no amount of compute helps, since reducing the residual only carries the state toward a confidently wrong answer.
• In (b), correct and spurious attractors coexist. The failure is basin selection: a clean convergence into the wrong basin.
• In (c), the correct attractor exists but its basin is too narrow to fall into. The failure is reachability.
• In (d), the well-aligned regime, residual decay is tightly coupled to error reduction. Only here is “iterate to convergence and trust the result” valid.

The training interventions move a task out of (a), (b) or (c) toward (d). Until a task gets there, the system’s sense of having settled is no evidence that it has settled on the truth.

MuZero corroborates this in a different domain. The off-policy decay of its learned model is the same phenomenon: the surrogate is reliable in distribution and misleading outside it. The policy prior is a mechanism for not trusting the surrogate where it was not trained. Whether the internal signal is a fixed-point residual or a value estimate, its calibration is bounded by the training distribution.

The lesson transfers. In any system whose objective at inference is a learned surrogate, the internal signal that it has “figured it out” (a low residual, a stable state, high confidence) is itself a trained artifact. Its calibration reaches only as far as the data that shaped it. Anyone who scales test-time compute against a convergence criterion, a self-consistency check or a confidence threshold relies on a landscape alignment they have not separately verified. The signal can be confidently, stably wrong.

4. Depth and Breadth Are Two Knobs, Not One

Test-time compute in these systems comes in two forms that are routinely treated as one dial. Depth is the number of iterations in a single trajectory, refining within whatever basin the trajectory has entered. Breadth is the number of independent restarts from different initializations, covering more basins. Equilibrium Reasoners count the total inference budget as their product, \mathrm{NFE} = D \cdot B, but the two factors do structurally different work.

Depth entrenches the current basin. More iterations pull the trajectory further toward whatever attractor has it. In the well-aligned regime (d), that is exactly what one wants, since deeper iteration refines toward the solution. In two other regimes the problem is which basin the trajectory is in, not how deep it is in it. There more depth makes things worse, and only breadth helps.

The first is the spurious-attractor regime (b). A trajectory that has settled into a confident wrong answer sinks deeper into it with more iterations, and the only escape is to start over somewhere else. Equilibrium Reasoners observe this interaction directly. Breadth becomes effective only past a minimum depth, around four model steps (equivalent to a few hundred unrolled layers), which a restart needs to explore and commit to a basin. Beyond that threshold, adding breadth consistently reduces both residual and prediction error, while adding depth alone cannot rescue a trajectory in the wrong basin.

The second regime is genuine multiplicity, and it differs conceptually because no basin is wrong. N-Queens and graph coloring have many valid solutions, and an open grid offers combinatorially many equally short paths between two corners. When several attractors are all correct, settling on one is not an error. It is information loss: the system collapses a distribution it was supposed to keep. GRAM is built to address this failure. Deterministic recursion, its authors argue, “collapses the space of plausible reasoning paths into a single attractor”. Their remedy makes the latent transitions stochastic. The reasoner becomes a generative model over trajectories, which can represent several hypotheses and scale by sampling them in parallel. Width becomes a first-class axis alongside depth. Language models trained by on-policy reinforcement learning lose alternatives in the same way, and Who Teaches the Weights? discusses a remedy of the same kind, Vector Policy Optimization, which trains the model to produce several answers that differ.

Both pathologies, entrenchment in a wrong basin and collapse of a legitimately multi-valued answer, are forms of premature convergence. Both resist more depth, and both yield to breadth. The unifying maxim is do not over-settle: keep the distribution alive until the task demands commitment. Read this way, a family of training tricks is one idea. The randomized initialization and path noise of §3 do double duty. Besides aligning the landscape so that convergence becomes a trustworthy signal, they brake premature convergence: they broaden where trajectories start and jostle them out of basins they would otherwise sink into early. GRAM’s stochastic transitions serve the same end. LDT uses a decide-temperature when it pins a cell, and runs many parallel chains per puzzle. Each is a brake on premature convergence, applied at a different point in the trajectory.

The cluster gestures at one direction it does not take; this is our reading, not theirs. For inputs with many solutions, the right terminal behavior may not be a fixed point selected from an ensemble of restarts. It may be a limit cycle: a bounded recurrent set that encodes “these are the valid readings” by visiting them in turn. The Equilibrium Reasoner formalism already permits this when it relaxes convergence to “a bounded recurrent set”. The paper never uses the allowance, because it tests only unique-solution Sudoku, where any cycling would be pathological and the lowest-residual run is by construction the one to keep. A distribution over valid attractors can be produced spatially, as an ensemble of independent restarts (GRAM’s breadth). It can also be produced temporally, by a single trajectory that refuses to settle and multiplexes the alternatives. Bistable perception does this with a Necker cube, flipping between its two valid three-dimensional readings rather than averaging or choosing. None of these architectures makes a non-converging recurrent set its terminal competence. That such a set is even expressible is a hint worth following.

5. Amortization Is Learning

The word “amortize” does double duty in this literature, and its two senses give opposite verdicts.

In the first sense, amortization is learning: the weights change to absorb computation that would otherwise happen at inference, and this raises the attainable ceiling at fixed data. The clearest evidence comes from Attractor Models. They treat refinement as solving for a fixed point in output-embedding space, and obtain gradients by implicit differentiation, so training memory stays constant in the effective depth. They deliver a Pareto improvement over plain Transformers and over stable looped models: up to 46.6% better perplexity and up to 19.7% better downstream accuracy, at lower training cost. A 770M-parameter model outperforms a 1.3B Transformer trained on twice the tokens. Attractor Models also show equilibrium internalization. Trained only on next-token loss, the backbone’s initial guess drifts closer to the fixed point over training, so fewer refinement steps are needed. Eventually the solver can be removed at inference with little degradation. The loop self-distills into the feedforward initialization. In the authors’ phrase, “recurrence acts as a moving training target, teaching the backbone where its computation should converge.”

In the second sense, amortization is efficiency: the ceiling stays where it is and compute is reallocated. One form is not spending, at deployment, compute the answer never needed. Equilibrium Reasoners show this with adaptive computation. A learned halting head cuts the average number of function evaluations by 17.4× at large depth, or 5.8× under breadth scaling, for a minor change in accuracy. It stops easy instances early and reserves long runs for the hard tail. The other form trades training compute for deployment compute: pay more at training so the operator reaches its answer in fewer deployment steps, with accuracy roughly held. LDT quantifies this trade (§6). Its limit is equilibrium internalization itself, with the deployment step count driven toward zero as the solver becomes removable. Internalization therefore has two faces. The same absorbed computation can be cashed as a higher ceiling at a fixed budget, which is the learning reading, or as the same ceiling at lower deployment cost, which is the efficiency reading. Which one we observe depends only on whether we hold accuracy or compute fixed.

The discriminator between the senses is ceiling versus cost-to-ceiling. Does the weights’ absorption of computation raise the accuracy attainable at fixed data, or only cut the compute needed to reach an accuracy already attainable? The cleanest controlled evidence for the first is easy to overstate, so we state exactly what is matched. Equilibrium Reasoners’ construction path compares a 42-block feedforward Sudoku baseline with a weight-tied variant of 2 blocks run for 21 iterations. Both apply 42 blocks, so inference compute is the same, but the tied model has about twenty-one times fewer parameters. At that matched budget the tied structure lifts accuracy from 2.6% to 32.6%, with about a thousand training examples. That is a controlled result, and it says something specific. At fixed compute and far fewer parameters, iterative structure raises the ceiling. The gain comes from the structure rather than from raw depth, and it appears where data is scarce, which is the signature of help to learning rather than to throughput. The headline figure, feedforward near 2.6% and the iterated operator past 99%, does not isolate this effect, because it does not hold test-time effort constant.

The 99% is still a real and important result. It is test-time depth extrapolation: the operator was trained at 16 iterations and generalizes to over a thousand, which feedforward structure cannot do at all. But it is a capability claim, not a measurement of the learning effect. LDT supplies a complementary signature within one model, with no feedforward comparison needed. Its per-puzzle compute distribution is bimodal. In “deduction mode” a puzzle is solved with no search; in “search mode” it needs branching. As training grows, mass shifts from search to deduction, and the search-mode peak moves to fewer forward passes. Search is converted into amortized deduction inside the operator. Soundness stays at 100% throughout, so this conversion visibly reduces the cost-to-ceiling while the architecture holds the ceiling fixed.

6. The Engine Is Signal Amplification

The mechanism behind the learning sense is signal amplification. It must be stated at the level of the gradient, because the naive version is false. For ordinary cross-entropy against a fixed correct label, a confident prediction does not get a stronger push: the gradient scales roughly as (prediction − target), so a confidently correct output contributes almost nothing. Amplification is real because in all of these architectures the confidence sits on the target side, not the prediction side. In Attractor Models, the loop’s converged state is the target the initialization is regressed onto. In MuZero, as in AlphaZero before it, the MCTS visit counts are the target the policy head is regressed onto. In LDT, the \alpha-aggregate of still-consistent solutions is the target the candidate head is regressed onto. In each case a confident intermediate computation manufactures a peaked target. A peaked target produces a large, sharply directed gradient on the component being distilled into. A diffuse intermediate makes a flat target and a weak, smeared push.

The confidence of the manufactured target sets the amplitude of the learning signal. Whether the target is grounded in truth sets its sign. Grounded targets include a supervised label, LDT’s α-aggregate computed from real solutions, and an actual game outcome. A confident, correct grounded target distills competence quickly. This is equilibrium internalization and its automatic curriculum: because the loop’s conviction is also correct, it sharpens the target its initialization chases. A confident wrong convergence meets a large supervised error and is pushed back down. The gradient flattens the wrong basin; it does not deepen it. The failure mode is the ungrounded case: a self-generated target with nothing to correct it, such as a policy head regressed onto its own search when that search was confidently mistaken. There the same strong push writes the error into the weights and biases the next search the same way. Only a grounding signal breaks the loop, as when AlphaZero corrects a confident but losing line against the actual game outcome. Ungrounded self-distillation is the regime to fear; the grounded refinement that the reasoners and LDT run corrects its own errors.

Grounding fixes the sign of each step, but not what a long run of steps does to the alternatives. When each step’s target is built from the previous iterate, even a correctly signed push compounds. Reinforcement learning against a verifiable reward is grounded in this essay’s sense. Yet Who Teaches the Weights? shows it collapsing onto one strategy. Each step’s reference is the previous policy, so the effective temperature falls with every step, and a strategy that scores slightly below the best disappears. A penalty toward the fixed starting model puts a floor under that fall. This is the multiplicity failure of §4, arriving through training rather than inference.

If the grounded gradient corrects wrong convergence, where do the spurious attractors of §3 come from? Not from the gradient deepening them, but from underdetermination. Output-level supervision constrains the decoded answer only along the trajectories that training actually visits. The rest of the latent landscape is free to harbor stable states that the loss never sees and never penalizes. That is why the corrections are geometric rather than gradient-shaped. Randomized initialization and path noise widen the region the corrective gradient covers during training. Breadth at inference escapes a basin the gradient was never positioned to flatten. The brakes of §3 and §4 manage coverage of the landscape, not the sign of the push.

On its own, amplification is only a pull toward coarsening, toward fewer and more decisive steps. By itself it would predict that the single-step limit is best, which the 2.6% feedforward result flatly refutes. There must be an opposing force, and its sharper version is a claim about learnability. Call the amplification hypothesis (1): compressing toward fewer, bigger steps is self-reinforcing during training, because a more decisive operator manufactures a more peaked target, and the peaked target strengthens the gradient toward it. The counter-hypothesis (2) is that, at a fixed parameter count, an operator that must make a bigger change per step is harder to learn. The per-step map is a more complex function, the objective is worse conditioned, and the sample demand is higher. So the converged quality of a coarser-grained operator is lower in expectation. This is a learnability reading of what Equilibrium Reasoners call the capacity–complexity gap. The relocation matters: the claim is not that a fixed operator computes a big step badly, but that a big-step operator is harder to fit. Forces (1) and (2) are of the same kind. Both act on the operator during training, with opposite signs on step granularity, so they settle at an optimal granularity: finer where the target map is intrinsically harder, coarser where it is easy. The small-to-large curriculum that internalization traces is the path of that balance point. Early in training the operator is weak and only a small step is learnable, so (2) dominates and the grain stays fine. As competence accrues, the learnable step coarsens and (1) gains, compressing the loop. Loosely, the prescription is to amortize no faster than alignment improves. The learnability reading sharpens it to no faster than learnability permits.

Read this way, the recurring design choices are the field paying to keep each step learnable. Deep supervision at every iteration shrinks what any single step must fit, since a per-step increment is a smaller and better-conditioned function than an end-to-end map. LDT supervises all sixteen of its internal iterations. Equilibrium Reasoners interleave parameter updates along the trajectory through segmented online training. The HRM/TRM lineage supervises each step. LDT’s α-operator is the most principled instance of the instinct. Rather than supervising against one fixed answer, it computes the most precise sound refinement of the current state and hands that over as the target. The signal is dense and state-conditional, and it keeps each step’s learning problem both well posed and sound.

This part of the picture is the least separated from its alternatives by the work in hand. “Bigger steps are harder to train at fixed capacity” shades into the general reason depth helps in deep learning at all. None of these papers isolates the specific claim that the binding constraint is learnability rather than forward expressivity. The ubiquity of deep supervision is strong circumstantial evidence, but it confounds learnability with optimization stability. The experiment that would separate them is a matched-parameter, matched-data sweep over enforced step granularity: cap the per-step change while holding the operator’s forward expressivity fixed.

The strongest form of the amortization-as-learning claim is not settled either, because these papers bundle learning to iterate with learning to compress. Two complementary experiments would tell them apart. The first holds compression off. Let the operator learn to iterate, but prevent it from learning to compress: fix or re-randomize the initialization so it cannot drift toward the fixed point, and cap the per-step change so it cannot coarsen its steps. Then run it to convergence. If quality survives, iterating a locally competent operator suffices, and compression is efficiency layered on top. If quality collapses, compression is doing the real work. Equilibrium Reasoners’ randomized initialization is already half of this control: it blocks internalization into the initialization, but leaves step coarsening free. The second experiment pushes compression to its limit. Train with the loop and then remove it, against never training with the loop, holding data fixed and sweeping data scale. This applies the discriminator of §5: does training through the loop raise the attainable feedforward ceiling, and does the gap widen as data shrinks? A widening gap would be the signature of learning rather than efficiency. LDT’s trade of training against search, below, makes the ceiling lift plausible from the principled side. So does the policy-improvement bootstrap that AlphaZero and MuZero inherit, where an improvement operator provably manufactures a target stronger than the raw label. But neither experiment has been run cleanly. Our reading is that iterating a locally competent operator carries most of the headline quality, and that compression buys efficiency and some additional ceiling. We think it; we have not proven it.

Two further design choices shape not the grain of the amplification but its sign. MuZero’s policy prior is a confidence gate. It lets amplification act only where the learned model is reliable, confining the search, and therefore the targets it manufactures, to the on-policy region that the surrogate actually fits. It is amplification on a leash. LDT engineers the asymmetry by hand in the loss. Its candidate-elimination head must be sound, because a wrongly eliminated candidate cannot be recovered. That head uses an asymmetric cross-entropy that weights false eliminations eight times more heavily than false retentions. This is deliberate de-amplification in the unsound direction, damping the push exactly where overconfidence would be irreversible. A separate conflict-detection head, which must instead be complete, is trained symmetrically. The mechanism is tuned to protect a correctness property.

LDT’s Sudoku table shows the whole division of labor in one place. Across training budgets of one, two and four thousand steps, soundness stays at 100%. Accuracy climbs from 85.6% to 99.3% to 100%, and inference cost falls from 0.78 to 0.028 seconds per example. Roughly four times the training buys about a twenty-eight-fold reduction in inference search. Soundness never moves, because the architecture installed it and it was never training’s to give. Training bought completeness and speed.

7. The Boundary: Amortizing Search Versus Amortizing Discovery

Everything in the previous sections amortizes and accelerates search over a correctness condition that is given. On the evidence, it does so almost without limit: forty thousand effective layers, 99%-plus on extreme Sudoku, superhuman play, and an 800K-parameter network at 100% where frontier LLMs score 0%. Within a given condition, the iterative-reasoning program is extraordinarily strong.

None of these systems amortizes the discovery of the condition. That, we think, is the real demarcation. It is not a limit on compute or parameters. It is a structural line between problems that hand over the correctness condition (the rules, the energy, the reward, the task metric, the Galois connection) and problems where the condition must be inferred per instance before any of the machinery can run.

LDT draws the line on itself, with unusual self-awareness. It works, its authors note, wherever “a fixed set of rules induces a sound deduction operator that the model learns to apply”: Sudoku, snowflake Sudoku, mazes, anything with stable logical structure. ARC breaks it. There each task carries its own rules, which the model must infer from a handful of demonstrations before it can deduce anything about the test input. A naive port of LDT plateaus around 36%. Tellingly, it gets no benefit from test-time search at all, because the conflict head becomes unreliable and the search can no longer tell good branches from bad. The convergence signal that made everything else work goes dark when there is no fixed condition for it to track. The authors’ own escape hatch is to imagine “a different abstract domain entirely: one over the programs that produce solutions, rather than over the solution states themselves.”

That move, from a domain over solutions to a domain over the programs that generate them, is the move from deduction to abduction and induction: from applying a given rule system to inferring the rule system that fits the evidence. Making it dissolves the scaffold that made amortization work. The lattice, the Galois connection, the contraction and the energy are each a way of encoding a fixed correctness condition, and each is what the iteration exploits. Take away the fixed condition and the search has no structure to descend. The conflict head is back to guessing, the residual is uninformative, and depth entrenches nothing in particular.

The demarcation yields a falsifiable prediction, which is the reason to prefer it over the trivial claim that dynamics do not supply correctness. Scaling these architectures will keep winning on Sudoku-, maze- and SAT-shaped problems at essentially any scale. It will keep hitting a wall on ARC-shaped rule-induction problems at essentially any scale. The reason is single and structural: the former hand over the condition, and the latter require finding it. The dividing line is givenness, not difficulty and not size. Suppose a future system in this family cracked open-ended rule induction by scaling depth, breadth and amortized training alone, without some new mechanism for representing and searching over candidate conditions. Then the demarcation would be wrong.

8. What Settling Does Not Certify

This essay has asked what these dynamics compute and whether what they compute is right. We have kept that question apart from what, if anything, it is like to be a system in such a dynamical mode. The two questions meet at one point, and only to confirm that they come apart. A system can settle stably and confidently, with every internal signal of completion, into a spurious attractor: maximally “settled”, entirely wrong. Stability of the dynamical mode is one thing; correctness of its content is another. The settling itself, as relaxation toward an attractor, is the subject of The Settling Backstop. The reading of a stable attractor as a kind of homeostat is developed in The Acquaintance Relation as Cognitive Homeostasis. Here we need only the negative point: settling, however vivid, certifies nothing about the world.

The systems described here have learned to apply a given correctness condition with a reliability that, on the right problems, is already superhuman. They are silent on where the condition comes from. The next problem, the one ARC poses and these architectures as built cannot reach, is amortizing discovery rather than search: learning to find the rules, the energy, the lattice or the condition, rather than to descend one that is handed over. That is a different kind of learning from any these systems perform, and it is where open-ended reasoning actually lives.

This article was co-authored by Łukasz Stafiniak and Claude (Opus 4.7). It continues the series on mind, metaphysics, and artificial cognition published at lukstafi.github.io and syndicated at lukstafi.substack.com. The principal sources are the recent cluster of iterative latent reasoners: Equilibrium Reasoners (Huang, Geng, Kolter); the Attractor Models / Deep Equilibrium line; Generative Recursive Reasoning (GRAM; Baek, Jo, Kim, Ren, Bengio, Ahn); and the Lattice Deduction Transformer (Davis, Haller, Alfarano, Santolucito), with its grounding in the abstract-interpretation framework of Cousot and Cousot. They are read against the analysis of MuZero’s learned model in “What model does MuZero learn?”.