Sandscale vs Daytona: containers or microVMs, and how each bills idle time Sandscale published a comparison of its agent sandbox platform against Daytona, contrasting Daytona's default Linux-container isolation with Sandscale's Firecracker microVM per sandbox. The writeup also details billing differences: Daytona charges for reserved vCPU, RAM and disk while a sandbox is started ($0.0504 per vCPU-hour, $0.0162 per GiB-hour of memory), whereas Sandscale bills only awake vCPU-hours at $0.05, excluding paused time and idle gaps between tool calls. Originally published on sandscale.dev https://sandscale.dev/blog/sandscale-vs-daytona . Daytona and Sandscale both give an AI agent a disposable computer through an SDK or API. The biggest technical difference is the default isolation boundary. Daytona's sandboxes are Linux containers unless you choose a VM class. Sandscale runs every sandbox as a Firecracker microVM. The second difference is what you pay for while an agent waits. Daytona facts below are from Daytona's public pricing page https://www.daytona.io/pricing , docs https://www.daytona.io/docs and GitHub repository https://github.com/daytonaio/daytona , read on 20 November 2026. Sandscale facts are from sandscale.dev. "Not published" means we did not find it on the pages we read. Both products change, so check the linked pages before you decide. Daytona. The default sandbox class is a container. Its isolation page https://www.daytona.io/docs/en/isolation describes it as an isolated container "with dedicated namespaces and enforced resource limits", and says code runs as root inside the sandbox without affecting the runner. Daytona also offers Linux VM and Windows sandboxes, which its isolation page describes as a "full virtual machine with its own kernel", plus GPU sandboxes containers with an exclusive GPU and macOS sandboxes. Daytona's overview text says each sandbox has "a dedicated kernel", while the isolation page assigns a separate kernel to the VM classes specifically. We read the isolation page as the more precise statement. The hypervisor behind Daytona's VM class is not named on the pages we read: not published. Sandscale. Each sandbox is its own Firecracker microVM with its own kernel, not a container sharing the host kernel. What this means in practice, in general terms: a container's processes make system calls into the host's kernel, so isolation depends on that kernel and its restrictions. A VM puts a separate kernel behind a hardware virtualization boundary. Neither is automatically safe or unsafe; the surrounding setup matters, and for a deeper look see our write-up of container, gVisor and microVM isolation https://sandscale.dev/blog/isolating-ai-agent-code-containers-gvisor-firecracker . Daytona's VM class is the closest match to Sandscale's model. It is a separate sandbox class, with its own snapshots daytona-vm-small , -medium , -large in the docs and some VM-only features such as pause and resume, fork and memory snapshots. Daytona bills https://www.daytona.io/docs/en/billing for reserved vCPU, RAM and disk while a sandbox is started. Its published rates are $0.0504 per vCPU-hour, $0.0162 per GiB-hour of memory, and $0.000108 per GiB-hour of storage after the first 5 GiB, billed per second. A stopped sandbox is billed for reserved disk only; a paused VM sandbox is billed for disk only, and its preserved memory state is not billed; an archived container sandbox is not billed. By default a sandbox auto-stops after 15 minutes of inactivity, and you can change that interval or set it to 0 to keep it running. Sandscale bills awake vCPU-hours: one vCPU running for an hour while the box is awake. Paused time and idle time between tool calls are not counted. Memory is included at 4 GiB per vCPU. Plans include monthly hours, and usage beyond that is $0.05 per awake vCPU-hour or $10 per 500-hour pack. For how Sandscale metering works in detail, see pricing https://sandscale.dev/pricing . So the question for Daytona is who stops the sandbox and when. If your agent stops it right after work, or auto-stop fires after the 15-minute default, you pay for reserved resources until then, then for disk. On Sandscale the gaps between tool calls are not billed without any action. There is also a state-handling difference. Daytona's docs say stopping clears memory and preserves the filesystem, while the VM class can pause with memory preserved. Sandscale's pause keeps memory and files on every plan. So on Daytona the container class loses in-memory state on stop, which matters for an agent in the middle of a task. This is an invented workload, not a measurement. An agent run uses a 2 vCPU, 4 GiB box for 60 minutes of wall-clock time: 10 minutes of real work, then 50 minutes waiting for a model or a person. The disk charge is left out for Daytona, since it depends on the size you reserve and the free allowance. The 4 GiB figure matches Daytona's daytona-medium snapshot of 2 vCPU and 4 GiB. Daytona, using its published rates: 2 vCPU × $0.0504/h = $0.1008 4 GiB × $0.0162/h = $0.0648 Started, per hour = $0.1656 Sandscale, same 2 vCPU box: 2 vCPU × 10 / 60 h = 0.333 awake vCPU-hours per run At 1,000 runs a month, that is 333.3 awake vCPU-hours, inside Pro's 1,500 included. At the $0.05 overage rate they would be worth $16.67, but on Pro they are covered by the plan. | 1,000 runs a month | Usage cost | Plan basis | Notes | |---|---|---|---| | Daytona, left running 60 min | $165.60 + disk | Pay as you go, $200 free compute | Limits depend on tier | | Daytona, auto-stop at 15 min | $69.00 + disk | same | | | Daytona, stopped at 10 min | $27.60 + disk | same | | | Sandscale, awake only | within 1,500 included hours 333.3 used | Pro: $20/mo billed annually, $25 monthly | 8 GiB included at 2 vCPU, more than the 4 GiB above | These figures show how the billing models behave on one invented shape of workload. They do not show that either platform is cheaper for yours. If your sandboxes are busy most of the time, idle billing matters little. Daytona sets limits https://www.daytona.io/docs/en/limits by organization tier, based on verification and top-ups: Tier 1 is email-verified with 10 vCPU in the pool, Tier 2 needs a linked card and a $25 top-up 100 vCPU , Tier 3 a $500 top-up 250 vCPU , and Tier 4 a $2,000 top-up every 30 days 500 vCPU . Per-sandbox limits are listed as a maximum of 4 vCPU, 8 GB RAM and 10 GB disk by default. Daytona's network policy also follows tier: Tier 1 and 2 get restricted outbound access that sandbox settings cannot override; Tier 3 and 4 get full internet access by default and can set per-sandbox allow lists. Sandscale's limits follow the plan: Free 3 boxes at once up to 2 vCPU; Pro 30 at once up to 16 vCPU; Team 30 at once, up to 16 vCPU 32 on request . Sandscale does not state a pool size in vCPU, only boxes at once. Sandscale's network default follows plan: Free runs with an egress allowlist; Pro and Team can open it see pricing https://sandscale.dev/pricing . A note on Daytona's open-source repository. Daytona's GitHub README says the repository "is no longer maintained" and that as of June 2026 core development "has moved to a private codebase"; the repository remains public under its license. If open source availability matters to you, read that notice. Limits on our side: US only today, no GPU, no Windows or macOS sandboxes, no published SOC 2 or similar certification we do not claim one , and a smaller published set of docs, integrations and examples. | | Sandscale | Daytona | |---|---|---| | Default isolation | Firecracker microVM, own kernel | Linux container with namespaces and resource limits | | VM option | Always | Linux VM and Windows classes with own kernel; hypervisor not published | | Billing basis | Awake vCPU-hours; idle and paused free | Reserved vCPU, RAM, disk while started; stopped = disk only; paused VM = disk only | | Published rate | Beyond plan $0.05 per awake vCPU-hour; $10 per 500 hours | $0.0504/vCPU-h, $0.0162/GiB-h, $0.000108/GiB-h storage after 5 GiB free; per second | | Memory | 4 GiB per vCPU included | Billed separately | | Plans | Free, Pro $20/mo annual $25 monthly , Team $40/member annual $48 monthly | Pay as you go; $200 free compute; startup credits up to $50k; Enterprise by contact | | Limits | Free 3 at once, Pro 30, Team 30 | Tier pools 10/100/250/500 vCPU; default max 4 vCPU, 8 GB, 10 GB per sandbox | | Default auto-stop | Not published | 15 minutes of inactivity | | In-memory state on stop | Pause keeps memory | Stop clears memory; VM pause keeps it | | GPU | Not published | Yes, listed models | | Windows / macOS | Not published | Yes | | Regions | US now; EU coming soon | US, EU shared; dedicated and custom | | BYOC | AWS, Enterprise | Enterprise; clouds not published | | Network default | Allowlist on Free; open on Pro and Team | By tier: restricted on Tier 1-2, open on Tier 3-4 | | Governance | Vault, DLP, approvals, audit log on every plan | API key scopes, organizations, secrets; SSO and audit logs on Enterprise; approvals and DLP not published | | Compliance | No certification claimed | Not published on the pages read footer links a Trust Center | | Open source | Not published | Core repo public but archived | | Start time | Not compared | "under 90ms" claimed by Daytona; method not published | If neither list settles it, run your own agent against both free tiers and compare how long each box is open with how long it is working. See pricing https://sandscale.dev/pricing , pause and resume https://sandscale.dev/sandboxes/pause-and-resume and the security overview https://sandscale.dev/security . Competitor pages read on 20 November 2026: Sandscale pages: pricing https://sandscale.dev/pricing , FAQ https://sandscale.dev/faq , security https://sandscale.dev/security , regions https://sandscale.dev/regions , pause and resume https://sandscale.dev/sandboxes/pause-and-resume .