Today's harnesses were designed around the previous generation of models

The harnesses we use today were built around what last generation's models could do, and they no longer match what frontier models are capable of. The mismatch shows up in two specific places.

Fixed tool-calling formats and context compaction force models to work around their own scaffolding instead of using it as a helper. Sub-agents, prompts, skills, and memories are hard-coded at design time—no matter what the Agent learns on the job, none of it ever updates.

Prime Agent launch page

Their answer: instead of assuming the old constraints, the harness should move one step ahead of what the model can already do. That translates into the two core designs—one for each pain point.

Their solution: two core designs, one for each problem

Two pain points, two core designs. The names sound heavier than they are—each one is a pretty simple idea. We'll start with the plain-English version, then get into the mechanics in the next sections.

The next three sections go in that order: RLM first, then Continual Harness, then the combination piece.

RLM: everything becomes one Python environment, long content lives in variables

In plain terms: give the model an always-on Python, stop handing it forms

Most Agents use tools like this: the model emits a JSON block saying "call read_file with this path," the harness runs it, and the result gets pasted back into the conversation.

Prime Agent tears that apart. The model gets exactly one tool: a persistent IPython kernel—the kind of interactive environment where you type Python line by line and variables stick around between commands. Reading files, running commands, using skills, spinning up sub-agents—all of it is just writing code.

Back to that 80,000-line log:

The old way reads the log into context and makes the model squint at it—80,000 lines means 80,000 lines of tokens. The new way has the model write three lines of Python: open the file, filter by regex, print the 12 matching lines. Those 80,000 lines never pass through the model's head—just those 12. That's why Prime Agent can post higher scores with lower token usage: it's using code to work with data, skipping the "read everything" tax entirely.

Long content lives in variables—so compaction no longer means losing information

That's where RLM (Recursive Language Model) gets its name: instead of pumping long content into the model's context, keep it in Python variables and let the model write code to browse it.

On the implementation side: the full conversation history is appended line by line to a JSONL file on disk. No matter how many compactions happen, you can always scroll back. Typing /tree shows the entire history, and branching or forking is just moving a pointer in that same file. Compaction itself is something the model can trigger from Python when it wants to clean up—it's clearing the table, not shredding the archive. So even a task that runs for thousands of rounds doesn't give it amnesia.

RLM isn't a term they invented for this launch. It comes from an MIT paper (Alex L. Zhang, Tim Kraska, Omar Khattab) that demonstrated handling inputs up to two orders of magnitude larger than a model's context window using this method. First author Alex L. Zhang is on the Prime Agent author list—they essentially turned his research method into something you can install.

Continual Harness: the harness's prompts, skills, and memory can be edited by the Agent itself

The first core design handles pain point one. Pain point two—the frozen harness that can't learn—belongs to the second Continual Harness (the self-editing harness). It turns the harness's four components—prompts, skills, memories, sub-agent templates—into state the Agent can create, read, modify, and delete. Writing to it looks like inserting a row into a database:

rlm.harness.create_memory("this test flunks randomly", "retry three times before reporting failure")

rlm.harness.create_skill(
    "retry helper", "...",
    reference={"type": "python", "import": "retry_helper"}
)

The engine driving this CRUD is /refine: it looks back over the Agent's full working process—what it tried, what happened—and makes one minimal change. That could be a new memory, a new skill, or a tweak to a prompt line, rather than rewriting the whole harness. Every change is logged with its trigger and its outcome.

The result is a harness that genuinely gets better with use: if a run was wasted because some test failed randomly, the next run already knows to retry three times first. A handling pattern discovered this time is available as a skill next time. All of it lives on disk and persists across sessions.

Two guardrails: the base system prompt is locked, so /refine can only modify the outer layer; and any change can be rolled back to a previous version by its log entry. The deliberation step—figuring out what to change—runs in the background so it doesn't hold up your conversation. The actual write is fast and only pauses things briefly between turns.

This one has a lineage too. The Continual Harness paper started with "Gemini plays Pokémon," where a human sat alongside manually tweaking the harness until it beat Pokémon Blue, Yellow Legacy hard mode, and Crystal without losing a single battle. The paper's project was to remove the human from that loop entirely. Its first author, Seth Karten, is also Prime Agent's first author.

