Running two loops at different speeds — one for planning, one for details — lets a tiny AI model solve puzzles that trip up much larger ones.

This explores what makes the Hierarchical Reasoning Model's two-timescale recurrence different from ordinary recurrence that just reuses the same weights in a loop. The short version: hierarchical dual-recurrence runs two coupled loops at different speeds — a slow module that does abstract planning and a fast module that fills in the detailed computation — whereas flat parameter-sharing recurrence runs one loop that reuses the same weights over and over at a single speed. The payoff is computational depth. Can recurrent hierarchies achieve reasoning that transformers cannot? shows that coupling slow and fast timescales lets a 27M-parameter model solve Sudoku and mazes near-perfectly with only 1,000 training samples — tasks where chain-of-thought collapses — because the design escapes the fixed-depth ceiling (AC0/TC0) that limits ordinary transformers.

Why does the depth matter so much? A flat recurrent pass, even if you unroll it many times, tends to stay shallow in the kind of computation it can express. The interesting result is that this isn't just an engineering quirk — it touches a hard wall. Why does autoregressive generation fail at constraint satisfaction? shows autoregressive transformers fail at constraint satisfaction because they can't retract an emitted token, and Can reasoning models actually sustain long-chain reflection? finds frontier reasoning models stuck at 20-23% exact match on backtracking problems. Hierarchical recurrence is one attempt to add the iterative, revisable depth that flat single-pass generation lacks. It's worth knowing the limit of that ambition too: Do large language models actually perform iterative optimization? shows that latent iteration often degrades into memorized pattern-matching, so depth-on-paper doesn't automatically become genuine iteration.

The more surprising thread is that depth isn't the only axis you can scale. Can reasoning systems scale faster by exploring parallel paths instead? argues for going wider instead of only deeper — sampling several parallel latent trajectories rather than grinding one recurrent chain longer, which sidesteps the serial latency cost. And Does adding randomness alone improve recursive reasoning models? adds a sharp caveat: just bolting randomness onto a recursive model does nothing; the gains come from variational training that learns *where* to branch. So 'hierarchical' vs 'flat' is really one cut in a larger design space — slow/fast timescales, narrow/wide trajectories, directed/undirected branching.

There's also a quieter reframing worth carrying away: recurrence doesn't have to be about prediction at all. Can recurrence consolidate memory without predicting tokens? describes recurrent passes that run *without input tokens* to consolidate recent context into persistent fast weights, mirroring how the hippocampus replays memories during sleep. That separates 'looping' from 'predicting the next token' entirely — which suggests the slow module in a hierarchical design and a consolidation pass are cousins: both use recurrence to do something other than immediate output.

If you want the broader backdrop on why architecture is doing the heavy lifting here, Do neural networks naturally learn modular compositional structure? shows networks naturally split compositional tasks into isolated subnetworks — a hint that the slow/fast division of labor in dual-recurrence is formalizing something nets already reach for. The throughline across all of this: flat parameter-sharing recurrence reuses one mechanism at one rhythm, while hierarchical dual-recurrence buys effective depth by giving the model two rhythms — and that extra rhythm is what lets a tiny model do things much larger flat ones can't.