AI Coding Getty Images/Joe Raedle

Prime Intellect published Verifiers v1 this week, a ground-up redesign of its open-source environment stack for agentic reinforcement learning that solves two architectural problems the research community has needed to crack for training long-horizon AI agents: a data format that grew quadratically with rollout length, and an environment design so tightly coupled that swapping one component required rewriting another. The release, built around a directed acyclic graph message format and a three-part composable architecture, also unlocks something the v0 design made structurally impossible — training coding agents on trajectories that exceed their own native context window.

The Verifiers library, originally created by Prime Intellect researcher Will Brown, has accumulated more than 4,200 GitHub stars. The v1 release arrives five days after Prime Intellect closed a $130 million Series A round at a $1 billion valuation — a round that brought total funding to over $150 million and attracted backing from NVIDIA Ventures, Intel Capital, and Dell Technologies Capital alongside lead investor Radical Ventures.

What the v0 Architecture Got Wrong

In the original verifiers library, an environment bundled its data, agent logic, and execution infrastructure together as a single monolithic unit. That design was adequate for simple prompt-completion pipelines. It did not hold up once modern evaluations started running fully featured coding agents with their own tools, compaction strategies, and subagents.

The coupling problem was painful but manageable. The data problem was not. Under v0, every turn in a multi-step rollout stored a full copy of the prompt alongside the new completion — meaning trace size grew with the square of the number of turns. For training runs that need hundreds of agent steps to solve a complex software engineering task, this was a hard architectural ceiling. An agent being trained to resolve 100-turn coding workflows would generate traces roughly 10,000 times larger than a 1-turn baseline, by the same mechanism that makes a quadratic algorithm practical at small inputs and crippling at large ones.

How the Three-Part Architecture Fixes Coupling

Verifiers v1 decomposes an environment into three independently swappable layers. A taskset defines what work the agent must do: the data, the tools available during the rollout, and the scoring logic that assigns rewards. A harness defines how the task is solved — a simple ReAct loop, a CLI-based agent such as Codex or Terminus 2, or a custom agent written by the researcher. A runtime defines where the rollout executes: locally as a subprocess or Docker container for development, or in horizontally scalable cloud sandboxes — including Prime Intellect's own Prime Sandboxes and Modal — for production training runs.

Because the three layers are decoupled from each other, any taskset can run under any compatible harness inside any runtime without code changes. The same addition task that runs under a bare null harness with no tools can also run under Kimi Code — a large, fully featured coding agent — using only a configuration change. This composability is the design goal the v0 architecture blocked.

The Interception Server: Harness-Agnostic by Design

Making that composability work in practice required solving a specific engineering problem: different agents speak different inference API dialects. Claude Code requires Anthropic Messages. Codex requires OpenAI Responses. A research team's custom agent might use OpenAI Chat Completions. An environment that only supports one dialect locks out the others.

Verifiers v1 handles this through a verifiers-managed interception server — an HTTP proxy that sits between the agent's runtime and the inference backend. Every inference request the agent makes routes through this server. It relays the request, captures the response, records a running trace, and can set sampling parameters even in harnesses that do not natively expose them. Critically, it can also rewrite tool responses on the fly — a mechanism designed specifically to mitigate reward hacking, the well-documented failure mode where an agent exploits gaps in a reward specification to score well on the proxy metric without actually learning the intended task.

The interception server detects which API dialect an incoming request uses through a class-level routing registry and normalizes it into canonical internal types, so scoring logic written against the canonical types remains independent of whichever agent is being tested. For scale, a single interception server handles up to 32 concurrent rollouts by default; a pool of servers scales elastically with observed concurrency, managing the load across training runs without manual tuning.

DAG Branching Breaks the Context Window Barrier

The most consequential architectural change in v1 is the redesign of the rollout trace itself. Where v0 stored a full copy of the prompt at every turn — the source of the quadratic data explosion — v1 builds the trace as a directed acyclic graph: a data structure in which each message is a unique node linked only to its predecessor. No message is ever stored twice. Trace size grows linearly with turn count regardless of how long the rollout runs.

On its own, that solves the data growth problem. The branching property of the DAG solves a second problem the research community has been less explicit about.

When a harness employs compaction — summarizing context to stay within a model's context window at the cost of some information — the conversation does not continue linearly. The agent summarizes what it has seen, and the next turn opens with a new effective starting point. Under the v1 message graph, that compaction creates a branch: a new root-to-leaf path through the graph. Each such path is an independent trainable sample. A trace with N compaction branches yields N usable training examples, not one.

This is what makes it possible to train an agent on a trajectory longer than the model's native context window. The model cannot hold a 500-turn conversation in a single forward pass. But each branch — each compaction-defined segment of that conversation — is short enough to be trainable as its own sample. The branches can then be drawn from the same trace without requiring the rollout to be rerun. Verifiers v1's message graph makes this structurally native rather than requiring a separate engineering workaround for each harness.

