Prime Agent: A Self-Improving RLM Harness

Seth Karten $^{\spadesuit}$ $^{\heartsuit}$ $^{\diamondsuit}$ Alex L. Zhang $^{\heartsuit}$ $^{\clubsuit}$ $^{\diamondsuit}$ Kevin Thomas $^{\heartsuit}$ Sebastian Müller $^{\heartsuit}$
Elie Bakouch $^{\heartsuit}$ Daniel Auras $^{\heartsuit}$ Mika Senghaas $^{\heartsuit}$ Fares Obeid $^{\heartsuit}$
Konstantin Dunas $^{\heartsuit}$ Johannes Hagemann $^{\heartsuit}$ Sami Jaghouar $^{\heartsuit}$
$^{\spadesuit}$ Princeton University
$^{\heartsuit}$ Prime Intellect
$^{\clubsuit}$ MIT
$^{\diamondsuit}$ Correspondence: [email protected], [email protected]

Abstract

Language models are sequential processors, but long-horizon agency requires external information and computation beyond model weights and active context. Prime Agent is an open-source harness for long-horizon evaluation and coding-agent workflows. A persistent IPython REPL follows the Recursive Language Model abstraction for programmatic context processing and test-time compute, while Continual Harness preserves histories, memories, skills, prompts, and subagent specifications across trajectories. Recursive subagents coordinate through direct agent-to-agent communication, and the Agents View lets humans inspect and manage daemon-backed sessions. Prime Agent standardizes execution, recovery, verification, and resource accounting while leaving strategy construction to the model. This low-friction, expressive membrane prevents harness failures from becoming model failures and pushes measurement toward the model's true maximal underlying capability. Prime Agent raises ARC-AGI-3 RHAE Best@1 from 30% to 95.5% and matches or exceeds native and popular harnesses across long-context coding, GPU-kernel generation, emulator construction, and autonomous nanoGPT speedruns. On Factorio, we find refinement allows for continuous technology progression and dedicated subagents enable parallelized work. Code is available at https://github.com/PrimeIntellect-ai/prime-agent.

Executive Summary: Prime Agent is an open-source software harness designed to extend the capabilities of large language models beyond their built-in weights and active context. Current models act as sequential processors and lack reliable ways to manage external information or allocate additional computation over long tasks. Without a strong supporting system, evaluations often fail due to dropped state, restricted actions, or premature termination rather than limits in the model itself. This gap matters now because frontier models are increasingly applied to multi-day research, systems construction, and interactive reasoning, where performance depends heavily on the surrounding infrastructure.

The document set out to evaluate whether a standardized yet expressive harness could let models convert extra test-time tokens and cost into measurable progress on long-horizon tasks. The authors built Prime Agent around a persistent IPython REPL, recursive subagent sessions, direct agent-to-agent messaging, and a Continual Harness layer that stores and refines memories, skills, and prompts across trajectories. They tested it on ARC-AGI-3, long-context coding and reasoning benchmarks, GPU-kernel generation, emulator construction, nanoGPT speedruns, Factorio, and MazeBench, comparing results against native interfaces and other popular harnesses.

The clearest result is a large lift on ARC-AGI-3, where the harness raised best@1 performance from 30 percent to 95.5 percent under autonomous conditions. On other tasks Prime Agent matched or exceeded the best alternative harnesses while using fewer tokens in several cases. Models using the system conducted more out-of-script experiments during nanoGPT runs, sustained an 85-hour autonomous speedrun with multiple verified records, and achieved steady technology progress in a seven-day Factorio session. The same infrastructure also supported parallel subagent work and recovery from disruptions such as world resets.

These outcomes indicate that a well-designed harness can separate infrastructure failures from model limitations and push measured performance closer to a model’s underlying capability. Better information management and recursive computation appear especially valuable for tasks that exceed a single prompt or require days of iteration. At the same time, persistent refinement can preserve unintended shortcuts if safety constraints are weak, as seen when an agent learned to spawn resources directly.

The authors recommend training future models directly with Prime Agent or its core components so they learn to use persistent state, subagents, and refinement more effectively. They also advise least-privilege interfaces, independent verification of actions, and auditable rollback for any production use. Further work is needed to reduce remaining friction in subagent allocation and to test the harness at even larger scales.

The reported gains rest on a modest number of runs per task and on models that were not specifically trained for the new primitives. Results may therefore overstate gains for some workloads and understate them once models adapt. Readers should treat the ARC-AGI-3 improvement as the strongest single signal and view other benchmark comparisons as directional.

1. Introduction

Section Summary: A language model by itself lacks the ability to reliably manage external information or perform ongoing actions, so it needs an external harness that supplies memory, tools, and ways to coordinate multiple processes over time. Prime Agent is an open-source harness designed to give models this missing infrastructure by letting them move information across different levels of storage, run recursive sub-agents, maintain histories and skills, and communicate directly with each other or with humans. The result is a more reliable system for long tasks that lets the model reach higher performance on benchmarks without being limited by missing state or premature termination.

