13 Best Sandbox Runners in 2026

Stanley Ulili
Updated on November 12, 2026

Running code in production can be risky if something goes wrong. Sandbox runners solve this by giving you a safe, isolated place to run and test code. If you're building AI agents, running user-generated code, or testing applications, a good sandbox runner keeps things secure without slowing everything down.

But with so many tools out there, choosing the right one can be hard. This guide walks through the best sandbox runners available right now so you can pick the right fit for your development workflow.

What is a sandbox runner?

A sandbox runner is a separate, secure environment where you can run code without affecting your main system or other processes. It creates a protective barrier around the code so it can't access sensitive data or interfere with other apps.

Sandbox runners are especially useful when you need to:

  • Run code submitted by users
  • Test scripts you don't fully trust
  • Build or run AI coding agents
  • Try experimental features without risking production systems

Factors to consider when choosing a sandbox runner

Before looking at specific tools, it helps to know what actually matters when picking a sandbox runner for your use case.

Isolation and security

The main job of any sandbox is to keep things safe. Your sandbox runner should clearly separate the code it runs from the main system. Look for things like containers, virtual machines, or microVMs that make it hard for code to "escape" its sandbox. It should also limit access to important resources like the file system, network, and system calls.

Performance and speed

Sandboxes always add some overhead, but good ones keep it small. Check how fast environments start, how quickly they run code, and whether they support snapshots, forks, or pause and resume to skip repeated setup. For production apps, performance can be the difference between a smooth experience and annoying slowdowns.

Billing model

Sandbox pricing now splits into two camps. Some providers bill every vCPU and GiB you reserve for as long as the sandbox runs, whether your code is working or waiting. Others bill only the CPU time your code actually uses, which can cut costs sharply for agents that spend most of their time waiting on model responses. Check how memory, idle time, and paused storage are billed too, since those lines often decide the final invoice.

Language and runtime support

Make sure the sandbox runner works with the languages and runtimes you actually use. Some tools only support a few languages like JavaScript or Python, while others accept any Linux-compatible image. Think about whether you need custom runtimes, certain language versions, or specific libraries and dependencies.

Scalability and resource management

As your app grows, your sandbox setup needs to grow with it. Look for tools that can run many sandboxes at once, manage resources efficiently, and offer pricing that makes sense as you scale. You should be able to set limits on CPU, memory, and execution time to avoid one job using up everything.

Developer experience and integration

A sandbox runner should be easy for developers to work with. Pay attention to the quality of the API, SDKs, and documentation, and how simple it is to plug into your existing systems and agent frameworks. The easier it is to integrate and update, the faster your team can ship.

Observability and debugging

Because sandboxes are isolated, it's important to have good visibility into what's happening inside them. Choose a tool that gives you logs, metrics, and debugging options. This really helps when you're fixing bugs, tracking down errors, or tuning performance.

With these points in mind, here are the best sandbox runners available.

Tool Pricing Language Support Isolation Method Self-hosting Execution Time Limits Key Use Case
E2B Free with $100 one-time credit, Pro from $150/mo Python, JavaScript, any Linux-compatible MicroVMs: Firecracker Enterprise only: BYOC, on-prem 1 hour on Hobby, 24 hours on Pro, resets on pause AI agents, code execution
Daytona $200 free credit, usage-based Any, via Docker/OCI images Containers: Docker/OCI, optional Kata Yes Configurable AI code execution, computer use
Modal Free with $30/mo credit, Team from $250/mo Any gVisor sandbox No Up to 24 hours ML/AI workloads
Fly.io Sprites Trial credit, usage-based Any, full Linux environment MicroVMs: Firecracker No None AI agents, persistent sandboxes
Freestyle Free, Hobby from $50/mo Any, full Linux VM Full Linux VMs: KVM No Configurable AI agents, full VM workloads
Cloudflare Sandboxes Workers Paid plan at $5/mo, plus usage Any Linux-compatible Isolated Linux containers per VM No Configurable AI agents, edge code execution
Vercel Sandbox Free on Hobby, usage-based on Pro Any, via custom OCI images MicroVMs: Firecracker No 45 min on Hobby, 24 hours on Pro per session AI agents, code generation
Runtime 100 free hours, then usage-based Any Linux-compatible MicroVMs: Firecracker No None, auto-pauses when idle AI agents, low-cost code execution
Upstash Box Free with 5 CPU hours/mo, usage-based Node.js, Python, Go, Ruby, Rust Containers No None, pauses when idle Background coding agents
Val Town Free, Pro from $250/yr JavaScript, TypeScript V8 isolates No 1 min on Free, 10 min on Pro API endpoints, automation
CodeSandbox Free, Scale from $170/mo JavaScript, TypeScript, frameworks MicroVMs: Firecracker No Configurable Web development, agent sandboxes via SDK
StackBlitz Free, paid plans available JavaScript, TypeScript, WebAssembly WebContainers No None Browser-based development
Replit Free, Core from $20/mo 50+ languages Containers No Varies by plan Multi-language development

