Reasoning or Guessing? When Recursive Models Hit the Wrong Fixed Point

Sudoku is a useful toy problem because it is cruel in exactly the right way.

A nearly completed grid with one blank cell should be easier than a brutal puzzle with dozens of missing entries. Humans know this. Basic software knows this. A model that can solve hard Sudoku should not suddenly collapse when the puzzle becomes almost finished.

And yet that is precisely the oddity this paper finds in the Hierarchical Reasoning Model, or HRM. HRM can solve Sudoku-Extreme puzzles that defeat several large language model reasoners in the cited benchmark setting. Then, when shown a trivial variant with only one missing token, it may fail, drift, or corrupt its own answer. The machine has not become less intelligent because the problem became easier. Something stranger is happening inside the recursion.

Ren and Liu’s paper, Are Your Reasoning Models Reasoning or Guessing? A Mechanistic Analysis of Hierarchical Reasoning Models, is valuable because it does not stop at the leaderboard result.¹ It asks what the recursive computation is actually doing. The answer is uncomfortable: HRM often behaves less like a model refining a solution step by step, and more like a system searching for a fixed point in latent space. Sometimes it finds the right one. Sometimes it finds a wrong one. The recursion then becomes loyalty to the first attractive answer it meets. Very human, unfortunately, but not in the flattering sense.

For businesses building agentic systems, latent-reasoning tools, or verification-heavy AI workflows, this is the useful lesson: “more thinking steps” is not automatically more reasoning. It can also mean more chances to settle into the wrong internal state with great confidence and terrible manners.

The mechanism starts with a fixed-point promise

HRM is a recursive latent-space model. Instead of writing out chain-of-thought tokens, it repeatedly updates a hidden state. Each segment takes the input and the current latent state, produces a new latent state, and eventually emits a prediction.

The practical attraction is obvious. If reasoning happens in latent space, the system can scale computation depth without generating long textual traces. That may save tokens, protect intermediate reasoning from leakage, and make small specialized models surprisingly capable on structured tasks.

The theoretical bargain is more delicate.

HRM uses deep supervision and a one-step gradient approximation. In simple terms, each segment receives a learning signal, but gradients do not need to flow through the entire long recurrent chain. That makes deeper recursion computationally feasible. The price is an assumption: once the model reaches a correct solution, further recursive updates should preserve it.

In fixed-point language, the model should eventually reach a latent state $z^\ast$ such that another application of the recurrent update leaves it effectively unchanged:

That equation is not decorative. It supports the idea that one-step gradient training can approximate the more expensive full recurrent training process. If the model reaches the right answer and then stays there, the later recursion is harmless. It becomes confirmation, not self-sabotage.

The paper’s first major move is to test whether this promise actually holds.

It does not always hold.

One blank cell exposes the wrong kind of confidence

The authors probe HRM with simplified Sudoku puzzles. These are not merely “easier examples” in a casual sense. They are constructed from complete Sudoku grids by masking only a row, or in the most revealing case, only one cell.

This test has a clear purpose: it is a fixed-point diagnostic, not a new benchmark. If HRM has learned stable solution states, a nearly solved puzzle should be a friendly environment. The correct answer is close. The model should fill it in and stop changing its mind.

Instead, the paper reports that HRM frequently reaches the right answer early and then drifts away after further segments. On these simple probes, it maintains stability only about 75% of the time. In more severe cases, it fails throughout even when just one token is missing.

That failure matters because it is not the kind of failure a normal accuracy table highlights. On the original Sudoku-Extreme distribution, the model may appear stable once it solves a hard puzzle. But that is a distribution-specific comfort. The model was trained on hard puzzles, so it learned a terminal behavior that works there. It did not necessarily learn the more general rule: if the answer is already correct, preserve it.

The paper’s explanation is not mystical. One-step gradient training encourages segments to solve hard puzzles in one step, because each detached segment is trained against the same final target. The model does not receive a well-controlled curriculum of partially solved intermediate states. Stability around near-solutions must emerge indirectly, late, and imperfectly.

A diffusion analogy helps: if a generative model only sees the noisiest inputs and the clean final target, it has a harder time learning the full denoising path. HRM, in this view, needs examples at multiple “difficulty levels” so that the recursion learns what to do near the answer, not only far away from it.

The fix is almost embarrassingly simple: data mixing. For each training puzzle, the authors create a simplified replicate by revealing a random portion of originally hidden tokens. This gives HRM explicit exposure to easier intermediate states.

The result is modest in headline accuracy but important mechanistically. Sudoku-Extreme exact accuracy rises from 55.0% to 59.9%. More importantly, the simple-puzzle failure and the post-solution drift are eliminated in the authors’ analysis. The intervention is not just a score booster. It repairs the fixed-point behavior that the model’s own training logic quietly required.

That distinction is the first business lesson. Some interventions are not valuable because they add a few points on a leaderboard. They are valuable because they repair a reliability assumption.

Average improvement hides per-sample guessing

The next part of the paper asks whether HRM’s recursive segments behave like gradual refinement.

