Daytona vs Morph Cloud
Daytona runs sandboxes as containers by default and sells Linux VM, Windows VM and GPU classes on top. Morph Cloud gives every agent a full VM that can be paused, branched and woken on request with its memory kept.
The companies and products
Daytona
Daytona is a cloud for running AI-generated code: you create sandboxes from code through its API and SDKs.
By default a Daytona sandbox is a Linux container with its own namespaces and reserved vCPU, memory and disk. You can also pick a Linux VM class (pause, fork, memory snapshots, /dev/kvm), a Windows VM class, or a GPU class with Nvidia and AMD cards. It is built for teams that run agent code, code interpreters and evals through Python, TypeScript, Ruby, Go or Java SDKs.
- Founded
- 2023
Morph Cloud
Morph Cloud sells full virtual machines for AI agents that can be snapshotted, branched and restored with their memory, which it calls Infinibranch.
You get MorphVM instances as low-level building blocks and Devboxes as ready workspaces on top of them, with SSH, preview URLs and a tmux API for running coding agents you install yourself. Everything is billed in MCUs, where one MCU is 1 vCPU, 4 GB of RAM or 16 GB of disk for an hour. It is built for teams that fan agents out from one saved state, and it also sells managed GitHub Actions runners and a shared filesystem.
- Regions
- Not published
Which use cases each one fits
For each use case, Battleships prices every sandbox provider on the same workload and sorts them from the cheapest monthly bill up. “15th cheapest of 367” means 14 of the other 366 providers run that workload, with every feature it needs, for less. “With limits” means the provider runs it but misses something, so it is listed after every full match. Open a use case for its whole ranking and what each provider misses.
| Use case and its workload | Daytona: price rank | Morph Cloud: price rank | boat: price rank |
|---|---|---|---|
| Software factory 100 at once · 4 vCPU / 8 GB · 2,200 sessions of 8 h a month Daytona fits once you pick its Linux VM class for pause, fork and /dev/kvm, while Morph's VMs fit only as a compromise; boat has Docker, a desktop and coding agents on every machine. | 15th cheapest of 367 $4,111 a month | 198th of 367, with limits $2,288 a month | 3rd cheapest of 367 $634 a month |
| Always-on AI employees 50 machines 24/7 · 2 vCPU / 4 GB | 24th cheapest of 366 $6,104 a month | 235th of 366, with limits $3,014 a month | 5th cheapest of 366 $657 a month |
| Code interpreter bursts 100 at once · 1 vCPU / 2 GB · 200,000 sessions of 1 min a month Both fit short code runs: Daytona creates hundreds of sandboxes a minute with no plan fee, and Morph pauses a machine with its memory and wakes it on the next request. | 25th cheapest of 345 $271 a month | 16th cheapest of 345 $154 a month | 186th of 345, with limits $2,000 a month |
| Sandboxes for your users 300 at once · 2 vCPU / 4 GB · 30,000 sessions of 23 min a month 300 sandboxes of 2 vCPU need 600 vCPU, more than Daytona's Tier 4 pool of 500, while Morph's Scale pool of 1,024 vCPU holds them. | 154th of 361, with limits $2,000 a month | 12th cheapest of 361 $905 a month | Cheapest of 361 $209 a month |
| RL rollouts 1,000 at once · 2 vCPU / 4 GB · 1,000,000 sessions of 3 min a month Morph's memory branching suits rollouts that all start from the same running state; Daytona can do the same only on its VM classes. | 130th of 360, with limits $8,261 a month | 86th of 360, with limits $4,847 a month | 34th of 360, with limits $2,000 a month |
| Agent evals 250 at once · 4 vCPU / 8 GB · 15,000 sessions of 20 min a month Morph fits agent evals fully, while Daytona fits them only as a compromise at this size. | 189th of 364, with limits $2,000 a month | 38th cheapest of 364 $675 a month | 10th cheapest of 364 $200 a month |
| CI runners 40 at once · 8 vCPU / 16 GB · 6,000 sessions of 12 min a month Morph sells managed GitHub Actions runners, while Daytona caps a sandbox at 4 vCPU by default, so an 8 vCPU job needs a raised limit there. | 308th of 377, with limits $805 a month | 39th cheapest of 377 $355 a month | 4th cheapest of 377 $86 a month |
| 24/7 dev boxes 1 machine 24/7 · 4 vCPU / 8 GB | 183rd of 368, with limits $245 a month | 85th cheapest of 368 $116 a month | 18th cheapest of 368 $26 a month |
| Computer-use agents 50 at once · 4 vCPU / 8 GB · 20,000 sessions of 15 min a month Daytona has a VNC desktop and a computer-use API on Linux and Windows; on Morph you install the browser and the computer use agent yourself, and boat streams a 60fps desktop with Chromium. | 26th cheapest of 369 $1,198 a month | 182nd of 369, with limits $595 a month | 6th cheapest of 369 $200 a month |
| Browser-use agents 50 at once · 2 vCPU / 4 GB · 30,000 sessions of 10 min a month | 93rd of 367, with limits $598 a month | 214th of 367, with limits $250 a month | 7th cheapest of 367 $200 a month |
| Scraping & bots (startup scale) 50 at once · 1 vCPU / 2 GB · 100,000 sessions of 3 min a month | 38th cheapest of 346 $404 a month | 239th of 346, with limits $234 a month | 6th cheapest of 346 $90 a month |
| Mass scraping & bots (undetectable) 1,000 at once · 1 vCPU / 2 GB · 3,000,000 sessions of 2 min a month | 202nd of 338, with limits $8,073 a month | 154th of 338, with limits $4,750 a month | 71st of 338, with limits $1,800 a month |
| Parallel red teaming 200 at once · 2 vCPU / 4 GB · 5,000 sessions of 30 min a month | 12th cheapest of 360 $2,000 a month | 214th of 360, with limits $228 a month | 2nd cheapest of 360 $200 a month |
| GPU eval jobs 10 at once · 8 vCPU / 32 GB · 500 sessions of 30 min a month Only Daytona fits: it rents Nvidia and AMD GPUs by the hour, and neither Morph nor boat has GPUs. | 20th cheapest of 98 $1,190 a month | Can't run it | Can't run it |
| macOS agents 5 at once · 4 vCPU / 8 GB · 1,000 sessions of 20 min a month | Can't run it | Can't run it | Can't run it |
Key features
| Feature | Daytona | Morph Cloud | boat |
|---|---|---|---|
| Isolation | Container by default; Linux VM and Windows VM classes on request | Full VM with its own kernel for every instance | Full VM with its own kernel for every sandbox, on dedicated AMD Ryzen 9 9950X hosts |
| CPU speed (Node.js build-and-test, 4 vCPU / 8 GB) | 21.52 runs/s on the Linux VM class; the container class reported no result | Not measured | 26.69 runs/s |
| Docker and nested virtualization | Docker in all classes; /dev/kvm only on Linux VMs, once KVM is turned on for your organization | Docker, Docker in Docker and local Kubernetes; nested virtualization is experimental | Docker, root, systemd and /dev/kvm on every machine |
| Pause and fork with memory | On Linux VM and Windows classes; containers cannot pause or fork | On every VM; branch into many copies in under 250 ms | Fork a running sandbox with its disk; resume reboots from disk |
| Wake on request | No | A paused VM resumes on the next HTTP request, SSH or exec call | No; a stopped sandbox is started by API |
| Files after a stop | Disk kept and billed while stopped; archived containers are free | Kept when you pause or snapshot; a plain stop deletes the instance | Disk saved every minute and on every stop; a stopped sandbox costs nothing |
| GPUs | Nvidia and AMD, from RTX 4090 to B300, on-demand or preemptible | None | None |
| Windows and macOS | Windows VM sandboxes in three sizes | Experimental Windows and macOS (x86) guests | Linux only; Wine for Windows apps |
| Desktop and computer use | VNC desktop and a computer-use API on Linux and Windows | Browser-based remote desktop; you install the browser and any computer use agent | 60fps desktop with Chromium, computer use and browser control, embeddable stream |
| Coding agents | Guides install agents and run them through process exec | You install the agent and drive it through a tmux API that sends keys and reads the screen | Claude Code, Codex, OpenCode and more preinstalled, with a prompt, steer and events API |
| Keeping keys out of the sandbox | Secrets proxy swaps placeholders in HTTPS request headers for allowed hosts | Responses Proxy for model APIs only; other secrets go into the machine | Credentials proxy for model providers and any HTTPS API; switches to another account when credits run out |
| Reaching the sandbox | HTTPS preview URLs on any port, token-protected or public; SSH; no raw TCP | Named HTTP services with optional API key auth; SSH through Morph's gateway; no raw TCP | HTTPS URLs for up to 50 ports, token-protected; raw TCP; dedicated IPv6 or IPv4 |
| Outbound internet | Tier 1 and 2 reach only an allowlist; open internet plus per-sandbox allowlists from Tier 3 | Open internet; no provider-side allowlist | Open internet on every plan; no provider-side allowlist |
| Regions | US and EU, plus dedicated regions or your own machines | Not published | EU only: Germany, Finland, France |
Every feature Battleships tracks (43)
| Feature | Daytona | Morph Cloud | boat |
|---|---|---|---|
| Full VM (own kernel) | No | Yes | Yes |
| Docker inside | Yes | Yes | Yes |
| Nested virtualization | Yes | Yes | Yes |
| Root | Yes | Yes | Yes |
| Systemd | Not published | Yes | Yes |
| Desktop GUI | Yes | Yes | Yes |
| Browser | Yes | No | Yes |
| Computer-use API | Yes | No | Yes |
| SSH | Yes | Yes | Yes |
| Persistent disk | Yes | Yes | Yes |
| Pause/resume | Yes | Yes | Yes |
| Automatic snapshots | Yes | Yes | Yes |
| Fork/clone | Yes | Yes | Yes |
| Live fork (no pause) | No | Yes | Yes |
| Memory fork | Yes | Yes | No |
| Custom image (Docker or snapshot) | Yes | Yes | Yes |
| ≥24 h sessions | Yes | Yes | Yes |
| Idle auto-stop | Yes | Yes | No |
| Wake on request | No | Yes | No |
| HTTPS preview URLs | Yes | Yes | Yes |
| Raw TCP inbound | No | No | Yes |
| Public IPv4 | No | No | No |
| Egress allowlist | Yes | No | No |
| Secret proxy | Yes | Yes | Yes |
| Secret proxy for any API | Yes | No | Yes |
| Preinstalled agents | Yes | No | Yes |
| Agent harness API | No | Yes | Yes |
| MCP server | Yes | No | No |
| GPU | Yes | No | No |
| Windows | Yes | Yes | No |
| Arm64 | No | No | No |
| Self-hosting | No | No | No |
| BYOC | Yes | No | No |
| Open source | No | No | No |
| Scoped API keys | Yes | Yes | Yes |
| Spend limits | Not published | Not published | Yes |
| Usage per sandbox (API) | Yes | Yes | Yes |
| Audit logs | Yes | Yes | No |
| SSO | Yes | Not published | No |
| SOC 2 | Yes | Not published | No |
| HIPAA | Yes | Not published | No |
| EU data residency | Yes | Not published | Yes |
| Zero data retention | Not published | Not published | Yes |
Performance
In StarSling's public run of 2026-09-29 at 4 vCPU / 8 GB, boat did 26.69 Node.js build-and-test runs per second and Daytona's Linux VM class did 21.52; Daytona's default container class reported no result. Morph Cloud was not in that run, so there is no comparable CPU number for it. Morph's under 250 ms snapshot restore measures start time, not CPU speed.
Node.js build-and-test loop at 4 vCPU / 8 GB, higher is better. Measured with the open hpc-sandbox-benchmarks suite. Daytona measured on: Linux VM sandbox (same rates; KVM / nested virt per-org feature). Morph Cloud has no published run in this suite yet, so there is no like-for-like number to compare.
Pricing in five scenarios
Each bill is priced from the providers' public price lists by the open Battleships engine, with the cheapest plan that runs the scenario.
| Scenario | Daytona, a month | Morph Cloud, a month | boat, a month |
|---|---|---|---|
| One coding agent, workdays 4 vCPU / 8 GB, 50 GB disk, 8 hours a day, 22 days a month, files kept between days | $56 · Tier 3 ($500 top-up) | $32 · Developer | $20 · $20/mo |
| One agent that never stops 4 vCPU / 8 GB, 50 GB disk, running 24/7 all month | $245 · Tier 3 ($500 top-up) | $121 · Team | $26 · $20/mo |
| 50 agents in parallel 50 machines of 4 vCPU / 8 GB at once, 8-hour sessions, 1,100 sessions a month, Docker inside | $2,682 · Tier 3 ($500 top-up) | $1,459 · Scale | $317 · $20/mo × 3 seats |
| Sandboxes for your users 2 vCPU / 4 GB, 30,000 sessions of 10 minutes a month, up to 300 at once | $2,000 · Tier 4 ($2,000 top-up every 30 days) · with limits | $325 · Scale | $200 · $100/mo × 2 seats |
| 1,000 short jobs at once 2 vCPU / 4 GB, 1,000 at once, 3 minutes each, 200,000 jobs a month | $2,000 · Tier 4 ($2,000 top-up every 30 days) · with limits | $869 · Scale | $2,000 · $2000/mo · with limits |
Daytona: Daytona bills per second for the vCPU, memory and disk you reserve, and keeps billing the disk while a sandbox is stopped. You pay from a prepaid wallet with $200 of free compute to start; open internet needs a $500 top-up (Tier 3) and the biggest pool needs $2,000 every 30 days (Tier 4).
Morph Cloud: Morph bills MCUs at $0.05 an hour, where a machine uses the largest of its vCPUs, its RAM in 4 GiB steps or its disk in 16 GiB steps. Team ($40 a month) and Scale ($250 a month) are discounted MCU bundles, Developer starts with no free credit, and a paused VM bills only its snapshot.
Morph Cloud: Plans start at $20 a month and the whole fee is usage credit spent per second while a sandbox runs. A stopped sandbox costs nothing and keeps its disk.
Limits in those scenarios
Both limit resources running at once, not sandbox counts: Daytona's pools go from 10 to 500 vCPU across Tier 1 to Tier 4, and Morph's from 64 vCPU on Developer to 1,024 on Scale. That is why 300 user sandboxes and 1,000 short jobs at once do not fit Daytona even at Tier 4, while Morph Scale fits both; boat fits the user sandboxes but queues the 1,000-job burst. Daytona also caps one sandbox at 4 vCPU / 8 GB by default and opens the internet only from Tier 3, and Morph raises the price once disk passes 16 GiB per MCU.
| Scenario | Daytona | Morph Cloud | boat |
|---|---|---|---|
| One coding agent, workdays |
|
| None that bite |
| One agent that never stops |
|
| None that bite |
| 50 agents in parallel |
|
| None that bite |
| Sandboxes for your users |
|
| None that bite |
| 1,000 short jobs at once |
|
|
|
Which one should you use?
Use Daytona when
your agents need GPUs, a real Windows desktop, a US region or your own machines.
- GPUs by the hour. Useful if your agents train or test models: Daytona rents Nvidia and AMD GPUs from RTX 4090 to B300, and Morph has none.
- Windows that is not experimental. Useful if agents must work on Windows: Daytona sells Windows VM sandboxes with computer use, while Morph lists Windows as experimental.
- US region and your own machines. Daytona runs in the US and EU and can manage sandboxes on your own machines; Morph does not publish its regions.
Use Morph Cloud when
every agent should get its own VM that branches from one running state with its memory, or sleeps between requests and wakes on demand.
- A VM for every agent. Every Morph instance is a full VM with its own kernel, while Daytona's default class is a container sharing the host kernel.
- Branch and wake on request. Useful for agents that fan out from one running state or sleep between requests: Morph branches memory in under 250 ms and wakes on demand.
- Bigger pools before custom limits. Morph's Scale pool holds 1,024 vCPU, so 300 user sandboxes of 2 vCPU fit where Daytona's 500 vCPU Tier 4 needs a custom limit.
Where boat fits
Daytona and Morph Cloud both hand you a machine and leave the agent, the desktop and saving work to you in some form. If your agents run for hours doing installs, builds, tests and browsing, boat gives each one a full VM with the agents and desktop already inside. Pick Daytona for GPUs or Windows, and Morph for memory branching.
A full VM with /dev/kvm by default
Daytona's default sandbox is a container that shares the host kernel; its VM class fixes that only once KVM is turned on for your organization. Morph's nested virtualization is experimental, so Android emulators and inner VMs are a gamble.
Coding agents you drive from outside
On Daytona you install the agent and run it as a process; on Morph you drive it by keystrokes through tmux. Both mean writing and keeping a harness that parses terminal output to know when the agent is done or stuck.
Work saved every minute, stops are free
On Morph a plain stop deletes the instance, so an agent that stops without a pause or snapshot loses its work. On Daytona the disk survives a stop but keeps billing until it is archived.
Use boat when your agents do real work for hours: installs, builds, tests, Docker and emulators on a full, faster VM, with coding agents, a 60fps desktop and a credentials proxy already inside. Compare it one to one: boat vs Daytona and boat vs Morph Cloud.
Questions people ask
Is Daytona cheaper than Morph Cloud?
Not in the scenarios we priced: one coding agent on workdays comes to $56 a month on Daytona and $32 on Morph, and 50 agents in parallel come to $2,682 against $1,459. For 1,000 short jobs at once, Morph Scale fits at $869 a month while Daytona does not fit even Tier 4. boat comes to $20, $317 and $2,000 for those three.
Which is faster, Daytona or Morph Cloud?
There is no CPU number to compare: Daytona's Linux VM class did 21.52 runs per second in StarSling's benchmark, and Morph was not in that run. boat did 26.69 in the same run. Morph is fast at restoring snapshots, under 250 ms, which is start time rather than CPU speed.
Are Daytona and Morph Cloud sandboxes VMs?
Morph's always are. Daytona's default class is a Linux container with its own namespaces, and it also sells Linux VM and Windows VM classes with their own kernel. On boat every sandbox is a full VM.
Can both run Docker?
Yes. Daytona runs Docker in all its classes, and Morph runs Docker, Docker in Docker and local Kubernetes. For /dev/kvm, Daytona needs its Linux VM class with KVM turned on, Morph lists nested virtualization as experimental, and boat has it on every machine.
Does Morph Cloud have GPUs like Daytona?
No. Daytona rents Nvidia and AMD GPUs by the hour, on-demand or preemptible, and Morph has none. boat has no GPUs either, so GPU work belongs on Daytona.
Is boat SOC 2 compliant?
SOC 2 is in progress. We're open about where we stand: live status at status.ascii.dev and our data retention policy at docs.boat.dev/data-retention.
Try boat
Install the CLI, then run boat new.
7-day free trial