Modal's $355M Series C Puts a Price on the Sandbox: What $0.33/Hour Per Agent Sandbox Really Costs vs Self-Hosted

In May 2026, Modal Labs raised $355 million at a $4.65 billion valuation — roughly 15 times its ~$300 million in annualized revenue, and more than 4 times the $1.1 billion it was worth eight months earlier. That multiple is the market declaring that AI-agent sandbox infrastructure is a category of its own now, not a Kubernetes-adjacent niche. E2B ($43.8 million raised), Daytona ($31 million), and a half-dozen others are all raising on the same thesis.

But a 15x revenue multiple has to be paid for out of unit economics eventually. So let's do the thing the funding headlines never do: work out what a Modal sandbox actually costs per hour, what the same isolation costs on hardware you own, and the exact utilization level where one beats the other. The answer is a single number — about 5% — and it reframes the whole "serverless vs self-hosted" debate for agent fleets.

The unit-price teardown: $0.33 per sandbox-hour​

Modal publishes two price books, and the distinction matters. Plain Modal Functions bill CPU at $0.0000131 per core-second and memory at $0.00000222 per GiB-second. Modal Sandboxes — the stateful, agent-oriented product — bill roughly 3x that: $0.00003942 per core-second and $0.00000667 per GiB-second.

One definitional trap first, because Modal's billing unit confuses everyone: one Modal core is a physical core, equal to 2 vCPUs. So a typical agent sandbox — 2 vCPUs and 8 GiB of RAM — is exactly 1 billed core. The derivation, line by line:

• CPU: 1 core × $0.00003942/s × 3,600 s = $0.1419/hr
• Memory: 8 GiB × $0.00000667/s × 3,600 s = $0.1921/hr
• Total: $0.334/hr — the $0.33 in the title — or ~$244/month always-on.

Two things jump out immediately. First, memory is 57% of the bill. Second, Modal bills CPU per active cycle (genuinely idle CPU costs $0), but memory bills for every second the sandbox is alive. An always-on-but-completely-idle sandbox still costs $0.1921/hr — $140/month for a sandbox doing literally nothing. Remember that number; it's the hinge of the whole comparison.

Now the self-hosted side. A Hetzner AX42 dedicated box (Ryzen 8-core/16-thread, 64 GB RAM, NVMe) lists at about €77/month after Hetzner's 2026 price adjustments. That box holds eight of our reference 2-vCPU/8-GiB sandboxes with room to spare — 16 threads ÷ 2, 64 GB ÷ 8 — so the amortized hardware cost is ~$11/month per sandbox slot, roughly a twenty-two-fold gap at 100% utilization.

But nobody runs at 100%. The honest comparison is a sensitivity table across utilization (hours the sandbox exists and is metered, per month):

The crossover sits at about 33 sandbox-hours a month — under 5% utilization. Below that, the meter wins. Above it, the flat-rate box wins, and the gap widens fast. Add Modal's $250/month Team plan floor (another $25/sandbox/month on a ten-sandbox fleet) and the crossover drops even lower.

GPUs tell the same story with a narrower gap. A Modal L4 at $0.000222/s ($0.80/hr) costs ~$584/month running continuously; a Hetzner GEX44 with an RTX 4000 Ada — a roughly comparable card class — runs ~€212/month. Crossover: ~40% utilization.

The caveat, disclosed plainly: Hetzner's GPU menu ends where Modal's begins. If your workload needs H100s ($3.95/hr on Modal) or B200s, no budget host has a self-hosted answer — and that GPU supply is precisely what Modal's $355 million is buying.

What the 15x multiple actually buys​

This is not a "Modal is overpriced" post. The meter charges for real things that cost real money to build:

• Fleet-scale fast starts. Modal promises sub-second sandbox creation across thousands of concurrent sandboxes, via gVisor checkpoint/restore plus a lazy content-addressed image filesystem. Third-party benchmarks put real-world cold starts closer to 1–5 seconds under load — still good, and still something you do not get for free.
• GPU tiers you cannot rent elsewhere cheaply. T4 to H100 to B200 on per-second billing, with no procurement cycle. For bursty inference or fine-tuning, that access alone justifies the meter.
• Zero operations. No node images to patch, no snapshot pools to warm, no capacity planning. For a team whose agents run in spikes — a coding agent that bursts for twenty minutes then goes quiet — per-CPU-cycle billing means the spikes cost pennies and the silence costs nothing (as long as sandboxes terminate rather than idle).
• Proof at scale. Lovable, Scale AI, and Ramp run on Modal; it's inside the OpenAI Agents SDK. Crossing $300M ARR with ~170 employees is genuine operating leverage, not just a story.

