Free Intensive Nov 21–22Free 2-day hands-on Vibecoding Intensive on Nov 21–22 at 16:00 MSK (Sat–Sun) · Live Cohort 3 starts Nov 23Join Free →Cohort 3 (Nov 23)
ReleaseResearch Paper · For R&DModal Blog→ original

Abundant runs 2 million sandboxes a month and pays for average usage, not peak

Startup Abundant builds tasks for training AI agents, and every attempt runs in its own isolated Modal sandbox. The company runs more than 2 million sandboxes a month, and it built the system in two weeks. Resources are ordered for average usage, while bursting covers the peaks: a sandbox can temporarily take more CPU and memory without crashing with an OOM error. For large-scale agent runs, this is cheaper than reserving hardware for the maximum.

AI-processed from Modal Blog; edited by Hamidun News
Abundant runs 2 million sandboxes a month and pays for average usage, not peak
Source: Modal Blog. Collage: Hamidun News.
Listen to article
Article Fact Sheet & Key Figures
ParameterDetails
Primary sourceModal Blog ↗
Editor-in-Chief
Key metric #1A monitor inside the sandbox sends an "alive" signal every 30 seconds
Key metric #2Silence is checked three times before the sandbox is shut down
Frontier RSI benchmark1300+ hours of agent work, about 500 attempts

Imagine you are training an AI agent to optimize a GPU kernel or fix a large repository. Each attempt has to run in an isolated environment, you need to watch for hangs, and you need to verify the result. If the agent needs more CPU or memory than you ordered, even for a minute, the process hits the limit or crashes with an out-of-memory (OOM) error, and all the work is lost.

If you over-provision, you pay for idle hardware. That is the problem Abundant ran into, and the Modal platform's blog described its experience. The result: more than 2 million isolated sandboxes (Sandboxes) a month, an architecture built in two weeks, and billing based on average usage, not peak.

What Abundant does and how it is built

Abundant builds reinforcement learning (RL) environments used by labs such as OpenAI, Anthropic, Google and Meta. The setup is simple: a model gets a hard task and tries to solve it, and a checking mechanism (a verifier) delivers a verdict of "done" or "not done." One such attempt is called a rollout. It needs an instruction, a goal, a verifier and infrastructure: compute, a Dockerfile, isolation and sometimes a GPU. Abundant has created more than 75 000 such runs, from GPU kernel optimization to long programming tasks. Each one runs in its own Modal Sandbox.

Almost the entire platform now runs on Modal. Modal Functions form the scheduler API: they launch tasks, clear out hung runs and check results. The environments live in Sandboxes. The team originally did not want to manage EC2 clusters by hand, so it could stay focused on its core product, the tasks themselves. As of November 2026, the platform runs more than two million sandboxes a month.

Each run has four steps: launch, attempt, verification and report. Throughout, a "monitor" has to confirm that the sandbox is alive. Abundant considered hosting the monitor outside the sandbox but chose another route: a small monitor runs inside the sandbox, and short-lived Functions launch the sandbox. Over HTTP, the monitor sends an "I'm alive" signal every 30 seconds, plus live events and the final result. If a sandbox goes silent, the control layer makes three attempts to reach it and only then shuts it down.

Bursting: paying for the average, not the peak

An agent's CPU and memory usage is uneven: it thinks, then compiles, then runs tests. The Modal team proposed a bursting mode. A sandbox orders an average amount of resources, automatically takes more when needed if the machine has free capacity, and then returns to its original size. This keeps running the sandboxes that would otherwise hit the CPU limit or crash with an OOM error.

The effect is twofold. First, Abundant pays less for idle resources: with a fixed setup you have to order for the peak, while here you can order for the average. Second, the routine work is gone: with this variety of tasks, tuning CPU and memory for each one by hand was tedious, and losing progress to OOM errors was costly. One caveat: bursting works only while the host has spare capacity, so it does not guarantee peak resources. The article gives no specific savings figures.

A verifier that is hard to fool

If a model can cheat, the evaluation is meaningless: a reliable verifier makes a model genuinely stronger. That is why tasks are first tested against adversarial agents. Early tests showed that models sometimes found copies of their own instructions. They realized they were being evaluated, and the results were skewed. For benchmarks, it matters that the agent believes it is working for real, in an environment and with data like those in actual production.

Abundant changed the launch order so that all instructions are deleted before work begins. It also added a reviewer agent to the verification step: it reads execution traces and flags signs that the agent guessed it was being evaluated.

Results and practical takeaway

The architecture was rolled out in about two weeks. Abundant's first public benchmark, Frontier RSI, tests the ability of language models to improve themselves. For the first published results, Modal provided more than 1300 hours of agent research work across nearly 500 attempts.

One caveat: the text was published on Modal's own blog, so it is a vendor case study, not an independent test. But the lessons apply more broadly. If you run agents at scale, keep the liveness monitor inside the isolated environment. Provision resources for average usage if the platform allows temporary headroom. And check that you are not leaving the agent traces of its instructions that would tell it it is being tested.

Story

Key Questions Answered

What Abundant does and how it is built?

Abundant builds reinforcement learning (RL) environments used by labs such as OpenAI, Anthropic, Google and Meta. The setup is simple: a model gets a hard task and tries to solve it, and a checking mechanism (a verifier) delivers a verdict of "done" or "not done." One such attempt is called a rollout. It needs an instruction, a goal, a verifier and infrastructure: compute, a Dockerfile, isolation and sometimes a GPU.

What are the key details on Bursting: paying for the average, not the peak?

An agent's CPU and memory usage is uneven: it thinks, then compiles, then runs tests. The Modal team proposed a bursting mode. A sandbox orders an average amount of resources, automatically takes more when needed if the machine has free capacity, and then returns to its original size. This keeps running the sandboxes that would otherwise hit the CPU limit or crash with an OOM error. The effect is twofold.

What are the key details on A verifier that is hard to fool?

If a model can cheat, the evaluation is meaningless: a reliable verifier makes a model genuinely stronger. That is why tasks are first tested against adversarial agents. Early tests showed that models sometimes found copies of their own instructions. They realized they were being evaluated, and the results were skewed. For benchmarks, it matters that the agent believes it is working for real, in an environment and with data like those in actual production.

ZK
Zhemal Khamidun — CPO at Alpina Digital, product manager of AlpinaGPT. Building AI products since 2019. Hamidun News is a pet project that grew into a production aggregator with 6,000+ readers.
✦ Private AI Builders Community · Vibe Club

Ship AI Faster with Founders, Engineers & Weekly Architecture Reviews

Inside Vibe Club (hamidun.com/club) — weekly live masterminds with Zhemal Khamidun, Tech Radar, full LMS access, and 370+ production Claude Code skills.

Join Vibe Club →Explore Hamidun Academy
What do you think?
Loading comments…