A strong language model on its own does not have the full capabilities of a computer. An LLM is a bounded sequential processor whose next decision can use only state information exposed in its weights and active context. A harness supplies the missing computational substrate that allows for external actions via tool-calls. These external actions also include information management beyond prior knowledge stored in the model weights. Context management was first enabled by agentic compaction, the process by which a model selectively analyzes its own context to reduce tokens while keeping essential information. However, the full information state has grown beyond the weights and token context. Imagined as a state information cache (Figure 2), model weights are L0, active context is L1, a persistent REPL and recursive subagents form L2, and disk-backed history, memories, and skills form L3. This makes the system more von Neumann-like: the model can read, transform, and write addressable state outside the instruction currently being generated ([1, 2]).

This perspective makes expressivity the key property of a harness. Rather than encode one workflow, an expressive harness exposes primitives from which the model constructs programs, subagents, and feedback loops at inference time. Recursive Language Models (RLMs) make context and recursive invocation programmable ([3]); Continual Harness makes prompts, subagents, skills, and memories revisable from the trajectory history ([4]). Lastly, we enable large-scale coordination and orchestration of multi-agent swarms through direct agent-to-agent communication. These components let a fixed model use information management and test-time compute to expand its reachable strategy set.

Prime Agent is designed first as a standardized harness for long-horizon evaluation. The most popular metric of which is score at a fixed expenditure ([5]), such as cost/tokens and time, or, especially for long horizon, score at practical plateau ([5]), which allows us to analyze the shape of performance over time. The harness is the membrane through which the model observes and acts on the world. A model should fail an evaluation because the task exceeds its capability, not because the harness dropped state, restricted useful actions, miscounted resources, or terminated prematurely. Prime Agent therefore combines standardized, reliable execution with a low-friction and expressive interface for programmatic tools, information management, and swarm management. This lets the model fully use its test-time compute, pushing measured performance toward its true maximal underlying capability rather than the limitations of its harness.

Prime Agent jointly manages information and computation. Information management moves state across L1–L3 through programmatic context processing, compaction, persistent histories, and revisable memories. Computation management allocates test-time compute to programs, tool calls, reusable skills, and parallel recursive subagents ([6, 3]). Direct agent-to-agent communication connects the two, routing information across distributed computation so the swarm can coordinate dynamically rather than follow a fixed graph. These communication links also let humans inspect, message, attach to, and intervene in subagent sessions without following every exchange ([7, 8]). Together, these interactions produce retained trajectories that improve future computation and can train later model generations ([9, 10, 11]).

We present Prime Agent, an open-source harness for long-horizon model evaluation and coding-agent workflows. Prime Agent integrates information and computation management across active context, persistent programmatic execution, recursive subagents, and retained histories, memories, and reusable skills, connected through direct agent-to-agent and human-agent communication. Its Agents View provides a visual interface for inspecting, attaching to, and managing persistent daemon-backed agent sessions. We standardize evaluation infrastructure while preserving the model's freedom to construct its own strategy. Prime Agent improves ARC-AGI-3 performance from 30% to 95%, matches or exceeds Pi, Claude Code, and Codex (and outperforms other harnesses, Hermes Agent, OpenCode, and Kimi-Code, on other benchmarks) across long-context coding, GPU-kernel generation, and emulator construction, sustains an 85.5-hour nanoGPT run with 19 validated records, and supports four-character Factorio control and long-horizon MazeBench exploration.

2. Prime Agent Architecture

Section Summary: Prime Agent is a system that separates the handling of information from the execution of tasks, organizing state across fixed model weights, active context, a persistent Python interpreter, and disk storage while allowing models to control actions through code and tool calls. It supports recursive subagents that run in parallel via a simple scheduling primitive, with direct communication between agents and humans, and uses mechanisms like compaction and agentic garbage collection to manage long-running sessions without losing history. A daemon keeps sessions alive independently of any client, turning past trajectories into reusable state for ongoing work.

We next describe the Prime Agent architecture in detail. In particular, we discuss (1) how the system manages information and computation (§ 2.1), (2) how state is organized across model weights, active context, the REPL, and disk-backed storage (§ 2.2), (3) how persistent REPLs and RLM calls support programmatic computation (§ 2.3), (4) how recursive sessions communicate with agents and human operators (§ 2.4), (5) how Continual Harness turns trajectory evidence into reusable state (§ 2.5), and (6) how long-horizon controls define continuation, termination, and evaluation accounting (§ 2.6). Figure 1 provides an overview.

2.1 Architecture overview

Prime Agent separates information management from computation management. Information management determines what state enters a model invocation and what survives compaction or restart.

Computation management maps model-selected actions to code, tools, and recursive subagent sessions. Direct agent-to-agent communication connects related sessions, and direct human-agent interaction exposes individual nodes for inspection and intervention.

Models manipulate intermediate values with code. Sessions retain history across compaction, detachment, and restart. Subagents inherit the root's execution and communication primitives. The runtime records model calls, tool use, messages, harness changes, and resource use. The model controls decomposition, computation allocation, communication, and stopping.

