The story is not that a half-billion-parameter language model solves a reasoning benchmark. It is that it does so by reusing the same weight block in a loop, without generating intermediate textual reasoning, and with a trainable parameter budget of only six million. The research team took Qwen2.5-0.5B-Instruct, split it into a Prelude, a weight-tied Recurrent Block, and a Coda, and introduced an identity-preserving one-loop path with a re-entry bridge on later loops. At loop 1 the retrofit remains non-inferior to its base on a preregistered ARC battery.

The first finding is that the installed mechanism is a reusable procedure rather than terminal-answer lookup. It works at two parameter budgets: six million trained parameters over frozen base weights and 180 million for the full block. With intermediate-step supervision, the model computes one task step per loop and persists when only final answers are graded. The adapter matched the full block overall (83.8% versus 84.0%), led through depth 11, and trailed beyond. Verbal fine-tuning reached 79-86% on controlled verbal renderings, with minimal zero-shot transfer. But when adapter verbal training started from the installed mechanism, it outpaced matched fresh training by 18.6 points, including on a held-out test set.

The second finding concerns extrapolation: the model extends depth to roughly 1.5 times its supervised depth, holding 70% accuracy through depth 18. The comparison with a same-size scratchpad-trained model is instructive. Within the learned horizon the two match, but beyond that limit the scratchpad model collapses. The recurrent model wins overall 84% versus 72%, retains 53% versus 2.5% beyond depth 10, and answers 7.6 times faster. There is a structural difference here: reasoning happens in latent space, not by generating intermediate tokens. For anyone managing on-premise or self-hosted inference, this shifts computational cost from generated tokens to internal model steps, with potential effects on latency and memory that must be measured case by case. AI-RADAR offers analytical frameworks at /llm-onpremise to evaluate these trade-offs.

The third finding, however, is the most interesting. A second task, running the rule in reverse, exposed the limits. The inverse was learnable in isolation, but no continuation acquired it while preserving the installed mechanism and general capability. This is a catastrophic-interference boundary. It means the recurrent retrofit is not a generic module that can be extended at will: the installation is task-specific, and transfer to related but inverse tasks can destroy what already works.

The open question is learned depth selection. The model does not learn by itself when to stop, and this has concrete implications. An on-premise deployment that wants to exploit iterative latent reasoning must today fix a number of loops, with the risk of using too much or too little compute. The weight-tied architecture reduces the number of unique parameters to keep in memory, but it does not solve the problem of deciding the optimal depth for each input. The road to models that reason in loops is open, but the boundary shown by the inverse task suggests that robustness does not come for free.