Update:Our Privacy Policy has changed
·34 min read

AI Agent Sandboxes Compared: 15 Providers on Isolation, Persistence, Agent Tooling, and Cost (2026)

Ali Tarık ŞahinAli Tarık ŞahinSoftware Engineer @Upstash
https://upstash.com/blog/ai-agent-sandbox-providers-compared-2026
Summary

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, 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 needProviders that fitWhy
A separate kernel per untrusted tenantBlaxel, Cloudflare, E2B, Fly Sprites, Freestyle, Koyeb, Namespace, Tensorlake, Vercel SandboxHardware VM isolation
A GPU in the sandboxBeam, Daytona, Koyeb, Modal, NorthflankGPU instances
Your own cloud account (BYOC)Beam, Blaxel, Daytona, E2B (Enterprise), Northflank, TensorlakeSelf-serve or enterprise BYOC
Memory that survives a pauseBlaxel, E2B, Freestyle, TensorlakeMemory snapshots
A persistent computer for an agent that is quick to set up and easy to plug inUpstash BoxTypeScript 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 modelUpstash Box, then Beam (Shared), CloudflareActive-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 sandboxUpstash 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

ProviderIsolationCold start (claimed)Billing basisIdle costSession capWhat survives a pauseAgent built in
Upstash BoxContainer: 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 storageNone (auto-pause, keep-alive, or 3-day ephemeral TTL)Filesystem, env, git stateYes: Claude Code, Codex, OpenCode, Cursor, custom
DaytonaContainer by default; Linux VM, Windows and macOS VM classesunder 90msWall-clock vCPU + RAMDisk only when stoppedNone documentedFilesystem (containers), memory (VMs)No (guides)
E2BFirecracker microVM~150ms (case study)Wall-clock vCPU + RAM$0 paused1h Hobby, 24h Pro; pause resets itFilesystem + memory + processesNo (docs for running agents inside)
Vercel SandboxFirecracker microVM"Milliseconds"Active CPU + provisioned memorySnapshot storage $0.08/GB-mo45m Hobby, 24h Pro per session; unbounded across sessionsFilesystem, auto-snapshot on stop and auto-resume on the next callCLIs preinstalled, no run API
ModalgVisor (VM option)Sub-secondWall-clock, max(request, actual); 0.125-core / 128 MiB default requestNo pause state24hNothing; snapshots insteadNo (examples)
Cloudflare SandboxFirecracker microVM (image runs as a container inside)1–3sActive CPU + provisioned memory, while awake$0 compute; R2 for backupsNone; stops shortly after idle unless an inactivity timeout is set (max 6h); 10m default on SDK 0.xNothing by default; filesystem snapshots (beta) or directory backups to R2No
BlaxelmicroVM~25ms resume from standbyMemory-based (GB-s) while active$0 compute, $0.20/GB-mo snapshotNone; 7–30d retention on low tiersFilesystem + memory + processesNo
NamespacemicroVM on own bare metal0.8s to agent connectedWall-clock units (1 vCPU + 2 GB per minute)Stopped: no compute; Devbox storage $0.20/GB-mo3h / 5h / 24h by planFilesystem (devbox volumes)No
BeamgVisor + runc container; microVM opt-in (use_vm=True)~0.5sWall-clock CPU + RAMNo pause; billed until TTLNoneNothing in place; fs and memory snapshotsNo
TensorlakeFirecracker / Cloud Hypervisor"A few hundred ms"Active CPU (20% of allocated vCPU minimum) + RAM + diskSnapshot storage $0.07/GB-mo2h Free, 24h Credits, unlimited ProFilesystem + memory + processesNo
NorthflankKata + Cloud Hypervisor microVM; gVisor for GPU sandboxes"Under 1 second"Wall-clock vCPU + RAMVolume storage onlyNoneFilesystem (volumes)Cloud Harnesses with agent CLIs, no run API
FreestyleKVM Linux VM~65ms provisionWall-clock vCPU + RAMStorage onlyNoneFilesystem + memory + processes on pause; disk only on stopNo
Fly SpritesFirecracker microVM1–2s create; 100–500ms warm wakeActual CPU and RAM use, while active$0 computeNoneFilesystem (100 GB); memory while warmCLIs preinstalled, no run API
KoyebmicroVM on bare metalunder 250msWall-clock per instance size$0 when scaled to zero24h auto-delete max; 12h after scale to zeroNothing (ephemeral)CLIs preinstalled, no run API
Runloop (winding down)VM on custom hypervisor"A few seconds" (docs)Wall-clock CPU + RAMStorage only when suspended (Pro plan)1h default, configurableDisk onlyPartly: 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