1. E2B

E2B screenshot

E2B is an open-source sandbox platform made for AI agents and LLM apps. It runs secure, isolated cloud environments using Firecracker microVMs (the tech behind AWS Lambda), which start in under 200ms. E2B reports that 94 of the Fortune 100 have signed up, more than 100,000 teams have run a sandbox on it, and it has passed a billion sandbox starts.

🌟 Key features

  • Firecracker microVM isolation for security
  • Sub-200ms startup
  • Support for Python, JavaScript, Ruby, C++, and any Linux-compatible language
  • Long-running sandboxes (up to 24 hours of continuous runtime on Pro)
  • Pause and resume, with paused sandboxes kept indefinitely
  • Code Interpreter with Python and JavaScript kernels
  • File system persistence, volumes, and file uploads
  • Terminal access and browser support
  • Custom sandbox templates with configurable CPU and RAM
  • Package installation (pip, npm, apt, etc.)
  • WebSocket streaming for real-time output
  • Desktop Sandbox for computer use agents
  • Native sandbox provider in the OpenAI Agents SDK

βž• Pros

  • Purpose-built for AI agents and LLM workflows
  • Wide enterprise adoption, with 94 of the Fortune 100 signed up
  • Open-source with an active community (~14k GitHub stars)
  • Fast startup times
  • Strong security through Firecracker microVM isolation
  • Supports any language or framework that runs on Linux
  • Can customize sandboxes with templates
  • Real-time output streaming for better UX
  • Integrates with all major LLM providers and agent frameworks
  • Available as BYOC, on-premise, or self-hosted for enterprises
  • Free Hobby tier with $100 in usage credits

βž– Cons

  • Bills reserved vCPU and RAM for as long as a sandbox runs, so idle agents still cost money until you pause them
  • Hobby tier limited to 1 hour of continuous runtime and 20 concurrent sandboxes
  • Self-hosting is not production-ready for most teams outside the Enterprise plan

πŸ’² Pricing

E2B has three main pricing tiers. The Hobby plan is free and includes a one-time $100 usage credit, 1 hour of continuous runtime, and 20 concurrent sandboxes. The Pro plan costs $150/month, raises continuous runtime to 24 hours, and includes 100 concurrent sandboxes, which you can expand to 1,100 with add-ons. Upgrading to Pro raises limits but does not add credits. Enterprise plans have custom pricing with BYOC, on-prem, or self-hosted options.

Usage is billed per second: about $0.05 per vCPU-hour plus $0.0162 per GiB-hour of RAM. The default sandbox (2 vCPUs, 512 MiB) comes to roughly $0.11 per hour, and compute billing stops as soon as a sandbox is paused or killed.

2. Daytona

Daytona screenshot

Daytona is a secure platform built for running AI-generated and untrusted code. After pivoting from development environments to AI agent infrastructure in early 2025, it now focuses on sub-90ms sandbox creation for AI agents, code execution workflows, and safe testing. In February 2026 Daytona raised a $24M Series A to expand its agentic infrastructure platform.

It uses Docker/OCI containers to isolate each sandbox (with optional Kata Containers for enhanced isolation), with configurable CPU, memory, and disk, plus controls for how long a sandbox stays active. Daytona also supports computer use sandboxes for desktop automation across Linux, macOS, and Windows, and GPU sandboxes for heavier workloads.

🌟 Key features

  • Sub-90ms sandbox creation (some configurations reach 27ms)
  • Docker/OCI container-based isolation with optional Kata Containers
  • Customizable resources (vCPU, RAM, disk)
  • Automated lifecycle management (auto-stop, auto-archive, auto-delete)
  • File system persistence across stop/start cycles
  • Snapshot support for environment templates
  • Preview URLs for running applications
  • Built-in toolbox (file system, Git, process execution, PTY)
  • Computer use sandboxes (Linux, macOS, Windows desktops)
  • GPU sandboxes, including preemptible options
  • Built-in language server support

βž• Pros

  • Among the fastest sandbox creation times available, at sub-90ms
  • Flexible resource configuration
  • Intelligent cost optimization with automatic state management
  • Supports any language or framework via Docker images
  • Can run indefinitely or auto-stop after inactivity
  • Archive sandboxes to object storage for cost-effective long-term retention
  • $200 in free compute credits included
  • Startup program offering up to $50,000 in credits
  • Enterprise on-premise deployment available
  • Large open-source community (~70k GitHub stars)

βž– Cons

  • Docker containers by default (weaker isolation than microVMs without Kata configuration)
  • Free credits can't be used on GPU sandboxes
  • Default resource limits may require support contact for higher allocations