According to Prime Intellect's own measurements using synthetic traces of approximately 1,000 tokens per turn, the size advantage of the v1 format over v0 grows substantially as turn count increases and widens further when training data includes multimodal content or router replay.

Supported Harnesses, Benchmarks, and the Training Stack

The release ships with built-in support for Codex, Terminus 2, Kimi Code, and Mini-SWE-Agent. Harbor — which has gained adoption as a standard abstraction for agentic task datasets — is the first fully-supported third-party taskset format. Porting a Harbor dataset such as Terminal Bench 2 into v1 requires a handful of lines of configuration code. NeMo Gym and OpenEnv have alpha support.

On the training side, v1 integrates directly with Prime Intellect's prime-rl framework. Environments configured for evaluation can be used for training without modification: the same TOML configuration file governs both. Traces feed into prime-rl with no redundant computation — branches are read directly from the trace structure rather than recomputed.

To validate the stack at production scale, Prime Intellect ran a length-penalty ablation training GLM-4.5-Air on the ScaleSWE benchmark across six H200 GPU nodes over two days, evaluating results on SWE-Bench-Verified — the industry-standard 500-instance coding agent benchmark, a curated subset of real GitHub issues validated in collaboration with OpenAI. The run produced a more capable and more inference-efficient coding agent, serving as a concrete proof that the v1 architecture holds up under multi-node production conditions. Prime Intellect notes these efficiency measurements are based on its own internal data; independent third-party validation of the specific performance gains has not yet been published.

What Comes Next

The v1 release is explicitly a preview. The legacy v0 code path was frozen with the v1 publication and will not receive active maintenance; Prime Intellect intends to fully deprecate it in a future release. New environments should be built on the verifiers.v1 namespace.

The roadmap toward a stable 1.0.0 release plans to add support for multi-agent environments — where multiple AI agents collaborate or compete within a single training task — along with training support for the Interactions API dialect and robust integration with all major environment frameworks, including OpenEnv and NeMo Gym.

That roadmap item matters because the most compelling near-term applications for long-horizon agentic training involve agents that hand work off to subagents, which is a multi-agent pattern the current v1 preview handles only partially. When multi-agent support reaches 1.0.0, the composable architecture — designed from the start to make minimal assumptions about what happens inside a harness — should require no changes to existing tasksets.

Does Agentic RL Actually Scale?

One honest caveat deserves explicit mention. Andrej Karpathy, an investor in Prime Intellect, has publicly stated that he is "bullish on environments and agentic interactions" but bearish on reinforcement learning as a scaling paradigm. The infrastructure problem that Verifiers v1 addresses — making it easier to build and run agentic RL training — is real and independently confirmed in multiple academic papers and industry analyses. Whether RL on long-horizon tasks will deliver the capability gains that justify the infrastructure investment remains an open empirical question.

The library is available now on GitHub under the MIT license. The verifiers.v1 namespace is the recommended entry point for all new development.

Frequently Asked Questions

What is the difference between Verifiers v0 and Verifiers v1?

The original Verifiers library (v0) bundled an environment's data, agent logic, and execution backend into a single tightly coupled unit, and stored a full copy of the conversation prompt at every turn — meaning trace sizes grew quadratically with rollout length. Verifiers v1 decomposes those into three independently swappable layers (taskset, harness, runtime) and replaces the prompt-duplication scheme with a directed acyclic graph in which each message is stored exactly once. The result is linear trace growth instead of quadratic, and the ability to swap any harness or runtime without rewriting environment code.

How does the DAG trace format enable training past a model's context window?

When an agent's rollout exceeds the model's context window, the harness uses compaction — summarizing earlier context and continuing with a new starting point. In the v1 message graph, each compaction creates a branch: a new root-to-leaf path through the graph. Each branch is short enough to be used as an independent training sample. A single trace with ten compactions yields ten trainable samples. This means a training corpus can be built from rollouts that far exceed what any single forward pass can hold, without rerunning those rollouts.

What is reward hacking, and how does Verifiers v1 address it?

Reward hacking occurs when an RL agent exploits a gap between the formal reward specification and the true intended task — achieving high scores on the proxy metric by finding a shortcut rather than by actually learning the desired behavior. In agentic coding settings, this often involves manipulating tool outputs. The Verifiers v1 interception server sits between the agent's runtime and the inference backend, giving the training framework the ability to intercept and rewrite tool responses before they reach the agent. This is a direct mitigation mechanism at the architectural layer where tool-response gaming would otherwise occur.

Which harnesses and benchmarks work with Verifiers v1 out of the box?

Verifiers v1 ships with built-in support for Codex, Terminus 2, Kimi Code, and Mini-SWE-Agent. It supports three inference API dialects — OpenAI Chat Completions, OpenAI Responses, and Anthropic Messages — so any agent that speaks one of those formats works without additional adapter code. For datasets, Harbor is fully supported as a first-class taskset format, with NeMo Gym and OpenEnv in alpha. The library integrates directly with prime-rl for training, reusing the same configuration files used for evaluation.