AI Agent Sandboxes Compared: Render, Vercel, Cloudflare, E2B and Daytona

A one-shot code interpreter can disappear the moment it has returned a result. A coding agent often cannot: it may hold a development server, wait for a human to review a diff, or return to the same repository tomorrow. That difference turns timeout semantics, snapshot contents, idle billing, and egress controls into architecture decisions.
This is a sandbox-only comparison of Render, Vercel, Cloudflare, E2B, and Daytona. If you are choosing a broader agent runtime with identity, memory, tool gateways, and an agent loop, start with our managed-agent runtime comparison. Here, the question is narrower: where should your agent's shell, files, and processes live?
TLDR
- Short tool calls: Cloudflare fits event-driven work when a Worker already owns the request. Its instance can stop after the work, but save files yourself before it does. Cloudflare documents the lifecycle and snapshot boundary.
- Long-running coding agents: Render is the clearest fit when a process must survive a human wait. It can disable both timeouts and its runtime snapshots retain memory and processes. It is a public beta.
- Pause for review, then resume in place: Daytona VM sandboxes and E2B can preserve memory and processes through a pause. Daytona charges disk while paused; E2B says a pause can preserve filesystem and memory. Daytona billing and E2B security documentation describe those states.
- Cheapest idle: E2B's homepage labels a paused sandbox as unbilled. Render stops CPU and memory charges when a sandbox is suspended, leaving snapshot storage at $0.08 per GB-month; Vercel bills its filesystem snapshot at the same rate, and Daytona VM pauses bill reserved disk. All of these are cents for an overnight wait; plan minimums matter more.
Prerequisites
- A workload description: how long a task actively computes, how long it waits, and whether a running process must survive the wait.
- An account with the plan and regional availability needed by the provider you choose.
- A place to persist the work product outside the sandbox when deletion would be unacceptable.
What we compared
The four dimensions in the table below are deliberately operational: how long the machine exists, what a pause means, what is billed, and what survives. “Not documented” means we could not find the detail in current official vendor material, not that the vendor necessarily lacks the feature.
| Provider | Runtime limits | Suspend or resume | Pricing and idle state | What persists |
|---|---|---|---|---|
| Render | Default runtime timeout 24 hours; set 60 seconds to 30 days (24 hours on Hobby workspaces), or 0 to disable. Default idle timeout 15 minutes. Up to 8 CPU, 16 GB RAM, 40 GB writable disk, 1,000 concurrent per group. |
Idle suspension keeps the filesystem and can resume within 30 days. Runtime snapshots keep filesystem, memory, and CPU state; filesystem snapshots keep files only. | Active CPU plus allocated memory; suspended means snapshot-storage only. List rates: $0.12 per active CPU-hour plus $0.038 per hour per 2 GB of memory ($0.076/hour for 2c-4g), and $0.08 per GB-month of snapshot storage. | Runtime snapshot preserves files, processes, and memory. Termination permanently deletes the filesystem unless exported or snapshotted. Outbound policy can allow all, allow a domain list, or deny all. |
| Vercel | Session default 5 minutes, maximum 45 minutes on Hobby and 24 hours on Pro and Enterprise. Up to 4, 8, or 32 vCPU by plan, with 2 GB per vCPU. | There is no in-memory pause. Persistent sandboxes stop, snapshot the filesystem, then boot a new session on use. | $0.128 active CPU-hour and $0.0212 GB-hour provisioned memory, plus $0.08 GB-month snapshot storage. CPU waiting on I/O is not billed, but memory is billed while the session runs. | Persistent is the default: filesystem and installed packages return, processes do not. A Drive can outlive a sandbox. A sandbox firewall can allow all, deny all, or apply a user-defined policy, changeable at runtime. |
| Cloudflare Sandboxes | No guaranteed runtime duration. Inactivity can be set to up to 6 hours; a platform event can stop an instance. Largest container is 4 vCPU, 12 GiB, 20 GB. | No pause. Stop ends memory, processes, and disk. A beta snapshot is filesystem-only and must be restored by your application. | Containers bill per 10 ms while running: active CPU, provisioned memory, and disk. Workers Paid includes 375 vCPU-minutes, 25 GiB-hours, and 200 GB-hours monthly. | A Durable Object keeps its storage until code deletes it. Snapshots expire 30 days after creation or last restore; mounted R2 objects outlive instances. Network egress pricing is documented by region. |
| E2B | Hobby sessions up to 1 hour; Pro up to 24 hours. Hobby has 10 concurrent; Pro has 100, expandable to 1,100. Default size is 2 vCPU and 4 GiB; a larger official per-sandbox maximum is not documented. | Pause can preserve filesystem and memory for resume. | E2B charges per second of a running sandbox: 2 vCPU is $0.000028/s and 4 GiB is $0.000018/s. Pro has a $150/month minimum. Its homepage labels the paused state as unbilled. | E2B says timeout or shutdown destroys sandboxes; pause can preserve filesystem and memory. Retention and storage pricing for paused sandboxes: not documented in the sources reviewed. |
| Daytona | Default auto-stop is 15 minutes; VM sandboxes default to 60-minute auto-pause if neither interval is set. Both can be disabled. Sandboxes default to 1 vCPU, 1 GB RAM, and 3 GiB disk, with a per-sandbox maximum of 4 vCPUs, 8 GB RAM, and 10 GB disk; organization limits are on the limits page. | VM pause() freezes running processes and retains memory. Containers do not support pause. |
Per-second resources: $0.0504/vCPU-hour, $0.0162/GiB-hour, and $0.000108/GiB-hour storage after the first 5 GiB. Paused and stopped VM sandboxes bill disk only. | VM pause preserves memory and filesystem; stop clears memory. Containers can archive filesystem to object storage. TTL and auto-delete can remove a sandbox. |
Checked against official docs on 2026-11-11; prices in USD, list prices.
All five expose a programmatic sandbox, but their isolation differs where documented: Render and Vercel use Firecracker microVMs and Firecracker microVMs respectively, E2B uses a Firecracker microVM with its own kernel, and Cloudflare describes a container instance as a Linux VM. Daytona publishes container, Linux VM, Windows, and GPU sandbox classes. SDK coverage differs too: Render and Vercel document TypeScript and Python SDKs, and Daytona documents Python, TypeScript, Ruby, Go, and Java. Render is Oregon-only during the beta, Daytona documents us and eu targets, and Vercel lists its sandbox regions on its pricing page.
Render: a runtime snapshot is a real checkpoint
Render Sandboxes entered public beta on November 4, 2026, which is the newest official status even though older pages may describe early access. The distinction that matters is its two snapshot kinds. A runtime snapshot captures writable files, memory, and CPU state, so a restored sandbox resumes running processes. A filesystem snapshot captures files and installed tools but not a process. A runtime snapshot must restore to the same compute plan.
That makes Render unusually direct for a coding agent waiting on a reviewer: its default 15-minute idle timer snapshots and suspends, a command or file transfer resumes it, and background processes do not count as activity. Render defines idle as no command execution or file transfer. If a test run is working only inside the sandbox, either keep an external interaction alive or disable idle suspension. A runtime timeout also resets after a suspend and resume.
There are beta gaps to plan for. Sandboxes do not yet have private networking to other Render services or public URLs, and credential brokering is not generally available. Those are listed as beta limitations.
Vercel: persistence is filesystem persistence
Vercel separates a long-lived named sandbox from the VM session inside it. When a persistent sandbox stops, it snapshots the filesystem, and the next operation boots a new session from that snapshot. The default is persistent. It is convenient for a workspace that needs node_modules, source edits, and configuration to return. It is not a pause: a development server, process memory, open terminal, and connection state are gone.
Vercel's sandbox firewall can switch from allow-all to deny-all or a user-defined policy at runtime without restarting the process, and it can broker credentials so secrets never enter the sandbox. For cost work, do not treat active CPU as the whole bill. Vercel excludes I/O wait from CPU metering, but provisioned memory is still measured for the time the session is running. Its own example explains both meters.
Cloudflare: an instance is not the durable object
Cloudflare's design is useful when the agent's durable control plane is a Worker and Durable Object, and a Linux machine is an attached execution unit. The Durable Object can retain a session record or snapshot identifier after the instance stops, but the instance's files, memory, and processes do not survive that stop. Cloudflare documents this split explicitly.
The sharp edge is activity. A Worker request, stream, WebSocket, or alarm can keep the Durable Object active. Work running only inside the instance does not. So a build can receive SIGTERM when the inactivity timer ends even while it is still working. Use an alarm that checks work more frequently than the inactivity timeout, or arrange for the process to finish before the timeout.
Snapshot when files matter, and restart the process after restore. Cloudflare says snapshots are public beta, filesystem-only, application-managed, and not restored automatically. Mounted R2 is the better fit for files that must outlive a workspace or be shared.
E2B: pause holds the machine state
E2B is a direct microVM sandbox service. Its official security material says each sandbox has its own Firecracker microVM and that filesystem and memory state can be preserved through pause and resume. That is the capability a human-review workflow needs. Its pricing page bills a running sandbox per second, rather than publishing separate active-CPU and provisioned-memory notions.
The important plan boundary is time: the free Hobby tier allows sessions up to one hour, while Pro allows up to 24 hours and starts at $150 per month. E2B's Enterprise offering is where it advertises multi-day and persistent sessions. Those are plan statements, not an implied retention guarantee for every paused sandbox.
E2B's homepage marks the paused state as unbilled, which makes it a cheap place for a sandbox to wait. What the official material reviewed here does not give is how long a paused sandbox is retained, or a per-sandbox maximum above the listed configuration options. Ask before you build a long review queue on paused sandboxes.
Daytona: choose VM if you mean pause
Daytona has more lifecycle states than the others, and the sandbox class changes what each state means. A Linux VM sandbox can pause, freezing processes and retaining memory. A container sandbox cannot pause, but can stop and later archive its filesystem. The lifecycle documentation distinguishes the two.
The default timer is another operational trap. Daytona's auto-stop fires after 15 minutes of no qualifying events, and an internal long-running process does not count. VM-capable sandboxes instead default to a 60-minute auto-pause when neither timer is supplied. Daytona calls out this exact failure mode in troubleshooting. Have the controller call refreshActivity() or configure the lifecycle deliberately.
Paused VM state is not billed for CPU or RAM, but it is billed for reserved disk. That makes Daytona a strong review-pause option, not automatically the cheapest idle option. Use archive for a container filesystem that can tolerate a cold return; archived containers stop billing, while snapshots remain billed storage. Daytona's billing table is explicit on each state.
Worked cost: 40 active minutes, then an 8-hour review
Assume the agent actively uses both vCPUs for 30 minutes, pauses or stops for 8 hours, then uses both vCPUs for 10 more minutes. The arithmetic below excludes network, creation, and storage retained beyond the stated resources. It also assumes no included allowance or account credit.
- Render: $0.21 plus snapshot storage.
(2 vCPU x 2/3 h x $0.12) + (2/3 h x $0.076 memory for 2c-4g) = $0.2107. The 8-hour suspended period has no CPU or memory charge; snapshot storage is $0.08 per GB-month, so a 10 GB snapshot held for 8 hours adds under one cent. - Vercel: $0.23 plus snapshot storage and one creation event.
(2 x 2/3 x $0.128) + (4 x 2/3 x $0.0212) = $0.2272. Stop, then let persistence restore the filesystem for the second session. Its 8-hour stored snapshot is charged by size at $0.08/GB-month, under one cent for 10 GB over 8 hours. - Cloudflare: not computable for exactly 2 vCPU and 4 GiB. Cloudflare sells fixed instance types, and its 2-vCPU type has 8 GiB and 16 GB disk, not 4 GiB. A saved workspace also needs a separately sized snapshot or R2 object.
- E2B: $0.1104 in running compute, plus the Pro plan minimum.
2,400 seconds x ($0.000028 + $0.000018) = $0.1104; E2B labels the 8-hour pause as unbilled. We assume Pro because the workflow spans more than Hobby's one-hour session limit; check how your plan counts a paused-and-resumed sandbox. - Daytona: $0.1104 for CPU and RAM, plus disk during all 8 hours and 40 minutes.
(2 x 2/3 x $0.0504) + (4 x 2/3 x $0.0162) = $0.1104. The result cannot include disk without choosing a disk size. The first 5 GiB are free, then the published disk rate applies.
The chart is not a lowest-price ranking. It is a warning that idle semantics move cost between CPU, memory, snapshot storage, disk storage, and plan minimums. A model call that waits for a response can be cheap in active-CPU systems, while a running session with provisioned memory continues to accrue memory cost.
The smallest useful SDK shape
The following calls follow current official examples. They are deliberately lifecycle examples, not a production authorization model. Cloudflare and E2B are omitted because their current examples require application-specific Durable Object setup, or because we could not verify a current TypeScript pause call without relying on a beta SDK reference.
How to pick
Choose Render if preserving a process through an idle wait is the defining requirement, and the beta status plus Oregon placement are acceptable. Choose Vercel if you need a named workspace whose filesystem resumes cleanly, and a restarted process is fine. Choose Cloudflare when the Worker and Durable Object are your durable agent control plane, with the sandbox treated as replaceable compute. Choose E2B when you want a focused microVM service with pause and resume, but price the Pro minimum and verify persistence retention. Choose Daytona VM sandboxes when a true pause matters and disk-only pause billing fits the workload.
Do not use an auto-stop default as job completion. For every option, persist a task checkpoint outside process memory before a timeout, a stop, or a platform event. If an agent can reach a production system, also constrain egress and give it a narrowly scoped identity. Our guide to agent prompt-injection controls explains why that boundary belongs outside the model prompt.
What we could not confirm
- A Render retention time for an automatically suspended sandbox beyond the stated 30-day resumability period.
- A Vercel in-memory pause (its persistence is filesystem-only).
- A Cloudflare fixed maximum instance lifetime or an exact 2 vCPU / 4 GiB configuration.
- E2B's retention period for paused sandboxes and a public per-sandbox maximum above the listed sizes.
- Daytona's retention duration for a paused VM sandbox.
We earn commissions when you shop through the links below.
Bitrise
Managed runners for GitHub Actions
Bitrise Build Hub runs your GitHub Actions jobs on M4 Macs and AMD Linux machines. Change runs-on and keep your workflows, secrets and logs on GitHub.
Atomsized
AWS platform engineering and GitOps
Design and automation for reliable AWS and Kubernetes platforms, safer delivery workflows, and preview and UAT environments your engineers can understand and own.
DigitalOcean
Cloud infrastructure for developers
Simple, reliable cloud computing designed for developers
DevDojo
Developer community & tools
Join a community of developers sharing knowledge and tools
SMTPfast
Developer-first email API
Send transactional and marketing email through a clean REST API. Detailed logs, webhooks, and embeddable signup forms in one dashboard.
QuizAPI
Developer-first quiz platform
Build, generate, and embed quizzes with a powerful REST API. AI-powered question generation and live multiplayer.
Want to support DevOps Daily and reach thousands of developers?
Become a SponsorTags
Found an issue?
Related Posts
Also worth your time on this topic
Where to Run AI Agents: 8 Managed Agent Runtimes Compared
DigitalOcean Managed Agents, Cloudflare, AWS AgentCore, Google, Microsoft Foundry, E2B, Vercel and Modal, compared on isolation, state, tool access, limits and price, with one cost scenario worked out on every platform.
AWS Security Checklist
Essential security configuration checklist for AWS cloud environments.
45-60 minutes
AWS VPC Networking Fundamentals
Explain the difference between public and private subnets in AWS VPC. How do instances in private subnets access the internet?
junior