The Next Wave of AI Progress Might Not Come From Bigger Models

A tiny 27-million-parameter model is outperforming systems 1000x its size on certain reasoning tasks. Here’s what that means.

For the last few years, the AI industry has operated on one core belief:

Make the model bigger, and it gets smarter.

More parameters. More data. More compute. More tokens. Bigger everything.

That bet has paid off enormously. It gave us today’s large language models, systems that can write, code, translate, and reason at a level that would have seemed implausible five years ago.

But a quieter question is gaining traction in AI research:

What if better reasoning doesn’t require a bigger model? What if it requires a model that thinks in loops?

That idea is called recursion, and it may be one of the more important concepts in the next phase of AI.

First, What Is Recursion?

In plain terms: doing something repeatedly, using the result of each step to improve the next.

Think about solving a Sudoku puzzle. You don’t look at the board once and immediately know every answer. You make one small deduction. That changes what you know. You make another. Slowly, the solution emerges.

That is the intuition behind recursive reasoning models.

Instead of asking a model to solve a problem in a single forward pass, you let it refine its answer across multiple steps, updating an internal “mental workspace” each time, before committing to an output.

That distinction turns out to matter a lot.

Why Standard LLMs Struggle With Certain Problems

Large language models are powerful, but they are fundamentally built around next-token prediction. They generate one token after another based on patterns learned from training data.

When we ask an LLM to reason step-by-step, it does so in text. The model “thinks” by writing out its thought process in the visible output stream. For many tasks, this works well.

But some problems resist that structure. Sorting algorithms, maze navigation, abstract pattern matching, and constraint-satisfaction puzzles require repeated updates, memory, and refinement. A single forward pass through billions of parameters isn’t always the right tool for that job.

What these problems often need is something closer to a scratchpad: a place to revise, not just a place to respond.

This is where recursive models come in.

A 27-Million-Parameter Model That Outperforms Much Larger Systems

The Hierarchical Reasoning Model (HRM) is one example worth looking at closely.

HRM uses two small recurrent modules: one for fast, lower-level computation; one for slower, higher-level planning. Instead of storing knowledge in hundreds of billions of parameters, it applies the same compact modules repeatedly, in nested loops of refinement.

The numbers are striking.

HRM achieves strong performance on difficult reasoning benchmarks with only 27 million parameters and roughly 1,000 training examples.

For context: leading frontier models have tens to hundreds of billions of parameters and are trained on datasets orders of magnitude larger.

The takeaway is not that HRM replaces those models. It is task-specific, not a general assistant. The takeaway is something more fundamental: a small model that can refine its internal state repeatedly may solve certain reasoning problems more efficiently than a much larger model answering in one shot.

Going Even Smaller: 7 Million Parameters, Real Results

The Tiny Recursive Model (TRM) pushes this logic further.

TRM simplifies HRM’s architecture down to a single recursive design that iteratively updates two things: an internal reasoning state, and the model’s proposed answer. Each loop brings the answer closer.

With only 7 million parameters, TRM reports:

• 45% accuracy on ARC-AGI-1
• 8% accuracy on ARC-AGI-2

Both figures outperform many models dramatically larger in size.

ARC-AGI is a benchmark specifically designed to test abstract reasoning, the kind of pattern recognition and generalization that standard deep learning struggles with. Doing well on it at this parameter count is not a parlor trick. It suggests something real about what recursion enables.

The Key Distinction: Reasoning in Words vs. Reasoning in State

Chain-of-thought prompting, where you ask a model to “think step by step,” is already widely used. But it is not the same thing as recursive reasoning.

Chain-of-thought asks a model to reason through words. The logic happens in the visible output stream, token by token.

Recursive reasoning asks a model to reason through internal state. The refinement happens in a private workspace before the model produces any output at all.

It is the difference between a person who talks through their thinking out loud and a person who silently works something through before speaking.

Both can arrive at good answers. But they are doing something structurally different, and for hard reasoning tasks, the internal refinement loop appears to have a meaningful edge.

What This Points Toward

If this line of research continues to develop, the next wave of AI progress may not look like another step-change in model size. It may look more like architectural sophistication: combining what large models are already good at with what small recursive modules do unusually well.

Large models excel at building rich representations from language, code, and images. They carry an enormous amount of world knowledge.

But reasoning inside those representations is still an open problem.

Recursive modules suggest one path forward, not as replacements for large models, but as complements. Future systems may pair the representation power of frontier models with lightweight recursive reasoning that refines answers before committing to them.

The old scaling equation was roughly:

More data + more parameters + more compute = better AI

The emerging one may look more like:

Better architecture + repeated refinement + intelligent memory = better reasoning

Where This Gets Interesting for Multi-Agent Systems

Most of the recursion research today focuses on a single model refining its own internal state.

But what happens when you extend that idea across multiple agents?

Today, most multi-agent systems communicate through text. One agent writes a plan, another critiques it, another executes it. That workflow has real value, but it is slow and token-heavy. Every intermediate thought has to be serialized into words before it can be passed to the next agent.

The next frontier may be agents that collaborate more like recursive systems: refining shared internal representations, passing compact state between modules, and only surfacing text when it is actually needed for output.

If HRM and TRM are about giving a single model better internal loops, RecursiveMAS is about giving multi-agent systems better collaborative loops.

That is the direction we are exploring at Contextus. The core question behind RecursiveMAS: instead of treating multi-agent collaboration as a long chat log, can agents reason together through recursive state updates, with less token overhead and more structured coordination?

Worth being clear about the constraints. True RecursiveMAS-style collaboration requires trained RecursiveLink modules and access to model hidden states, which most managed APIs do not currently expose. That makes it a research direction rather than a deployed feature today. What is available now is recursive context compilation: assembling and refining the right context before an agent acts, rather than passing everything and hoping.

The longer-term goal is the full loop. Not just better reasoning inside one model, but better reasoning across agent systems, with recursive state, shared memory, and fewer tokens spent narrating intermediate steps.

That is where I think the field is heading, and it is the problem worth building toward.

We are exploring this direction through Contextus, where the goal is to make recursive agent workflows cheaper, safer, and more observable, from recursive context compilation today to RecursiveMAS-style agent collaboration in lab mode. coreledger.ca

By Kelvin Musodza | Coreledger Tech.