In the near future, we will expand Prime Sandboxes to offer GPU microVMs, state snapshotting, sandbox forking, and shared persistent workspaces. This foundation will enable autonomous research loops that can explore, recover, and compound progress over time. If you would like to be a part of our roadmap, join our Sandbox Platform team: primeintellect.ai/careers/26…

Getting started is simple:

Our pricing is built for scale, with no subscriptions or minimum spend. For our launch through December 22, we’re proud to offer the most competitive pricing on the market for sandboxes, at a third of the cost of other large sandbox providers.

Here are some tasks you can run with Prime Sandboxes: 1. Perform a training run 2. Generate synthetic data 3. Run an eval 4. Run a persistent, remote agent All accounts begin with a limit of 1,024 concurrent sandboxes, and teams that need more can contact us directly.

Prime Sandboxes are available both as standalone infrastructure through our CLI/SDK and as part of our RL suite. Users can enjoy the following features: 1. Full VM fidelity 2. Elastic capacity at scale 3. First-class RL support 4. Bring your own environment 5. Competitive tier-free pricing With an architecture built for agentic training and pricing designed for tens of thousands of concurrent instances, they are the most cost-effective sandboxes available today.

Introducing Prime Sandboxes: MicroVM sandboxes purpose-built for RL training. Model training requires running tens of thousands of concurrent sandboxes, leading to complex and costly configuration. We built Prime Sandboxes for our own team. Today we're releasing them publicly.

The Goodfire team used Prime Intellect to train activation probes to detect reward hacking. With them, they are able to catch reward hacking in various models. Their probes are performing similarly or better than frontier LLM-as-judge setups, while being more efficient.

With sharding-aware RDMA transfer using NIXL, we cut GLM 5.2’s weight transfer time down to only ~9 seconds, including engine pause and resume — transferring the full 1.6TB policy between hundreds of GPUs. Experimental path allows us to cut this down further, saturating the network bandwidth at ~4 seconds per update.

Because we trace vLLM's real load path instead of hand-coding it, this method works automatically for any model, kernel, or parallelism strategy. In other words, it eliminates the need to rewrite the mapping every time a new model or quantization scheme is introduced.

To solve this, we adapted a concept of LazyTensor from the vLLM team: we traced the exact operations vLLM performs when loading weights and built a map from trainer bytes to their destination. This allowed us to transfer only what's needed from GPU to GPU, with minimal post-load processing. The result: less memory waste and faster transfer.

Instead of NCCL, we rebuilt the weight transfer on NIXL, using remote direct memory access (RDMA) to read and write bytes directly between GPUs. This bypasses the CPU entirely for fast synchronization. But doing it on an open-source inference engine isn’t trivial: you need to know exactly where each byte land, and that runtime weight format isn't documented, but instead changes with hardware, model, and parallelism strategy.

Over the past few months, we've spent a lot effort improving our trainer and inference, reducing GLM 5.2’s training time to <4 minutes per step. However, these improvements introduced a different bottleneck: weight transfer. When training speeds up, trainer-to-inference transfer makes up a larger fraction of the overall step time. As MoE models pack in more total parameters, sync time can become a major impediment. Using NCCL, weight transfer for GLM 5.2 (a 800B model) takes up ~60–90 seconds per update: this was a large enough proportion of the step time that we've decided to optimize it.

Our RL stack now supports NIXL weight transfer, reducing trainer-to-inference transfer time 9x compared with NCCL: from 86 seconds down to single-digit seconds for an 800B-parameter model, and even <4 seconds in our experiments. For prime-rl users, this means over 25% more throughput end-to-end compared with our previous speed. It also clears the way for fault-tolerant, elastic inference scaling that NCCL's rigid process groups made difficult.

We found a universal sandbox exploit. There's a common flaw in evals routinely run by major AI labs: agents can bypass network isolation by making requests through an authorized API proxy. Just running the eval itself can be unsafe.

While it's difficult to draw quantitative conclusions on a harness's effect in autoresearch tasks, model behavior 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.

