Verifiers v1 Explained: Prime Intellect’s New Architecture for Agentic RL Training and Evals

Prime Intellect has released verifiers v1 (shipped as verifiers 0.2.0 under the new verifiers.v1 namespace) — a ground-up rewrite of its environment stack for agentic reinforcement learning and evaluations. If you train or benchmark AI agents, this release changes how you’ll structure that work. Here’s a technical breakdown.

Why a Rewrite Was Needed

Modern evaluations don’t just send a prompt and score a reply anymore. Today’s coding agents use tools, compact their own context, and spawn subagents. The old verifiers (v0) bundled an environment’s data, agent logic, and infrastructure into one package — fine for linear chat rollouts, but a poor fit for branching, long-horizon agentic workloads.

The Three-Piece Architecture

• Taskset — defines the work: the data, the tools available, and the scoring (reward) logic.
• Harness — the thing that solves the task and produces a rollout. This can be a ReAct loop, a CLI agent like Codex or Terminus 2, or your own custom agent.
• Runtime — where the rollout executes: locally or inside a sandbox, with lifecycle managed by the framework.

The Interception Server: The Clever Part

The central component is a verifiers-managed interception server that sits between the agent’s runtime and the inference server. It proxies every request and response, and while doing so it records the full trace, sets sampling parameters, and can even rewrite tool responses — a practical mitigation against reward hacking during training.

Each server multiplexes a fixed number of rollouts (32 by default), and a pool scales elastically with concurrency. During evaluation, an EvalClient acts as a blind HTTP proxy; during training, a TrainClient wraps renderers for faithful token-in RL training. Since harnesses speak different API dialects, v1 ships adapters for three: OpenAI Chat Completions, OpenAI Responses, and Anthropic Messages — all normalized into canonical types so your scoring stays agent-independent.

v0 vs v1: What Actually Changed

A Minimal Taskset in Code

import verifiers.v1 as vf

class AdditionData(vf.TaskData):
    answer: int

class AdditionTask(vf.Task[AdditionData]):
    @vf.reward
    async def exact_match(self, trace: vf.Trace) -> float:
        return float(trace.last_reply == str(self.data.answer))

class AdditionTaskset(vf.Taskset[AdditionTask, vf.TasksetConfig]):
    def load(self) -> list[AdditionTask]:
        return [
            AdditionTask(
                AdditionData(idx=i, prompt=f"What is {i} + {i}?", answer=2 * i),
                self.config.task,
            )
            for i in range(100)
        ]

The taskset defines data and scoring with zero knowledge of which agent will attempt it. You then pick a harness and model via a TOML config and launch from the CLI.

Real-World Usage Already

• Terminal-Bench 2 was ported into v1 with a single small class, and matched Harbor’s performance on the same tasks in internal testing. Harbor is the first fully supported third-party format; NeMo Gym and OpenEnv have alpha support.
• On the training side, the same environments plug directly into prime-rl. In one ablation, GLM-4.5-Air was trained on ScaleSWE across six H200 nodes for two days and evaluated on SWE-Bench-Verified, demonstrating stable agentic RL training.

Why This Matters

Agentic RL infrastructure has been fragmenting fast — every lab has its own environment format, and benchmarks don’t transfer. A taskset/harness/runtime split with dialect adapters is a genuine step toward write-once, evaluate-anywhere. If you’re building agent benchmarks or training pipelines in 2026, verifiers v1 is worth a serious look.

Sources & further reading: Prime Intellect announcement · MarkTechPost coverage · verifiers on GitHub.