AI Agent Sandboxes Compared: 15 Providers on Isolation, Persistence, Agent Tooling, and Cost (2026)
A side-by-side comparison of 15 AI agent sandboxes, last checked in November 2026 against each provider's docs and pricing pages (sources at the end).
- Upstash Box is the best overall option on feature set and price. It has the broadest agent tooling of the fifteen (a built-in coding agent, git-to-PR, a managed browser, cron, secret injection, MCP) on a persistent computer that is quick to set up and easy to plug into your own agent. A few hard filters point elsewhere: a separate kernel per tenant, a GPU, your own cloud, or memory that survives a pause. The table below maps each need to the providers that meet it.
- Billing is the biggest hidden difference. Most providers bill wall-clock CPU and memory, while Cloudflare, Fly Sprites, Tensorlake, Upstash Box, and Vercel meter CPU by actual use. Box also leaves memory free and offers an always-on box at a rate of $0.0111 per hour (about $8 per month), which puts it among the lowest-cost rows in the worked example below.
- Isolation is three designs, not a ranking. Hardware VMs with their own kernel (Blaxel, Cloudflare, E2B, Fly Sprites, Freestyle, Koyeb, Namespace, Tensorlake, Vercel, Kata on Northflank for CPU sandboxes), gVisor's userspace kernel (Beam, Modal), and hardened containers (Daytona by default, Upstash Box).
Which sandbox fits which need
| If you need | Providers that fit | Why |
|---|---|---|
| A separate kernel per untrusted tenant | Blaxel, Cloudflare, E2B, Fly Sprites, Freestyle, Koyeb, Namespace, Tensorlake, Vercel Sandbox | Hardware VM isolation |
| A GPU in the sandbox | Beam, Daytona, Koyeb, Modal, Northflank | GPU instances |
| Your own cloud account (BYOC) | Beam, Blaxel, Daytona, E2B (Enterprise), Northflank, Tensorlake | Self-serve or enterprise BYOC |
| Memory that survives a pause | Blaxel, E2B, Freestyle, Tensorlake | Memory snapshots |
| A persistent computer for an agent that is quick to set up and easy to plug in | Upstash Box | TypeScript and Python SDKs, CLI, MCP server, and SSH; works with your own agent loop or runs Claude Code, Codex, or OpenCode for you |
| The lowest cost for agent work that mostly waits on a model | Upstash Box, then Beam (Shared), Cloudflare | Active-CPU billing with memory free: about $0.017 for the hour in the worked example below |
| The lowest cost for an always-on or CPU-bound sandbox | Upstash Box (keep-alive), then Beam (Shared), Koyeb | $0.0111 per wall-clock hour for a 2 vCPU / 4 GB box |
This post compares 15 popular AI agent sandbox providers side by side, from the same angles for each: capabilities, agent-native features, deployment, developer experience, and cost. Every row has a source at the end.
At a glance
| Provider | Isolation | Cold start (claimed) | Billing basis | Idle cost | Session cap | What survives a pause | Agent built in |
|---|---|---|---|---|---|---|---|
| Upstash Box | Container: own fs, process tree, network namespace | ~2.5s create to first command, ~0.4s resume (measured by us from Europe, September 2026) | Active CPU only, memory free | $0 compute, $0.10/GB-mo storage | None (auto-pause, keep-alive, or 3-day ephemeral TTL) | Filesystem, env, git state | Yes: Claude Code, Codex, OpenCode, Cursor, custom |
| Daytona | Container by default; Linux VM, Windows and macOS VM classes | under 90ms | Wall-clock vCPU + RAM | Disk only when stopped | None documented | Filesystem (containers), memory (VMs) | No (guides) |
| E2B | Firecracker microVM | ~150ms (case study) | Wall-clock vCPU + RAM | $0 paused | 1h Hobby, 24h Pro; pause resets it | Filesystem + memory + processes | No (docs for running agents inside) |
| Vercel Sandbox | Firecracker microVM | "Milliseconds" | Active CPU + provisioned memory | Snapshot storage $0.08/GB-mo | 45m Hobby, 24h Pro per session; unbounded across sessions | Filesystem, auto-snapshot on stop and auto-resume on the next call | CLIs preinstalled, no run API |
| Modal | gVisor (VM option) | Sub-second | Wall-clock, max(request, actual); 0.125-core / 128 MiB default request | No pause state | 24h | Nothing; snapshots instead | No (examples) |
| Cloudflare Sandbox | Firecracker microVM (image runs as a container inside) | 1–3s | Active CPU + provisioned memory, while awake | $0 compute; R2 for backups | None; stops shortly after idle unless an inactivity timeout is set (max 6h); 10m default on SDK 0.x | Nothing by default; filesystem snapshots (beta) or directory backups to R2 | No |
| Blaxel | microVM | ~25ms resume from standby | Memory-based (GB-s) while active | $0 compute, $0.20/GB-mo snapshot | None; 7–30d retention on low tiers | Filesystem + memory + processes | No |
| Namespace | microVM on own bare metal | 0.8s to agent connected | Wall-clock units (1 vCPU + 2 GB per minute) | Stopped: no compute; Devbox storage $0.20/GB-mo | 3h / 5h / 24h by plan | Filesystem (devbox volumes) | No |
| Beam | gVisor + runc container; microVM opt-in (use_vm=True) | ~0.5s | Wall-clock CPU + RAM | No pause; billed until TTL | None | Nothing in place; fs and memory snapshots | No |
| Tensorlake | Firecracker / Cloud Hypervisor | "A few hundred ms" | Active CPU (20% of allocated vCPU minimum) + RAM + disk | Snapshot storage $0.07/GB-mo | 2h Free, 24h Credits, unlimited Pro | Filesystem + memory + processes | No |
| Northflank | Kata + Cloud Hypervisor microVM; gVisor for GPU sandboxes | "Under 1 second" | Wall-clock vCPU + RAM | Volume storage only | None | Filesystem (volumes) | Cloud Harnesses with agent CLIs, no run API |
| Freestyle | KVM Linux VM | ~65ms provision | Wall-clock vCPU + RAM | Storage only | None | Filesystem + memory + processes on pause; disk only on stop | No |
| Fly Sprites | Firecracker microVM | 1–2s create; 100–500ms warm wake | Actual CPU and RAM use, while active | $0 compute | None | Filesystem (100 GB); memory while warm | CLIs preinstalled, no run API |
| Koyeb | microVM on bare metal | under 250ms | Wall-clock per instance size | $0 when scaled to zero | 24h auto-delete max; 12h after scale to zero | Nothing (ephemeral) | CLIs preinstalled, no run API |
| Runloop (winding down) | VM on custom hypervisor | "A few seconds" (docs) | Wall-clock CPU + RAM | Storage only when suspended (Pro plan) | 1h default, configurable | Disk only | Partly: Broker runs and manages an agent process |
Runloop is winding down. Its docs say transition support for existing customers runs through November 13, 2026, with migration guides to Tensorlake, Modal, and Freestyle, and its benchmark product is discontinued. Upstash Box could also be a good fit for teams moving off it, since it covers the same agent-running, secret-injection, and MCP columns in the tables below. The Runloop rows are kept for reference and for anyone migrating off it, but it is left out of the recommendations.
What each column is telling you:
Isolation is three designs, not a ranking: a VM with its own kernel, gVisor's userspace kernel, or a hardened container. Most providers run a VM. Daytona (by default) and Box run hardened containers, each with its own filesystem, process tree, and network namespace.
Cold start is what vendors lead with and what matters least, since booting is a fraction of the time a task spends cloning, installing, and calling a model. The figures are not like for like: they mix create-to-first-command, resume-from-standby, and time-until-an-agent-connects, and each is the vendor's own claim except the Box row, which we measured with five runs from Europe in September 2026.
Billing basis is the one that surprises people at scale. Wall-clock charges for every second the sandbox is up, including the minutes it waits on a model; active CPU charges only for what the code burns. Among the active-CPU providers, memory is still billed while the sandbox is up on all but Box.
Idle cost is what you pay between sessions, usually storage for the saved disk. Providers with no pause state keep charging the full rate until the sandbox is deleted.
Session cap is easy to miss until it bites: an hour is fine for a code interpreter, wrong for a long task, and the longer cap is often a paid plan away. Seven of the fifteen, Box included, have no cap at all.
What survives a pause decides how you structure a session: filesystem only means restarting processes, memory as well means a loaded model is still there, nothing means starting from a snapshot each time. Blaxel, Box, E2B, Tensorlake, and Vercel are the ones built around pausing and coming back.
Agent built in separates platforms that run an agent behind an API you call with a prompt from those that only let you install one. "CLIs preinstalled" is the middle ground. Box is on the yes side, and Runloop's Broker was before the wind-down.
Capabilities
| Provider | Snapshot / fork | Custom images | Egress control | Built-in tooling |
|---|---|---|---|---|
| Upstash Box | Disk snapshots incl. agent config; fan out to N boxes | Node, Python, Go, Ruby, Rust images; custom Docker images planned | Open default; deny-all; domain + CIDR allow, CIDR deny; changeable on a running box; private ranges always blocked | Coding agent, headless Chromium with AI actions and recordings, git with createPR, cron schedules, authenticated public URLs, PTY sessions, SSH, per-run cost and logs, skills and MCP servers for the agent, remote MCP server, CLI |
| Daytona | Disk snapshots; VM snapshots with memory; VM fork | Any image, Dockerfile, declarative builder | Restricted on Tiers 1–2, open on 3–4; CIDR (max 10) and domain (max 100) allowlists, block-all; changeable on a running sandbox on Tiers 3–4 | Git, LSP, PTY, MCP server, Computer Use desktop, VNC, SSH, signed preview URLs, audit logs, Windows and macOS VMs |
| E2B | Memory + fs snapshots; fork() up to 20 per call in the SDKs | Any Docker image or Dockerfile | Open default; allow by domain, CIDR, IP; deny by CIDR, IP (allow wins); runtime updates; header injection (beta) | Code interpreter (Python, JS, R, Java, Bash), Desktop/VNC, Kernel cloud browser template, MCP Gateway, public URLs, webhooks |
| Vercel Sandbox | Persistent by default; disk snapshots; fork from snapshot; 30-day default expiry, configurable to indefinite | Any OCI image via Vercel registry, Dockerfile; managed images | Open default; deny-all; domain + CIDR allow, CIDR deny; live updates; credential brokering | Preinstalled opencode, Claude Code, Codex, pi; preview URLs; per-agent Linux users; persistent Drives; Harbor evals |
| Modal | Fs and directory snapshots; exit snapshots (beta); memory snapshots alpha | Any registry image or Dockerfile | Open default; block-all, CIDR allowlist, domain allowlist (beta, 443 only); policy swap on a running sandbox (alpha) | Tunnels, connect tokens, secret injection (beta), sidecars (beta), OIDC identity; Claude Code as an example |
| Cloudflare Sandbox | Filesystem snapshots (beta, 30-day TTL, 20 GB max), restorable into a new instance; directory backups to R2 | Dockerfile or Docker Hub image, 20 GB disk max | Closed default on SDK 1.0 (open on 0.x); host allow/deny globs and CIDRs; HTTP/HTTPS only; runtime changes; secrets from the Worker | PTY exec, file and R2 mount helpers, filesystem snapshots (beta); code interpreter, preview URLs and tunnels are built in on SDK 0.x only |
| Blaxel | Memory + disk + process snapshots; fork (private preview) | Dockerfile that embeds Blaxel's binary; 20+ templates | Domain allow/deny with wildcards, method and path rules; no CIDR; MITM secrets proxy | MCP server per sandbox, codegen tools, preview URLs with custom domains, PTY, browser and Jupyter templates, sandbox schedules (cron) |
| Namespace | Marketing mentions snapshot and clone; no SDK methods | Dockerfile (Linux); managed macOS images | Opt-in policies: BLOCK mode with domain allow rules, secret-header injection (needs deep packet inspection) | SSH, exec, ingress URLs with custom domains, Docker, nested KVM, macOS and Windows machines, VNC desktop on macOS Devboxes |
| Beam | Fs + memory snapshots; fork | Any registry image, Dockerfile | Open default; block-all; allowlist by hostname, wildcard domain, IP, CIDR (max 64) | Public port URLs, fs and process APIs, Volumes, S3 mounts, Docker |
| Tensorlake | Fs or memory snapshots; clone from running or suspended | Dockerfile, SDK image builder, any OCI image | Open default; allow/deny by domain, IP, CIDR; air-gap mode | Public URLs, PTY, VNC image, warm pools, durable workflows |
| Northflank | Container snapshots: filesystem of a running pod, restore a service from it (Kata runtime only); no fork | Any OCI image | Open default; IP/CIDR/FQDN policies on BYOC only | Public DNS per port, exec API, cron jobs, databases and queues on the same platform |
| Freestyle | Memory + disk snapshots; fork a running VM without pausing | Base snapshots up to 32 vCPU / 64 GiB on Pro (larger needs custom limits); custom snapshots; no Dockerfile base | Deny-by-default; allow rules only (CIDR, VM, VPC, port); exact-domain allow via TLS rules, no wildcards | style.dev domains with TLS, forward auth, SSH, PTY, VPCs, WireGuard |
| Fly Sprites | Disk-only checkpoints, restore in place; no fork | Fixed Ubuntu image | Unrestricted default; optional DNS domain allowlist; private IPs blocked | Preinstalled Claude, Gemini, Codex, Cursor CLIs; private-by-default URL; Connectors credential gateway; hosted remote MCP |
| Koyeb | Experimental fs snapshots in the Python SDK; no fork | Any Docker image, private registries | Block-all or IP/CIDR allowlist; open otherwise | Default image with Mistral Vibe, Codex, Gemini, OpenCode CLIs; expose_port URLs, TCP proxy |
| Runloop (winding down) | Disk snapshots, fan-out | Blueprints (Dockerfile on Runloop base), Docker-in-Docker | Unrestricted default; hostname allowlist; deny-all; no CIDR rules | Playwright browser with live view, Ubuntu desktop, tunnels with bearer auth, MCP Hub, Agent Gateways, Broker, PTY, SSH |
Snapshot / fork makes parallel work cheap: set up once, snapshot, then start ten sandboxes from that state. Whether it carries memory as well as disk decides whether those ten start warm or cold.
Custom images move setup to build time. Most providers take any Docker image or Dockerfile. Box, Fly Sprites, and Freestyle work differently: Box offers per-runtime images plus snapshots, with custom images planned.
Egress control is the column to read closely if the sandbox runs code you did not write. Almost every provider starts open; Freestyle and Cloudflare (SDK 1.0) start closed, and Beam, Box, Cloudflare, Daytona (Tiers 3–4), E2B, Modal (alpha), and Vercel let you change the policy on a running sandbox.
Built-in tooling is the gap between a machine and a runtime. It ranges from a code interpreter and preview URLs to browsers, desktops, credential gateways, and agent runners. The next section breaks the agent-specific part down.
GPUs inside the sandbox: Beam, Daytona, Koyeb, Modal, and Northflank, plus Tensorlake by request. Blaxel, Box, E2B, Namespace, and Sprites are CPU-only.
Agent-native features
A sandbox that only runs commands leaves you to build the agent loop, the git flow, the browser, the scheduler, and the secret handling yourself. These columns cover that layer. They matter if you want the platform to do it; if you already run your own agent loop, weigh the earlier tables more.
| Provider | Run a coding agent with one call | Typed output | Scheduled runs in the sandbox | Secrets kept off the sandbox | Managed browser | Git-to-PR helper | MCP: control / tools |
|---|---|---|---|---|---|---|---|
| Upstash Box | Yes: box.agent.run() with Claude Code, Codex, OpenCode, Cursor, or a custom harness | Yes (Zod or Pydantic schema) | Yes: box.schedule.exec and box.schedule.agent on a cron | Yes: Attach Headers, injected on the host | Yes: headless Chromium, AI actions, recordings, live view, CDP | Yes: git.clone, commit, push, createPR | Control: yes. Tools: yes |
| Daytona | No (guides) | No | No | Yes: placeholder substitution in an outbound proxy, with response scrubbing | Computer Use / VNC only | Git ops, no PR helper | Control: yes. Tools: no |
| E2B | No (docs for Claude Code, Codex, OpenCode inside) | No | No | Yes: header injection via egress proxy (beta) | Via Kernel (third party, own API key); Desktop/VNC | No (git module deprecated; run git through commands) | Control: no. Tools: yes (MCP Gateway) |
| Vercel Sandbox | CLIs preinstalled, no run API | No | No | Yes: credential brokering in the firewall | No | git and gh in image | No |
| Modal | No (examples) | No | No (cron is for Functions) | Yes: header injection via Outbound Policy (beta) | No | No | No |
| Cloudflare Sandbox | No | No | No (Cron Triggers are separate) | Yes: handlers in the Worker | No | No | No |
| Blaxel | No | No | Yes: sandbox schedules (cron, at, delay) run a command | Yes: MITM proxy injection | Via templates | No | Control: yes. Tools: no |
| Namespace | No | No | No | Yes: INJECT rules from Vault (needs deep packet inspection) | No | No | Control: yes (hosted MCP server). Tools: no |
| Beam | No | No | Platform @schedule, not per sandbox | Yes: brokered secrets, placeholder swapped in HTTPS headers to approved hosts | No | No | No |
| Tensorlake | No | No | Platform cron for Orchestration endpoints, not per sandbox | No | VNC image | No | No |
| Northflank | Cloud Harnesses: Claude Code, Codex, Cursor, OpenCode, Pi, Devin CLI in a managed workspace; no run API | No | Platform cron jobs | Yes: secret injection at egress (per product page) | Chromium in the Harness image only | No | Control: yes (hosted MCP server). Tools: no |
| Freestyle | No | No | No | Yes: header injection at the edge via TLS rules | No | No | No |
| Fly Sprites | CLIs preinstalled, no run API | No | No | Yes: Connectors gateway | No | No | Control: yes (hosted remote MCP). Tools: no |
| Koyeb | CLIs preinstalled, no run API | No | No | No | No | No | No |
| Runloop (winding down) | Partly: Broker starts the agent process, orders turns, auto-resumes; you wire the event streams | No | No | Yes: Agent Gateways and MCP Hub | Yes: Playwright with live view | No | Control: yes (CLI MCP server). Tools: yes (MCP Hub) |
Run a coding agent with one call has three levels: you bring the agent, the CLIs are preinstalled and you parse stdout, or the platform runs the process for you. Box exposes it as an SDK method with a typed result; Runloop's Broker runs the process and you wire the event streams.
Typed output lets one agent's answer feed the next step without a parser in between. Box takes a Zod or Pydantic schema in the SDK and returns a validated object; elsewhere it comes from the agent or framework you run inside.
Scheduled runs in the sandbox suit agents that work on a cadence rather than on a request. Blaxel and Box have cron inside the sandbox, and Box can also schedule an agent run; Beam, Northflank, and Tensorlake schedule at the platform level.
Secrets kept off the sandbox matters because the obvious approach is the unsafe one: an environment variable is readable by the code the model just wrote. A host-side proxy that injects the credential keeps it out of reach, and most providers here now have some form of it.
Managed browser decides whether web work is a feature or a Chromium install you maintain. Box ships one, as did Runloop; E2B documents Kernel's cloud browsers, Daytona and Tensorlake give you a VNC desktop instead, and Blaxel has browser templates.
Git-to-PR helper is the difference between a finished task and a diff sitting in a container. Daytona wraps git operations and Vercel ships git and gh in the image; Box is the one with a createPR call.
MCP is two questions in one heading: driving the sandbox from an MCP client, and giving the agent inside MCP tools. Box does both; Blaxel, Daytona, Fly Sprites, and Namespace offer a control server, and E2B a tools gateway.
As an example of what the built-in route looks like, here is a full task on Box: clone, branch, run the agent, commit, push, open the pull request, with the run's cost attached:
import { Agent, Box } from "@upstash/box"
const box = await Box.create({
runtime: "node",
agent: { harness: Agent.ClaudeCode, model: "anthropic/claude-fable-5" },
git: { token: process.env.GITHUB_TOKEN },
attachHeaders: { "api.stripe.com": { Authorization: `Bearer ${process.env.STRIPE_KEY}` } },
})
await box.git.clone({ repo: "https://github.com/your-org/your-repo", branch: "main" })
await box.cd("your-repo")
await box.git.exec({ args: ["checkout", "-b", "fix/null-token"] })
const run = await box.agent.run({ prompt: "Fix the null-token bug in src/auth.ts and add tests" })
await box.git.commit({ message: "fix: handle null token in auth" })
await box.git.push({ branch: "fix/null-token" })
const pr = await box.git.createPR({ title: "Fix null token bug", base: "main" })
console.log(pr.url, run.cost.totalUsd)On providers without the git and agent helpers, the same flow is your own code around exec: shell out to git, stream the agent's output, parse it, then call the GitHub API yourself. That is more code, and also more control over the loop.
Deployment
| Provider | Hosting | Regions | Compliance |
|---|---|---|---|
| Upstash Box | Managed; SDKs and CLI open source | AWS us-east-1; regional requirements on Enterprise | SOC 2 for Upstash Redis on Pro and Enterprise (trust center); HIPAA covers Redis; both in progress for Box |
| Daytona | Managed shared and dedicated regions; BYOC; open-source repo archived, unmaintained since June 2026 | us, eu | SOC 2 Type II, HIPAA, GDPR, ISO 27001 |
| E2B | Managed on GCP and AWS; BYOC on AWS, GCP and Azure (Enterprise); Apache-2.0 self-hosted runtime (E2B Embed) | GCP us-west1 default; AWS us-west-2 and us-east-1, EU, APAC on request (EU and APAC need a payment method) | SOC 2 Type II; HIPAA BAA on request; GDPR DPA |
| Vercel Sandbox | Managed only; SDK Apache-2.0 | 19–20 regions, iad1 default | SOC 2 Type II; Vercel-wide ISO 27001, HIPAA BAA, GDPR, PCI |
| Modal | Managed only | 19 narrow regions plus US/EU/AP; 1.15x–1.75x price multipliers | SOC 2 Type II; HIPAA BAA (Enterprise) |
| Cloudflare Sandbox | Managed only; SDK Apache-2.0 | "Region: Earth", no selection | Cloudflare-wide SOC 2 Type II, ISO 27001, PCI, HIPAA BAA |
| Blaxel | Managed; bring-your-own-metal and private VPC interconnect, control plane stays managed | Oregon, Virginia, London, Frankfurt | SOC 2, HIPAA ($250/mo add-on), ISO 27001 |
| Namespace | Managed on own hardware | Not enumerated; residency on Enterprise | SOC 2 Type 2 |
| Beam | Managed; BYOC; self-host via Beta9 (AGPL-3.0) | US default; "30+" claimed | SOC 2 Type II; HIPAA BAA (Enterprise); GDPR DPA |
| Tensorlake | Managed; BYOC on AWS, GCP, Azure, CoreWeave, Nebius, bare metal | Not documented | SOC 2 Type 2; HIPAA BAA on Pro and above |
| Northflank | Managed; self-serve BYOC on AWS, GCP, Azure, OCI, Civo, CoreWeave, Nebius; bring your own Kubernetes | 17 managed regions across Americas, EMEA, and Asia Pacific; more via BYOC | SOC 2 Type 2; ISO 27001; HIPAA BAA (Enterprise) |
| Freestyle | Managed only | Not documented | Not documented |
| Fly Sprites | Managed only | Nearest Fly region, not selectable | Fly-wide SOC 2 Type 2; HIPAA BAA |
| Koyeb | Managed only | FRA, WAS, SIN, TYO, PAR, aws-us-east-1, SFO | ISO 27001, SOC 2 (Enterprise) |
| Runloop (winding down) | Managed; Enterprise deploy to VPC | Not documented | SOC 2 Type II, HIPAA, GDPR |
Hosting rules providers out rather than ranking them. For your own cloud account the list is Beam, Blaxel, Daytona, E2B (Enterprise), Northflank, and Tensorlake; the rest, Box included, are managed-only.
Regions range from a single region to dozens. Box runs in us-east-1 today, with more regions planned.
Compliance is where you read the scope rather than the badge. Most of these cells describe the parent company's certification, not an audit scoped to the sandbox.
Developer experience
| Provider | SDKs | Documented framework integrations | Concurrency |
|---|---|---|---|
| Upstash Box | TypeScript, Python (sync and async), CLI, remote MCP server | Vercel AI SDK, LangChain Deep Agents, Eve, TanStack, CrewAI and Pydantic AI (custom harness), Herdr, OpenClaw, Hermes | 10 Free; 1,000 Pay-as-you-go (soft); custom Enterprise |
| Daytona | TypeScript, Python, Ruby, Go, Java, CLI | OpenAI Agents SDK, LangChain, LangGraph, Vercel AI SDK, Mastra, Google ADK, MCP | vCPU pools 10 → 500 by tier; 4 vCPU / 8 GB per sandbox |
| E2B | Python, JS/TS, CLI | OpenAI Agents SDK, Vercel AI SDK, LangChain Deep Agents, CrewAI, Mastra, Letta | 10 Hobby, 100 Pro, up to 1,100 |
| Vercel Sandbox | TypeScript, Python, CLI, REST | Vercel AI SDK, LangChain, OpenAI and Anthropic SDKs, TanStack AI, Claude Agent SDK | 10 Hobby, 10,000 Pro |
| Modal | Python; JS/TS and Go (beta) | OpenAI Agents SDK, LangGraph, Claude Managed Agents | 100 Starter, 5,000 Team |
| Cloudflare Sandbox | TypeScript only | OpenAI Agents SDK, Codex, Workers AI | 15,000 concurrent vCPU per account (default, raisable) |
| Blaxel | TypeScript, Python, Go, CLI | LangChain/LangGraph, OpenAI Agents SDK, Vercel AI SDK, CrewAI, Mastra, Pydantic AI | 10 Tier 0 up to 100k+ |
| Namespace | Go, TypeScript, gRPC, CLI, hosted MCP server | Claude Managed Agents, Cursor Cloud Agents, Devin | 32 / 64 / 160 vCPU pools |
| Beam | Python, TypeScript, CLI | LangChain example | 30 CPU Developer; 1,000 Team |
| Tensorlake | Python, TypeScript, CLI | Claude Managed Agents, Cursor Cloud Agents, Devin Outposts, Harbor, OpenCode, Crabbox | 1 Free, 100 Credits, 1,000 Pro |
| Northflank | REST, CLI, JavaScript and Python clients | Not documented | Unlimited on pay-as-you-go |
| Freestyle | TypeScript, CLI | OpenAI Agents SDK, Mastra, Claude Agent SDK (guides) | 10 Free, 40 Hobby, 400 Pro |
| Fly Sprites | Python, JS/TS, Go, Elixir | OpenAI Agents SDK, Google ADK, TanStack AI, OpenEnv, Claude Managed Agents, Cursor Cloud Agents | 20 to 2,000 active by plan; cold unlimited |
| Koyeb | Python, JS/TS, CLI | Claude Agent SDK, Codex tutorials | 100 CPU Pro; 1,000 Scale |
| Runloop (winding down) | Python, TypeScript, CLI | OpenAI Agents SDK and Agents API, OpenCode, Browserbase, Claude Code via Broker | 3 on trial; paid caps not documented |
SDKs decide whether the sandbox fits your stack without a REST wrapper of your own. TypeScript and Python are near-universal; Cloudflare is TypeScript-only.
Documented framework integrations show how much glue the provider has already written and tested. The Vercel AI SDK, LangChain, and the OpenAI Agents SDK are the common ones; Northflank documents none.
Concurrency is a plan limit rather than a technical one. Free tiers sit around 10 to 30 and paid ceilings vary by three orders of magnitude.
Cost
List prices, pay-as-you-go. Many providers have a plan with no monthly fee but gate features behind a paid one: E2B Pro ($150/mo) for 24h sessions, Namespace Team ($100/mo) for 5h instances, Tensorlake Pro ($250 per cycle, which includes $250 of usage) for the lower rates. Cloudflare needs the $5/mo Workers Paid plan, and new Koyeb accounts need Pro ($29/mo) or above. Freestyle's docs and pricing page disagree on whether persistent VMs need Hobby ($50/mo).
| Provider | Billing basis | CPU | Memory | Free tier | Idle cost |
|---|---|---|---|---|---|
| Upstash Box | Active core-hours only | $0.10 / $0.20 / $0.40 per active CPU-hour for small (2 vCPU), medium (4), large (8) | Free | 10 boxes, 5 CPU-h/mo, no card | Paused: $0 compute, $0.10/GB-mo storage. Keep-alive at $0.0111 / $0.0222 / $0.0444 per hour (about $8 / $16 / $32 per month) |
| Daytona | Wall-clock per second | $0.0504/vCPU-h | $0.0162/GiB-h | $200 credit (not for GPU) | Stopped: disk only |
| E2B | Wall-clock per second | $0.0504/vCPU-h | $0.0162/GiB-h | $100 one-time credit, 10 concurrent, 1h sessions | Paused: $0 |
| Vercel Sandbox | Active CPU + provisioned memory | $0.128/active vCPU-h | $0.0212/GB-h | 5 active CPU-h, 420 GB-h, 10 concurrent | Stopped: snapshot storage only |
| Modal | Wall-clock, max(request, actual); 0.125-core / 128 MiB default request | ~$0.142 per physical core-h (2 vCPU); 3x its Function rate | ~$0.024/GiB-h | $30/mo credit | No pause state |
| Cloudflare Sandbox | Active CPU + provisioned memory and disk, while awake | $0.072/vCPU-h | $0.009/GiB-h | None on Free plan | Sleeping: $0 compute |
| Blaxel | Memory-based per second while active | No vCPU line item | $0.0414/GB-h | Up to $200 credit, 10 concurrent | Standby: $0 compute |
| Namespace | Wall-clock per minute in 1 vCPU + 2 GB units | ~$0.09/unit-h overage, ~$0.06 prepaid | Included in unit | 30-day trial | Stopped: no compute; Devbox storage $0.20/GB-mo |
| Beam | Wall-clock per millisecond | $0.05/vCPU-h Performance (default); $0.011 Shared; $0.0063 Spot | $0.01/GiB-h Performance; $0.0055 Shared; $0.00135 Spot | None listed; Developer plan $20/mo includes $20 credit | No pause |
| Tensorlake | Active CPU (20% of allocation minimum); RAM and disk wall-clock | $0.07/core-h Credits; $0.042 Pro | $0.015/GB-h Credits; $0.009 Pro | 1 sandbox, 1 vCPU / 1 GB, 2h sessions | Suspended: snapshot storage only |
| Northflank | Wall-clock per second | $0.01667/vCPU-h | $0.00833/GB-h | 2 services, 2 jobs, 1 database; up to $20/mo of resources | Scaled to zero: volume only |
| Freestyle | Wall-clock per second | $0.04032/vCPU-h | $0.0129/GiB-h | 200 vCPU-h, 400 GiB-h per month; persistent VMs listed on Free in the docs, paid-only on the pricing page | Paused: storage only |
| Fly Sprites | Actual CPU and RAM use, while active | $0.0385/CPU-h | $0.021875/GB-h | $1 trial credit, 7 days, no card | Warm or cold: $0 compute |
| Koyeb | Wall-clock per instance size | large (4 vCPU / 4 GB) $0.0576/h | Bundled | None for sandboxes | Scaled to zero: $0 |
| Runloop (winding down) | Wall-clock per second | $0.108/CPU-h | $0.0252/GB-h | $50 trial credit | Suspended: storage only (Pro-only) |
CPU and memory are the per-core-hour and per-GB-hour rates, and billing basis and idle cost repeat from At a glance because they decide whether those rates apply all hour or only to the busy seconds. Free tier is usually a one-off credit, not a monthly allowance.
The rate card is the wrong thing to compare. Agent work comes in bursts: the CPU is busy for a few seconds per tool call and idle while the model thinks. What matters is what you pay for the idle time.
One hour on a 2 vCPU / 4 GB sandbox, usage charges only, in two shapes: mostly idle (about 10 core-minutes of real CPU use, the rest waiting on a model) and CPU busy (both vCPUs working the full hour).
| Provider | Formula (mostly idle) | Mostly idle | CPU busy |
|---|---|---|---|
| Upstash Box (small) | 0.167 core-h × $0.10; keep-alive is $0.0111/hour | ~$0.017 | $0.0111 on a keep-alive box; ~$0.20 pay-as-you-go |
| Daytona, E2B | 2 × $0.0504 + 4 × $0.0162 | ~$0.166 | ~$0.166 |
| Vercel Sandbox | 0.167 × $0.128 + 4 × $0.0212 | ~$0.106 | ~$0.341 |
| Modal (1 physical core / 4 GiB requested) | 1 × $0.142 + 4 × $0.024 | ~$0.238 | ~$0.238 |
| Cloudflare (custom 2 vCPU / 4 GiB / 16 GB disk) | 0.167 × $0.072 + 4 × $0.009 + 16 × $0.000252 | ~$0.052 | ~$0.184 |
| Blaxel | 4 × $0.0414 if kept active; less with auto-standby | up to ~$0.166 | ~$0.166 |
| Namespace | 2 units × 60 min × $0.0015 | ~$0.18 | ~$0.18 |
| Beam | 2 × $0.05 + 4 × $0.01 (Performance, the default); 2 × $0.011 + 4 × $0.0055 (Shared, opt-in) | ~$0.14 (Performance), ~$0.044 (Shared) | ~$0.14 (Performance), ~$0.044 (Shared) |
| Tensorlake | 0.4 × $0.07 + 4 × $0.015 (Credits; CPU floor is 20% of 2 vCPU); Pro 0.4 × $0.042 + 4 × $0.009; disk extra | ~$0.088 (Credits), ~$0.053 (Pro) | ~$0.20 (Credits), ~$0.12 (Pro) |
| Northflank | 2 × $0.01667 + 4 × $0.00833 | ~$0.067 | ~$0.067 |
| Freestyle | 2 × $0.04032 + 4 × $0.0129 | ~$0.132 | ~$0.132 |
| Fly Sprites | 0.167 × $0.0385 + memory in use × $0.021875 | ~$0.012 with 256 MB in use, ~$0.094 with all 4 GB | ~$0.083 with 256 MB in use, ~$0.165 with all 4 GB |
| Koyeb (large; the 2 vCPU / 4 GB eco-large is $0.0288/h but not verified for sandboxes) | 1h × $0.0576 | ~$0.058 | ~$0.058 |
| Runloop (winding down) | 2 × $0.108 + 4 × $0.0252 | ~$0.317 | ~$0.317 |
Examples computed from list prices, not quotes. Storage is excluded except where shown, as are egress, creation fees, and monthly plan fees.
In these configurations Box is the lowest fixed-size row in the mostly idle hour at $0.017, because only the 10 active core-minutes are billed and memory is free. Next are Beam on its Shared tier ($0.044), Cloudflare ($0.052), Tensorlake Pro ($0.053), and Koyeb (~$0.058), and the highest are Modal and Runloop. Fly Sprites is the one that depends on your process: it bills memory actually in use, so a light process can come in under Box and a memory-heavy one well above it.
For a sandbox that is busy or simply up all the time, a Box keep-alive box is billed at a rate of $0.0111 per wall-clock hour for 2 vCPU / 4 GB with CPU and storage included. The next lowest are Beam Shared ($0.044/h, about $32 a month always on), Koyeb ($0.058/h, about $42), and Northflank (~$0.067/h, about $49). A single CPU-saturated hour on a pay-as-you-go box, without keep-alive, is ~$0.20.
Wall-clock providers cost the same in both columns, so the more time your agent spends waiting on a model, the more active-CPU billing saves.
Two caveats on single rows. Modal bills max(request, actual) per second, so with no resource request the mostly idle hour drops to roughly $0.03 to $0.12 depending on memory in use (our estimate from its 0.125-core default request). And other configurations will move the order: these are 2 vCPU / 4 GB examples at each provider's listed rates, not a claim about every workload.
Model usage is separate everywhere: none of the fifteen includes model tokens in the sandbox price, and on Box agents run on your own provider key.
How to choose
For most agent workloads, start with Upstash Box: it is the best overall option on feature set and price. If you have a constraint you cannot move, start from that instead:
- A separate kernel per untrusted tenant. Blaxel, Cloudflare, E2B, Fly Sprites, Freestyle, Koyeb, Namespace, Tensorlake, or Vercel. Beam (by default) and Modal use gVisor, a userspace kernel on a shared host kernel.
- A GPU in the sandbox. Beam, Daytona, Koyeb, Modal, or Northflank.
- Your own cloud. Beam, Blaxel (bring-your-own-metal), Daytona, E2B (Enterprise), Northflank, or Tensorlake.
- State that must survive in RAM. Blaxel, E2B, Freestyle, or Tensorlake.
- The sandbox has to live inside your platform. Cloudflare, Modal, or Vercel Sandbox.
- A persistent computer for your agent that is quick to set up and easy to plug in. Upstash Box: TypeScript and Python SDKs, a CLI, an MCP server, and SSH, with your own agent loop or a built-in coding agent, plus git-to-PR, a browser, and cron when you want them.
- An agent that mostly waits on a model. An active-CPU provider: Upstash Box (memory free as well), Cloudflare, Fly Sprites, Tensorlake, or Vercel.
- An always-on sandbox for your own agent. An Upstash Box keep-alive box at a rate of $0.0111 per hour (2 vCPU / 4 GB), or Beam (Shared tier), Koyeb, or Northflank on per-hour rates.
Try Box
import { Agent, Box } from "@upstash/box"
const box = await Box.create({
runtime: "node",
agent: { harness: Agent.ClaudeCode, model: "anthropic/claude-fable-5" },
})
const run = await box.agent.run({
prompt: "Write a /health endpoint in server.js and start it on port 3000",
})
console.log(run.result, run.cost.totalUsd)The free tier is 10 concurrent boxes and 5 CPU-hours a month, with no card and no platform fee. Agents use your own model provider key (Anthropic, OpenAI, OpenRouter, ...). The quickstart takes a few minutes.
Sources
Last checked in November 2026 (first published September 2026). Compliance cells repeat what the provider states.
Upstash Box (pricing) · E2B (persistence, egress) · Daytona (isolation, persistence) · Modal (sandboxes, networking) · Vercel Sandbox (concepts, firewall) · Cloudflare (limits, outbound) · Runloop (lifecycle, Broker, CLI) · Blaxel (overview, bring-your-own-metal, Baseten) · Namespace (egress policy) · Beam (security) · Tensorlake (lifecycle) · Northflank (sandboxes) · Freestyle (limits) · Fly Sprites (lifecycle, rates) · Koyeb (sandboxes, instances)
FAQ
What is the cheapest sandbox for AI agents?
In the 2 vCPU / 4 GB configurations we priced, Upstash Box. For an hour that mostly waits on a model (about 10 core-minutes of real work) it is about $0.017, because it bills active CPU only and leaves memory free; the next lowest are Beam's Shared tier at about $0.044 and Cloudflare at about $0.052. Fly Sprites bills memory actually in use, so a light process there can cost less. For a sandbox that stays on all the time, a keep-alive box is billed at a rate of $0.0111 per wall-clock hour, against about $0.044 on Beam Shared and $0.058 on Koyeb.
How do AI sandbox providers bill?
Two models. Wall-clock billing (Daytona, E2B, Modal, Northflank and most others) charges vCPU and memory for every second the sandbox is up. Active-CPU billing (Cloudflare, Fly Sprites, Tensorlake, Upstash Box, Vercel) charges CPU only while code runs; of these, Box does not charge for memory and the others do.
Which AI sandbox has the strongest isolation?
The ones that give each sandbox its own kernel in a hardware VM: Blaxel, Cloudflare, E2B, Fly Sprites, Freestyle, Koyeb, Namespace, Tensorlake, Vercel Sandbox, and Northflank's CPU sandboxes (Kata). Beam (by default) and Modal use gVisor. Daytona (by default) and Upstash Box use hardened containers.
Which sandboxes have a coding agent built in?
Upstash Box runs Claude Code, Codex, OpenCode, Cursor or a custom harness with one call and returns a typed result. Runloop's Broker starts and manages an agent process, but Runloop is winding down. Vercel Sandbox, Fly Sprites and Koyeb preinstall agent CLIs without a run API.
Which AI sandboxes support GPUs?
Beam, Daytona, Koyeb, Modal and Northflank, plus Tensorlake by request. Blaxel, E2B, Fly Sprites, Namespace and Upstash Box are CPU-only.
If a cell is out of date, open an issue or tell us on X. Providers ship changes every week, and we would rather fix a row than argue about it.