Verifiers: we designed Prime Agent to be able to run as your go-to harness. Prime Agent is designed to be run in long-horizon evals thanks to 3 feature mechanisms. These allow you to set goal-based, time-based, and token-based budgets. Try it with uv tool install prime

We limit-tested this method in a seven-day Factorio livestream. While our logs show up to 633 agents and up to 7 active at any time, cooperative behaviors emerged between agents including friendly resource management and splitting tasks into non-overlapping roles. The results spoke for themselves: at the time of completion, progress on the tech tree was steady with no sign of slowing down.

We believe direct agent-to-agent communication will be essential to efficient swarm cooperation. To this end, we implement persistent agent lifecycles with asynchronous communication and turn completion message hooks.

We treat agent state as an information hierarchy: L0 weights, L1 active context, L2 persistent REPL + subagents, and L3 disk-backed state. We address memory overload created by the harness with "agentic garbage collection" and refinement to respectively clean up your RAM and disk over time. Our current results show promise across the long-horizon SWE and moving forward we are interested in short-horizon SWE improvements.

We've released a full technical report on Prime Agent. Extending from our blog post, we center our discussion around how harnesses should be designed and evaluated. We innovate on 4 fronts: 1. Agentic context management 2. Swarms and depth-n+ RLMs 3. Verifiers support for standardized evals 4. Out-of-loop experiments during autoresearch

The model used this and the niche file_url parameter from the OpenAI responses API to effectively launch sub-agents of itself using cURL. That way, it gained broad web access and ultimately recovered the flag.

Our experiment was run using verifiers, where the agent is placed inside the sandbox. To communicate with the inference server, frameworks allow the communication with said service. verifiers does this using a proxy, the InterceptionServer.

As models become more capable, reward hacks become an increasingly serious problem. During a controlled experiment, we found a novel reward hack in which agents are able to gain web access in offline sandboxes.

Join us at Prime Intellect to build open superintelligence and the infrastructure powering self-improving agents. We’re hiring across 25+ roles. Research • AI Research Resident • Research Engineer, Distributed Training • Research Engineer, Reinforcement Learning • Research Engineer, RL Infrastructure Compute • Compute Finance & Strategy • Compute Intelligence Engineer • Head of Compute • Solutions Architect, AI Infrastructure • Technical Account Manager, AI Infrastructure Engineering • MTS, Compute Platform • MTS, Full-Stack • MTS, GPU Infrastructure • MTS, Inference • MTS, Sandbox Platform • MTS, Security • MTS, Training Platform Growth • Applied AI: Product Strategy & Revenue • Forward-Deployed AI Strategy • Head of Growth • Head of Marketing • Community and Devrel Other • Internship • Open Application for Unconventional Talent Apply here: primeintellect.ai/careers

Our Prime Agent harness gives models a persistent IPython kernel, which can help them build their own research workflows. Kimi K3 built tools for controlled optimizer variants, loss-curve comparisons and Newton-Schulz tuning, then revised its hypothesis when its cleaner update lost in training.

What separated the strongest models: which experiments to run, how to navigate the benchmark's inherent noise, and which old negatives to revisit as the recipe changed. Some even built small simulations to isolate a mechanism before deciding if another GPU run was worth it.

The task: iterate on a 124M GPT training recipe from a shared baseline, only changing optimizer related hyperparameters, no internet access. We tested Fable 5, Opus 5, GPT-5.6 Sol, Kimi K3, Grok 4.5, GLM 5.2, Muse Spark 1.1, DeepSeek V4 Pro, Grok 4.6, Muse Spark 1.2, Qwen 3.8 Max.

We ran the largest open experiment on how frontier models do AI research. 100+ autonomous runs across 10+ models, sandboxed on 8xH200s for up to 8 days, iterating on the nanoGPT optimizer track. Best runs closed 82% of the gap to a record built by dozens of humans over months.

