Modal's $355M, Daytona's $24M, E2B's Billionth Sandbox: Where Agent-Infra Money Went in 2026

Three numbers tell you where agent-infrastructure spend actually went in 2026: $355 million into Modal, $24 million into Daytona, and one billion sandboxes through E2B. The first two are fundraising announcements months apart. The third is a usage odometer. Together they say something no single raise can: investors are still writing large checks for independent sandbox companies after the hyperscalers entered the category — and developers are burning through isolated execution environments at a scale that makes the checks look rational.

That table is the whole article in miniature. The rest of this post substantiates every row: what each war chest is actually buying, why the hyperscalers' entry didn't pre-empt the independents, the per-sandbox-second math that justifies the premiums, and where the money goes next — GPU-backed sandboxes, longer-lived sessions, enterprise compliance — with a read on what a team running its own machines should watch versus build.

What each war chest is actually buying​

Start with Modal, because the size forces the question. A $355 million Series C led by Redpoint Ventures and General Catalyst, with Accel and Menlo participating, valuing the company at $4.65 billion — up from $1.1 billion eight months earlier, when its $80 million Series B closed. The round landed the same week Cognition raised over $1 billion at a $26 billion valuation, which tells you the market context: late-stage capital was paying up for anything in the agent-build path that week.

But Modal's raise has a specific thesis behind it. The company sells per-second metered compute across the full NVIDIA lineup, from T4s to B200s, to production customers including Runway, Suno, Lovable, and Quora — and its CTO has spent the months since the raise talking about the shift from "developer experience" to "agent experience" as a design principle: infrastructure whose primary caller is a loop that provisions, executes, inspects, and retries, not a human reading docs.

The $355 million buys the unglamorous half of that vision: capacity reservations on scarce GPUs, private high-throughput networking for multi-node serverless jobs, and a reliability layer thick enough that an agent's retry loop rarely needs to fire.

Daytona's $24 million Series A, led by FirstMark Capital with Pace Capital and strategic money from Datadog and Figma Ventures, is a different bet at a different scale. Daytona's pitch compresses to a slogan — "give every agent a computer" — and the product is a sandbox with state: CPU, memory, storage, GPU, and OS configurable on demand, startable, pausable, and snapshotable mid-execution, with Git-like branching so an agent can fork a running environment, try something, and restore.

The number the company wants you to remember is sub-90-millisecond sandbox creation, with optimized configurations reportedly reaching as low as 27 milliseconds. That is the entire differentiation in one metric. When an agent loop spins up hundreds of environments per task, creation latency is not overhead — it is the product.

Daytona is selling the cold-start crown, and FirstMark's Matt Turck taking a board seat says the firm believes the crown compounds: faster starts attract more agent frameworks, whose volume funds more optimization.

E2B's number is not a raise but an odometer: more than a billion sandboxes started, per the company's own counter. Its last priced round was a $21 million Series A led by Insight Partners in mid-2025, which makes the billion-sandbox figure the interesting one — E2B has scaled usage far past what its raised capital would suggest, on the back of an open-source runtime, pay-per-second pricing around five cents per vCPU-hour, and distribution into the enterprises its marketing counts as most of the Fortune 100, with Perplexity and BlackBox AI among the named users. If Modal's raise says "investors will pay for GPU capacity" and Daytona's says "investors will pay for speed," E2B's odometer says "developers will standardize on whatever is already everywhere." Distribution is its moat, and a billion executions is distribution you can measure.

Why the hyperscalers didn't kill the trade​

The obvious objection to all three numbers: the giants already ship this. AWS Bedrock AgentCore includes a code-interpreter sandbox and AWS has since raised its runtime quotas several-fold to push enterprises toward it. Vercel's Sandbox reached general availability at the end of January 2026 — Firecracker microVMs with direct agent-SDK integration. Cloudflare offers a sandbox SDK spanning its edge network. Fly.io's Sprites boot Firecracker microVMs in under a second with checkpoint and restore in the hundreds of milliseconds. Every credible hyperscaler and edge platform now has an answer to "where does untrusted agent-generated code run."

And yet the independents raised anyway — after, not before, most of those launches. That sequencing is the signal. It means investor and developer demand for agent-execution infrastructure is real and growing faster than the platforms can absorb it, not a niche the hyperscalers pre-empted.

There are three structural reasons:

• Neutrality. An agent framework that standardizes on one cloud's sandbox inherits that cloud's gravity, while E2B or Daytona runs anywhere the agent runs.
• Specialization. A general-purpose cloud sandbox optimizes for the median customer, while Daytona can spend its entire $24 million making starts faster and Modal can spend its $355 million making accelerators cheaper per billed second.
• The API surface. The independents compete on the ergonomics of the sandbox primitive itself — branching, snapshots, pause and resume — while a hyperscaler's sandbox is one feature inside a two-hundred-service console.

None of this means the giants lose. It means the category is big enough that "bundled default" and "best-of-breed primitive" both clear the bar, which is exactly what a maturing infrastructure layer looks like.

The unit economics that justify the premiums​

Cold-start speed and isolation guarantees command funding-round premiums because they convert directly into per-task cost. Work it through with a representative workload: a coding agent that runs 10,000 tasks a day, each burning an average of 3 minutes of single-vCPU sandbox time. That is 30,000 sandbox-minutes, or 500 vCPU-hours per day. At roughly five cents per vCPU-hour — E2B's published neighborhood, with community-compiled comparisons putting Daytona and Cloudflare within a few cents of it — the execution line item is about $25 a day, or on the order of $750 a month before storage, egress, and concurrency headroom. That is cheap enough that no engineering manager will ever see the line item, which is precisely why the market works: sandboxes are priced below the approval threshold and consumed by loops, not humans.

Now vary the input that actually moves the result — session shape, not volume. Short, bursty tasks are the rental model's home turf: per-second billing with sub-100-millisecond starts means you pay for almost exactly what you burn. Stretch the session and the math tilts. A sandbox held open for hours of interactive agent work, paused and resumed across a day, or snapshot repeatedly for branching, accumulates metered time and storage that a flat fleet does not. Push to GPUs and the tilt becomes a cliff: accelerator seconds cost orders of magnitude more than CPU seconds, and fractional-GPU sharing is still scarce enough that whoever schedules it best wins margin. This sensitivity is the whole strategic picture in one paragraph: the independents' premiums are justified at short bursty sessions on CPU, contested at long stateful sessions, and wide open at GPU-backed execution. Any team choosing between renting and running its own pool should model its own session-length distribution before anything else — the answer falls out of that histogram.

For a self-hosted platform, the comparison is structural rather than marginal. A box you already own — a 64 GB dedicated machine in the $50-to-$60-a-month class — can host dozens of concurrent Firecracker microVMs, which means the marginal cost of the thousandth sandbox on your own fleet is effectively zero once the machine is paid for. You do not get sub-90-millisecond starts or a billion executions of operational polish on day one, and you take on the isolation hardening yourself. But there is no separate sandbox product and no separate bill: agent execution rides the same compute you already provision for apps. The independents have to beat "free at the margin" with speed, ergonomics, and GPUs — which is exactly, not coincidentally, where their war chests are aimed.

Where the money goes next: watch, don't compete​

Follow the funded roadmaps and three destinations repeat: GPU-backed sandboxes, longer-lived agent sessions, and enterprise compliance. GPU execution is the highest-margin frontier — fractional allocation, topology-aware placement, and driver-level isolation between tenants are unsolved enough that capital has something to buy. Session longevity is the architectural frontier — the current generation caps sessions at hours (an hour on hobby tiers, up to a day on pro), and whoever makes pause, resume, snapshot, and branch boring infrastructure owns the stateful-agent era. Compliance is the enterprise frontier — SOC 2, region pinning, and audit trails are what convert a billion sandbox starts into renewals.

A team running its own fleet should watch all three and compete on none of them directly. GPU scheduling primitives are standardizing in the open faster than any single vendor's roadmap — track the shared scheduling APIs and let the funded players discover the pricing. Session snapshotting on Firecracker is well-understood machinery; adopt the patterns once they stabilize rather than funding the discovery. Compliance is a checklist, not a moat, for anyone already operating multi-tenant infrastructure. The correct posture toward $379 million of other people's sandbox R&D is gratitude with a Firecracker pool: let the independents prove what agents will pay for, then bundle the proven shape into compute you already own.

The sandbox funding wave of 2026 is the market telling you agent execution is real infrastructure, not a feature. Bex.co is the open-source, AI-native Render alternative — push a git repo, get a running HTTPS service on machines you own. Star the repo on GitHub and run your agents' code where your apps already live.