At the average level, the answer looks reassuring. Across test samples, loss decreases as more segments are applied. This is the chart one would expect from recursive reasoning: more internal computation, lower error, better answer.

But averages have a long history of helping models look better dressed than they are.

When the authors inspect individual samples, the curve changes shape. Loss often drops quickly to a moderate level, then sits on a plateau for many segments, and then suddenly falls to zero in one or a few steps. In failure cases, it may never make the jump.

This is the paper’s “grokking along segments” observation. The model is not usually shaving off errors in a smooth sequence of tiny improvements. It hovers near a plausible region, then either snaps into the correct solution or stays wrong.

That behavior changes how we should interpret recursion. If each segment were doing deliberative refinement, then longer computation would mean a longer chain of useful intermediate work. But if most segments are spent near an attractor, waiting for a jump, the recursion is closer to repeated latent search. It gives the model more opportunities to land in a good state. That can work. It just should not be mistaken for step-by-step reasoning.

The distinction is not philosophical decoration. In operational systems, “thinking longer” is often sold as a reliability lever. This paper suggests a more careful question: does extra computation produce incremental evidence, or does it merely increase the number of attempts to hit a useful attractor?

Those are different engineering regimes.

False attractors explain why the model gets stuck

The paper then gives the latent-space story a visual and mechanistic shape.

By projecting HRM’s latent trajectories onto principal components, the authors classify four reasoning modes:

The interesting category is non-trivial failure. Here the model does not merely fail noisily. It converges. It settles. It becomes stable around the wrong answer.

That is worse than ordinary uncertainty. A wandering model at least looks confused. A model at a spurious fixed point looks internally satisfied.

The authors describe these misleading states as false attractors. Once HRM enters their neighborhood, leaving becomes difficult. In some non-trivial success cases, the model lingers near a false attractor and then makes a sudden orthogonal leap toward the true one. In non-trivial failure cases, the leap never happens.

This explains the “guessing” claim more precisely. HRM is not guessing in the sense of random output sampling. Its forward pass is deterministic. It is guessing in the sense that the initial trajectory commits to one basin of attraction. If that basin contains the correct fixed point, success looks like reasoning. If it contains a false fixed point, failure looks strangely confident.

The paper goes one step further by proposing a heuristic way to understand why false attractors can be sticky. For Sudoku, the authors define a label-agnostic conflict metric: count violations in rows, columns, and boxes. A correct Sudoku has no conflicts. Around rival attractors, the misleading point can appear as a shallow local minimum of this conflict-like metric. Moving from the false attractor toward the true one may require first increasing the heuristic error before eventually dropping to zero.

This is not a proof that HRM is literally optimizing that metric. The authors are careful on that point. But it is a useful analogy: if the model’s dynamics are attracted to locally plausible structures, it may lack the incentive to cross an “energy barrier” toward the globally correct answer.

In business terms, this is the kind of failure mode that makes single-output evaluation dangerous. A system may not be uncertain in the places where it is wrong. It may be locally coherent, internally stable, and still incorrect. The most expensive errors often wear a clean shirt.

The performance jump comes from scaling attempts, not adding wisdom

Once the paper frames HRM as fixed-point search, the proposed improvements become much easier to understand.

If the model often succeeds by reaching the right attractor, then accuracy should improve when we increase either the quality of attractors or the diversity of attempts. That is exactly what the authors test.

The most important number is 96.9%, but not because it is large. Large numbers are cheap entertainment unless the mechanism is clear.

The useful interpretation is that the three methods attack different parts of the same failure process.

Data mixing improves the quality of the model’s fixed-point behavior. It teaches the model not to wander away after it is already right. Input relabeling creates semantically equivalent Sudoku variants by changing token labels. Because HRM treats tokens as separate embeddings, the relabeled puzzle is not operationally identical to the original from the model’s perspective. It becomes another route through latent space. Model bootstrapping uses nearby training checkpoints as parameter-space perturbations. Ten checkpoints from later training, separated by around 1,000 steps, are sufficiently different that they solve different test samples.

The authors explicitly distinguish these techniques from ordinary pass@k sampling. In standard LLM generation, multiple passes are driven by next-token randomness. Here, the diversity comes from structured perturbations: equivalent inputs and nearby model parameters. The forward passes remain deterministic, but the path through latent space changes.

This is a cleaner reliability idea than “ask the model several times and hope democracy saves us.” Democracy is already having a difficult century. Better not outsource too much to it.

The Maze-Hard appendix is a robustness check, not a second thesis

The appendix matters because it tests whether the analysis is purely a Sudoku artifact.

On Maze-Hard, the authors find similar but simpler dynamics. Fixed-point violation appears in many failure cases. Spurious attractors also exist, though they are rarer and less central than in Sudoku. The successful maze trajectories are usually short: the model tends to find the solution early when it succeeds.

The augmentation results transfer directionally:

This appendix should be read as robustness and scope exploration. It supports the idea that fixed-point instability and perturbation-based inference improvements are not limited to Sudoku. It does not prove that every recursive latent reasoner is governed by the same attractor geometry.