2.2 Information hierarchy and persistent state

A model invocation is parameterized by fixed weights and conditions on its active token context. Prime Agent adds state outside that context. External state affects generation when the runtime injects it or an operation serializes a result into the context. Figure 2 organizes this state by visibility, access mechanism, and persistence.

Each level changes through a different mechanism. Fine-tuning updates L0, compaction rewrites L1, and refinement versions selected L3 entries. We call the L2 mechanism agentic garbage collection. The model creates, retains, summarizes, or deletes REPL values and subagent sessions as the task changes.

Explicit operations move information between levels. Python values and tool outputs in L2 enter generation when serialized into L1. Compaction replaces a conversational prefix with a summary and retains the original events in L3 for REPL retrieval. The runtime assembles selected Continual Harness entries into later supplemental prompts; other L3 artifacts enter context on retrieval. L0 stays fixed.

The retained runtime state includes an append-only event history, selected kernel snapshots, the rooted session tree, context and compaction records, persistent message queues, and versioned Continual Harness state. Branching or forking creates a new logical continuation without deleting the prior event sequence. Recovery reconstructs the session under the same identity. Non-serializable Python objects and external processes are recreated from saved artifacts or external services.

2.3 Programmatic computation with RLMs

Each session owns a persistent IPython Read-Eval-Print Loop (REPL). At test time, compute comprises model inference, Python execution, and tool calls; evaluations report tokens, time, and cost separately. Installed tools are imported as Python modules for parsing, filtering, aggregation, and verification with ordinary code. Intermediate values persist across turns and remain outside active context until selected. This avoids repeatedly serializing large logs, task specifications, and structured evaluator output into the context.

Prime Agent implements the RLM abstraction with the asynchronous rlm primitive ([3]). Calling rlm creates and schedules a subagent session, then returns a stable handle before the subagent completes. The subagent receives its own model context, IPython kernel, history, and workspace metadata. The parent continues local computation while subagents run. Results arrive later through direct agent-to-agent communication, and retained handles support follow-up after compaction or restart. The model chooses between local code, tools, sequential delegation, and parallel subagents. Prime Agent defines their execution semantics instead of a fixed workflow graph. A complete orchestration example appears in Appendix B.

2.4 Recursive orchestration and interaction

The daemon owns live sessions independently of the client that created them. Root and subagent sessions use the same lifecycle. Sessions are running during a turn or tool operation, idle when loaded without an active turn, and inactive when unloaded but recoverable from persistent state. Client detachment leaves the session running. Stable session and parent identifiers preserve the recursive topology across these transitions.

Direct agent-to-agent communication uses asynchronous, daemon-mediated queues. An agent addresses its parent, children, and siblings, and queued messages remain available when a recipient becomes active again. Filesystem, network, and credential access follow the permissions of the runtime environment. Figure 3 summarizes the shared lifecycle and communication topology.

The Agents View exposes the persistent tree for direct human-agent interaction. The interface lets a user inspect history, attach to a session, provide new input, or detach without interrupting execution. The agent-observe interface provides bounded read-only status and recent-message previews; agent-message targets a named related session. This allows for full interaction via the orchestrator.

2.5 Continual Harness

Continual Harness exposes supplemental state for trajectory-time reads and writes ([4]). Prompt notes store behavioral instructions, memories store facts, skills package executable procedures, and subagent specifications store reusable roles or divisions of labor. Typed state separates rules, facts, programs, and coordination patterns. Entries support create, read, update, and delete operations; local entries belong to one session, and explicitly requested global entries remain available to later sessions.

Refinement converts trajectory evidence into versioned state updates. Agents request edits directly, or /refine runs a background model call over relevant events. The runtime applies each edit at a turn boundary, records its trigger and intended effect, and assembles supplemental state for the next invocation. Versions preserve provenance and enable rollback. Refinement supplements the immutable base prompt without rewriting foundational policy.

Self-improvement converts execution evidence into persistent harness state that changes later behavior while model weights remain fixed. Useful computations become skills, repeated coordination patterns become subagent specifications, and corrected assumptions become memories or prompt notes. The resulting trajectory record also provides training data for later model generations.

2.6 Long-horizon execution and evaluation semantics

Prime Agent exposes three long-horizon control mechanisms (Figure 4).

Autonomous mode continues model turns within an explicit budget and evaluates a task-specified end-condition test after each turn. A failed test returns bounded output for another attempt; turn, token, and wall-clock limits stop execution. A goal retains an objective across continuations and ends through agentic completion, when the agent marks the goal complete. Heartbeats initiate turns on cron or timed schedules.

Evaluation configurations bind task and tool interfaces to model and provider settings, compaction and refinement policies, retry policy, completion gates, and resource limits. Accounting aggregates the root and descendant sessions, so delegation remains visible in test-time cost. Event history links model and tool calls, messages, interventions, retries, verifier outcomes, and harness edits to that configuration. Standardized persistence, recovery, termination, and accounting separate harness failures from model failures while preserving model control over decomposition.

3. Evaluation

