A new paper from MIT CSAIL just dropped a paradigm shift for long-context AI. Recursive Language Models (RLMs) achieved 91.33% accuracy on extreme-length tasks where direct prompting scored 0%. Zero percent. That’s not incremental improvement—that’s a different approach entirely.
Published December 31, 2025 on arXiv (2512.24601) by Alex L. Zhang, Tim Kraska, and Omar Khattab, the research tackles what every developer hitting context limits already knows: throwing more tokens at the problem isn’t sustainable. RLMs use recursive decomposition and verification instead of brute-force context windows.
This isn’t vaporware. The code is open source, the benchmarks are public, and Prime Intellect already published implementation details on January 1, 2026. Let’s unpack why this matters.
The Context Window Arms Race Hit a Wall
Every few months, a new model launches with a bigger context window. 32K tokens became 100K, then 200K, now we’re at 1M+ with Gemini. It feels like progress until you look at the actual performance curves.
Long-context models suffer from the “lost in the middle” problem—they forget information buried in massive prompts. Retrieval-Augmented Generation (RAG) helps but introduces its own failure modes when retrieval misses critical context. And both approaches scale costs linearly (or worse) with context length.
RLMs sidestep this entirely. Instead of jamming everything into one prompt, they break complex tasks into recursive subtasks, verify intermediate results, and build solutions compositionally. Think world models meets divide-and-conquer algorithms.
How Recursive Language Models Actually Work
The architecture has three core components: a proposer, a verifier, and recursive orchestration. Here’s the breakdown without the academic jargon.
The Proposer generates candidate solutions or decomposes problems into subproblems. It’s your standard LLM doing what LLMs do best—pattern matching and generation. But instead of trying to solve everything in one shot, it focuses on tractable pieces.
The Verifier is where RLMs diverge from standard approaches. It doesn’t just check syntax—it evaluates whether a proposed solution actually solves the subproblem. For code tasks, it runs tests. For reasoning tasks, it checks logical consistency. This creates a feedback loop that catches errors early instead of propagating them through a long chain.
Recursive Orchestration ties it together. When the proposer encounters a problem too complex for direct solution, it decomposes it into subproblems, solves those recursively, then combines verified results. This scales to arbitrary depth without hitting context limits because each recursive call operates on a focused subset.
The whole system mirrors how humans tackle complex problems—break it down, verify steps, build up solutions. Except it does this systematically at scale with mechanistic precision instead of intuition.
The Performance Numbers Are Ridiculous
Let’s talk benchmarks. The MIT team tested RLMs across four challenging datasets designed to stress-test long-context reasoning. The results aren’t subtle.
| Benchmark | Task Type | Context Length | Direct LLM | RLM |
|---|---|---|---|---|
| BrowseComp-Plus | Web navigation | 10M+ tokens | 0.00% | 91.33% |
| CodeQA | Repository QA | 100K-1M tokens | 24% | 62% |
| OOLONG | Order reasoning | Variable | 44% | 56.5% |
| OOLONG-Pairs | Pairwise order | Variable | 0.04 F1 | 58 F1 |
BrowseComp-Plus is the killer result. This benchmark requires navigating massive web-like structures with 10 million+ tokens of context. Direct prompting fails completely—0% accuracy. RLMs hit 91.33%. That’s not a marginal win; it’s solving a previously unsolvable class of problems.
CodeQA shows 2.7x improvement over direct approaches when answering questions about large codebases. OOLONG and OOLONG-Pairs test logical ordering across complex scenarios—RLMs win decisively on both. The F1 score jump from 0.04 to 58 on OOLONG-Pairs is particularly notable because it represents going from “basically random” to “actually useful.”
Prime Intellect’s implementation achieved 100x effective context extension compared to standard approaches. That means handling 100x more information without proportional degradation in quality. The full details are in their blog post and the arXiv paper.
RLMs vs RAG vs Long Context: Pick Your Poison
Three approaches exist for handling tasks beyond standard context windows. Each has trade-offs.
| Approach | Strengths | Weaknesses | Best For |
|---|---|---|---|
| Long Context | Simple, one-shot | Expensive, degrades with length, limited to ~1M tokens | Medium docs that fit in window |
| RAG | Efficient retrieval, scales to huge corpora | Retrieval failures, no reasoning across sources | Question-answering on static knowledge |
| RLMs | Handles extreme length, compositional reasoning, verifiable | Higher latency, more complex setup | Multi-step tasks requiring synthesis |
Long-context models are great when your task actually fits in the window and doesn’t require cross-referencing distant parts. RAG works well for retrieval-style tasks where you can identify relevant chunks independently. RLMs shine when you need to reason across massive contexts or build solutions compositionally.
Cost and latency matter. RLMs add 40-80% latency overhead due to recursive calls and verification. Queries cost around $0.99 on average in the benchmarks. That’s steep compared to a single API call, but trivial compared to manually solving the same problems—or compared to the cost of getting wrong answers from cheaper approaches.
The real question isn’t “which is best” but “which matches your task structure.” If you’re building agentic systems that need to decompose complex goals, RLMs are probably worth the overhead. If you’re doing simple lookup, RAG is fine. If you’re summarizing a 50K token document, long context works.
What RLMs Can’t Do (Yet)
Let’s be honest about limitations. RLMs aren’t magic and won’t replace every use of long-context models or RAG.
First, they’re slower. Recursive decomposition and verification add round trips. The 40-80% latency overhead is real and matters for latency-sensitive applications. If you need sub-second responses, RLMs probably aren’t it.
Second, they require good verifiers. The whole approach depends on accurately checking intermediate results. For well-defined tasks like code (where you can run tests) or math (where you can check proofs), this works great. For open-ended creative tasks with subjective quality metrics, verification is harder. The system is only as good as its ability to distinguish correct from incorrect subproblem solutions.
Third, setup complexity is higher than just calling an API. You need to define decomposition strategies, implement verifiers, and orchestrate the recursion. The open-source implementation helps, but it’s still more infrastructure than “paste text, get answer.”
Finally, cost scales with problem complexity. Simple tasks that don’t benefit from decomposition will pay the recursion overhead without gaining accuracy. RLMs are for genuinely hard problems, not everyday queries.
Getting Started With RLMs
The good news: you can experiment today. MIT and Prime Intellect both released open-source implementations.
- MIT’s reference implementation: github.com/alexzhang13/rlm
- Prime Intellect’s verifiers: github.com/PrimeIntellect-ai/verifiers
- Research paper: arXiv:2512.24601 for theoretical foundations
- Implementation guide: Prime Intellect’s blog post walks through practical setup
Start with a well-defined domain where you can write good verifiers. Code repositories are ideal because you can use existing test suites. Multi-step reasoning tasks with checkable intermediate steps also work well. Avoid open-ended creative tasks until you figure out robust verification strategies.
The architecture pairs well with advances in efficient model architectures. If you can reduce per-call costs through better base models, the recursion overhead becomes more palatable.
Why This Matters Beyond Benchmarks
RLMs represent a shift from “bigger models with more context” to “smarter orchestration of existing capabilities.” That’s important because it suggests scaling intelligence doesn’t require scaling context windows to infinity.
The verification component creates natural checkpoints for reliability. Instead of hoping a 1M token prompt produces correct output, you verify correctness at each step. This makes RLMs more suitable for high-stakes applications where wrong answers have real consequences.
The compositionality enables tackling problems that are genuinely too large for any single context window. When you can extend context 100x through recursion, you unlock new problem classes—analyzing entire codebases, reasoning over book-length documents, navigating massive knowledge graphs.
And critically, it’s open. The code is public, the benchmarks are reproducible, and the approach is model-agnostic. You can build on this without waiting for API providers to add features.
The 91.33% vs 0% result on BrowseComp-Plus isn’t just a benchmark improvement. It’s proof that recursive decomposition with verification solves problems direct prompting cannot. That’s the kind of result that changes how we build systems.
Get the Daily Pulse
Sharp analysis on what's actually moving in AI. No hype, no filler, no weekly digest.
