Source: Prime Intellect — 2026-08-05
Summary
Prime Intellect open-sourced Prime Agent, an MIT-licensed general-purpose coding harness built on two novel abstractions: a Recursive Language Model that treats context, tools, and sub-agents as variables inside a persistent IPython kernel instead of traditional tool-schema JSON, and a Continual Harness that lets the agent rewrite its own prompts, memory, and skills mid-task through a /refine command. With Opus 5, it reports 95.5% on ARC-AGI-3, edging past the reported human-expert baseline of 95.4%, with gains reported across other models compared to their proprietary harnesses too.
Key Takeaways
- The Recursive Language Model abstraction ditches the standard tool-schema-JSON approach entirely — instead, the agent treats its own context and sub-agent delegation as programmable objects inside a persistent IPython kernel, meaning it can write code to manipulate its own working memory directly.
- The Continual Harness treats the agent's prompts, sub-agents, skills, and memory as mutable state it can create, read, update, and delete from within its own trajectory — not fixed configuration set before the run starts.
- A
/refinecommand lets the agent update its own prompts, memory, and skills mid-task, based on what it's observed is and isn't working during the current run — self-modification without a separate training step. - On ARC-AGI-3, three runs scored 95.0%, 95.2%, and 95.5% (Best@3 of 99.97%, completing all 183/183 levels), edging past the reported 95.4% human-expert baseline — and the gains are reported to generalize across multiple models compared to their own proprietary harnesses, not just being ARC-AGI-3-specific.
- It's MIT-licensed and open source, meaning the full harness architecture is inspectable and reusable, not just a benchmark claim.
Reel Script
Hook: An open-source coding agent just beat the reported human-expert baseline on ARC-AGI-3 — and its core trick is that it can rewrite its own instructions in the middle of a task, without anyone retraining it.
Core Concept:
Most agent harnesses treat an agent's context, tools, and sub-agents as fixed configuration — you set them up before the run starts, and they don't change while the agent works. Prime Agent's architecture breaks that assumption in two connected ways. First, the Recursive Language Model idea: instead of the agent calling external tools through a rigid schema, it operates inside a persistent IPython kernel — think of that as a live coding notebook the agent never closes — and treats its own context, and even delegating work to sub-agents, as things it can manipulate with code, the same way you'd manipulate a variable. Second, the Continual Harness: the agent's prompts, memory, and skills aren't locked in at the start — they're state the agent itself can read and rewrite as it goes, through a command called /refine. So if the agent notices halfway through a task that its current approach isn't working, it can literally edit its own instructions and try again with the update in place, all within the same run.
Hands-On: The concrete result: on ARC-AGI-3, a benchmark specifically designed to be hard for pattern-matching without genuine reasoning, Prime Agent running on Opus 5 scored 95.5%, with a Best@3 across three runs of 99.97% and all 183 levels completed. The reported human-expert baseline on that same benchmark is 95.4% — meaning this harness reportedly edged past it. And notably, Prime Intellect says the improvement isn't just an ARC-AGI-3 quirk — they saw gains across multiple different models when swapped into this harness, compared to each model's own proprietary harness.
Takeaway: Letting an agent edit its own operating instructions mid-task, instead of treating the prompt as fixed, is the architectural idea worth internalizing here, benchmark score aside — it's a genuinely different design point from the "carefully engineer one static prompt" approach most teams still use. It's MIT-licensed and on GitHub, so go actually read the harness code before you take the benchmark number as gospel.