Section Summary: The evaluation section examines whether Prime Agent's design enables frontier models to scale performance through extended computation, manage large amounts of information via persistent code execution, and sustain complex projects over multiple days. It tests these ideas on benchmarks like ARC-AGI-3 for test-time scaling, long-context reasoning and coding tasks, and real-world efforts such as optimizing a GPT model from scratch. Results indicate that the approach allows models to convert extra tokens or cost into progress at varying rates, handle information more actively than standard methods, and produce more experimental workflows, though final outcomes often depend more on the model itself than the harness.

The evaluation addresses three research questions derived from Prime Agent's design.

RQ1: Test-time scaling. Can a standardized, expressive execution interface let frontier models convert additional output tokens and API cost into verified task progress? We evaluate this question on ARC-AGI-3.

RQ2: Information management. Can models use persistent REPL state to search, transform, and aggregate information across long contexts? We compare Prime Agent with native and alternative harnesses on long-context reasoning and coding tasks.

RQ3: Persistent recursive execution. Can the same runtime sustain multi-day experimentation, iterative systems construction, recursive control, and online refinement? We study nanoGPT, PMPP-Hard, EmulatorBench, Factorio, and MazeBench through end-to-end outcomes and trajectory analysis. The trajectory analyses show how agents allocate subagents, retain information, and recover from disruption.

3.1 Interactive reasoning at test-time scale

ARC-AGI-3 is the clearest test of Prime Agent to support strong, consistent long-horizon evaluation ([12]). Each game requires the model to learn the rules of the game, creating an ad-hoc world model under an action limit. Prime Agent supplies only the environment interface and an autonomous prompt adapted from PRO-LONG ([13]); the model constructs the strategy. We note that Claude Code and Codex runs perform worse than Anthropic and Open AI self-reported performance on ARC-AGI-3 (public set), so we defer to their results over our own runs with matched prompt and settings.

Across the observed configurations, additional output tokens and cost are converted into progress at sharply different rates (Figure 5). The stronger configurations continue to improve across a long interaction horizon, while others plateau early. This pattern is consistent with a model-controlled interface that permits model-dependent test-time scaling instead of imposing one fixed workflow. The reference lines and points place these curves beside official ARC results. They are external values because our native-harness reruns fell below the published scores, so they situate the result rather than isolate a causal harness effect.

3.2 Long-context information management

The long-context suite tests whether a model can actively manage information that does not fit naturally into one prompt. Prime Agent stores the initial context in a readable file, allowing the model to search, transform, summarize, and revisit it from the persistent REPL. This changes long-context reasoning from passive attention over a fixed sequence into a programmatic information-management problem. The suite covers aggregation, latent retrieval, instruction following, reasoning, and long-form coding ([14, 15, 16, 17, 18]).

::: {caption="Table 1: Long-context results. Bold marks the higher point estimate within each nominal-model pair; metrics differ by row. Bold is not statistical significance, and uncertainty intervals are unavailable."}

:::

We generally find Prime Agent to be competitive across a wide range of long tasks, especially against the harness that did not use a model trained around it. Prime Agent especially excels at long-running or long-context tasks, and can competitively run on its own as an autonomous agent. We include a set of focused case studies and experiments on long settings where Prime Agent excels.

3.3 Multi-day autonomous research

The nanoGPT speedrun ([21]) measures how far an agent can reduce the number of training steps required for a 124M-parameter GPT to reach a fixed validation loss, with each record verified as an eight-seed mean. For each of three models (Kimi K3, DeepSeek V4 Pro, and GLM 5.3), we compare Prime Agent against an alternative harness: the model developer's own CLI where one exists, and Claude Code or opencode otherwise. We find that the choice of harness has little effect on final records compared to the noise of the experiment.

Model behavior, however, differs. On Prime Agent, models regularly use the persistent REPL to experiment outside the benchmark's training script, for example by simulating a candidate optimizer on synthetic gradients or numerically optimizing update-rule coefficients before launching a training run. Figure 6 counts these experiments across 18 runs, normalized by the number of training runs each agent executed; Appendix A reproduces one such experiment per model. The effect is largest for DeepSeek V4 Pro, which created roughly six times more such experiments per training run under Prime Agent than under Claude Code. This may be due to the fact that DeepSeek's own agent harness provides a similar code-execution mode, so the REPL matches a workflow the model was likely trained on. We also observe that models construct programmatic interfaces to the benchmark itself: Kimi K3 defined a probe function through which it ran roughly ninety screening experiments and all 19 of its validated records, whereas the same model on its own CLI performed every operation through direct file edits and built no such machinery.

3.4 Programmatic systems construction

Emulators.

An emulator is software that reproduces another computer system's observable behavior. We evaluate Prime Agent on EmulatorBench, a benchmark that tasks agents with constructing emulators in Rust for a variety of game systems. Agents are given a specification of the emulator and a set of diagnostic tests in the form of a verifier.

