Daytona vs Agent 37
Daytona is a sandbox cloud with containers by default and extra classes for Linux VMs, Windows and GPUs, in the US and EU. Agent 37 hosts one always-on agent per user in gVisor sandboxes in the US that sleep when idle, keep their memory and wake on the next message.
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
Agent 37
Agent 37 hosts AI agents, one isolated, always-on sandbox per user, behind one API.
You create an instance from a template (Hermes, OpenClaw, Claude Code, Codex, OpenCode, Pi, Grok or your own Docker image) and talk to it through a chat API, files, exec, SSH and HTTPS URLs. The default instance is a container enforced by gVisor; a VM type gives a full Linux machine with its own kernel for Docker, Kubernetes and Android emulators. It is built for companies that give each of their customers an agent.
- Where it runs
- Dedicated servers in the United States
- Instance types
- Default (shared), Performance (dedicated cores), VM
- Compliance
- SOC 2 Type I, Type II in progress
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 | Agent 37: price rank | boat: price rank |
|---|---|---|---|
| Software factory 100 at once · 4 vCPU / 8 GB · 2,200 sessions of 8 h a month All three fit; Agent 37 ranks 2nd on price but needs its VM type for Docker, Daytona ranks 15th, and boat gives every agent Docker, systemd and a desktop on a full VM. | 15th cheapest of 367 $4,111 a month | 2nd cheapest of 367 $551 a month | 3rd cheapest of 367 $634 a month |
| Always-on AI employees 50 machines 24/7 · 2 vCPU / 4 GB This is what Agent 37 is built for, so Agent 37 ranks first: one assistant per user that sleeps when idle, keeps its memory and wakes on the next message. | 24th cheapest of 366 $6,104 a month | Cheapest of 366 $279 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; Agent 37 ranks first on price and Daytona creates up to 300 to 600 sandboxes a minute, while boat's start limits make big bursts a compromise. | 25th cheapest of 345 $271 a month | Cheapest of 345 $22 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 Neither fits 300 at once on self-serve: Daytona's Tier 4 pool stops at 500 vCPU (this needs 600), and Agent 37 stops at 200 instances, counting sleeping ones; boat fits. | 154th of 361, with limits $2,000 a month | 30th of 361, with limits $79 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 | 6th of 360, with limits $363 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 | 90th of 364, with limits $58 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 Daytona caps a sandbox at 4 vCPU by default, so bigger jobs need a raised limit; Agent 37 ranks 2nd and boat allows 8 vCPU from the $20 plan. | 308th of 377, with limits $805 a month | 2nd cheapest of 377 $84 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 | 3rd cheapest of 368 $12 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 All three fit: Daytona has a VNC desktop and computer-use API on Linux and Windows, Agent 37 adds noVNC through a template, and boat streams a 60fps desktop. | 26th cheapest of 369 $1,198 a month | Cheapest of 369 $53 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 | 48th of 367, with limits $29 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 | Cheapest of 346 $32 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 | 36th of 338, with limits $648 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 can fork only on its VM class and Agent 37 has no fork, while boat runs each attempt on its own VM and can fork one that is already running. | 12th cheapest of 360 $2,000 a month | Cheapest of 360 $43 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 Agent 37 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 | Agent 37 | boat |
|---|---|---|---|
| Isolation | Container by default; Linux VM and Windows VM classes with their own kernel | gVisor by default; full VM as an opt-in instance type | Every sandbox is a full VM with its own kernel |
| Docker inside | Docker in all classes | Only on the VM type, at 2.5x the default compute rate; the gVisor type cannot run a Docker daemon | Docker, root and systemd in every sandbox |
| Nested virtualization | /dev/kvm only on Linux VMs, and KVM must be turned on for your organization | /dev/kvm on the VM type, with a ready Android template | /dev/kvm in every sandbox, Android emulator works |
| 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 published result; shared by default, Performance type on dedicated cores at 4x the compute rate | 26.69 runs/s on dedicated AMD Ryzen 9 9950X hosts |
| Idle sleep and memory | Idle auto-stop or auto-pause; VM classes pause and resume with memory kept | Auto-sleep after a quiet period, memory checkpointed, wakes on the next request | No idle timer; a time limit you set or none; resume reboots from disk |
| Fork and snapshots | Linux VM and Windows: fork with memory kept; containers: no pause or fork | No fork; daily backups plus one on-demand backup, restored in place only | Fork a running sandbox; snapshots every minute and on stop; named snapshots as templates |
| Custom images | Docker images and declarative builds for containers; VM snapshots from an image | Your own linux/amd64 Docker image as a template | Templates from named snapshots, no Dockerfile builds |
| Coding agents | Guides install agents and run them through process exec | Hermes, OpenClaw, Claude Code, Codex, Grok, OpenCode, Pi, with a chat API per instance | Claude Code, Codex, pi, 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 | Managed LLM, search and Composio through a per-instance token; your own keys go in as env vars | Proxy for model providers and any HTTPS API you register; switches to another account when credits run out |
| Desktop and computer use | VNC desktop (xfce4) and a computer-use API on Linux and Windows | noVNC desktop through a template build or the Ubuntu VM template | 60fps desktop and Chromium in every sandbox, embeddable stream |
| Reaching the sandbox | HTTPS preview URLs on any port; SSH; no raw TCP or public IP | HTTPS URL per port, custom domains; no public IP, SSH through a WebSocket tunnel | HTTPS URLs for up to 50 ports, raw TCP, dedicated IPv6 or IPv4 |
| Outbound internet | Tier 1 and 2 reach only registries, git hosts and AI APIs; open internet and allowlists from Tier 3 | Open internet from the wallet | Open internet on every plan |
| GPUs and Windows | Nvidia and AMD GPUs by the hour; Windows VM sandboxes | Neither | Neither; Wine for Windows apps |
| Regions | US and EU, plus dedicated regions or your own machines | United States | EU only (Germany, Finland, France), EU data residency |
Every feature Battleships tracks (43)
| Feature | Daytona | Agent 37 | boat |
|---|---|---|---|
| Full VM (own kernel) | No | No | Yes |
| Docker inside | Yes | No | Yes |
| Nested virtualization | Yes | No | Yes |
| Root | Yes | Yes | Yes |
| Systemd | Not published | Not published | Yes |
| Desktop GUI | Yes | Yes | Yes |
| Browser | Yes | Yes | Yes |
| Computer-use API | Yes | Yes | 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 | No | 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 | Not published | 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 | Yes | Yes |
| Agent harness API | No | Yes | Yes |
| MCP server | Yes | No | No |
| GPU | Yes | No | No |
| Windows | Yes | No | No |
| Arm64 | No | No | No |
| Self-hosting | No | No | No |
| BYOC | Yes | No | No |
| Open source | No | No | No |
| Scoped API keys | Yes | Not published | Yes |
| Spend limits | Not published | Yes | Yes |
| Usage per sandbox (API) | Yes | Yes | Yes |
| Audit logs | Yes | Not published | No |
| SSO | Yes | No | No |
| SOC 2 | Yes | Yes | No |
| HIPAA | Yes | No | No |
| EU data residency | Yes | No | 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. Agent 37 has no published result on that benchmark, so there is no comparable number for it; its default instances share host cores, and its Performance type runs on dedicated cores.
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). Agent 37 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 | Agent 37, 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) | $6 · Wallet (any top-up) | $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) | $12 · Wallet (any top-up) | $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) | $329 · Wallet ($100 lifetime top-ups) | $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 | $33 · Wallet ($250 lifetime top-ups) · with limits | $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 | $73 · Wallet ($250 lifetime top-ups) · with limits | $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).
Agent 37: Agent 37 uses a prepaid wallet with no plan fee, metered per minute: $0.80 per vCPU and $0.70 per GB of RAM per month while running, and $0.09 per GB of disk per month even while stopped or asleep. VM compute costs 2.5x and Performance compute 4x the default rate.
Agent 37: A monthly plan from $20, and all of it is usage credit spent per second on running sandboxes. A stopped sandbox costs nothing and keeps its disk.
Limits in those scenarios
Daytona limits the total vCPU running at once (10, 100, 250 or 500 from Tier 1 to Tier 4), caps one sandbox at 4 vCPU / 8 GB by default, and only opens the internet from Tier 3. Agent 37 caps instances at 1, 10, 50 or 200 by lifetime top-ups, counting sleeping and stopped ones, and a 4 vCPU / 8 GB instance takes at most 20 GB of disk. That is why neither fits 300 sandboxes for your users or 1,000 short jobs at once without asking for more. The 50-agent scenario needs Docker, so Agent 37 is priced on its VM type there.
| Scenario | Daytona | Agent 37 | 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 or Windows, a sandbox that pauses and forks with its memory, or must run in the US, the EU or on 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.
- Windows and memory fork. Useful if you need Windows desktops, or a sandbox that pauses and forks with its memory kept: Daytona's VM classes do both.
- Two regions and your own machines. Daytona runs in the US and the EU, can manage sandboxes on machines you bring, and limits egress per sandbox from Tier 3.
Use Agent 37 when
you host one mostly idle assistant per customer in the US that should sleep with its memory kept and wake on the next message.
- Sleeps when idle and keeps its memory. Useful for assistants that sit idle most of the day: an instance sleeps, keeps its memory and wakes on the next message.
- Lowest bill in every scenario. Agent 37 meters per minute with no plan fee, and comes out lowest of the two in every scenario we priced.
- Built for one agent per customer. Agent 37 starts Hermes, OpenClaw, Claude Code and others from templates and gives each instance a chat API.
Where boat fits
Look at boat when your agents do real work for hours: installs, builds, Docker and emulators. Daytona and Agent 37 both start you on a lighter sandbox and sell a full VM as a separate class, while every boat sandbox is a full VM. boat runs in the EU only and has no GPUs or Windows, so those needs stay with Daytona.
A full VM is the default
Daytona's default container shares the host kernel, and its VM class needs KVM turned on for your org. Agent 37's gVisor type cannot run Docker, and its VM type costs 2.5x with no systemd.
Fork a machine while it runs
Agent 37 has no fork, so each try rebuilds a half-done task from the start. Daytona forks only on its VM class, never its default containers. boat copies any running sandbox into a new one.
Disk saved every minute, free stops
Daytona keeps billing the disk of a stopped sandbox, and Agent 37 bills disk while stopped or asleep and backs up daily. boat snapshots every minute and a stopped sandbox costs nothing.
Use boat when your agents do real work for hours: installs, builds, tests, Docker and emulators on a full, faster VM you can fork while it runs, with a desktop and coding agents built in. Compare it one to one: boat vs Daytona and boat vs Agent 37.
Questions people ask
Is Daytona cheaper than Agent 37?
No. Agent 37 is lower in every scenario we priced: one coding agent on workdays comes to $6 a month against $56 on Daytona, and one agent running all month to $12 against $245. For 50 agents in parallel, Agent 37 needs its VM type for Docker and comes to $329 against $2,682 on Daytona; boat comes to $317.
Which is faster, Daytona or Agent 37?
There is no fair answer yet: Daytona's Linux VM class did 21.52 runs per second in StarSling's benchmark, and Agent 37 has no published result. boat did 26.69 in the same run.
Can Daytona and Agent 37 run Docker?
Daytona runs Docker in all its classes. On Agent 37 the default gVisor type cannot run a Docker daemon; you need the VM type, which bills compute at 2.5x. Docker works in every boat sandbox.
Are they containers or VMs?
Daytona's default is a Linux container, with Linux VM and Windows VM classes on request. Agent 37's default is a gVisor sandbox, with a full VM type on request. Every boat sandbox is a full VM.
Do Daytona or Agent 37 have GPUs?
Daytona rents Nvidia and AMD GPUs by the hour, on demand or preemptible. Agent 37 has no GPUs, and neither does boat.
Where do Daytona and Agent 37 run?
Daytona offers US and EU regions, plus dedicated regions and your own machines. Agent 37 runs on dedicated servers in the United States. boat runs only in the EU, in Germany, Finland and France.
Try boat
Install the CLI, then run boat new.
7-day free trial