πŸ’² Pricing

Daytona uses usage-based pricing with no subscription fee, and you don't need a credit card for the free trial. You get $200 in free compute credits to start. Compute is billed per second at $0.0504 per vCPU-hour and $0.0162 per GiB-hour of memory, and storage costs $0.000108 per GiB-hour after the first 5 GiB. A small sandbox with 1 vCPU and 1 GiB of RAM costs about $0.067 per hour while it is running, and when it is stopped you only pay for storage. Windows sandboxes add $0.0858 per vCPU-hour, GPUs are priced separately by type, and startups can apply for up to $50,000 in additional credits.

3. Modal

Modal screenshot

Modal is an AI infrastructure platform designed for data and machine learning workloads. It provides containerized execution environments that scale from zero to tens of thousands of concurrent instances in seconds, making it ideal for inference, training, batch processing, and any workload that needs to run at scale. Companies like Lovable and Quora run millions of untrusted code executions through Modal every day, and Modal says it has run more than a billion sandboxes.

🌟 Key features

  • Container-based execution with sub-second cold starts
  • Elastic GPU scaling (B200, H200, H100, A100, L40S, A10, L4, T4)
  • Automatic scaling from zero to thousands of concurrent containers
  • SDKs for Python, JavaScript, and Go
  • Scheduled jobs and cron support
  • HTTP endpoints and web servers
  • Built-in distributed storage layer
  • Programmatic sandboxes for untrusted code
  • Shareable collaborative notebooks
  • Secrets management

βž• Pros

  • Exceptional for AI/ML and data workloads
  • Multi-language SDK including Python, JavaScript, and Go
  • Easy access to GPUs for inference and training, including inside sandboxes
  • Scales automatically based on workload
  • Sub-second cold starts
  • Proven at massive scale, with Lovable and Quora running millions of executions daily
  • Pay only for actual compute time
  • Great for batch processing and parallel execution
  • Built-in scheduling for periodic tasks
  • Unified observability with integrated logging
  • $30/month free compute credits
  • SOC 2 and HIPAA compliant

βž– Cons

  • gVisor isolation by default rather than microVMs
  • No BYOC deployment option
  • Python-first SDK; JavaScript and Go SDKs are available but less mature
  • Sandboxes are billed at a non-preemptible rate, roughly three times the base CPU price

πŸ’² Pricing

Modal uses per-second billing where you pay only for actual compute time. The Starter plan includes $30/month free compute credits with up to 3 workspace seats, 100 containers, 10 GPU concurrency, and community support. The Team plan at $250/month adds $100 in monthly credits, unlimited seats, 1,000 containers, 50 GPU concurrency, and priority support. Enterprise plans offer volume discounts, higher limits, and dedicated support.

Sandboxes use non-preemptible pricing at $0.00003942 per physical CPU core per second (one physical core equals two vCPUs, so about $0.14 per core-hour) and $0.00000667 per GiB of memory per second. Since October 2026, network egress also counts toward your bill at $0.04 per GiB once you pass your plan's included allowance.

4. Fly.io

Fly.io screenshot

Fly.io is a global platform for running full-stack apps and, since January 2026, home to Sprites, its purpose-built stateful sandbox product for AI agents. Sprites are persistent Linux VMs that create in 1 to 2 seconds, checkpoint and restore in around 300ms, and automatically go to sleep when inactive so you only pay for what you use. Each Sprite gets a 100GB NVMe filesystem that survives indefinitely between sessions.

Fly.io CEO Kurt Mackey's pitch for Sprites is direct: "Ephemeral sandboxes are obsolete. Claude doesn't want a stateless container. Claude wants a computer." The result is a sandbox that installs packages once, persists state across sessions, and picks up exactly where it left off.

🌟 Key features

  • Firecracker microVM isolation
  • Persistent 100GB NVMe root filesystem per Sprite
  • Checkpoint/restore in ~300ms
  • Auto-sleep with no compute billing when inactive
  • Global deployment across 35+ regions
  • Any language or framework via full Linux environment
  • Built-in managed PostgreSQL and Redis (via Fly Machines)
  • Private networking (WireGuard mesh)
  • GPU support (A10, L40S, A100) via Fly Machines
  • REST API and TypeScript/Go SDKs for Sprites
  • Pre-installed Skills for Claude Code integration

βž• Pros

  • Persistent state across sessions, so agents don't rebuild environments every run
  • Firecracker microVM isolation for strong security
  • Checkpoint/restore means instant rollback from a broken state
  • Bills actual CPU and memory consumed, not what the Sprite was allocated
  • Auto-sleep keeps costs near zero when a Sprite is not in use
  • Full Linux environment with no language or runtime restrictions
  • Global edge regions with automatic traffic routing
  • No per-Sprite charge and no plan required