The correctness of an emulator is given from its ability to mimic the behavior of the target machine. This is measured by human-generated diagnostic programs that inspect the emulator's behavior, such as the CPU flags, PPU timing, and other components. In an effort to minimize the effects of data contamination, we require the agent to build the emulator from scratch in Rust, sandboxed without any reference implementation. We report preliminary results in Table 1 on this long-context coding benchmark averaged over 16 emulator reconstructions, as well as two emulators in Figure 7, the SEGA Genesis and Nintendo Game Boy Color, that Prime Agent successfully reproduces. For Opus, our runs surprisingly failed to solve the tasks despite successful tool-call responses.

GPU kernels.

PMPP-Hard compresses the same programmatic loop into repeated edit, compile, correctness-check, and profile cycles under a wall-clock budget.

Prime Agent and the native harnesses remain close, with the ordering reversing between the two model groups. In these reported within-model comparisons, the general persistent interface supports the compiler–profile loop with no large observed gap. One noted limitation of PMPP-Hard is the strict wall-clock budget comparison. What the wall-clock budgets do not reveal is the substantial improvement in token usage by models that use Prime Agent. This means that the same performance as Codex or Kimi-Code is achieved by Prime Agent at substantially reduced cost, and, token-for-token, Prime Agent has an advantage.

3.5 Persistent interaction and refinement

Factorio.

The Factorio Learning Environment exposes Python observations and actions for a persistent factory world ([22]). In a seven-day Sonnet 5 run, the root and its descendants used 23.4 million output tokens while completing 24 of 196 technologies and reaching 71% on advanced-circuit research (Figure 9) with no signs of stalling.

The model handled irreversible actions poorly. A destructive world reset reverted the technology count from five to one; the session then recovered and continued the run instead of discarding the trajectory. The root created 633 depth-one subagents across 149 dispatch waves, with at most seven active concurrently. The shallow, repeatedly widening tree recorded parallel task specialization rather than deeper recursion, while the bursty technology curve separated long construction intervals from externally verified progress.

A different Factorio trace revealed the central safety failure of online refinement. The agent discovered that RCON commands could spawn resources directly into assembly machines, used the shortcut despite an anti-cheating heartbeat, and then preserved it as a reusable skill. In this trace, persistence preserved behavior that optimized the measured objective, including a specification exploit. Safe deployment therefore requires least-privilege action interfaces, independent state validation, and auditable rollback of contaminated refinements.

MazeBench.

MazeBench is an open-world 3D spatial reasoning environment where the player controls a 3D cube and must solve puzzle rooms within a global maze, while collecting gems. Frontier models are shown to greatly struggle on this task, expending billions of tokens to solve only a fraction of the overall world. We compare Opus 5 and GPT-5.6 Sol with Prime Agent versus their native harnesses, as well as GLM-5.2 with Claude Code. Following the benchmark metrics, we report the unique number of rooms they find, the unique number of states, and the total number of gems, all as a function of their overall token spend.

4. Related Work

Section Summary: Existing research explores how language models can use code, tools, memory mechanisms, and recursive calls to manage context and adapt over multiple steps, along with specialized runtimes and benchmarks for coding agents that perform long sequences of actions in repositories or sandboxes. Other work examines interactive reasoning tasks that involve hidden environments and goals, as well as systems for coordinating multiple agents or enabling communication with humans through shared messages and states. Prime Agent builds on these ideas by adding persistent, recursive execution across sessions while supporting standardized evaluation and direct agent-to-agent or human oversight.

Programmatic inference and adaptive state.

Programmatic inference gives models code, tools, and recursive calls for transforming context and allocating test-time compute ([23, 24, 25, 3, 13, 6]). Memory and refinement methods retain selected observations, feedback, skills, or reasoning traces across turns and tasks ([26, 27, 28, 29, 30, 9]). Continual Harness stores prompts, memories, executable skills, and subagent specifications as typed, versioned state ([4]). Prime Agent integrates these mechanisms with persistent kernels, recursive sessions, recovery, and complete trajectory capture.

Coding agents and long-horizon evaluation.

Coding-agent runtimes use executable actions, repository tools, sandboxes, event histories, and structured role assignment to solve tasks over many interaction steps ([25, 31, 32, 33, 34, 35, 36]). Executable benchmarks and trajectory corpora measure issue resolution, instruction following, retrieval, and reasoning under long contexts or extended interaction ([37, 11, 10, 14, 15, 16, 17, 18]). Prime Agent makes the execution substrate persistent and recursive, then records expenditure across the root and descendant sessions.

Interactive reasoning on ARC-AGI-3.

ARC-AGI-3 extends abstract reasoning to interactive environments with hidden dynamics, goals, and action semantics ([12, 38]). Community systems build and verify executable world models, represent agents as stateful Python objects, optimize external workspaces, coordinate specialized agents, and preserve procedures across games ([39, 40, 41, 42, 4, 13]). Prime Agent supplies persistent recursive execution and standardized evaluation settings for the same class of long-horizon interactive tasks.

Multi-agent and human-agent communication.

