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, docs and GitHub repository, 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.
Isolation: what each actually uses
Daytona. The default sandbox class is a container. Its isolation page 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.
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.
Billing: reserved resources versus awake time
Daytona bills 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. 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.
A worked example (hypothetical workload)
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
- Left running for the hour: $0.1656 per run.
- Auto-stop at the 15-minute default (10 minutes of work, then 15 minutes until auto-stop fires, so 25 minutes started): 25/60 × $0.1656 = $0.0690 per run, plus disk. This assumes the inactivity timer starts when the work ends.
- Stopped explicitly after 10 minutes: 10/60 × $0.1656 = $0.0276 per run, plus disk.
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.
Limits and tiers
Daytona sets 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).
Where Daytona is ahead or more mature
- More environment types. Daytona documents Linux container, Linux VM, Windows, macOS and GPU sandboxes, with a published GPU price list (NVIDIA and AMD models) on its pricing page. Sandscale has no GPU option on the pages we read.
- Regions. Daytona lists shared US and EU regions, plus dedicated and custom regions. Sandscale runs in the US today and lists Frankfurt as coming soon.
- Large published pools. Daytona’s tiers reach 500 vCPU in the organization pool without contacting sales.
- Persistence options. Daytona documents volumes, archiving of container sandboxes to object storage, and memory snapshots on VM classes.
- Enterprise options. Its pricing page lists SSO, audit logs and BYOC under Enterprise.
- Published start-time claim. Daytona publishes “under 90ms” from code to execution for its sandboxes (its docs and README). We cannot compare it here: neither the method nor ours is published, and we are not citing a figure for Sandscale.
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.
Where Sandscale differs
- Every sandbox is a Firecracker microVM, not only an optional class.
- Idle time between tool calls is free by default, with pause for longer waits.
- Agent governance on every plan: Vault (secrets kept out of prompts and logs), DLP on prompts and tool calls, human approvals and a hash-chained audit log. Policies are on Team and Enterprise. Daytona documents API key scopes, organizations and secrets; we did not find approval workflows or prompt-level DLP in its docs: not published.
- One account for sandboxes, workspaces and build hosts.
- Plan pricing starts at $20 a month (Pro, billed annually) with included awake hours. Daytona’s billing docs describe a pay-as-you-go wallet with top-ups; a monthly plan fee is not published on the pages we read.
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.
Fact table
| 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 |
When to pick Daytona
- You need GPU, Windows or macOS sandboxes.
- You want US and EU regions, or dedicated and custom regions, now.
- Container-class isolation fits your threat model and you want the Docker/OCI compatibility Daytona describes.
- You want a pay-as-you-go wallet with no monthly plan.
- You already stop sandboxes promptly, so billing for idle time is a small part of your cost.
- You want volumes and archive-to-object-storage for long-lived container sandboxes.
When to pick Sandscale
- You want every sandbox in a microVM with its own kernel by default.
- Your agents spend most of their time waiting and you would rather not manage stop logic.
- You want approvals, DLP, Vault and an audit log as part of the platform.
- You want sandboxes, workspaces and build hosts under one plan and one bill.
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, pause and resume and the security overview.
Sources
Competitor pages read on 20 November 2026:
- https://www.daytona.io/pricing
- https://www.daytona.io/docs/en/sandboxes
- https://www.daytona.io/docs/en/isolation
- https://www.daytona.io/docs/en/architecture
- https://www.daytona.io/docs/en/billing
- https://www.daytona.io/docs/en/limits
- https://www.daytona.io/docs/en/network-limits
- https://www.daytona.io/docs/en/regions
- https://www.daytona.io/docs/en/persistence
- https://www.daytona.io/docs/llms.txt
- https://github.com/daytonaio/daytona
Sandscale pages: pricing, FAQ, security, regions, pause and resume.