βž– Cons

  • Newer product with a smaller ecosystem than E2B or Daytona
  • CPU-only for Sprites (GPU workloads require a separate Fly Machines setup with Docker images)
  • Creation time of 1 to 2 seconds is slower than Daytona's sub-90ms or E2B's sub-200ms
  • More complex for teams not already familiar with Fly.io

πŸ’² Pricing

Fly.io has usage-based pricing with per-second billing and no plans to pick for Sprites. After the pricing update that took effect on October 1, 2026, Sprites bill $0.0385 per CPU-hour of CPU actually used and $0.021875 per GB-hour of memory actually used. Hot storage costs $0.000683 per GB-hour while a Sprite is awake, and cold storage costs $0.000027 per GB-hour for as long as you keep the data. Using Fly.io's own example, a 4-hour Claude Code session comes to roughly $0.09 in CPU and $0.13 in memory, plus a few cents of storage. New accounts get trial credit to start.

5. Freestyle

Freestyle screenshot

Freestyle is a VM platform built for AI agents and developer sandboxes, offering full Linux environments that provision in under 800ms. Unlike microVM-based runners, Freestyle gives you real root access, nested virtualization support, and a first-class TypeScript SDK, which makes it a strong fit for teams building coding agents, user sandboxes, or browser automation workflows that need more than a constrained execution environment.

Each VM runs with full KVM support, meaning you can run Docker, other VMs, or any virtualization stack inside a Freestyle VM. Agents can fork a running VM without pausing it, and VMs can be paused to disk so compute billing stops while state is fully preserved.

🌟 Key features

  • Full Linux VMs with root access and real networking stack
  • Live forking: clone a running VM without pausing it
  • Pause and resume with full memory state intact, billed only for storage while paused
  • Nested virtualization with full KVM support (run Docker, VMs-in-VMs)
  • Declarative VmSpec for reproducible environments and snapshot layering
  • Automatic idle timeout with configurable suspension
  • Pre-built language integrations: Node.js, Python, Bun, Ruby, uv, Java
  • SSH access and interactive web terminal
  • First-class TypeScript SDK (freestyle-sandboxes)

βž• Pros

  • Full Linux power, not a constrained sandbox; supports any OCI image and real system-level operations
  • Live forking enables parallel agent exploration without duplicating setup work
  • Pause and resume preserves exact VM state across sessions at no compute cost
  • Nested virtualization covers use cases other runners block entirely (Docker-in-VM, browser automation with full stack)
  • Declarative specs with snapshot caching mean repeated VM creation is instant after the first build
  • Language integrations are composable, so you can mix Node.js, Python, and Bun in a single VM
  • Free plan never bills for usage
  • Default VM specs are generous (4 vCPUs, 8GB RAM)

βž– Cons

  • Newer platform with a smaller ecosystem and community than E2B or Modal
  • Bills allocated vCPU and memory, not measured use, unless you negotiate active CPU pricing on Enterprise
  • No BYOC option currently available

πŸ’² Pricing

Freestyle uses monthly plans where the fee doubles as included usage. The Free plan costs nothing and includes up to 10 concurrent VMs and 10 saved VMs, with VMs up to 4 vCPUs and 8 GiB. The Hobby plan is $50/month, covers your first $50 of usage, and allows up to 40 concurrent VMs and 200 saved VMs. The Pro plan is $500/month, covers your first $500 of usage, and allows up to 400 concurrent VMs, 4,000 saved VMs, and VMs as large as 32 vCPUs and 64 GiB.

Usage is metered per second on allocated resources: vCPU at $0.04032/hour, memory at $0.0129/GiB-hour, and storage at $0.000086/GiB-hour. Every plan includes 200 vCPU-hours, 400 GiB-hours of memory, and 60,000 GiB-hours of storage each month.

6. Cloudflare Sandboxes

Cloudflare Sandboxes screenshot

Cloudflare Sandboxes provides secure, isolated environments for running AI agents and untrusted code. Built on Cloudflare's global network, each sandbox runs in its own isolated Linux container: a full Ubuntu environment with Python, Node.js, Git, and common developer tools pre-installed. Sandboxes and the Containers platform underneath them became generally available in April 2026. Because they are built on Cloudflare Containers and Durable Objects, sandboxes are addressed by name, start on demand, sleep when idle, and integrate directly with Workers, R2, and the rest of Cloudflare's developer platform.

🌟 Key features

  • Per-VM isolated Linux containers (Ubuntu)
  • Supports Python, Node.js, and any Linux-compatible language or runtime
  • Global deployment across Cloudflare's network
  • Integrated with Cloudflare's developer platform (Workers, R2, KV, AI)
  • Persistent code interpreters for Python, JavaScript, and TypeScript
  • Secure credential injection through an egress proxy, so agents never see raw secrets
  • Interactive PTY terminals with multiple isolated shells per sandbox
  • Backup and restore APIs to resume a coding session without repeating setup
  • Filesystem watching for real-time reactions to file changes
  • Git operations, background processes, and preview URLs