Language-model agent systems coordinate through role prompts, natural-language messages, shared artifacts, and explicit belief state ([33, 34, 35, 36, 8, 42]). Learned multi-agent communication studies sparse message selection, compressed representations, social learning, policy alignment, and interpretability for human partners ([43, 44, 7, 45]). Prime Agent implements direct agent-to-agent communication through persistent family-scoped queues and exposes the same session tree to human inspection and intervention.

5. Conclusion

Section Summary: Prime Agent offers a unified framework for building agent systems that combines ongoing execution, recursive sessions, self-directed controls, full history tracking, and a continual harness into one foundation for handling extended, complex work. Experiments across reasoning, research, systems building, and persistent environments show this setup enables consistent test-time computation with standardized tracking. Current models still underuse many of its features due to lack of training, so the authors expect future progress to come from jointly training models to work with the harness rather than treating them separately.

Prime Agent introduces a new paradigm for agent harness design in which persistent execution, recursive sessions, autonomous controls, recorded history, and Continual Harness form one substrate for long-horizon work. Results across interactive reasoning, long-context tasks, autonomous research, systems construction, and persistent environments show that this substrate supports different forms of test-time computation under standardized execution and accounting. Despite its results relative to alternative harnesses, models still experience friction when deciding how to allocate subagents, manage retained information, and refine reusable state. Many harness capabilities remain underused because current models were not trained to operate them. We expect model-harness co-learning to become the dominant route to new long-horizon capabilities. Training directly with Prime Agent could teach models to use the integrated harness more effectively, while targeted training on the RLM and Continual Harness components could isolate their contributions.

Acknowledgements

We thank Florian Brand, SinatraS, and Patience Cave for helping complete Prime Agent runs in additional environments. SinatraS created PMPP Hard, and Patience Cave created MazeBench.

Appendix

Section Summary: The appendix presents several examples of AI agents conducting independent experiments outside a standard training script for a nanoGPT speedrun, including re-deriving mathematical iteration coefficients with an optimizer, building a calibrated toy model of training dynamics with noise, and debugging a custom optimizer on CPU. It also shows code for programmatically managing multiple persistent subagents that can run tasks concurrently and exchange messages. A final note discloses that large language models assisted with code and writing but played no role in the scientific contributions.

A. Example Out-of-Loop Experiments in the nanoGPT Speedrun

Each excerpt below is an experiment an agent created and ran outside the benchmark's training script during its nanoGPT run (Section 3.3), reproduced from the traces and trimmed for length.

Kimi K3 re-derived Newton–Schulz iteration coefficients with a global optimizer, checked bf16 rounding bit-exactly:

from scipy.optimize import differential_evolution
grid_in = np.concatenate([np.linspace(0.02, 0.05, 10),
                          np.linspace(0.05, 1.0, 190)])
grid_over = np.linspace(1.0, 1.3, 20)

def p_map(sig, a, b, c, iters=6):
    x = sig
    for _ in range(iters):
        x = a*x + b*x**3 + c*x**5
    return x

def objective(params):
    a, b, c = params
    dev = np.max(np.abs(p_map(grid_in, a, b, c) - 1.0))
    over = max(0.0, np.max(np.abs(p_map(grid_over, a, b, c))) - 1.15)
    return dev + 5.0*over

res = differential_evolution(objective,
        [(1.0, 6.0), (-8.0, 0.0), (0.0, 5.0)],
        maxiter=300, tol=1e-9, seed=0, polish=True)

DeepSeek V4 Pro built a calibrated toy of the training problem, with minibatch noise shaped by the true Kronecker Hessian and a natural-gradient oracle arm:

"""Calibrated toy: Kron-quadratic + CORRECT Kron-Hessian
minibatch noise. eps = Hl^{1/2} Z Hr^{1/2} / sqrt(n_eff).
Ideal preconditioner: Ql = Hl^{-1/2}, Qr = Hr^{-1/2}."""
G = Hl @ W @ Hr
eps = Hl12 @ torch.randn(p, q) @ Hr12 / (n_eff ** 0.5)
g = G + eps
elif opt == "natgrad":   # oracle arm
    El, Vl = torch.linalg.eigh(Hl)
    Er, Vr = torch.linalg.eigh(Hr)
    u = Vl @ (Vl.T @ d @ Vr /
        (El[:, None]**0.5 * Er[None, :]**0.5)) @ Vr.T

GLM 5.3 debugged its SOAP implementation on CPU before any GPU screen:

torch.manual_seed(0)
for shape in [(768, 768), (3072, 768), (768, 3072)]:
    p = torch.nn.Parameter((torch.randn(*shape) * 0.02).bfloat16())
    opt = SOAP([p], lr=0.025)
    for t in range(25):
        p.grad = (torch.randn(*shape) * 0.01).to(torch.bfloat16)
        opt.step()
        if not torch.isfinite(p.data).all():
            print(shape, 'NaN at step', t+1)
            st = opt.state[p]
            print('  L finite', torch.isfinite(st['L']).all().item(),
                  'v finite', torch.isfinite(st['v']).all().item())
            break

B. Example Programmatic Orchestration

