ARC-AGI-3 From 30% to 95.5% With One Harness — What Prime Agent Actually Does

Prime Agent, from PrimeIntellect, landed on arXiv yesterday. It's an open-source harness for long-horizon agent evaluation and coding workflows. The headline number—ARC-AGI-3 RHAE Best@1 from 30% to 95.5%—sounds like a benchmark hack or a model improvement. It's neither. It's an architectural claim about what happens when you stop treating the model as the whole system.

ARC-AGI-3 is the hardest public reasoning benchmark. The RHAE metric measures raw attempts, not cores solved—so 95.5% means the harness improves the model's hit rate at generating correct solutions by over 3x just by changing how it lets the model think. The model weight is the same. What changed is the scaffolding around it.

---

The Architecture: Three Layers, No Fluff

Prime Agent's design is the story. Three abstractions, each solving a distinct failure mode in existing agent frameworks:

graph TD
  subgraph "Prime Agent Architecture"
    A[Model] --> B[RLM Abstraction]
    B --> C[Persistent IPython REPL]
    B --> D[Continual Harness]
    C --> E[Programmatic context
+ test-time compute]
    D --> F[History • Memories
Skills • Prompts • Subagents]
    F --> G[Agent-to-Agent
Communication]
    E --> H[Recovery • Verification
Resource Accounting]
  end
  style A fill:#a78bfa,stroke:#a78bfa,color:#0a0a0b
  style B fill:#27272a,stroke:#52525b
  style H fill:#27272a,stroke:#22c55e

Layer 1 — Recursive Language Model (RLM) Abstraction. The core idea: a persistent IPython REPL that lives across turns. Instead of dumping everything into a growing context window and praying the model can attend to it, Prime Agent gives the model a programmatic scratchpad. Variables persist. State accumulates. Computation happens inside the REPL, not inside the attention pattern. This is the Piffer thesis taken seriously—augmented symbolic working memory as infrastructure, not accident.

Layer 2 — Continual Harness. Histories, memories, skills, prompts, and subagent specifications survive across trajectories. The harness doesn't reset on every task. When the model discovers a useful pattern, it gets captured and reused. This is not chain-of-thought. It's chain-of-experience.

Layer 3 — Subagent Mesh. Recursive subagents coordinate through direct agent-to-agent communication. An Agents View lets humans inspect and manage daemon-backed sessions. In the Factorio experiments, this meant dedicated subagents for parallel resource refinement while the main agent managed technology progression.

The Numbers That Matter

ARC-AGI-3 RHAE Best@1 is the flagship metric, but the paper's evaluation is broader:

• ARC-AGI-3 RHAE Best@1: 30% → 95.5% (3.2x improvement over the same model without the harness)
• Long-context coding: matches or exceeds native and popular harnesses (LangChain, CrewAI, AutoGen baselines)
• GPU-kernel generation: structurally more correct outputs under the same model
• Emulator construction: completed tasks that failed under other harnesses due to state loss between turns
• nanoGPT speedruns: autonomous training runs with fewer wasted iterations
• Factorio: continuous technology progression via refinement, parallelized subagent work

The across-the-board improvement is suspicious until you read the architecture. Most harnesses are thin wrappers—a tool schema, a loop, a prompt template. Prime Agent is a computational environment. The model doesn't just generate text into a conversation; it operates inside a persistent runtime that preserves state, manages resources, and enforces recovery. The harness failures that become model failures in other systems—lost context, resource leaks, state corruption—are structurally impossible here.

The Subagent Coordination Pattern That Actually Works

Factorio is the most illustrative test case. Building and managing a Factorio factory requires parallel resource flows, sequential tech unlocks, and spatial reasoning about layout. Prime Agent's approach:

1. A main agent manages technology progression—what to research next, in what order, based on current resources
2. Dedicated subagents handle specific resource chains—iron, copper, oil—each running in their own REPL with their own state
3. Subagents communicate their outputs directly to each other (not through the context window)
4. The main agent consumes summaries, not raw logs

This is genuinely different from the "all agents dump everything into the same chat" pattern that causes the diversity collapse described in the Interaction Tax paper (also on today's arXiv). By limiting inter-agent communication to structured summaries rather than full outputs, Prime Agent avoids the failure mode where agents converge on the first solution they see.

Limitations

• Infrastructure complexity: Prime Agent requires daemon-backed sessions, a persistent runtime, and resource accounting. It's not a pip-install-and-go harness. The overhead is justified for long-horizon tasks but excessive for simple Q&A or single-turn coding.
• Evaluation scope: the ARC-AGI-3 result, while dramatic, is on a single benchmark with consistent framing. It's not clear the 3.2x multiplier holds across all reasoning tasks. The paper's other evaluations show parity or marginal improvement, not the same jump.
• Model-dependent gains: the harness improves every model tested, but the improvement magnitude varies. Weaker models benefit more from the scaffolding, which may indicate that the harness compensates for reasoning gaps rather than amplifying genuine capability.
• Subagent coordination is hand-designed: the Factorio workflow was configured, not discovered. The paper doesn't demonstrate that agents autonomously develop this coordination pattern—it was engineered into the task configuration.

Why This Matters for People Building Agents Today

Prime Agent's core insight is something every practitioner has felt but hasn't named: the harness is the bottleneck, not the model.

Every time an agent loses state between turns, every time context overflow trashes a useful intermediate result, every time a tool call fails and the model doesn't recover gracefully—that's a harness failure that gets attributed to model capability. The standard fix is to switch to a better model or add more context. Prime Agent says: build a harness that doesn't let those failures happen in the first place.

The RLM abstraction is the most directly portable idea. A persistent REPL that preserves state across turns is trivially implementable in any agent framework. The Continual Harness—structured memory that survives trajectories—is where most existing systems fall short. Mem0, MemGPT, and Zep solve the retrieval side, but they don't preserve skill definitions, subagent specifications, or learned prompting strategies across sessions. That's the gap Prime Agent fills.

If you're building an agent system that executes tasks longer than a single conversation, Prime Agent's architecture is worth studying. The ARC-AGI-3 number is the hook. The design is the substance.

---