The team at @mixedbreadai used Prime Intellect to train Toast 1. A state-of-the-art search agent that retrieves relevant documents, Slack messages, Drive files, PDFs, and images. The resulting model matches GPT-5.6 Sol and Opus 5 while being up to 12x faster and 10x cheaper.

Nemotron 3.5 Lightning is here, with Day-0 support on Prime Intellect 30B MoE with 3B active params, up to 4x higher throughput, 30% faster task completion Post-train it for your own domain with prime-rl and Prime Lab primeintellect.ai

We believe the agent abstraction will be useful beyond training and evaluation, in particular for synthetic data pipelines. To illustrate one such agent script: set off Laguna S-2.1 to find the latest released verifiers version.

Our new abstractions open up a wide range of training setups: - Agentic Judging — solver traces are graded by a judge - Self-Play — a model playing against itself - User-Sim — a user agent interacting with an assistant

The core idea: an environment is just a program over agents. Run them sequentially, in parallel, or interleave them turn by turn. Mix models, harnesses, and runtimes. Multi-Agent is a natural extension of verifiers v1.

Prime Agent was designed as a coding agent, but also can be used for general agentic tasks in any domain. Prime Agent can autonomously run on challenging long-horizon settings like Factorio and MazeBench and yield strong results relative to existing harnesses.

On EmulatorBench, it built SEGA Genesis and Game Boy Color emulators from scratch in Rust, reproducing target hardware behavior against diagnostic tests.

We recommend using Prime Agent for both day-to-day work and standalone evals. We find strong downstream performance gains for open and closed frontier models using Prime Agent on standard long-context and long-horizon tasks, despite modern models not being trained around Prime Agent.

The RLM treats context as a variable. A persistent IPython kernel is the model's only tool. It can program over history, call tools, launch sub-agents, and keep useful state outside the active context. Long sessions become a programming problem.

Prime Agent combines three ideas: 1. Recursive Language Models-native programmatic tool calling 2. Persistent multi-agent orchestration 3. A self-improving Continual Harness Together, they let the model act on its own context and harness

Prime Agent is a general-purpose coding harness On ARC-AGI-3, it scores 95.5%, surpassing the human-expert baseline, but the gain is not benchmark-specific. We see major improvements across models when compared to their proprietary harnesses:

Introducing Prime Agent: A self-improving RLM harness for coding and long-running autonomous tasks. Designed to be both token-efficient and expressive through programmatic tool calling, context as a variable, multi-agent messaging, and a self-modifiable harness state.

A task is only useful if it produces a clean reward signal: gold patch → tests pass, no patch → tests fail. A surprising amount of open task data fails this. We ran gold-patch and no-op validation on every default dataset - multiple passes, 10x retries to separate flaky from broken.

Every taskset runs with one command, in any harness, on any runtime - that's the verifiers v1 decomposition doing its job.

Scaling agentic RL environments: today we're publishing 365,000+ tasks for SWE, terminal, and search agents - 23 tasksets behind one API, one sandbox lifecycle, one command.

Laguna S 2.1 (118B-A8B) by @poolsideai is out Incredibly strong open model for its size Post-train, deploy and inference it using primeintellect.ai

verifiers v1 plugs straight into prime-rl for training. We have been using v1 internally for all our production runs. In this run, we train GLM-4.5-Air on ScaleSWE tasks with under-4-minute steps and 35-turn rollouts, completing 1K steps in 2 days on just 6 H200 nodes.

Rollouts aren't linear. Compaction and subagents create branches in the graph — and every root→leaf branch is a contiguous, trainable sample. One trace, N training samples. Long-horizon training past the context window, natively.

These traces are now message DAGs: every message is stored exactly once. Now, trace sizes are O(n) in turns instead of O(n²), which makes long horizon agentic rollouts feasible, especially for router replay and multimodal data.

The central piece is the verifiers-managed interception server which proxies the requests between the harness and the inference server. It records traces on the fly, which allows for training and rewriting (e.g. to mitigate reward hacks).