βž• Pros

  • Strong isolation through per-VM Linux containers
  • Active CPU pricing, so you only pay for CPU cycles your code uses
  • Benefits from Cloudflare's global infrastructure and low-latency edge network
  • Integrates natively with Cloudflare Workers, R2, KV, and Workers AI
  • Supports any Linux-compatible language, not just Python and Node.js
  • Built-in security and DDoS protection at the network layer
  • High limits, with thousands of concurrent containers on the standard plan
  • Purpose-built for AI agents and untrusted code
  • Battle-tested infrastructure powering millions of sites

βž– Cons

  • Container state resets when a sandbox sleeps unless you back it up first
  • Requires a Workers Paid plan ($5/month)
  • No BYOC option
  • No GPU support

πŸ’² Pricing

Cloudflare Sandboxes pricing is based on the underlying Containers platform, plus the Workers and Durable Objects usage each sandbox generates. CPU is billed on active usage only (not provisioned resources) at $0.00002 per vCPU-second, about $0.072 per active vCPU-hour. Memory and disk are billed on provisioned resources. You need a Workers Paid plan at $5/month, after which usage scales with consumption.

7. Vercel Sandbox

Vercel Sandbox screenshot

Vercel Sandbox is a compute primitive built for safely running untrusted or user-generated code. It is designed for AI agents, code generation, and developer experimentation, giving you isolated environments to execute third-party code without exposing production systems. Each sandbox runs inside a Firecracker microVM, and you are billed for active CPU time rather than I/O wait, so time spent waiting on model calls, databases, or network requests doesn't count toward the CPU line.

🌟 Key features

  • Firecracker microVMs for untrusted code execution
  • Active CPU billing (I/O wait excluded)
  • Custom OCI images, plus managed images with Node.js and Python
  • Up to 8 vCPUs on Pro and 32 vCPUs on Enterprise, with 2 GB RAM per vCPU
  • Persistent sandboxes that resume across sessions
  • Snapshots and drives for data that outlives a sandbox
  • Git repository cloning and package installation
  • Up to 15 open ports per sandbox
  • 19 regions to run sandboxes in
  • Real-time log streaming
  • TypeScript and Python SDKs, plus a CLI

βž• Pros

  • Active CPU billing, with Vercel claiming up to 95% lower cost for bursty workloads
  • Purpose-built for AI agents and code generation workflows
  • Can clone private repositories and install packages
  • Real-time development server support with live previews
  • Strong isolation for running untrusted code safely
  • Integrates with Vercel's existing authentication (OIDC)
  • Free monthly allotment on the Hobby plan
  • High concurrency, with up to 10,000 sandboxes at once on Pro and Enterprise
  • Free inbound data, so downloading packages and repositories costs nothing
  • Works as a standalone SDK on non-Vercel platforms

βž– Cons

  • Provisioned memory keeps billing while the CPU sits idle
  • Hobby plan capped at 45-minute sessions and 10 concurrent sandboxes
  • No self-hosting or BYOC option

πŸ’² Pricing

Vercel Sandbox is available on all plans with usage-based pricing. The Hobby plan includes 5 active CPU hours, 420 GB-hours of provisioned memory, 20 GB of data transfer, and 5,000 sandbox creations per month for free. Pro and Enterprise plans pay $0.128 per active CPU hour, $0.0212 per GB-hour of provisioned memory, $0.60 per million sandbox creations, and $0.08 per GB-month of snapshot storage, with Pro usage drawing from the plan's $20 monthly credit first. Maximum session duration is 45 minutes on Hobby and 24 hours on Pro and Enterprise, and the limit resets each time a persistent sandbox stops and resumes. The default timeout is 5 minutes, which you can configure.

8. Runtime

Runtime screenshot

Runtime is a sandbox cloud for AI agents built around one idea: you should pay for the CPU your agent's code actually uses, not the CPU it holds. Every sandbox is a Firecracker microVM with its own Linux kernel, started from a single API call, CLI command, or MCP tool. You can sign up with a Google account and start on free usage without adding a card.

Runtime's open-source SDKs cover TypeScript, Python, Go, Ruby, and Java, and the same package ships the runtime CLI and an MCP server for coding agents like Claude Code, Codex, and Cursor. If you're moving from another provider, Runtime offers drop-in import layers for code written against E2B, Daytona, Vercel Sandbox, Blaxel, Modal, and Cloudflare's Sandbox SDK, so the switch can be as small as changing one import.