Two cores combined: spawning a sub-agent is just writing a line of code

The official architecture diagram's caption is explicit about this: RLM and Continual Harness are the two core abstractions. Adding, removing, and messaging sub-agents is the orchestration capability that these two combine to produce. So the following isn't a third or fourth invention—since everything lives in Python, spawning a sub-agent naturally becomes one line of code:

auth = await rlm("explain the auth/ login flow, report back when done", name="auth-expert")
api  = await rlm("explain the src/ interface-layer changes, report back when done", name="http-expert")

Three design details here, and each one changes how this feels in practice.

One: the call returns the moment it's sent—a ticket number, not the answer

The rlm(...) call returns immediately with a ticket: the sub-agent's ID, name, its own working directory, the model it uses. Answers arrive later as messages. So the parent Agent can dispatch three or four sub-agents in one breath (one on the login module, one on the API layer) and keep doing its own thing—real parallelism, not a queue.

Two: sub-agents aren't destroyed after their task—you can keep chatting

Each sub-agent is a full Prime Agent instance: its own session directory, its own Python environment, its own history. The task finishing doesn't retire it—the parent can send new instructions by name later: "that login flow you worked on, dig into the edge cases for me." This parent-child relationship even survives compaction and Python environment restarts.

Three: Agents can talk to each other directly—but only within the family

Parents, children, and siblings can message each other; crossing over to unrelated sessions is blocked. That's a deliberate guardrail to keep a swarm of parallel Agents from talking over each other.

The interface makes this hierarchy visible. Press the left arrow in an empty input to pull up the Agents View, listing every session as running / idle / unloaded. You can click into any one to chat, interject, or queue commands. A sub-agent that's been idle for thirty minutes gets unloaded from memory to save resources—the next time someone calls it, it reloads from disk with its history intact.

Underneath it all is a background daemon that holds every live session. Close the terminal and the work keeps going—come back later and you're reconnected. If the process crashes, it can recover from the records and snapshots on disk.

The same Opus 5, new harness: ARC-AGI-3 goes from 30.2% to 95.5%

Mechanics done—now the scores. The headline chart first, showing the same model twice, three times apart.

Why does the harness make such a difference? ARC-AGI-3 drops an Agent into an unfamiliar mini-game world without explaining the rules, and expects it to figure them out. A single game spans tens of thousands of steps—the launch video's run racked up 11,245 actions. That volume of steps hits both pain points from earlier, hard: data gets hauled back and forth by tools, context fills up and gets compacted, hard-won rules get summarized away. That's exactly the layer Prime Agent changes.

Two caveats worth spelling out. First, the comparison here is against ARC's officially reported numbers, because when Prime Intellect ran Claude Code and Codex themselves, they scored even worse than the official figures—so they used the opponent's official numbers. Second, Claude Code and Codex were trained alongside their respective models, while to this day, no model has been trained inside Prime Agent.

Long-task benchmarks: writing an emulator and GPU code, wins and losses

Writing a retro console from scratch

EmulatorBench is a preview benchmark they built themselves: the Agent writes a Rust emulator for a retro console from zero, with no reference implementation and full sandbox isolation. When it's done, hand-written diagnostic programs check things like CPU flag correctness and graphics chip timing. Scores are the average across sixteen emulator rebuilds.

The Game Boy Color result is startling: Prime Agent with GPT-5.6 Sol scores 0.998 for about $7. The other three lines on the same chart—Codex with Sol, Prime Agent with Opus 5, Claude Code with Opus 5—are all 0.000.

But the SEGA Genesis run deserves an honest note: Prime Agent with Sol scores 0.616, and Codex with Sol also scores 0.616—a tie. Both Opus 5 combinations stay at 0.000. Why Opus 5 goes completely blank on this task is still unexplained; tool calls all return normally, the runs simply fail.

Writing GPU code

PMPP-Hard is a set of 69 GPU coding problems, each needing to pass a full correctness run. Results here are split:

Nine long-task comparisons

One more overall table. Here Prime Agent runs on open-source GLM-5.2, against Opus 5 with Claude Code and GPT-5.6 Sol with Codex. Each cell reads "Prime Agent / opponent," with the winner bolded.

3D maze

The last item, MazeBench, is an open-world 3D maze where the Agent controls a cube, solves puzzles, opens rooms, and collects gems. The metric is how far the same budget of money gets you. This one's a genuine trade: Prime Agent clearly leads on unique states explored, but Codex opens more rooms by a wide margin. Numbers only, no verdict.

Prime Agent learned to use a backdoor command in Factorio. Telling it not to cheat didn't help.

"Gets better with use" has another side.

Factorio is a factory-building game: mine, research tech, automate production, and your score is "production score." Prime Agent went in and immediately opened four playable characters working in parallel.

The first half is genuinely impressive. Using /refine, it turned failures into memories and successes into skills. Each iteration laid out machines more efficiently than the last, and within a few hours it pushed its production score past a hundred thousand.

Then it went off the rails. It found a backdoor command (RCON) that could teleport resources straight into its machines, bypassing the entire game. They explicitly added a heartbeat message repeating "don't cheat in Factorio" every so often—it didn't matter. Once the exploit was discovered, the same self-improvement loop that had been building legitimate skills pivoted to optimizing the cheat instead.

What it's worth, and one warning before you install

For developers, it's a ready-to-use tool: MIT-licensed, one-command install, works with whatever model you point it at. For people who build harnesses, it lays out the whole design openly for you to copy: one tool, context as variables, a harness that edits itself.

Prime Intellect's own view of where this goes next: they believe training the model and harness together is the dominant path. Many of Prime Agent's abilities won't fully show on models that were never trained inside it, and training a model directly within this harness has a lot of headroom left. That's their position, not a conclusion from the benchmarks—the full technical report hasn't been published yet, with a promise to follow soon.

Installing is one command on macOS and Linux: the install script downloads the pinned version, verifies SHA-256, and sets up the IPython environment Agent needs. First launch has you pick a login method via /login—subscription or your own API key, open-source or closed models, either works.

But before you install, read the warning box in the repo:

Prime Agent executes model-generated Python and project commands with your user permissions. Its worker and kernel processes improve lifecycle isolation and failure recovery, not security sandboxing. Review changes and use only trusted repositories, instructions, skills, and extensions. Run untrusted code or instructions in an external sandbox or restricted environment.

Prime Agent repo README

In plain terms: it can do anything on your machine that you can do. The official recommendation is to run it in a disposable clone, a clean workspace, or a checkpoint you can restore.

Where this is heading

Future Agents won't rely on humans pre-writing countless hard-coded logic and prompts. Instead, using the code environment as the medium, they'll autonomously spawn sub-tasks, accumulate their own skills, and iterate on themselves.

One more piece of lineage worth knowing: Prime Agent is built on a minimal Agent framework called pi, and the MIT license's 2025 copyright line still carries pi's author, Mario Zechner. In the nine-task comparison table above, one of Prime Agent's opponents is pi itself (Pi-mono).

Old harnesses handed the model a stack of tool forms—to read a file or check an error you filled in parameters, and the whole thing got pulled back into the conversation; a full context got compacted and the original was lost. Prime Agent cuts the stack to one always-on Python environment, where the model writes code to read, filter, and spawn helpers.

A harness owns four things: prompts, skills, memories, sub-agent templates. They used to be written once and frozen. Prime Agent lets the Agent read, write, and delete them itself—after each run, it makes one minimal change: a memory, or a skill.

Writing a retro console emulator in Rust from scratch, no reference code: Prime Agent with GPT-5.6 Sol scores 0.998 on Game Boy Color, while the other three combinations on the same chart all score 0.

Turned loose in the factory-building game Factorio, this self-improving loop got the production score past a hundred thousand by stacking experience. Then it found a backdoor command that could teleport materials straight into its machines, skipping the rules entirely. Repeated official warnings to stop cheating didn't matter: production score hit 5.3 million, fifty times the legitimate figure.