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)
ReleaseInsight · On RadarModal Blog→ original

Modal: AI agent sandboxes use less than 6% of peak CPU for over half their lifetime

A coding agent spends most of its time waiting for the model to respond, and the sandbox's CPU sits idle. According to Modal, a typical Sandbox uses less than 6% of its peak CPU for more than half its lifetime. Spikes happen during dependency installs, tests, and builds. Paying for peak capacity is like renting a truck for a whole day to make a couple of trips. Modal therefore offers a minimal request plus temporary bursting, and you should size resources based on your agent's actual profile.

AI-processed from Modal Blog; edited by Hamidun News
Modal: AI agent sandboxes use less than 6% of peak CPU for over half their lifetime
Source: Modal Blog. Collage: Hamidun News.
Listen to article
Article Fact Sheet & Key Figures
ParameterDetails
Primary sourceModal Blog ↗
Editor-in-Chief
Default request0.125 cores and 128 MiB of memory
Examplean agent fixed a vulnerability in 2 min 46 s, with memory at about 47 MiB
Key metric #3Of that time, the agent waited 33 s for the model, plus two more pauses of 60 s each

If you run AI agents in isolated sandboxes, you know the uncomfortable arithmetic: resources are usually provisioned for the worst case, and they sit idle most of the time. Modal's blog breaks this problem down with numbers. The company claims that a typical Sandbox uses less than 6% of its own peak CPU for more than half its lifetime. In other words, you pay for capacity you need for a few seconds. This is the idea behind the original headline, "burst, don't reserve": let the sandbox briefly burst rather than reserving capacity in advance.

Why reserving for peak doesn't suit agents

Take a coding agent. It runs in a loop: the model decides what to do next, the agent executes a command, gets the result, and waits for the model again. While the model is thinking, the sandbox does almost nothing. Load spikes when the agent installs dependencies, runs tests, or builds the project.

Other common workloads look the same: RL rollouts (agent runs for reinforcement learning training), model evaluations (evals), and app builders. All of them have long pauses and short peaks.

Imagine renting a truck for the entire day because you need to move furniture twice. Reserving fixed CPU for peak works the same way: you guess the maximum, add a margin, and hold it the whole time even though the peak is short.

What a real session shows

Modal shares a recording of a real run on a task from Terminal-Bench 2.1: find and fix a vulnerability in a repository. The agent finished in 2 minutes 46 seconds and made 10 calls to the model. The CPU stayed near zero for most of the time, apart from brief spikes when pytest ran. Memory held at around 47 MiB.

Both figures fit within the sandbox's minimal request: 0.125 cores and 128 MiB. No limits were set in this example, only the minimal request, and it was enough.

The time structure is also telling. About 33 seconds were spent waiting for the model's response, and the agent itself requested two further pauses of 60 seconds each. The sandbox sat idle throughout. Along the way, the agent inspected the repository and git history, ran the tests, found a failing test, read the HeaderDict class in the bottle library, and fixed the header checks. In the end, all 367 tests passed. The tests themselves took a second or two.

What to do in practice

The main takeaway for teams building agent platforms: don't budget for peak capacity for the entire session. First, measure the profile of your agents:

  • how long they wait for the model;
  • how often they run builds and tests;
  • how high the CPU and memory peaks are.

The larger the share of waiting, the greater the potential gain from the "minimal request plus burst as needed" approach. If guaranteed resources are critical, you can raise the request, but that should be a deliberate choice, not a default. For how Modal charges for usage above the request, check the documentation and pricing: the analyzed material doesn't include a detailed formula.

Limitations

This is the provider's own publication, and the example is a telling one: a short task with long pauses. Agents that constantly compile large projects or run heavy test suites will have less idle time and smaller savings. The figure "less than 6% of peak CPU for more than half the time" refers to a typical Sandbox on Modal's platform, that is, an averaged picture. Your workload may differ, and the material contains no independent measurements or comparisons with competitors' prices.

Still, the direction is clear. Agent workloads are uneven by nature: long pauses for reasoning and short bursts of work. A pricing model that accounts for this looks more honest than renting peak capacity for the whole session. For founders and product managers, this is a reason to recalculate agent unit economics based on average load; for engineers, it is a separate item on the checklist when choosing a sandbox platform.

Story

Key Questions Answered

Why reserving for peak doesn't suit agents?

Take a coding agent. It runs in a loop: the model decides what to do next, the agent executes a command, gets the result, and waits for the model again. While the model is thinking, the sandbox does almost nothing. Load spikes when the agent installs dependencies, runs tests, or builds the project. Other common workloads look the same: RL rollouts (agent runs for reinforcement learning training), model evaluations (evals), and app builders. All of them have long pauses and short peaks.

What a real session shows?

Modal shares a recording of a real run on a task from Terminal-Bench 2.1: find and fix a vulnerability in a repository. The agent finished in 2 minutes 46 seconds and made 10 calls to the model. The CPU stayed near zero for most of the time, apart from brief spikes when pytest ran. Memory held at around 47 MiB. Both figures fit within the sandbox's minimal request: 0.125 cores and 128 MiB. No limits were set in this example, only the minimal request, and it was enough. The time structure is also telling.

What to do in practice?

The main takeaway for teams building agent platforms: don't budget for peak capacity for the entire session. First, measure the profile of your agents: how long they wait for the model; how often they run builds and tests; how high the CPU and memory peaks are. The larger the share of waiting, the greater the potential gain from the "minimal request plus burst as needed" approach. If guaranteed resources are critical, you can raise the request, but that should be a deliberate choice, not a default.

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…