🌟 Key features

  • Firecracker microVM per sandbox, never a container on a shared kernel
  • Pause with memory and running processes kept; sandboxes auto-pause after 5 idle minutes and wake on the next command, file call, or preview visit
  • Forks that copy a running sandbox, including its memory and processes, up to 10 copies at a time
  • Custom images from a package list, any public or private image, or a Dockerfile
  • Volumes with daily off-server backups, plus S3, R2, or Google Cloud Storage buckets mounted as folders
  • Private HTTPS preview URLs, custom domains, public TCP ports, and WireGuard private networks
  • Docker inside a sandbox, plus SSH and port forwarding without opening ports to the internet
  • Built-in desktop and code interpreter for Python, JavaScript, TypeScript, R, Java, Bash, and Go
  • Scheduled jobs on a cron schedule, each in a fresh sandbox
  • Secrets the sandbox never sees: it holds a placeholder, and the real value is added only on HTTPS requests to hosts you name
  • Per-sandbox network allow and deny lists
  • Per-sandbox CPU and memory metrics, signed webhooks, and OpenTelemetry export
  • SDKs for TypeScript, Python, Go, Ruby, and Java, plus a REST API, CLI, and MCP server

βž• Pros

  • Lowest headline CPU rate in this list, at $0.025 per active vCPU-hour billed on measured use
  • Idle sandboxes pay only for paused storage, so agents waiting on model responses cost very little
  • No plan fee and no credit card needed to start
  • Drop-in compatibility layers make migrating from E2B, Daytona, Vercel, Modal, or Cloudflare quick
  • Broad SDK coverage, including Go, Ruby, and Java, which many competitors skip
  • Forks with memory let you warm one sandbox and fan out copies instead of repeating setup
  • OpenTelemetry export sends sandbox telemetry to the observability stack you already use
  • Single sign-on (SAML and OIDC) and SCIM are free on every account
  • Spending controls such as per-key daily limits and per-sandbox cost caps
  • Paid accounts get a 99% monthly API uptime SLA with automatic credits, backed by a public status page

βž– Cons

  • Very new platform with a small community compared to E2B, Daytona, or Modal
  • Runs only on Runtime's own servers, with no self-hosting or BYOC option

πŸ’² Pricing

Runtime has no plan fee. CPU costs $0.025 per active vCPU-hour, measured on actual use above a floor of a twentieth of a vCPU, and memory costs $0.0075 per reserved GiB-hour. A paused sandbox bills only for storage at $0.08 per GB per month, inbound traffic is free, and the first 100 GiB of outbound traffic each month is free before it costs $0.02 per GB.

New accounts get 100 free hours of a 1 GB machine (100 GiB-hours of memory and 25 vCPU-hours of active CPU) once in their first 30 days, and that free usage renews monthly once you've paid. Without credit, you can run 4 sandboxes at once with up to 2 vCPUs and 4 GiB each. Paid accounts can run 100 sandboxes at once from the first top-up, each with up to 16 vCPUs and 64 GiB, and Runtime matches credit added within the first 30 days, up to $1,000. For a sense of scale, Runtime's own example prices 1,000 one-minute agent runs at $0.64.

9. Upstash Box

Upstash Box screenshot

Upstash Box is a persistent cloud computer for AI agents from Upstash, the company behind the serverless Redis platform. It launched in Developer Preview in March 2026 and dropped the preview label in August 2026. Most runners on this list hand you an isolated machine and leave the agent loop to you, but Box ships the coding agent inside the sandbox: Claude Code, Codex, OpenCode, or Cursor runs in the box, works on your repository, and returns the result through an API, often as a ready pull request.

Each box is an isolated Linux container with its own filesystem, process tree, and network stack, plus git and a headless Chromium browser. The workspace persists between tasks, idle boxes pause automatically, and you pay only for the CPU your agent actually uses, with memory not billed at all.

🌟 Key features

  • Built-in coding agents: Claude Code, Codex, OpenCode, and Cursor, or bring your own harness
  • Agent runs return text, a stream, or typed output, along with what each run cost
  • Persistent workspace that keeps the repository, installed dependencies, and files between tasks
  • Auto-pause when idle, with the box waking on the next request
  • Git to pull request from the SDK: clone, branch, commit, push, and open a PR
  • Headless Chromium with screenshots, page actions, typed data extraction, live view, and recordings
  • Cron schedules for commands or agent prompts inside a box
  • Keep-alive boxes that never pause, for bots and always-on personal agents
  • Snapshots that let you start new boxes from a ready environment for each user, task, or parallel attempt
  • Outbound network allowlists, plus Attach Headers that inject secrets on the host so API keys never enter the box
  • SSH access to any box
  • Node.js, Python, Go, Ruby, and Rust runtimes
  • TypeScript and Python SDKs, a CLI, and the Upstash MCP server

