boat vs Daytona
Daytona runs sandboxes as containers by default and sells Linux VMs, Windows and GPUs as extra classes. boat gives every sandbox its own VM with Docker, a desktop and coding agents built in, and it costs less in most of the scenarios below.
Where boat stands out
A full VM for every sandbox
On boat every sandbox has its own kernel, with root, systemd, Docker and /dev/kvm ready. On Daytona the default is a container that shares the host kernel. Its Linux VM class closes that gap, but it is built only from VM snapshots, and KVM must be turned on for your organization.
Faster CPU in the same test
In the same public benchmark run at 4 vCPU / 8 GB, boat did 26.69 runs per second and Daytona's Linux VM class did 21.52. boat also finished the Better Auth install, lint, build and test workflow first. Daytona's default container class reported no result in that run.
Coding agents built in
boat ships Claude Code, Codex, pi, OpenCode and other agents inside each sandbox, and you drive them from outside with a prompt, steer and events API. On Daytona you install the agent yourself and run it as a process. boat's credentials proxy also keeps real AI keys out of the sandbox and can switch to another account when one runs out of credits.
The companies and products
boat
boat.dev runs sandboxes for AI agents: each one is a full Linux VM with its own kernel.
You start a machine with one command or one API call, then SSH in, run Docker, open a desktop, or let a built-in agent (Claude Code, Codex, OpenCode and others) work in it. The disk stays between sessions, and a stopped sandbox costs nothing.
- Isolation
- Full VM per sandbox, own kernel
- Regions
- EU: Germany, Finland, France
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
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. “2nd cheapest of 366” means 1 of the other 365 providers runs 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 | boat: price rank | Daytona: price rank |
|---|---|---|
| Software factory 100 at once · 4 vCPU / 8 GB · 2,200 sessions of 8 h a month Both fit; boat has Docker, a desktop and nested virtualization on every machine, while on Daytona you choose the Linux VM class to get pause, fork and /dev/kvm. | 2nd cheapest of 366 $634 a month | 7th cheapest of 366 $4,111 a month |
| Always-on AI employees 50 machines 24/7 · 2 vCPU / 4 GB Both fit; boat keeps each assistant on its own VM by default, while Daytona needs its Linux VM class to avoid a shared kernel. | 4th cheapest of 362 $657 a month | 21st cheapest of 362 $6,104 a month |
| Code interpreter bursts 100 at once · 1 vCPU / 2 GB · 200,000 sessions of 1 min a month Daytona fits one-minute runs better: it creates up to 300 to 600 sandboxes a minute with no plan fee, while boat's start limits make big bursts a compromise. | 183rd of 342, with limits $2,000 a month | 18th cheapest of 342 $271 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 at once need 600 vCPU, more than Daytona's Tier 4 pool of 500 vCPU, so it needs a custom limit there. | Cheapest of 361 $209 a month | 151st of 361, with limits $2,000 a month |
| RL rollouts 1,000 at once · 2 vCPU / 4 GB · 1,000,000 sessions of 3 min a month | 33rd of 358, with limits $2,000 a month | 123rd of 358, with limits $8,261 a month |
| Agent evals 250 at once · 4 vCPU / 8 GB · 15,000 sessions of 20 min a month | 9th cheapest of 363 $200 a month | 184th of 363, with limits $2,000 a month |
| CI runners 40 at once · 8 vCPU / 16 GB · 6,000 sessions of 12 min a month Daytona caps a sandbox at 4 vCPU by default, so an 8 vCPU CI job needs a raised limit; boat allows 8 vCPU from the $20 plan. | 4th cheapest of 377 $86 a month | 297th of 377, with limits $805 a month |
| 24/7 dev boxes 1 machine 24/7 · 4 vCPU / 8 GB | 17th cheapest of 369 $26 a month | 177th of 369, with limits $245 a month |
| Computer-use agents 50 at once · 4 vCPU / 8 GB · 20,000 sessions of 15 min a month Both fit: Daytona has VNC and a computer-use API on Linux and Windows, and boat streams a 60fps desktop you can embed in your app. | 5th cheapest of 367 $200 a month | 25th cheapest of 367 $1,198 a month |
| Browser-use agents 50 at once · 2 vCPU / 4 GB · 30,000 sessions of 10 min a month | 5th cheapest of 363 $200 a month | 87th of 363, with limits $598 a month |
| Scraping & bots (startup scale) 50 at once · 1 vCPU / 2 GB · 100,000 sessions of 3 min a month | 4th cheapest of 341 $90 a month | 35th cheapest of 341 $404 a month |
| Mass scraping & bots (undetectable) 1,000 at once · 1 vCPU / 2 GB · 3,000,000 sessions of 2 min a month | 65th of 337, with limits $1,800 a month | 195th of 337, with limits $8,073 a month |
| Parallel red teaming 200 at once · 2 vCPU / 4 GB · 5,000 sessions of 30 min a month | 3rd cheapest of 357 $200 a month | 10th cheapest of 357 $2,000 a month |
| GPU eval jobs 10 at once · 8 vCPU / 32 GB · 500 sessions of 30 min a month Only Daytona fits: it rents GPUs by the hour, and boat has no GPUs. | Can't run it | 20th cheapest of 97 $1,190 a month |
| 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 |
Key features
| Feature | boat | Daytona |
|---|---|---|
| Isolation | Every sandbox is a full VM with its own kernel | Container by default; Linux VM and Windows VM classes on request |
| CPU speed (Node.js build-and-test, 4 vCPU / 8 GB) | 26.69 runs/s | 21.52 runs/s on the Linux VM class; the default container class reported no result |
| Docker and nested virtualization | Docker, root, systemd and /dev/kvm on every machine | Docker in all classes; /dev/kvm only on Linux VMs, and KVM must be turned on for your organization |
| Desktop and computer use | 60fps desktop and Chromium, computer use and browser control, embeddable stream | VNC desktop (xfce4) and a computer-use API on Linux and Windows |
| Files after a stop | Snapshots every minute and on stop; a stopped sandbox costs nothing | The disk is kept and billed while stopped; archived containers are free |
| Pause and fork | Fork a running sandbox; resume reboots from disk (no memory snapshots) | Linux VM and Windows: pause, resume and fork with memory kept; containers: no pause or fork |
| Custom images | Named snapshots (templates), shareable by code; no Dockerfile builds | Docker images and declarative builds for containers; VM snapshots from an image |
| Reaching the sandbox | HTTPS URLs for up to 50 ports, token-protected; raw TCP; dedicated IPv6 or IPv4 | HTTPS preview URLs on any port, token-protected or public; SSH; no raw TCP or public IP |
| Outbound internet | Open internet on every plan; no provider-side allowlist | Tier 1 and 2 reach only package registries, git hosts and AI APIs; Tier 3 and up get open internet plus per-sandbox domain or CIDR allowlists |
| Keeping keys out of the sandbox | AI credentials proxy for model providers and any HTTPS API you register; switch a credential to another account when credits run out | Secrets proxy swaps placeholders in HTTPS request headers for allowed hosts |
| Coding agents | Claude Code, Codex, OpenCode and more preinstalled, with a prompt, steer and events API | Guides install agents and run them through process exec |
| GPUs | None | Nvidia and AMD GPUs, on-demand or cheaper preemptible |
| Windows | No Windows guests; Wine for Windows apps | Windows VM sandboxes in three sizes |
| Regions | EU only: Germany, Finland, France | US and EU, plus dedicated regions or your own machines (BYOC) |
| Compliance and transparency | SOC 2 is in progress. We're open about where we stand: live status and data retention policy. | SOC 2 |
Every feature Battleships tracks (43)
| Feature | boat | Daytona |
|---|---|---|
| Full VM (own kernel) | Yes | No |
| Docker inside | Yes | Yes |
| Nested virtualization | Yes | Yes |
| Root | Yes | Yes |
| Systemd | Yes | Not published |
| Desktop GUI | Yes | Yes |
| Browser | Yes | Yes |
| Computer-use API | Yes | Yes |
| SSH | Yes | Yes |
| Persistent disk | Yes | Yes |
| Pause/resume | Yes | Yes |
| Automatic snapshots | Yes | Yes |
| Fork/clone | Yes | Yes |
| Live fork (no pause) | Yes | No |
| Memory fork | No | Yes |
| Custom image (Docker or snapshot) | Yes | Yes |
| ≥24 h sessions | Yes | Yes |
| Idle auto-stop | No | Yes |
| Wake on request | No | No |
| HTTPS preview URLs | Yes | Yes |
| Raw TCP inbound | Yes | No |
| Public IPv4 | No | No |
| Egress allowlist | No | Yes |
| Secret proxy | Yes | Yes |
| Secret proxy for any API | Yes | Yes |
| Preinstalled agents | Yes | Yes |
| Agent harness API | Yes | No |
| MCP server | No | Yes |
| GPU | No | Yes |
| Windows | No | Yes |
| Arm64 | No | No |
| Self-hosting | No | No |
| BYOC | No | Yes |
| Open source | No | No |
| Scoped API keys | Yes | Yes |
| Spend limits | Yes | Not published |
| Usage per sandbox (API) | Yes | Yes |
| Audit logs | No | Yes |
| SSO | No | Yes |
| SOC 2 | No | Yes |
| HIPAA | No | Yes |
| EU data residency | Yes | Yes |
| Zero data retention | Yes | Not published |
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 was also in that run but reported no result, so there is no CPU number for the class most Daytona sandboxes use.
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).
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 | boat, a month | Daytona, 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 | $20 · $20/mo | $56 · Tier 3 ($500 top-up) |
| One agent that never stops 4 vCPU / 8 GB, 50 GB disk, running 24/7 all month | $26 · $20/mo | $245 · Tier 3 ($500 top-up) |
| 50 agents in parallel 50 machines of 4 vCPU / 8 GB at once, 8-hour sessions, 1,100 sessions a month, Docker inside | $317 · $20/mo × 3 seats | $2,682 · Tier 3 ($500 top-up) |
| Sandboxes for your users 2 vCPU / 4 GB, 30,000 sessions of 10 minutes a month, up to 300 at once | $200 · $100/mo × 2 seats | $2,000 · Tier 4 ($2,000 top-up every 30 days) · with limits |
| 1,000 short jobs at once 2 vCPU / 4 GB, 1,000 at once, 3 minutes each, 200,000 jobs a month | $2,000 · $2000/mo · with limits | $2,000 · Tier 4 ($2,000 top-up every 30 days) · with limits |
boat: You pick a monthly plan from $20, and all of it becomes usage credit spent per second on running sandboxes. A stopped sandbox costs nothing and keeps its disk.
Daytona: Daytona bills per second for the vCPU, memory and disk you reserve, including while a sandbox is starting or stopping, and keeps billing the disk while it is stopped. You pay from a prepaid wallet: open internet needs a $500 top-up (Tier 3), and the biggest pool needs $2,000 every 30 days (Tier 4).
Limits in those scenarios
Daytona limits the total vCPU, memory and disk running at once, not the number of sandboxes: 10, 100, 250 or 500 vCPU from Tier 1 to Tier 4. That is why 300 sandboxes for your users (600 vCPU) and 1,000 short jobs at once (2,000 vCPU) do not fit even Tier 4 without a custom limit. On boat the limit is a sandbox count (100 to 2,000 by plan) plus starts per minute, so the 1,000-job burst gets queued and needs more starts per day than the $2,000 plan allows. Daytona also caps one sandbox at 4 vCPU / 8 GB by default and only opens the internet from Tier 3.
| Scenario | boat | Daytona |
|---|---|---|
| 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 or Windows, or must run in the US or on your own machines.
- GPUs by the hour. Useful if your agents train or test models: Daytona rents Nvidia and AMD GPUs by the hour, from RTX 4090 to B300.
- Windows and memory pause. Useful if you need Windows desktops, or a sandbox that pauses and comes back with its memory: Daytona's VM classes do both.
- Network rules, US region, your own machines. From Tier 3 a sandbox can be limited to chosen domains, and Daytona also runs in the US and on your own machines.
Use boat when
your agents do real work for hours: installs, builds, tests, Docker and emulators on a full, faster VM with a desktop and coding agents built in.
- A full VM for every sandbox. A container shares the host kernel, so a kernel bug is a way out for code an agent wrote, and emulators need /dev/kvm. On Daytona you avoid both only by choosing the VM class and getting KVM turned on.
- Faster CPU in the same test. At 21.52 runs per second against 26.69, every install, build and test takes about a quarter longer on Daytona's VM class, and you pay for the waiting. Its default containers have no measured number at all.
- Coding agents built in. Without a driving API you write and maintain the code that starts, prompts and watches each agent yourself. When an account runs out of credits, boat switches the credential, so the agent keeps working instead of stopping.
Questions people ask
Is boat cheaper than Daytona?
In most of the scenarios we priced, yes: one coding agent on workdays comes to $20 a month on boat and $56 on Daytona, and one agent running all month comes to $26 versus $245. 50 agents in parallel come to $317 versus $2,682. For 1,000 short jobs at once, both land at $2,000 and neither fits without higher limits.
Are Daytona sandboxes containers or VMs?
Both. The default class is a Linux container with its own namespaces and reserved resources. Daytona also offers Linux VM and Windows VM classes with their own kernel, which add pause, fork and memory snapshots. On boat, every sandbox is a full VM.
Does boat have GPUs or Windows like Daytona?
No. boat has no GPUs and no Windows guests; it runs Linux VMs on AMD Ryzen 9 9950X machines and has Wine docs for Windows apps. If you need GPUs or a Windows desktop, Daytona has both.
Can Daytona sandboxes reach the internet?
On Tier 1 and Tier 2, only a list of essential services is reachable, such as package registries, git hosts and AI APIs. Open internet starts at Tier 3, which needs a $500 top-up, and from there you can set allowlists per sandbox. boat sandboxes have open internet on every plan.
Where does my data run?
boat runs only in the EU (Germany, Finland and France), with EU data residency and a zero data retention option. Daytona offers US and EU regions, plus dedicated regions and custom regions on your own machines.
Is boat SOC 2 compliant?
SOC 2 is in progress. We're open about where we stand: live status at https://status.ascii.dev and our data retention policy at https://docs.boat.dev/data-retention. Daytona says on its pricing page that it meets HIPAA, SOC 2 and GDPR standards.
Start a sandbox
Install the CLI, then run boat new.
7-day free trial