ProviderSnapshot / forkCustom imagesEgress controlBuilt-in tooling
Upstash BoxDisk snapshots incl. agent config; fan out to N boxesNode, Python, Go, Ruby, Rust images; custom Docker images plannedOpen default; deny-all; domain + CIDR allow, CIDR deny; changeable on a running box; private ranges always blockedCoding 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
DaytonaDisk snapshots; VM snapshots with memory; VM forkAny image, Dockerfile, declarative builderRestricted 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–4Git, LSP, PTY, MCP server, Computer Use desktop, VNC, SSH, signed preview URLs, audit logs, Windows and macOS VMs
E2BMemory + fs snapshots; fork() up to 20 per call in the SDKsAny Docker image or DockerfileOpen 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 SandboxPersistent by default; disk snapshots; fork from snapshot; 30-day default expiry, configurable to indefiniteAny OCI image via Vercel registry, Dockerfile; managed imagesOpen default; deny-all; domain + CIDR allow, CIDR deny; live updates; credential brokeringPreinstalled opencode, Claude Code, Codex, pi; preview URLs; per-agent Linux users; persistent Drives; Harbor evals
ModalFs and directory snapshots; exit snapshots (beta); memory snapshots alphaAny registry image or DockerfileOpen 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 SandboxFilesystem snapshots (beta, 30-day TTL, 20 GB max), restorable into a new instance; directory backups to R2Dockerfile or Docker Hub image, 20 GB disk maxClosed default on SDK 1.0 (open on 0.x); host allow/deny globs and CIDRs; HTTP/HTTPS only; runtime changes; secrets from the WorkerPTY exec, file and R2 mount helpers, filesystem snapshots (beta); code interpreter, preview URLs and tunnels are built in on SDK 0.x only
BlaxelMemory + disk + process snapshots; fork (private preview)Dockerfile that embeds Blaxel's binary; 20+ templatesDomain allow/deny with wildcards, method and path rules; no CIDR; MITM secrets proxyMCP server per sandbox, codegen tools, preview URLs with custom domains, PTY, browser and Jupyter templates, sandbox schedules (cron)
NamespaceMarketing mentions snapshot and clone; no SDK methodsDockerfile (Linux); managed macOS imagesOpt-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
BeamFs + memory snapshots; forkAny registry image, DockerfileOpen default; block-all; allowlist by hostname, wildcard domain, IP, CIDR (max 64)Public port URLs, fs and process APIs, Volumes, S3 mounts, Docker
TensorlakeFs or memory snapshots; clone from running or suspendedDockerfile, SDK image builder, any OCI imageOpen default; allow/deny by domain, IP, CIDR; air-gap modePublic URLs, PTY, VNC image, warm pools, durable workflows
NorthflankContainer snapshots: filesystem of a running pod, restore a service from it (Kata runtime only); no forkAny OCI imageOpen default; IP/CIDR/FQDN policies on BYOC onlyPublic DNS per port, exec API, cron jobs, databases and queues on the same platform
FreestyleMemory + disk snapshots; fork a running VM without pausingBase snapshots up to 32 vCPU / 64 GiB on Pro (larger needs custom limits); custom snapshots; no Dockerfile baseDeny-by-default; allow rules only (CIDR, VM, VPC, port); exact-domain allow via TLS rules, no wildcardsstyle.dev domains with TLS, forward auth, SSH, PTY, VPCs, WireGuard
Fly SpritesDisk-only checkpoints, restore in place; no forkFixed Ubuntu imageUnrestricted default; optional DNS domain allowlist; private IPs blockedPreinstalled Claude, Gemini, Codex, Cursor CLIs; private-by-default URL; Connectors credential gateway; hosted remote MCP
KoyebExperimental fs snapshots in the Python SDK; no forkAny Docker image, private registriesBlock-all or IP/CIDR allowlist; open otherwiseDefault image with Mistral Vibe, Codex, Gemini, OpenCode CLIs; expose_port URLs, TCP proxy
Runloop (winding down)Disk snapshots, fan-outBlueprints (Dockerfile on Runloop base), Docker-in-DockerUnrestricted default; hostname allowlist; deny-all; no CIDR rulesPlaywright 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.