For spiky, bursty, GPU-heterogeneous workloads, Modal is plausibly the cheapest option that exists. The multiple pays for elasticity and GPU supply — the two things flat-rate hardware cannot do.

What venture capital cannot subsidize​

But look again at the cost lines, because two of them don't shrink with scale:

Memory-while-alive metering. At $0.1921/hr for 8 GiB, an agent sandbox that stays warm 24/7 to avoid cold starts costs $140/month before it does a single useful cycle. Always-on agent fleets — persistent dev agents, long-running research agents, background coding agents holding workspace state — pay this on every sandbox, every hour. Snapshot/restore (E2B's Firecracker snapshots resume in ~150ms; Daytona's in under 90ms) exists precisely to dodge this line item: a snapshotted sandbox costs $0. But then you're managing snapshot lifecycle, which is operations work again.

The plan floor. Starter's $30/month credit is generous for experiments. The moment you need a team, it's $250/month before the meter starts. On a small fleet that floor can exceed the compute itself.

Neither line is a trick — both are published pricing. They're just the shape of metered economics: the meter is kind to workloads that stop, and relentless toward workloads that never do. And agent fleets increasingly never do. The whole industry direction — persistent agents with cross-session memory, long-horizon coding tasks, always-warm dev environments — pushes utilization up, which pushes every fleet toward the wrong side of the 5% crossover.

The self-hosted recipe, honestly priced​

Twenty-two-to-one at full utilization sounds like a sales pitch, so here's the other half of the ledger: what you must build and operate to collect it.

The runtime layer is increasingly commoditized open source. Daytona (open-source, 72k stars, sub-90ms sandbox creation with snapshot/resume) can self-host on your own machines; E2B's stack is open-source with Firecracker microVM isolation; the snapshot/restore pool pattern both use — pre-warmed paused microVMs claimed in milliseconds — is well documented. On one Hetzner AX42 you can run a pool of eight warm sandboxes with Firecracker-grade isolation for ~€77/month all-in on hardware.

What you must build yourself: the pool warmer and snapshot lifecycle, network egress policy per sandbox, image/template management, patching cadence for host and guest, and capacity planning (your elasticity is "order another €77 box," on a hours-to-days timescale, not seconds). Budget realistically: the hardware is $11/sandbox/month, but the first 20–40 hours of platform engineering to stand it up, plus ongoing maintenance, is the actual price. For a fleet of five sandboxes that math may not close; for a fleet of fifty always-on agents it closes in the first month.

And one disclosure the self-hosting crowd sometimes skips: Hetzner raised prices twice in 2026 — up to 37% in April across cloud and dedicated, plus June adjustments that more than doubled some US cloud plans — citing hardware and energy costs. The numbers in this post use post-hike pricing, and the 22x gap survived both hikes. But flat-rate hardware is not immune to repricing; it just reprices annually and loudly instead of per-second and silently.

The decision rule​

Strip out the brand names and the decision is one question: what fraction of the month does each sandbox exist and stay warm?

• Under ~5% utilization, or spiky with full termination between bursts: use the meter. Modal's per-CPU-cycle billing and $30 free tier make bursty fleets genuinely cheap, and you get H100/B200 access no budget host matches.
• Above ~5% sustained, always-warm, or stateful-across-sessions: self-host. Every point of utilization past the crossover is margin you donate to someone else's 15x multiple.
• GPU-bound: same logic at ~40% crossover for L4-class cards; above H100-tier, the hosted vendors are currently the only game in town, and that's exactly what the venture capital is for.

The deeper point: Modal's raise proves the category is real — agent sandboxes are infrastructure now, with analyst coverage, conformance chatter, and hyperscaler entrants (AWS AgentCore, Google's Agent Sandbox, Vercel Sandbox, Cloudflare's Sandbox SDK all shipped in 2026). Categories that real get commoditized from below.

The meter sets the price of convenience; open-source runtimes on owned hardware set the price of the thing itself. Today those differ by 22x at full utilization. Watch that gap — it, more than any funding headline, tells you where the market goes next.

Bex.co is the open-source, AI-native Render alternative — push a git repo, get a running HTTPS service on machines you own, with agent sandbox infrastructure on the roadmap rather than the invoice. Star the repo on GitHub or deploy your first app today.