Prime Intellect has released Verifiers v1, a major redesign of its environment stack for training and evaluating AI agents. The new framework splits what was previously bundled together into three independent, reusable components: tasksets (the work to be done), harnesses (how agents solve tasks), and runtimes (where the work runs). This modular approach allows teams to run the same dataset under different AI models and agent architectures without rewriting code.

What Problem Does Verifiers v1 Solve?

Before v1, building environments for agentic reinforcement learning (RL) meant tightly coupling data, agent logic, and infrastructure together. If you wanted to test a different model or agent type on the same task, you had to rebuild everything from scratch. Verifiers v1 decouples these pieces, so any taskset can run under any compatible harness, dramatically reducing redundant work.

The framework also addresses a technical bottleneck: trace growth. In the previous version, traces grew quadratically with the number of turns in an agent's reasoning process. V1 replaces this with a linear message graph, meaning long-horizon training (where agents reason through many steps) becomes computationally feasible. This matters because longer reasoning chains are essential for complex problem-solving tasks.

How Does the New Architecture Work?

At the heart of Verifiers v1 is an interception server that sits between the agent's runtime and the inference model. This server proxies requests and responses, records execution traces on the fly, and can even rewrite tool responses to prevent reward hacking during training. The server multiplexes up to 32 rollouts by default and scales elastically based on demand.

The framework supports three different agent communication formats: OpenAI Chat Completions, OpenAI Responses, and Anthropic Messages. A dialect adapter normalizes each format into a canonical type, so your scoring logic stays independent of which model you're testing. This flexibility is crucial for teams that want to benchmark multiple models on the same task.

Steps to Get Started With Verifiers v1

• Define a Taskset: Create a taskset that specifies the data, tools, and scoring logic for your task. This is independent of any specific model or agent architecture.
• Choose a Harness: Select how your agent will solve the task. Options include ReAct loops, CLI agents, or custom implementations. Compatible harnesses include Codex and Terminus 2.
• Select a Runtime: Decide where the work runs, either locally or in a sandbox environment. The framework handles lifecycle management automatically.
• Configure via TOML: Use a simple configuration file to specify your model, taskset, and harness, then run evaluation or training from the command line.

What Real-World Results Show?

Prime Intellect ported Terminal Bench 2, a complex coding benchmark, into v1 with only a small code change. In internal testing, Verifiers matched the performance of Harbor, an earlier framework, on the same tasks. This demonstrates that the new modular design doesn't sacrifice accuracy.

On the training side, the same environments plug directly into Prime Intellect's RL training pipeline. In one experiment, GLM-4.5-Air trained on ScaleSWE (a software engineering benchmark) across six H200 GPU nodes over two days, then evaluated on SWE-Bench-Verified. The training remained stable throughout, showing that the framework can handle real-world agentic training at scale.

The framework also supports third-party datasets. Harbor datasets can now be reused without rewriting reward logic, and NeMo Gym and OpenEnv have alpha support. This ecosystem approach means teams can leverage existing benchmarks rather than building from scratch.

Why Does This Matter for AI Development?

Agentic AI, where models act autonomously to solve problems, is becoming increasingly important. But training and evaluating these systems at scale has been fragmented and inefficient. Verifiers v1 addresses this by providing a standardized, composable framework that reduces engineering overhead and enables faster experimentation. Teams can now swap models, datasets, and agent architectures without rewriting core logic, accelerating the pace of research and deployment.

The linear trace model is particularly significant for long-horizon tasks. As agents take more steps to solve complex problems, the computational cost of tracking their reasoning shouldn't explode. V1's design keeps that cost proportional to the number of steps, making it feasible to train agents on genuinely difficult tasks that require sustained reasoning.