A tiny network that re-runs its own thinking just beat AI models a thousand times its size.

This explores whether recursion — looping a small network over its own reasoning state — can outperform billion-parameter models on hard puzzles, and the corpus says yes, with a sharp caveat about *why*. The headline result is a 7-million-parameter, two-layer network that recurses on its latent reasoning state and reaches 45% on ARC-AGI-1, beating LLMs thousands of times larger Can tiny recursive networks outperform massive language models?. The crucial finding isn't "small is fine" — it's that the gain comes from recursion itself, not from scale or even hierarchical structure. A related hierarchical model couples slow planning with fast computation across two timescales and nails Sudoku and mazes where chain-of-thought collapses entirely, escaping a depth ceiling that fixed-depth transformers provably can't cross with only 27M parameters Can recurrent hierarchies achieve reasoning that transformers cannot?.

The deeper mechanism is *iterated depth*. Looping a model's layers back on themselves lets it track state and compose steps in ways that simply adding more parameters cannot — recursion gives you effective computational depth, and convergence signals even tell the model when to stop Can models learn by looping instead of growing larger?. This reframes the question: hard puzzles aren't bottlenecked by how much a model knows, but by how many sequential reasoning steps it can actually execute. That's also why depth tends to beat width even in conventional small models — stacking layers to compose abstract concepts outperforms spreading the same parameters sideways Does depth matter more than width for tiny language models?.

What's striking is the *opposing* evidence about big models on these same problems. Large LLMs don't iterate in latent space at all — they pattern-match optimization problems to memorized templates and emit plausible-but-wrong answers, a failure that doesn't go away with scale Do large language models actually perform iterative optimization?. And on genuine constrained-optimization tasks they plateau around 55–60% regardless of parameter count or architecture, suggesting a ceiling rather than a scaling gap Do larger language models solve constrained optimization better?. So the tiny recursive network isn't just cheaper — it's doing a *kind* of computation the giants structurally skip.

A word of caution the corpus volunteers: don't mistake the moving part. Naively bolting randomness onto a recursive model yields nothing; the gains in stochastic recursive reasoning come specifically from a principled variational training objective, not from noise Does adding randomness alone improve recursive reasoning models?. The same lesson echoes elsewhere — small models match large ones when the *training regime* carries the reasoning, whether that's verifiable-reasoning post-training pipelines at 3B parameters Can small models match frontier reasoning without massive scale? or preference-trained small models matching big ones on structured tasks Can small models match large models on function calling?.

The thing you might not have known you wanted to know: the win is bounded to problems with checkable structure — puzzles, grids, verifiable tasks where iterating actually converges on a right answer. Recursion buys you reasoning *depth*, but it doesn't buy you the broad world-knowledge that scale provides. The tiny network beats the giant precisely where the problem rewards thinking longer over knowing more.