ProviderRun a coding agent with one callTyped outputScheduled runs in the sandboxSecrets kept off the sandboxManaged browserGit-to-PR helperMCP: control / tools
Upstash BoxYes: box.agent.run() with Claude Code, Codex, OpenCode, Cursor, or a custom harnessYes (Zod or Pydantic schema)Yes: box.schedule.exec and box.schedule.agent on a cronYes: Attach Headers, injected on the hostYes: headless Chromium, AI actions, recordings, live view, CDPYes: git.clone, commit, push, createPRControl: yes. Tools: yes
DaytonaNo (guides)NoNoYes: placeholder substitution in an outbound proxy, with response scrubbingComputer Use / VNC onlyGit ops, no PR helperControl: yes. Tools: no
E2BNo (docs for Claude Code, Codex, OpenCode inside)NoNoYes: header injection via egress proxy (beta)Via Kernel (third party, own API key); Desktop/VNCNo (git module deprecated; run git through commands)Control: no. Tools: yes (MCP Gateway)
Vercel SandboxCLIs preinstalled, no run APINoNoYes: credential brokering in the firewallNogit and gh in imageNo
ModalNo (examples)NoNo (cron is for Functions)Yes: header injection via Outbound Policy (beta)NoNoNo
Cloudflare SandboxNoNoNo (Cron Triggers are separate)Yes: handlers in the WorkerNoNoNo
BlaxelNoNoYes: sandbox schedules (cron, at, delay) run a commandYes: MITM proxy injectionVia templatesNoControl: yes. Tools: no
NamespaceNoNoNoYes: INJECT rules from Vault (needs deep packet inspection)NoNoControl: yes (hosted MCP server). Tools: no
BeamNoNoPlatform @schedule, not per sandboxYes: brokered secrets, placeholder swapped in HTTPS headers to approved hostsNoNoNo
TensorlakeNoNoPlatform cron for Orchestration endpoints, not per sandboxNoVNC imageNoNo
NorthflankCloud Harnesses: Claude Code, Codex, Cursor, OpenCode, Pi, Devin CLI in a managed workspace; no run APINoPlatform cron jobsYes: secret injection at egress (per product page)Chromium in the Harness image onlyNoControl: yes (hosted MCP server). Tools: no
FreestyleNoNoNoYes: header injection at the edge via TLS rulesNoNoNo
Fly SpritesCLIs preinstalled, no run APINoNoYes: Connectors gatewayNoNoControl: yes (hosted remote MCP). Tools: no
KoyebCLIs preinstalled, no run APINoNoNoNoNoNo
Runloop (winding down)Partly: Broker starts the agent process, orders turns, auto-resumes; you wire the event streamsNoNoYes: Agent Gateways and MCP HubYes: Playwright with live viewNoControl: 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