βž• Pros

  • Coding agents ship inside the box, so you skip wiring up the agent loop, output parsing, and git yourself
  • Memory is free, and CPU is billed on active use only, so an idle box costs nothing for compute
  • Finished tasks arrive as pull requests instead of diffs sitting in a container
  • The MCP server lets Claude Code, Cursor, or Codex offload builds and tests to a remote box instead of your laptop
  • Flat keep-alive pricing from $8/month for agents that must stay reachable
  • Free tier with no credit card required
  • Default quota of 1,000 concurrent boxes on pay as you go, raisable on request

βž– Cons

  • Runs in a single region, AWS us-east-1, for now
  • No GPU, self-hosting, or BYOC option, and agent runs require your own model provider key

πŸ’² Pricing

The Free plan includes 10 concurrent boxes and 5 CPU hours per month, with a 1-hour idle timeout. Pay as you go has no monthly fee and bills $0.10, $0.20, or $0.40 per active CPU hour for Small (2 vCPU, 4 GB RAM, 10 GB disk), Medium (4 vCPU, 8 GB RAM, 20 GB disk), and Large (8 vCPU, 16 GB RAM, 30 GB disk) boxes, with a 6-hour idle timeout. Memory is free, and storage costs $0.10 per GB per month, snapshots included. Using Upstash's own example, running both cores of a Small box flat out for an hour costs $0.20, while 10% of one core for an hour costs $0.01.

Fixed keep-alive boxes never pause and cost a flat $8, $16, or $32 per month by size, with CPU and storage included. Model usage is billed separately by your own provider, since Upstash does not resell model access.

10. Val Town

Val Town screenshot

Val Town lets you write and run TypeScript or JavaScript in the browser with instant execution. Each function you create (a "val") gets its own API endpoint, so you can quickly build webhooks, cron jobs, and small utilities without managing servers.

It runs on Deno, uses V8 isolates for safe sandboxing, and has a social layer where you can browse, fork, and remix other people's code. With the built-in Townie AI assistant and MCP support, Val Town is especially useful for fast automations, simple APIs, and custom workflows.

🌟 Key features

  • Browser-based code editor with instant deployment
  • Automatic API endpoints for every function
  • Scheduled execution (cron jobs as fast as 1-minute intervals on paid plans)
  • Built-in blob storage for file uploads and data
  • Social features (browse, fork, remix code)
  • NPM package support and Deno compatibility
  • Built-in secrets management
  • Townie AI coding assistant with monthly credits on paid plans
  • MCP integration
  • Custom domain support
  • Version control and code intelligence

βž• Pros

  • Incredibly fast to go from idea to deployed function
  • No infrastructure management required
  • Built on Deno runtime with web standards
  • Social features make learning and collaboration easy
  • Free tier with 100,000 runs per day for experimentation
  • Automatic HTTPS endpoints for all functions
  • Can integrate with thousands of APIs
  • Great for automation, bots, and glue code
  • Active community with shared templates

βž– Cons

  • Execution time limits can be restrictive for complex tasks
  • TypeScript/JavaScript only (no other language support)
  • Free tier limited to 1-minute wall clock time, and new vals are public on Free accounts

πŸ’² Pricing

Val Town has four pricing tiers: Free, Pro, Business (formerly Teams), and Enterprise. The Free plan includes 100,000 runs per day and a 1-minute wall clock limit per run. Pro costs $25/month for new users, or $250 billed yearly, and adds 10-minute runs, 1-minute cron intervals, 1,000,000 runs per day, custom domains, and monthly Townie credits. Business starts at about $167/month billed yearly and adds team accounts, higher run limits, and $100/month in Townie credits. Existing Pro subscribers keep the legacy $10/month price.

11. CodeSandbox

CodeSandbox screenshot

CodeSandbox is a browser-based development environment built for web development, now part of Together AI. It uses Firecracker microVMs to provide full environments in the cloud, letting you work on complete projects with backend services, databases, and frontend frameworks all running together. Its SDK also powers Together AI's code sandbox for agents.

🌟 Key features

  • Full-stack development environments
  • Real-time collaboration
  • Firecracker microVM-based sandboxes and devboxes
  • GitHub integration
  • Framework templates (React, Vue, Next.js, etc.)
  • Built-in terminal and debugging
  • Hot reload and instant preview
  • CodeSandbox SDK for programmatic management
  • Private NPM registry support
  • VS Code extension

βž• Pros

  • Excellent for web development workflows
  • Real-time collaboration features are superb
  • Fast environment setup with templates
  • Integrates seamlessly with GitHub
  • Can run backend services alongside frontend
  • Great for teaching and code demonstrations
  • No local setup required for contributors
  • Built-in browser preview for instant feedback
  • SDK enables programmatic environment creation for agents
  • Unlimited Browser and VM Sandboxes on all plans

βž– Cons

  • VM credit system can be complex to understand
  • Build plan limited to 40 hours of VM credits monthly and 10 concurrent VMs
  • Products are migrating to Together AI's platform, so branding and docs are in flux

