Three paths, three tradeoffs
Every company deploying AI agents faces the same infrastructure decision. The agents need somewhere to run — isolated compute for code execution, browsers for web automation, desktops for GUI applications. Three options exist, and each optimizes for a different priority:
| Path | Time to deploy | Engineering cost | Flexibility | Lock-in risk |
|---|---|---|---|---|
| Build on AWS/GCP | 6–10 months | $200K+ upfront + 0.5–1 FTE ongoing | Maximum | None (you own it) |
| Managed platform | 1 day – 1 week | $0 upfront, pay-per-use | High (API-based) | Low (standard APIs, portable) |
| Agent's built-in compute | Immediate | $0 | None (locked to one agent) | Maximum (can't switch agents) |
The managed platform market: who's who
Six funded startups are competing to be the "AWS for AI agents." Each started with a different wedge and is expanding toward the same vision. Here's the honest landscape:
E2B — the code execution specialist
Raised: $14.4M. Focus: Firecracker-based code execution sandboxes with ~300ms cold start. Best at: pure code execution, fastest startup time in the market, excellent Python/TypeScript SDKs. Doesn't have: browser containers, desktop containers, persistent storage (beyond session). Best for: coding agents that only need a terminal.
Modal — the ML infrastructure play
Raised: $113M. Focus: Serverless compute with native GPU scheduling. Best at: ML inference, batch processing, container image caching, Python-first developer experience. Doesn't have: browser containers, desktop containers, SSH access, interactive terminals. Best for: data science and ML workloads, not interactive agent tasks.
Daytona — the open-source dev environment
Raised: $5M. Focus: Devcontainer-compatible development workspaces, self-hostable. Best at: open-source, full control, standardized dev environments. Doesn't have: browser containers, desktop containers, warm pools. Best for: teams that want to self-host on their own infrastructure.
Fly.io — the general-purpose compute layer
Raised: $120M+. Focus: Global app deployment with the Machines API for programmable VM lifecycle. Best at: always-on VMs, global edge compute, cheapest per-hour pricing. Doesn't have: browser/desktop containers (build-it-yourself), warm pools, agent-specific features. Best for: teams that want raw VMs and are willing to build the agent layer themselves.
Runloop — the AI agent sandbox
Focus: AI-agent-specific sandboxes with persistent storage. Best at: long-running agent tasks, persistent workspaces, good Python SDK. Status: browser support in beta. No desktop containers. Best for: coding agents that need persistence.
Sandbox Platform (us) — the full workstation
Focus: Terminal + browser + desktop. The complete AI employee workstation. Best at: the combination — 6 browser types, 4 desktop types, EC2 sandboxes, warm pools, cost tracking, multi-tenancy. Tradeoff: EC2-based sandboxes have slower cold start than Firecracker-based E2B. Best for: teams that need agents operating web portals, GUI applications, AND executing code.
The honest feature comparison
| Feature | E2B | Modal | Daytona | Fly.io | Runloop | Us |
|---|---|---|---|---|---|---|
| Terminal / code execution | Yes | Yes | Yes | Yes | Yes | Yes |
| Browser containers (CDP) | No | No | No | DIY | Beta | 6 types |
| Desktop containers (VNC) | No | No | No | No | No | 4 types |
| Warm pools | Yes | Yes | No | No | Yes | Yes |
| Persistent storage | Session | Volumes | Yes | Volumes | Yes | Yes |
| SSH access | No | No | Yes | Yes | Yes | Yes + certs |
| GPU instances | No | Native | No | Yes | No | Yes |
| Multi-tenancy / RBAC | Basic | Workspace | No | Org | Basic | Full |
| Per-user cost tracking | No | No | No | No | No | Yes |
| Self-hostable | No | No | Yes | No | No | On roadmap |
The real cost of building it yourself
Every infrastructure team considers "just building it on AWS." Here's the honest assessment of what that entails.
A basic sandbox (launch an EC2 instance, run a command, return output) takes 2–3 weeks. It feels fast. You have a demo. Leadership is impressed.
Then the requirements pile up:
- "We need browser containers for web automation." — 4–6 weeks (cloud containers + CDP + proxy routing).
- "We need desktop containers for ERP automation." — 4–6 weeks (VNC + noVNC + display server + session management).
- "We need warm pools so browsers start instantly." — 3–4 weeks (state machine, health recycling, claim/release).
- "Finance wants per-department cost tracking." — 2–3 weeks.
- "Security wants egress control and audit logging." — 3–4 weeks.
- "We need multi-tenancy for the new team." — 3–4 weeks.
- "The proxy routing keeps breaking." — ongoing.
Total: 6–10 months, $200K+ in engineering time, and a permanent 0.5–1 FTE maintenance burden.
The first 80% of the feature set (basic sandbox, execute command, SSH) takes 20% of the time. The last 20% (warm pools, multi-tenancy, cost tracking, browser containers, desktop containers, proxy routing, audit logging) takes 80% of the time. Every team that builds this underestimates the tail by at least 3x.
The bundled compute trap
Devin, Codex, and Cursor each bundle their own compute. It's convenient — the sandbox comes with the agent. But it creates lock-in:
- Devin's sandbox only runs Devin. If you want to switch to Claude Code or a custom LangChain agent, you need new infrastructure.
- Codex's containers only run GPT. You can't use Claude, Gemini, or open-source models in Codex's sandbox.
- Cursor's VMs only serve Cursor. Your ops team can't use them for AP automation or competitive intelligence.
A managed platform decouples the compute from the agent. Run Claude Code, Codex CLI, Aider, a LangChain agent, or a custom script — all on the same infrastructure. Switch models without switching infrastructure. Use the same sandbox for coding agents and business automation agents.
When to choose what
| Your situation | Best choice | Why |
|---|---|---|
| Only need code execution, speed matters most | E2B | Fastest cold start, purpose-built for code sandboxes |
| Primarily ML/GPU workloads | Modal | Best GPU scheduling, Python-native |
| Must self-host, open-source matters | Daytona | Only open-source option with full control |
| Want raw VMs, will build agent layer | Fly.io | Cheapest VMs, global presence, Machines API |
| Agents need terminal + browser + desktop | Sandbox Platform | Only platform with all three interfaces + warm pools + cost tracking |
| Locked to one agent, convenience over flexibility | Agent's built-in compute | Zero setup, just use the agent |
| Data residency / defense / extreme customization | Build yourself | Full control, full responsibility |
The question that decides it
The build-vs-buy decision comes down to one question: is sandbox infrastructure your product, or is it infrastructure for your product?
If sandbox infrastructure IS your product (you're building the next E2B, the next Devin, the next Cursor), build it. You need the control, the customization, and the deep understanding of the stack.
If sandbox infrastructure is infrastructure FOR your product (you need agents to run somewhere so they can do useful work), buy it. Every month spent building infrastructure is a month not spent deploying agents and capturing value. The platform costs $30/month for your first 7 agents. The build costs $200K before you deploy a single agent.
That's not a close call.
What's next
Ship agents this week, not this quarter
Terminal. Browser. Desktop. Warm pools. Cost tracking. Skip the 6-month build and deploy agents today.
Get Started Free