ProviderHostingRegionsCompliance
Upstash BoxManaged; SDKs and CLI open sourceAWS us-east-1; regional requirements on EnterpriseSOC 2 for Upstash Redis on Pro and Enterprise (trust center); HIPAA covers Redis; both in progress for Box
DaytonaManaged shared and dedicated regions; BYOC; open-source repo archived, unmaintained since June 2026us, euSOC 2 Type II, HIPAA, GDPR, ISO 27001
E2BManaged 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 SandboxManaged only; SDK Apache-2.019–20 regions, iad1 defaultSOC 2 Type II; Vercel-wide ISO 27001, HIPAA BAA, GDPR, PCI
ModalManaged only19 narrow regions plus US/EU/AP; 1.15x–1.75x price multipliersSOC 2 Type II; HIPAA BAA (Enterprise)
Cloudflare SandboxManaged only; SDK Apache-2.0"Region: Earth", no selectionCloudflare-wide SOC 2 Type II, ISO 27001, PCI, HIPAA BAA
BlaxelManaged; bring-your-own-metal and private VPC interconnect, control plane stays managedOregon, Virginia, London, FrankfurtSOC 2, HIPAA ($250/mo add-on), ISO 27001
NamespaceManaged on own hardwareNot enumerated; residency on EnterpriseSOC 2 Type 2
BeamManaged; BYOC; self-host via Beta9 (AGPL-3.0)US default; "30+" claimedSOC 2 Type II; HIPAA BAA (Enterprise); GDPR DPA
TensorlakeManaged; BYOC on AWS, GCP, Azure, CoreWeave, Nebius, bare metalNot documentedSOC 2 Type 2; HIPAA BAA on Pro and above
NorthflankManaged; self-serve BYOC on AWS, GCP, Azure, OCI, Civo, CoreWeave, Nebius; bring your own Kubernetes17 managed regions across Americas, EMEA, and Asia Pacific; more via BYOCSOC 2 Type 2; ISO 27001; HIPAA BAA (Enterprise)
FreestyleManaged onlyNot documentedNot documented
Fly SpritesManaged onlyNearest Fly region, not selectableFly-wide SOC 2 Type 2; HIPAA BAA
KoyebManaged onlyFRA, WAS, SIN, TYO, PAR, aws-us-east-1, SFOISO 27001, SOC 2 (Enterprise)
Runloop (winding down)Managed; Enterprise deploy to VPCNot documentedSOC 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

ProviderSDKsDocumented framework integrationsConcurrency
Upstash BoxTypeScript, Python (sync and async), CLI, remote MCP serverVercel AI SDK, LangChain Deep Agents, Eve, TanStack, CrewAI and Pydantic AI (custom harness), Herdr, OpenClaw, Hermes10 Free; 1,000 Pay-as-you-go (soft); custom Enterprise
DaytonaTypeScript, Python, Ruby, Go, Java, CLIOpenAI Agents SDK, LangChain, LangGraph, Vercel AI SDK, Mastra, Google ADK, MCPvCPU pools 10 → 500 by tier; 4 vCPU / 8 GB per sandbox
E2BPython, JS/TS, CLIOpenAI Agents SDK, Vercel AI SDK, LangChain Deep Agents, CrewAI, Mastra, Letta10 Hobby, 100 Pro, up to 1,100
Vercel SandboxTypeScript, Python, CLI, RESTVercel AI SDK, LangChain, OpenAI and Anthropic SDKs, TanStack AI, Claude Agent SDK10 Hobby, 10,000 Pro
ModalPython; JS/TS and Go (beta)OpenAI Agents SDK, LangGraph, Claude Managed Agents100 Starter, 5,000 Team
Cloudflare SandboxTypeScript onlyOpenAI Agents SDK, Codex, Workers AI15,000 concurrent vCPU per account (default, raisable)
BlaxelTypeScript, Python, Go, CLILangChain/LangGraph, OpenAI Agents SDK, Vercel AI SDK, CrewAI, Mastra, Pydantic AI10 Tier 0 up to 100k+
NamespaceGo, TypeScript, gRPC, CLI, hosted MCP serverClaude Managed Agents, Cursor Cloud Agents, Devin32 / 64 / 160 vCPU pools
BeamPython, TypeScript, CLILangChain example30 CPU Developer; 1,000 Team
TensorlakePython, TypeScript, CLIClaude Managed Agents, Cursor Cloud Agents, Devin Outposts, Harbor, OpenCode, Crabbox1 Free, 100 Credits, 1,000 Pro
NorthflankREST, CLI, JavaScript and Python clientsNot documentedUnlimited on pay-as-you-go
FreestyleTypeScript, CLIOpenAI Agents SDK, Mastra, Claude Agent SDK (guides)10 Free, 40 Hobby, 400 Pro
Fly SpritesPython, JS/TS, Go, ElixirOpenAI Agents SDK, Google ADK, TanStack AI, OpenEnv, Claude Managed Agents, Cursor Cloud Agents20 to 2,000 active by plan; cold unlimited
KoyebPython, JS/TS, CLIClaude Agent SDK, Codex tutorials100 CPU Pro; 1,000 Scale
Runloop (winding down)Python, TypeScript, CLIOpenAI Agents SDK and Agents API, OpenCode, Browserbase, Claude Code via Broker3 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).