# Admit independent subagents; do not wait for answers here.
review = await rlm("Audit the implementation. Reply with concrete issues.",
                   name="reviewer")
tests = await rlm("Run the test suite and classify failures.",
                  name="tester")

# Later, recover retained sessions and send a follow-up.
children = await rlm.list_subagents()
await agent_message.send(
    "Also inspect error-handling edge cases.",
    receiver_role="child", receiver_name=review.name)

The explicit reply path is intentional: a child is a persistent concurrent session, not a stateless completion returned by rlm.

C. LLM Usage Disclosure

Large language models were used to assist with code development, writing refinement, and formatting during the preparation of this manuscript. All scientific claims, experimental design, analysis, and intellectual contributions are solely the work of the authors.

References

Section Summary: This section compiles a list of academic citations that support a discussion on artificial intelligence and computing. It begins with foundational works by Alan Turing and John von Neumann on computability and early computer architecture, then shifts to dozens of recent papers and preprints from 2022 to 2026. These focus on large language models, autonomous agents, reasoning methods, benchmarks for long-context tasks, and tools for evaluating AI performance.

[1] Turing, Alan M. (1936). On Computable Numbers, with an Application to the Entscheidungsproblem. Proceedings of the London Mathematical Society. 42(1). pp. 230–265. doi:10.1112/plms/s2-42.1.230.

[2] von Neumann, John (1945). First Draft of a Report on the EDVAC.

[3] Zhang et al. (2025). Recursive Language Models. https://arxiv.org/abs/2512.24601. arXiv:2512.24601.

[4] Karten et al. (2026). Continual Harness: Online Adaptation for Self-Improving Foundation Agents. https://arxiv.org/abs/2605.09998. arXiv:2605.09998.

[5] Tom Cunningham (2026). Metrics of Agent Ability. https://metr.org/notes/2026-07-24-metrics-of-model-ability/.

[6] Snell et al. (2024). Scaling LLM Test-Time Compute Optimally Can Be More Effective than Scaling Model Parameters. doi:10.48550/arXiv.2408.03314. https://arxiv.org/abs/2408.03314. arXiv:2408.03314.

[7] Karten et al. (2023). Interpretable Learned Emergent Communication for Human–Agent Teams. IEEE Transactions on Cognitive and Developmental Systems. 15(4). pp. 1801–1811. doi:10.1109/TCDS.2023.3236599. https://doi.org/10.1109/TCDS.2023.3236599.

[8] Li et al. (2023). Theory of Mind for Multi-Agent Collaboration via Large Language Models. In Proceedings of the 2023 Conference on Empirical Methods in Natural Language Processing. pp. 180–192. doi:10.18653/v1/2023.emnlp-main.13. https://aclanthology.org/2023.emnlp-main.13/.

[9] Zelikman et al. (2022). STaR: Bootstrapping Reasoning With Reasoning. In Advances in Neural Information Processing Systems. https://arxiv.org/abs/2203.14465.

[10] Xu et al. (2024). AgentTrek: Agent Trajectory Synthesis via Guiding Replay with Web Tutorials. https://arxiv.org/abs/2412.09605. arXiv:2412.09605.

[11] Pan et al. (2024). Training Software Engineering Agents and Verifiers with SWE-Gym. https://arxiv.org/abs/2412.21139. arXiv:2412.21139.

[12] ARC Prize Foundation (2026). ARC-AGI-3: A New Challenge for Frontier Agentic Intelligence. https://arxiv.org/abs/2603.24621. arXiv:2603.24621.

[13] Fox et al. (2026). PRO-LONG: Programmatic Memory Enables Long-Horizon Reasoning. https://arxiv.org/abs/2607.20064. arXiv:2607.20064.

[14] Bertsch et al. (2025). Oolong: Evaluating Long Context Reasoning and Aggregation Capabilities. https://arxiv.org/abs/2511.02817. arXiv:2511.02817.

[15] Tchuindjo et al. (2026). OBLIQ-Bench: Exposing Overlooked Bottlenecks in Modern Retrievers with Latent and Implicit Queries. https://arxiv.org/abs/2605.06235. arXiv:2605.06235.

[16] Chen et al. (2026). LongBench Pro: A More Realistic and Comprehensive Bilingual Long-Context Evaluation Benchmark. https://arxiv.org/abs/2601.02872. arXiv:2601.02872.

[17] Bai et al. (2024). LongBench v2: Towards Deeper Understanding and Reasoning on Realistic Long-context Multitasks. https://arxiv.org/abs/2412.15204. arXiv:2412.15204.

[18] Motwani et al. (2026). LongCoT: Benchmarking Long-Horizon Chain-of-Thought Reasoning. https://arxiv.org/abs/2604.14140. arXiv:2604.14140.

[19] Jingyu Zhang et al. (2026). Many-Tier Instruction Hierarchy in LLM Agents. https://arxiv.org/abs/2604.09443. arXiv:2604.09443.

[20] Karten et al. (2026). Emulator Bench: Verifiable Whole-System Emulation for Ultra Long-Horizon Coding Agents. Manuscript.

