This paper from MIT puts actual numbers behind a feeling many people working with LLMs already have: most model failures are not knowledge failures, they’re first-draft failures. The paper studies Recursive Language Models (RLMs) and asks a very specific question: What happens if you let the same model revise its own output multiple times instead of scaling parameters? The answer is surprisingly concrete. Across reasoning-heavy benchmarks, the authors show that recursion consistently improves accuracy with no change in model size. On multi-step reasoning tasks, adding just 2–4 recursive passes improves correctness by 10–25%, depending on task complexity. On longer planning problems, error rates drop even more sharply, because early logical mistakes get corrected in later passes instead of propagating forward. One figure in the paper makes this especially clear. They plot task accuracy vs. recursion depth. The curve is steep at first: • Pass 1 → baseline performance • Pass 2 → large jump in correctness • Pass 3–4 → diminishing but still meaningful gains After ~4 iterations, returns taper off, which suggests something important: most reasoning failures happen early, and a small amount of structured revision fixes a large fraction of them. There’s also a cost comparison that’s hard to ignore. The authors compare: • A larger non-recursive model • A smaller recursive model using multiple passes The recursive model reaches comparable or better accuracy while using fewer parameters and fewer total tokens in the final answer. Even though recursion adds compute internally, the output length shrinks because later passes compress and clean up earlier drafts. In plain terms: the model thinks more, but talks less. Another quantitative result I found fascinating is hallucination reduction. The paper measures factual consistency across iterations and finds that later recursive passes explicitly remove unsupported claims introduced in earlier drafts. The probability of a hallucinated statement surviving to the final output drops significantly after the second pass, because the model is now evaluating its own content instead of blindly extending it. This directly challenges the “long chain-of-thought = better reasoning” assumption. The data suggests the opposite. Better reasoning comes from iterative self-correction, not from dumping more intermediate tokens. The recursion acts like an internal verifier that gradually aligns the output with constraints imposed by the task. There’s also a subtle systems insight hidden in the math. If accuracy improves roughly logarithmically with recursion depth but model size improves accuracy sublinearly with parameter count, then recursion is simply a more efficient lever. You get more reasoning per unit of compute by looping than by scaling. That’s a big deal for deployment. Instead of asking: “How big can we make the model?” This paper asks: “How many chances does the model get to be wrong before we trust it?” The broader implication is hard to miss. We’ve been benchmarking models on their first answer. But intelligence doesn’t live in the first answer. It lives in revision curves, error decay rates, and how quickly a system converges toward correctness when allowed to reflect. This paper doesn’t just propose a technique. It quietly suggests we’ve been measuring the wrong thing all along.