ProviderBilling basisCPUMemoryFree tierIdle cost
Upstash BoxActive core-hours only$0.10 / $0.20 / $0.40 per active CPU-hour for small (2 vCPU), medium (4), large (8)Free10 boxes, 5 CPU-h/mo, no cardPaused: $0 compute, $0.10/GB-mo storage. Keep-alive at $0.0111 / $0.0222 / $0.0444 per hour
DaytonaWall-clock per second$0.0504/vCPU-h$0.0162/GiB-h$200 credit (not for GPU)Stopped: disk only
E2BWall-clock per second$0.0504/vCPU-h$0.0162/GiB-h$100 one-time credit, 10 concurrent, 1h sessionsPaused: $0
Vercel SandboxActive CPU + provisioned memory$0.128/active vCPU-h$0.0212/GB-h5 active CPU-h, 420 GB-h, 10 concurrentStopped: snapshot storage only
ModalWall-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 creditNo pause state
Cloudflare SandboxActive CPU + provisioned memory and disk, while awake$0.072/vCPU-h$0.009/GiB-hNone on Free planSleeping: $0 compute
BlaxelMemory-based per second while activeNo vCPU line item$0.0414/GB-hUp to $200 credit, 10 concurrentStandby: $0 compute
NamespaceWall-clock per minute in 1 vCPU + 2 GB units~$0.09/unit-h overage, ~$0.06 prepaidIncluded in unit30-day trialStopped: no compute; Devbox storage $0.20/GB-mo
BeamWall-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 SpotNone listed; Developer plan $20/mo includes $20 creditNo pause
TensorlakeActive 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 Pro1 sandbox, 1 vCPU / 1 GB, 2h sessionsSuspended: snapshot storage only
NorthflankWall-clock per second$0.01667/vCPU-h$0.00833/GB-h2 services, 2 jobs, 1 database; up to $20/mo of resourcesScaled to zero: volume only
FreestyleWall-clock per second$0.04032/vCPU-h$0.0129/GiB-h200 vCPU-h, 400 GiB-h per month; persistent VMs listed on Free in the docs, paid-only on the pricing pagePaused: storage only
Fly SpritesActual CPU and RAM use, while active$0.0385/CPU-h$0.021875/GB-h$1 trial credit, 7 days, no cardWarm or cold: $0 compute
KoyebWall-clock per instance sizelarge (4 vCPU / 4 GB) $0.0576/hBundledNone for sandboxesScaled to zero: $0
Runloop (winding down)Wall-clock per second$0.108/CPU-h$0.0252/GB-h$50 trial creditSuspended: 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).

ProviderFormula (mostly idle)Mostly idleCPU 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, E2B2 × $0.0504 + 4 × $0.0162~$0.166~$0.166
Vercel Sandbox0.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
Blaxel4 × $0.0414 if kept active; less with auto-standbyup to ~$0.166~$0.166
Namespace2 units × 60 min × $0.0015~$0.18~$0.18
Beam2 × $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)
Tensorlake0.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)
Northflank2 × $0.01667 + 4 × $0.00833~$0.067~$0.067
Freestyle2 × $0.04032 + 4 × $0.0129~$0.132~$0.132
Fly Sprites0.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:

  1. 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.
  2. A GPU in the sandbox. Beam, Daytona, Koyeb, Modal, or Northflank.
  3. Your own cloud. Beam, Blaxel (bring-your-own-metal), Daytona, E2B (Enterprise), Northflank, or Tensorlake.
  4. State that must survive in RAM. Blaxel, E2B, Freestyle, or Tensorlake.
  5. The sandbox has to live inside your platform. Cloudflare, Modal, or Vercel Sandbox.
  6. 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.
  7. An agent that mostly waits on a model. An active-CPU provider: Upstash Box (memory free as well), Cloudflare, Fly Sprites, Tensorlake, or Vercel.
  8. 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.