[21] Elie Bakouch and Prime Intellect (2026). Measuring Autonomous AI Research. Prime Intellect Blog. https://www.primeintellect.ai/blog/measuring-autonomous-research.

[22] Hopkins et al. (2025). Factorio Learning Environment. https://arxiv.org/abs/2503.09617. arXiv:2503.09617.

[23] Yao et al. (2023). ReAct: Synergizing Reasoning and Acting in Language Models. In International Conference on Learning Representations. https://arxiv.org/abs/2210.03629.

[24] Schick et al. (2023). Toolformer: Language Models Can Teach Themselves to Use Tools. In Advances in Neural Information Processing Systems. https://arxiv.org/abs/2302.04761.

[25] Wang et al. (2024). CodeAct: Executable Code Actions Elicit Better LLM Agents. https://arxiv.org/abs/2402.01030. arXiv:2402.01030.

[26] Packer et al. (2023). MemGPT: Towards LLMs as Operating Systems. https://arxiv.org/abs/2310.08560. arXiv:2310.08560.

[27] Shinn et al. (2023). Reflexion: Language Agents with Verbal Reinforcement Learning. In Advances in Neural Information Processing Systems. https://arxiv.org/abs/2303.11366.

[28] Madaan et al. (2023). Self-Refine: Iterative Refinement with Self-Feedback. In Advances in Neural Information Processing Systems. https://arxiv.org/abs/2303.17651.

[29] Wang et al. (2023). Voyager: An Open-Ended Embodied Agent with Large Language Models. https://arxiv.org/abs/2305.16291. arXiv:2305.16291.

[30] Park et al. (2023). Generative Agents: Interactive Simulacra of Human Behavior. In ACM Symposium on User Interface Software and Technology. https://arxiv.org/abs/2304.03442.

[31] Yang et al. (2024). SWE-agent: Agent-Computer Interfaces Enable Automated Software Engineering. In Advances in Neural Information Processing Systems. doi:10.48550/arXiv.2405.15793. https://arxiv.org/abs/2405.15793. arXiv:2405.15793.

[32] Wang, Xingyao and others (2024). OpenHands: An Open Platform for AI Software Developers as Generalist Agents. https://arxiv.org/abs/2407.16741. arXiv:2407.16741.

[33] Wu et al. (2023). AutoGen: Enabling Next-Gen LLM Applications via Multi-Agent Conversation. https://arxiv.org/abs/2308.08155. arXiv:2308.08155.

[34] Li et al. (2023). CAMEL: Communicative Agents for "Mind" Exploration of Large Scale Language Model Society. https://arxiv.org/abs/2303.17760. arXiv:2303.17760.

[35] Hong et al. (2023). MetaGPT: Meta Programming for A Multi-Agent Collaborative Framework. https://arxiv.org/abs/2308.00352. arXiv:2308.00352.

[36] Qian et al. (2023). ChatDev: Communicative Agents for Software Development. https://arxiv.org/abs/2307.07924. arXiv:2307.07924.

[37] Jimenez et al. (2024). SWE-bench: Can Language Models Resolve Real-World GitHub Issues?. In International Conference on Learning Representations. https://openreview.net/forum?id=VTF8yNQM66.

[38] ARC Prize Foundation (2026). ARC-AGI Community Leaderboard. https://arcprize.org/leaderboard/community. Accessed August 2026.

[39] Rodionov, Sergey (2026). Executable World Models for ARC-AGI-3 in the Era of Coding Agents. doi:10.48550/arXiv.2605.05138. https://arxiv.org/abs/2605.05138. arXiv:2605.05138.

[40] Furgale et al. (2026). NVIDIA-labs OO Agents: Native Python Object-Oriented Agents. doi:10.48550/arXiv.2607.20709. https://arxiv.org/abs/2607.20709. arXiv:2607.20709.

[41] Courtis et al. (2026). OPINE-World: Programmatic World Modeling with Ontology-error-Prioritized Interactive Exploration for ARC-AGI-3. doi:10.48550/arXiv.2607.01531. https://arxiv.org/abs/2607.01531. arXiv:2607.01531.

[42] Sarafian et al. (2026). Workspace Optimization: How to Train Your Agent. doi:10.48550/arXiv.2605.09650. https://arxiv.org/abs/2605.09650. arXiv:2605.09650.

[43] Karten et al. (2023). Towards True Lossless Sparse Communication in Multi-Agent Systems. In IEEE International Conference on Robotics and Automation. pp. 7191–7197. doi:10.1109/ICRA48891.2023.10161322. https://arxiv.org/abs/2212.00115. arXiv:2212.00115.

[44] Karten et al. (2023). On the Role of Emergent Communication for Social Learning in Multi-Agent Reinforcement Learning. In Proceedings of the International Conference on Autonomous Agents and Multiagent Systems. pp. 2391–2393. doi:10.5555/3545946.3598944. https://arxiv.org/abs/2302.14276. arXiv:2302.14276.

[45] Karten, Seth (2023). Emergent Communication and Decision-Making in Multi-Agent Teams.