πŸ’² Pricing

CodeSandbox uses a VM credit system where one credit costs about $0.015. The Build plan is free with 40 hours of monthly VM credits, unlimited sandboxes, up to 5 workspace members, 10 concurrent VMs, and VMs up to 4 vCPUs and 8 GiB of RAM. The Scale plan starts at $170/month per workspace and adds up to 20 members, 160 hours of monthly VM credits, on-demand credits at $0.15 per hour, 250 concurrent VMs, and larger VM tiers.

12. StackBlitz

StackBlitz screenshot

StackBlitz created WebContainers, a WebAssembly-based system that runs Node.js directly in your browser. Instead of using remote servers, your whole dev environment runs inside the tab, so it starts instantly and can even work offline.

🌟 Key features

  • WebContainer technology (Node.js in browser via WebAssembly)
  • Instant environment startup (milliseconds)
  • Offline-capable development
  • Full npm package support
  • Integrated terminal
  • Hot reload and fast refresh
  • GitHub repository integration
  • Framework templates
  • Bolt.new AI code generation
  • WebContainer API for embedding
  • Zero network latency

βž• Pros

  • Runs entirely in your browser for privacy and speed
  • Instant cold starts with no waiting for servers
  • Can continue working offline
  • No remote server costs for basic usage
  • Excellent for creating bug reproductions
  • Great documentation and examples
  • Strong integration with popular frameworks
  • Secure by default (code doesn't leave your device)
  • AI-powered app creation with Bolt.new
  • Trusted by major companies (Shopify, Google, etc.)

βž– Cons

  • Limited to JavaScript/TypeScript ecosystem
  • Complex projects may hit browser resource limits
  • WebContainer technology requires modern browsers

πŸ’² Pricing

StackBlitz offers a generous free tier for public projects with full access to WebContainers technology, making it ideal for learning, open-source work, and demonstrations. Paid plans provide private repositories, increased resources, and priority support, with specific pricing available on their website.

13. Replit

Replit screenshot

Replit is an online IDE and hosting platform that runs in the browser and supports 50+ languages using isolated containers. It is used by millions of developers, from hobbyists to Fortune 500 teams.

🌟 Key features

  • 50+ language support
  • Browser-based IDE with AI assistance (Replit Agent)
  • Parallel agents on paid plans
  • Real-time collaboration
  • Instant hosting and deployment
  • Built-in PostgreSQL database
  • Package management for all languages
  • Always-on deployments
  • Mobile app for coding anywhere
  • Visual Editor for design refinement
  • Autonomous agent that tests its own code
  • Figma import capability
  • Built-in Auth and Database services

βž• Pros

  • Supports more languages than almost any competitor
  • Zero setup required to start coding
  • Real-time collaboration for pair programming
  • Great for learning, prototyping, and production
  • Replit Agent dramatically speeds up development
  • Can deploy applications directly from the IDE
  • Mobile app lets you code from anywhere
  • Strong community with 40 million creators
  • SOC 2 compliant for enterprise use
  • Private deployments for internal tools
  • SSO and RBAC for team management

βž– Cons

  • Free Starter plan is limited to daily Agent credits and one published app
  • Agent usage is billed by effort on top of the plan fee, which makes heavy months hard to predict
  • Weakest isolation model among AI-focused options in this list

πŸ’² Pricing

Replit offers a Starter plan that is free with daily Agent credits and one published app. The Core plan costs $20/month billed annually ($25 billed monthly) and includes $25 in monthly credits, up to 5 collaborators, and 2 parallel agents. The Pro plan, which replaced the old Teams plan in February 2026, costs $100/month ($95 billed annually) and includes $100 in monthly credits, up to 15 builders, and 10 parallel agents. Enterprise pricing is custom.

Final thoughts

Isolation is no longer what separates most of these tools: nearly every AI-focused runner now gives you a microVM or a full VM. The real decision is how you want to pay for an agent that spends most of its life waiting. E2B, Daytona, Modal, and Freestyle charge for the resources a sandbox reserves for as long as it runs, while Runtime, Vercel Sandbox, Cloudflare, Fly.io Sprites, and Upstash Box meter the CPU your code actually burns.

If you need a safe default, start with E2B. Its Firecracker isolation, open-source SDKs, and adoption across most of the Fortune 100 make it the lowest-risk pick. Reach for Runtime when your agents are I/O-bound and cost is the pressure, Upstash Box when you want the coding agent, git, and browser already wired in and can live with container isolation, Modal when your workloads are GPU-heavy and Python-first, Fly.io Sprites when agents need persistent state across long sessions, and Freestyle when you need full Linux VMs with nested virtualization.

Whichever you choose, run a week of your real agent traffic through it before you commit, because your invoice will settle the billing-model question faster than any pricing page.