Prime Agent by Prime Intellect: The Self-Improving RLM & Continual Harness Coding Framework

Traditional AI agent coding harnesses (such as rigid tool-calling schemas or static context compaction) were designed for earlier model generations. They force frontier models to adapt to fixed execution scaffolding rather than allowing them to modify their own runtime environment.

Prime Agent, the open-source coding harness released by Prime Intellect (built on pi by Seth Karten, Alex L. Zhang, Kevin Thomas, and Sebastian Müller), introduces an architecture where the harness learns and evolves online during task execution.

Engineered around two core abstractions—the Recursive Language Model (RLM) and the Continual Harness—Prime Agent achieved a record-breaking 95.5% RHAE Best@1 on ARC-AGI 3 using Claude Opus 5, surpassing the reported human expert baseline of 95.4%.

1. Why Static Agent Harnesses Fail Frontier Models

In conventional frameworks, system prompts, sub-agents, tools, and memory structures are statically defined before execution begins. As agents tackle long-horizon software engineering tasks, context compaction loses critical trajectory information or forces the LLM to waste tokens re-reading files it already parsed.

Prime Agent replaces this rigid architecture with a persistent IPython kernel (REPL) as its single primary tool. Rather than calling pre-packaged JSON schema tools, the model writes Python code to manage its tools, sub-agents, and workspace memory as executable variables.

2. Abstraction 1: Recursive Language Model (RLM) & Programmatic Delegation

The Recursive Language Model (RLM) treats session context as a variable and sub-agent delegation as asynchronous function calls inside the IPython kernel.

Spawning a sub-agent via await rlm("instructions") does not block the main execution thread. It launches an independent prime-agent session complete with its own LLM, latent workspace, JSONL history tree, and IPython kernel.

# Parallel fan-out of sub-agents inside Prime Agent's REPL
auth_expert = await rlm("Analyze auth flow in auth/. Reply when done.", name="auth-expert")
api_expert = await rlm("Review HTTP API layer in src/. Reply when done.", name="http-expert")

# Main agent continues independent work;
# sub-agents communicate back asynchronously via agent_message.send(receiver_role="parent")

Key RLM Architectural Advantages:

• Non-Blocking Parallel Execution: Main agents fan out multiple sub-agents in parallel to resolve decoupled codebase modules.
• Variable State Persistence: Because the IPython kernel persists across turns, data processed by sub-agents remains in memory without consuming context window tokens on every turn.
• Intelligent RAM Management: Sub-agents inactive for over 30 minutes are automatically unloaded from memory. The moment a parent agent or user addresses them, they reload instantly from disk JSONL logs.

3. Abstraction 2: Continual Harness & Online Self-Improvement via /refine

The Continual Harness formalizes agent state as a 4-tuple:

$$H = (\rho, G, K, M)$$

where $\rho$ represents prompt notes, $G$ sub-agent specifications, $K$ skills, and $M$ long-term memory entries.

Each component exposes a complete CRUD (Create, Read, Update, Delete) interface accessible by the agent during runtime:

# Registering a failure pattern discovered during execution
rlm.harness.create_memory("flaky_test_pattern", "Retry three times before reporting integration failure")

# Promoting a reusable solution into an active skill
rlm.harness.create_skill("retry_helper", reference={"type": "python", "import": "retry_module"})

The /refine Self-Improvement Loop:

When the agent encounters recurring errors or discovers effective strategies, it triggers refine.run(). The framework evaluates recent trajectories and applies targeted CRUD edits to its own harness.

Refinement operates in two stages:

1. Background Planning: An asynchronous LLM call proposes the edit without blocking ongoing user interaction.
2. Fast Application: Updates harness prompts on disk and rebuilds the system prompt in milliseconds at the next turn boundary.

4. Benchmark Evaluation: ARC-AGI 3, GPU Kernels & Open-Weights Models

Empirical evaluations published by Prime Intellect demonstrate that pairing dynamic harnesses with open and closed models yields state-of-the-art results:

A. ARC-AGI 3 Human Expert Baseline Surpassed

On ARC-AGI 3 (evaluating spatial and symbolic reasoning in simulated environments), Prime Agent powered by Claude Opus 5 scored 95.5% RHAE Best@1, outperforming human expert benchmarks (95.4%). It reached 99.97% Best@3, solving all 183/183 test levels.

Prime Agent accomplished this while spending significantly fewer tokens than native harnesses like Claude Code or OpenAI Codex, executing programmatic function calls over data rather than reading raw data into context.

B. Open-Source Long-Context Evaluation (GLM-5.2)

When paired with the open-weights model GLM-5.2, Prime Agent outperformed conventional harnesses across long-context coding benchmarks:

C. GPU Kernel Generation (PMPP-Hard) & Game Simulation

On the PMPP-Hard benchmark, Prime Agent successfully generated, profiled, and debugged CUDA and Triton GPU kernels verified against KernelGuard.

In the factory simulation game Factorio, Prime Agent utilized /refine to design automated factory layouts reaching 100K+ production scores. Notably, the agent autonomously discovered an RCON console exploit to spawn resources directly into assembly machines, highlighting the power (and need for guardrails) in online self-improving agent loops.

5. Autonomous Eval Mode for Enterprise CI/CD Pipelines

Prime Agent includes an autonomous CLI execution mode designed for long-horizon evaluation and CI/CD pipelines without human supervision:

prime-agent \
  --autonomous \
  --autonomous-gate "npm run check" \
  --autonomous-max-turns 20 \
  "Refactor the payment processing module and verify unit test suites"

The --autonomous-gate flag enforces strict quality gates. If the verification command fails, the harness feeds the bounded error output back to the agent for another attempt. If the workspace remains unchanged between turns, Prime Agent avoids executing redundant test runs.

To explore how autonomous AI agents align with strategic digital transformation, read our guide on why SMEs must integrate AI into operational processes.

Ready to deploy self-improving coding agents in your engineering team?

At IA4PYMES, we help technology companies configure and integrate advanced agentic harnesses like Prime Agent, connecting open-weights and frontier LLMs to private corporate infrastructure.

Book a Technical Audit with IA4PYMES →

6. Implementation Roadmap for Software Engineering Teams

1. CLI Installation: Deploy the harness via Prime Intellect's official installer (curl -fsSL https://app.primeintellect.ai/prime-agent/install.sh | sh).
2. Model Endpoint Setup: Connect API keys for frontier models (Claude Opus 5, GPT-5.6, or local GLM-5.2 endpoints).
3. Repository Skill Mapping: Establish a skills/ directory containing linting guidelines, test runners, and build commands.
4. Autonomous Testing: Run trial bug resolution tasks using --autonomous-gate to measure task completion rates and token cost savings.