Daytona vs Beam
Daytona runs sandboxes as containers by default and sells Linux VM, Windows and GPU classes on top, paid from a prepaid wallet. Beam is a serverless GPU platform with quick gVisor sandboxes, a separate line of CPU VMs and an open-source runtime you can host yourself.
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
Beam
Beam is a serverless cloud for GPU inference, sandboxes and background jobs, built on its open-source runtime Beta9.
Beam runs functions, REST endpoints, task queues, pods, sandboxes and VMs on CPUs and GPUs, all from a Python or TypeScript SDK. A sandbox is a container isolated with gVisor that starts in a second or two, lives until you terminate it or its time to live runs out, and can be saved as a filesystem image or a memory snapshot. Beam VMs are a separate CPU product: a microVM with its own kernel, systemd and a root disk that stays when it stops. Much of Beam is a GPU serverless platform for AI teams.
- Bring your own cloud
- Management fee per vCPU and GB of RAM, on top of your own cloud bill
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 | Beam: price rank | boat: price rank |
|---|---|---|---|
| Software factory 100 at once · 4 vCPU / 8 GB · 2,200 sessions of 8 h a month Daytona fits a software factory with its Linux VM class, while Beam is a compromise because its sandboxes end with their time to live and document no /dev/kvm; boat gives every sandbox Docker, systemd and /dev/kvm. | 15th cheapest of 367 $4,111 a month | 69th of 367, with limits $551 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 | 115th of 366, with limits $651 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 Beam fits short code runs well, with sandboxes that start in a second or two and stop when their timer ends, and Daytona fits too with no plan fee. | 25th cheapest of 345 $271 a month | 8th cheapest of 345 $117 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 Beam's Team plan fits 300 user sandboxes at once, while 600 vCPU is more than Daytona's Tier 4 pool of 500 vCPU, so Daytona needs a custom limit. | 154th of 361, with limits $2,000 a month | 3rd cheapest of 361 $290 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 | 130th of 360, with limits $8,261 a month | 341st of 360, with limits $939 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 | 189th of 364, with limits $2,000 a month | 13th cheapest of 364 $251 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 Beam fits CI jobs on its Team plan, while Daytona caps a sandbox at 4 vCPU by default; jobs that build Android apps need /dev/kvm, which boat has on every sandbox. | 308th of 377, with limits $805 a month | 12th cheapest of 377 $171 a month | 4th cheapest of 377 $86 a month |
| 24/7 dev boxes 1 machine 24/7 · 4 vCPU / 8 GB A Beam VM keeps its root disk while stopped at a low hourly rate, while Daytona keeps billing the disk of a stopped sandbox; boat saves the disk every minute and a stopped sandbox costs nothing. | 183rd of 368, with limits $245 a month | 13th cheapest of 368 $21 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, Beam has no desktop or browser product, and boat streams a 60fps desktop with Chromium. | 26th cheapest of 369 $1,198 a month | 111th of 369, with limits $237 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 | 195th of 367, with limits $176 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 | 200th of 346, with limits $131 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 | 42nd of 338, with limits $923 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 Daytona fits parallel red teaming, while Beam is a compromise; boat gives each attacker its own full VM. | 12th cheapest of 360 $2,000 a month | 175th of 360, with limits $155 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 Both rent GPUs: Daytona from RTX 4090 to B300 and AMD MI355X, Beam from T4 to H100, H200 and B200; boat has no GPUs. | 20th cheapest of 98 $1,190 a month | Cheapest of 98 $458 a month | 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 | Beam | boat |
|---|---|---|---|
| Isolation | Container by default; Linux VM and Windows VM classes with their own kernel | gVisor container by default for sandboxes; separate Beam VMs are CPU microVMs with their own kernel | Every sandbox is a full VM with its own kernel 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 default container class reported no result | No result on this test | 26.69 runs/s |
| Docker, systemd and /dev/kvm | Docker in all classes; /dev/kvm only on Linux VMs, once KVM is turned on for your organization | Docker in sandboxes with docker_enabled; systemd only in Beam VMs; /dev/kvm not documented | Docker, root, systemd and /dev/kvm on every machine |
| Files after a stop | The disk is kept and billed while stopped; archived containers are free | A sandbox ends with its time to live unless you save an image or use a volume; a Beam VM keeps a 50 GiB root disk while stopped | Disk saved every minute and on stop; a stopped sandbox costs nothing |
| Pause, fork and memory snapshots | Linux VM and Windows classes pause, resume and fork with memory kept; containers do not | Memory snapshot of a running sandbox with its processes, restored into new sandboxes | Fork a running sandbox with its disk; resume reboots from disk |
| Desktop and computer use | VNC desktop (xfce4) and a computer-use API on Linux and Windows | No desktop or browser product | 60fps desktop with Chromium, computer use and browser control, embeddable stream |
| Inbound access | HTTPS preview URLs on any port, token-protected or public; SSH; no raw TCP or public IP | HTTPS URL per exposed port, public with no built-in auth; no raw TCP or dedicated IP | HTTPS URLs for up to 50 ports, token-protected; raw TCP; dedicated IPv4 or IPv6 |
| Outbound internet | Tier 1 and 2 reach only package registries, git hosts and AI APIs; Tier 3 and up get open internet plus domain or CIDR allowlists | Open internet; block all traffic or allow up to 10 CIDR ranges, changeable while running | Open internet on every plan; no provider-side allowlist |
| Keeping keys out of the sandbox | Secrets proxy swaps placeholders in HTTPS request headers for allowed hosts | Secrets are environment variables inside the sandbox | Credentials proxy for model providers and any HTTPS API; switch a credential to another account when credits run out |
| Coding agents | Guides install agents and run them through process exec | None preinstalled; you install and run them through process exec | Claude Code, Codex, OpenCode and more preinstalled, with a prompt, steer and events API |
| GPUs | Nvidia B300 to RTX 4090 and AMD MI355X, on-demand or preemptible | GPU sandboxes and serverless GPUs from T4 and RTX 4090 up to H100, H200 and B200 | None, CPU only |
| Windows | Windows VM sandboxes in three sizes | No Windows | No Windows guests; Wine for Windows apps |
| Regions | US and EU, plus dedicated regions or your own machines | US only; no other region is listed | EU only: Germany, Finland, France |
| Self-hosting and source code | Managed runners on your machines (BYOC); public repository stopped receiving updates in June 2026 | Beta9 runtime is AGPL-3.0 and free to self-host; bring your own cloud for a fee | No self-hosting |
Every feature Battleships tracks (43)
| Feature | Daytona | Beam | boat |
|---|---|---|---|
| Full VM (own kernel) | No | No | Yes |
| Docker inside | Yes | Yes | Yes |
| Nested virtualization | Yes | No | Yes |
| Root | Yes | Yes | Yes |
| Systemd | Not published | No | Yes |
| Desktop GUI | Yes | No | Yes |
| Browser | Yes | No | Yes |
| Computer-use API | Yes | No | Yes |
| SSH | Yes | Yes | Yes |
| Persistent disk | Yes | Yes | Yes |
| Pause/resume | Yes | No | Yes |
| Automatic snapshots | Yes | No | 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 | No | No |
| Wake on request | No | No | No |
| HTTPS preview URLs | Yes | Yes | Yes |
| Raw TCP inbound | No | No | Yes |
| Public IPv4 | No | No | No |
| Egress allowlist | Yes | Yes | No |
| Secret proxy | Yes | No | Yes |
| Secret proxy for any API | Yes | No | Yes |
| Preinstalled agents | Yes | No | Yes |
| Agent harness API | No | No | Yes |
| MCP server | Yes | Yes | No |
| GPU | Yes | Yes | No |
| Windows | Yes | No | No |
| Arm64 | No | No | No |
| Self-hosting | No | Yes | No |
| BYOC | Yes | Yes | No |
| Open source | No | Yes | No |
| Scoped API keys | Yes | Not published | Yes |
| Spend limits | Not published | Not published | Yes |
| Usage per sandbox (API) | Yes | No | Yes |
| Audit logs | Yes | Not published | No |
| SSO | Yes | No | No |
| SOC 2 | Yes | Yes | No |
| HIPAA | Yes | Yes | 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. Beam has no result on that test, so we cannot say how fast it is at CPU work; its own guide says sandboxes cold-boot in 1 to 3 seconds.
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). Beam 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 | Beam, 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) | $5 · 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) | $22 · Developer | $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) | $410 · Team | $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 | $191 · Team | $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 | $259 · Team | $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: open internet needs a $500 top-up (Tier 3), and the biggest pool needs $2,000 every 30 days (Tier 4).
Beam: Beam sandboxes bill per second for each CPU core (two vCPU) and GiB of RAM until they are terminated or their time to live ends, and Beam VMs bill only while running. Developer has no fee; Team adds an $89 monthly fee that is not usage credit, and there are no egress fees.
Beam: 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
Daytona limits the total vCPU running at once, 500 vCPU at Tier 4, so 300 user sandboxes (600 vCPU) and 1,000 short jobs (2,000 vCPU) do not fit without a custom limit, and Tier 1 and 2 reach only an allowlist of hosts. Beam's Developer plan allows 30 CPU containers at once, so 50 parallel agents need Team, which fits every scenario here. Beam publishes no price for extra disk, so its figures count no disk cost. boat queues starts in the 1,000-job burst, so that one does not fit on boat either.
| Scenario | Daytona | Beam | 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
you need Windows sandboxes, memory pause and fork, a desktop for computer use, or sandboxes in the EU or on your own machines.
- Windows and memory pause. Useful if you need Windows desktops, or sandboxes that pause and fork with memory kept: Daytona's VM classes do both.
- US, EU and your own machines. Daytona runs in the US and the EU, and can also manage sandboxes on dedicated regions or machines you bring.
- A desktop for computer use. Daytona ships a VNC desktop and a computer-use API on Linux and Windows, which Beam does not offer.
Use Beam when
you want GPUs and sandboxes in one platform, big bursts of short CPU jobs at a low price, or a runtime you can self-host.
- Low cost for always-on CPU work. A Beam VM keeps its root disk while stopped, and in our scenarios Beam costs far less than Daytona for steady agents.
- Large fleets and bursts. Beam's Team plan allows 1,000 CPU containers at once, so 300 user sandboxes or 1,000 short jobs fit without a custom limit.
- Open source and outbound rules. Beam's Beta9 runtime is AGPL-3.0 and free to self-host, and any sandbox can be cut off or limited to 10 CIDR ranges.
Where boat fits
If your agents do long work like installs, builds, Docker and emulators, both Daytona and Beam make you pick a special class or product to get a real kernel. boat gives every sandbox a full VM with /dev/kvm, a 60fps desktop and coding agents built in. Pick Daytona or Beam instead if you need GPUs, Windows or the US.
A full VM with /dev/kvm by default
Daytona's default container shares the host kernel, and /dev/kvm needs its VM class plus KVM turned on for your organization. Beam's gVisor sandboxes have no systemd, and neither Beam product documents /dev/kvm, so Android emulators have nowhere to start.
Faster CPU in the same test
In StarSling's run at 4 vCPU / 8 GB, boat did 26.69 runs per second and Daytona's VM class 21.52, so each build takes about a quarter longer there. Beam has no measured result at all.
Agents, desktop and keys built in
On both Daytona and Beam you install agents yourself and run them as processes. Beam has no desktop and keeps secrets as environment variables an agent can read; boat drives preinstalled agents from outside and keeps keys in a proxy.
Use boat when your agents do real work for hours: installs, builds, Docker and emulators on a full, faster VM with a desktop and coding agents built in. Compare it one to one: boat vs Daytona and boat vs Beam.
Questions people ask
Is Daytona cheaper than Beam?
No, in every scenario we priced Beam costs less. One agent that never stops comes to $245 on Daytona and $22 on Beam, and 50 agents in parallel come to $2,682 against $410. Beam publishes no price for extra disk, so its figures leave disk out; boat comes to $26 and $317 for the same two.
Which is faster, Daytona or Beam?
We cannot say: Beam has no result on the StarSling CPU test. Daytona's Linux VM class did 21.52 runs per second at 4 vCPU / 8 GB, and boat did 26.69 in the same run.
Are Daytona and Beam sandboxes containers or VMs?
Both default to containers. Daytona also sells Linux VM and Windows VM classes with their own kernel, and Beam sells separate CPU microVMs with systemd. Every boat sandbox is a full VM.
Can Daytona and Beam run Docker?
Yes. Daytona supports Docker in all its classes, and Beam supports it in sandboxes with docker_enabled. For /dev/kvm, Daytona needs its Linux VM class with KVM turned on, and Beam does not document it; boat has Docker and /dev/kvm on every machine.
Which one has GPUs?
Both. Daytona rents Nvidia cards from RTX 4090 to B300 and the AMD MI355X, and Beam offers GPU sandboxes and serverless GPUs up to H100, H200 and B200. boat has no GPUs.
Where do Daytona and Beam run?
Daytona runs in the US and the EU, plus dedicated regions and your own machines. Beam runs on AWS and Google Cloud in the US, and its runtime can be self-hosted. boat runs only in the EU, in Germany, Finland and France.
Try boat
Install the CLI, then run boat new.
7-day free trial