A Counterintuitive Fact
You might think the bottleneck for coding agents like Claude Code and Codex is model capability. It isn't. It's the context window burning money.
When an agent works autonomously in a large codebase—reading dozens of files, searching, editing, searching again—its context balloons every turn. Each additional token raises inference cost linearly, while model performance actually degrades. This phenomenon has a name: context rot.
The Prime Intellect team put it bluntly in their January 2026 research blog: per-token cost grows linearly with context length, while model capability declines with context length. One curve rises, the other falls—the crossover point is the death line for agent economics.
Prime Agent is their answer—an open-source coding agent that gained 2,271 GitHub stars in a single day, built around a core abstraction called Recursive Language Model (RLM).
RLM: Treat Context as Variables, Sub-Agents as Functions
RLM's core idea in one sentence:
> Don't have one LLM swallow all the context. Let it manage context as variables in a Python REPL and call sub-LLMs as functions.
Traditional agents work like this: everything goes into the prompt → the LLM reasons → output. Context grows monotonically, irreversibly.
RLM works differently. The LLM gets a persistent IPython environment and can:
- Store large PDFs, datasets, and videos in Python variables without loading them into context, retrieving them with code when needed
- Call
rlm(...)to spawn sub-agents, delegating tasks; results come back programmatically (not as natural-language summaries) - Let sub-agents spawn their own sub-agents, forming a recursive call stack
- The base system prompt is immutable—
/refinenever rewrites it - Every update has a snapshot, supporting rollback
- Updates must be evidence-backed, never invented
- The total token budget?
- Dependencies between sub-agents?
- Timeouts when one sub-agent hangs the whole tree?
- GitHub: https://github.com/PrimeIntellect-ai/prime-agent
- RLM blog: https://www.primeintellect.ai/blog/rlm
- RLM paper: https://arxiv.org/abs/2512.24601
- Continual Harness paper: https://arxiv.org/abs/2605.09998
This is not filesystem-style external memory (like Claude Code's summarization). It's the model actively managing its own context window. The difference: external-file schemes are "use it and forget it"; RLM lets the model decide when to forget and when to recall.
Why This Is More Than an Engineering Optimization
A key judgment from Prime Intellect's blog:
> "teaching models to manage their own context end-to-end through reinforcement learning will be the next major breakthrough, enabling agents to solve long-horizon tasks spanning weeks to months."
The weight of this statement: they aren't building better scaffolding—they're training the model to learn scaffolding itself.
The core insight of the RLM paper (arXiv:2512.24601, Alex Zhang, October 2025): instead of writing increasingly complex context-management logic outside the model (summarization, compression, retrieval), let the model learn through RL when to delegate, when to fold context, and when to call sub-agents.
This follows Sutton's "Bitter Lesson": hand-crafted scaffolding is the short-term answer; learning to scaffold yourself is the long-term one.
Continual Harness: Letting Agents Accumulate Experience
Prime Agent's second core abstraction is the Continual Harness. The problem it solves:
> Agents start every new session from zero and never accumulate experience.
Continual Harness stores supplemental prompts, memories, skill descriptions, and sub-agent specifications as durable state. The agent can improve its own trajectory in small steps via a /refine command—evidence-backed updates, not arbitrary rewrites.
Key design constraints:
This suggests an analogy: Continual Harness is git commits for agents. The base prompt is the main branch—no direct pushes; supplemental state is a feature branch, each refine is a commit, with diffs, history, and the ability to revert.
Why Prime Agent Gained 2,271 Stars in a Day
Three reasons stack up:
1. The novelty of the RLM paradigm: not better scaffolding, but training models to scaffold themselves. A paradigm-level bet. 2. Engineering completeness: daemon-backed sessions (survive disconnects), agent-to-agent communication (without routing through the user), heartbeat/schedule (timed wake-ups), autonomous mode (unattended runs). Not a demo—a production tool for long tasks. 3. Timing: in August 2026, the coding-agent market had reached a consensus that "context rot is the #1 bottleneck." Prime Agent answers that consensus directly.
A Question Worth Thinking Hard About
RLM's recursive call stack means an agent can spawn sub-agents, which spawn grandchild agents. Each level has its own context window. This is isomorphic to an OS process tree—init spawns services, services spawn workers, workers spawn ephemeral tasks.
But operating systems have schedulers, resource limits, and permission isolation. RLM agent trees currently have none of these.
When agents can recursively spawn sub-agents without limit, who manages:
Prime Agent leaves these questions to Continual Harness's /refine mechanism—letting the agent learn to manage them itself. But that "learning" requires substantial RL training—and where does the training data come from?
This is the open question of the RLM paradigm, and the focus of Prime Intellect's next research phase.
Links
One-line takeaway: Prime Agent isn't just a better coding agent—it's a bet that LLM's next breakthrough is "learning to manage its own context," not "a bigger context window."