The difference between Sudoku and Maze-Hard is also informative. Sudoku has richer combinatorial structure, and spurious attractors appear more consequential. Maze-Hard seems more dominated by final-stage instability. That means the diagnostic vocabulary travels, but the dominant failure mechanism may differ by task.

For deployment, that is exactly the right level of generalization. Do not copy the Sudoku intervention mechanically. Copy the diagnostic discipline.

What this changes for business AI evaluation

The paper directly studies HRM on Sudoku-Extreme and Maze-Hard. Cognaptus’ business reading is broader but bounded: recursive, agentic, and latent-reasoning systems should be evaluated not only by final accuracy, but by the stability and diversity of their internal solution paths.

Here are the practical translations.

For a business building an AI workflow, this suggests three test layers.

First, test monotonicity under simplification. If a system can solve a complex task, it should not become erratic when the task is partially solved. In document automation, that might mean testing complete forms versus almost-complete forms. In coding agents, it might mean testing a nearly fixed bug. In compliance workflows, it might mean testing obvious cases alongside borderline ones.

Second, test stability under additional computation. If the model reaches a correct answer at step 5, what happens at step 10? Does it preserve the answer, improve its justification, or drift? A reasoning system that cannot hold onto a correct state is not “more thoughtful.” It is indecisive with better hardware.

Third, test structured perturbation. Equivalent inputs should not radically change the answer unless the task itself is ambiguous. Relabeling Sudoku digits is the clean version. In business settings, analogues include reordering fields, changing harmless names, rotating presentation formats, or using semantically equivalent templates. If output quality changes sharply, the system may be relying on brittle attractor paths rather than robust task understanding.

The value is diagnosis before deployment, not poetic debates about reasoning

The title asks whether the model is reasoning or guessing. That question is rhetorically useful, but the operational answer is less dramatic.

A deployed system does not need to reason like a human to be valuable. It needs to fail in ways engineers can detect, bound, and repair. The paper’s real contribution is not that it embarrasses HRM by calling it a guesser. The contribution is that it turns “reasoning” into inspectable mechanics: fixed points, attractors, plateaus, perturbation routes, and stability tests.

That vocabulary matters for AI products.

When teams evaluate a model, they often ask: what is the benchmark accuracy? A better question is: what process produced the answer? Did the model gradually converge, jump after a plateau, stop too early, drift after success, or settle into a wrong stable state?

Those patterns determine what kind of safety wrapper helps.

If the problem is fixed-point instability, curriculum-like data mixing may help. If the problem is sensitivity to input representation, structured perturbation and voting may help. If checkpoints solve different samples, model bootstrapping may help. If the system has no stable signal that distinguishes true from false attractors, then adding more attempts may simply create a more expensive roulette table. Stylish, perhaps. Still roulette.

Boundaries: do not overgeneralize the Sudoku lesson

This paper’s evidence is strongest for HRM on Sudoku-Extreme, with supporting evidence on Maze-Hard. The authors also position their analysis as relevant to recursive models more broadly, but that broader claim remains a research direction, not a deployment law.

Three boundaries matter.

First, the study is mechanistic but task-specific. Sudoku is unusually structured, symbolic, and constraint-heavy. False attractors in Sudoku may be easier to visualize and interpret than false attractors in open-ended business reasoning.

Second, the interventions are not free. Augmented HRM reaches 96.9% on Sudoku-Extreme by combining data mixing, input relabeling, and checkpoint bootstrapping. That implies multiple forward passes and checkpoint management. In a production system, the ROI depends on task value, latency tolerance, and error cost.

Third, “guessing” should not be reduced to an insult. The model’s deterministic latent search is not random guessing. It is structured attractor selection. The point is not to shame the architecture. The point is to stop pretending that recursive depth automatically means deliberative reasoning.

That discipline makes the paper more useful, not less. The result is not “recursive models are bad.” The result is “recursive models need trajectory-aware evaluation.” Much less viral. Much more likely to survive contact with operations.

Conclusion: trust the path, not only the answer

HRM’s strongest lesson is not that it fails. All models fail. The interesting part is how.

It can solve hard puzzles, fail on simple probes, plateau for many segments, jump suddenly to the right answer, or converge confidently to a false fixed point. These behaviors make sense once we stop imagining recursion as a neat chain of reasoning steps and start seeing it as navigation through a latent landscape.

That shift changes the engineering playbook.

Do not only scale model size. Do not only scale reasoning depth. Scale diagnostic coverage. Test simplified cases. Check whether correct answers remain stable. Use symmetry-preserving perturbations. Preserve useful model diversity when the economics justify it. Treat multi-pass inference not as a magic accuracy button, but as a controlled way to explore alternative routes through the problem.

The romantic version says the model thinks longer and becomes wiser.

The useful version says the model searches for attractors, sometimes chooses badly, and can be helped by better training distributions and structured second chances.

As usual, the useful version is less flattering and more profitable.

Cognaptus: Automate the Present, Incubate the Future.