Daytona vs Freestyle
Daytona runs sandboxes as containers by default and sells Linux VM, Windows and GPU classes, in the US, the EU or on your own machines. Freestyle gives every sandbox a full KVM VM that can pause with its memory, fork while running and wake on the next request.
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
Freestyle
Freestyle sells full Linux virtual machines for AI agents, built for long running, complex tasks.
Each Freestyle VM is a KVM virtual machine with its own kernel, booted from an Ubuntu base snapshot with systemd, Docker and coding agent CLIs preinstalled. VMs can be paused with their memory, snapshotted while running, forked and woken by the next request, and every VM starts behind a default-deny firewall. It is built for teams that give each agent or each user its own machine, driven from a TypeScript SDK, a CLI or an API.
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 | Freestyle: price rank | bochka: price rank |
|---|---|---|---|
| Software factory 100 at once · 4 vCPU / 8 GB · 2,200 sessions of 8 h a month Daytona fits fully with its Linux VM class and faster CPU, Freestyle is a compromise because its docs send sustained heavy CPU work elsewhere, and bochka runs Docker, systemd and /dev/kvm on faster CPUs still. | 15th cheapest of 367 $4,111 a month | 241st of 367, with limits $3,311 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 | 263rd of 366, with limits $4,195 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, and Freestyle pauses VMs with their memory and wakes them on the next request; bochka's start limits make big bursts a compromise. | 25th cheapest of 345 $271 a month | 40th cheapest of 345 $482 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 Freestyle fits 300 user sandboxes at once on Pro, while Daytona's Tier 4 pool of 500 vCPU is short of the 600 vCPU needed; bochka fits with a desktop and hosting built in. | 154th of 361, with limits $2,000 a month | 16th cheapest of 361 $1,358 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 Freestyle can snapshot a running VM with its memory and boot copies from it, which suits rollouts that branch from one state. | 130th of 360, with limits $8,261 a month | 107th of 360, with limits $6,600 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 | 53rd cheapest of 364 $1,046 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 and Freestyle's docs say CPU-heavy builds are better served elsewhere; bochka allows 8 vCPU from the $20 plan on faster CPUs. | 308th of 377, with limits $805 a month | 168th of 377, with limits $625 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 | 98th cheapest of 368 $151 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, Freestyle needs you to install the desktop and VNC yourself, and bochka streams a 60fps desktop. | 26th cheapest of 369 $1,198 a month | 234th of 369, with limits $940 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 | 257th of 367, with limits $482 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 | 278th of 346, with limits $482 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 | 183rd of 338, with limits $6,560 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 Many isolated machines at once fit Daytona and bochka fully, while Freestyle is a compromise for this workload. | 12th cheapest of 360 $2,000 a month | 272nd of 360, with limits $482 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, Freestyle offers private GPU sandboxes only on Enterprise, and bochka has no 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 | Freestyle | bochka |
|---|---|---|---|
| Isolation | Container by default; Linux VM and Windows VM classes have their own kernel | Full KVM VM with its own kernel for every sandbox | Full VM with its own kernel for every sandbox, on dedicated AMD Ryzen 9 9950X hosts |
| CPU benchmark (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 | 9.64 runs/s | 26.69 runs/s |
| Docker and nested virtualization | Docker in all classes; /dev/kvm only on Linux VMs, with KVM turned on for your organization | systemd as pid 1, Docker from boot, full KVM support | Docker, root, systemd and /dev/kvm on every machine |
| Biggest machine | 4 vCPU / 8 GiB per sandbox by default, raisable per region | Up to 32 vCPU / 64 GiB on Pro, 64 / 128 with custom limits | Up to 16 vCPU / 32 GB on the $100 plan and above |
| Pause and fork | Linux VM and Windows classes pause and fork with memory kept; containers do not | Pause with memory, clone a running VM without pausing it, snapshot memory and disk | Fork a running sandbox with its disk; resume boots again from disk |
| Wake on request | No | Yes; a VM paused by idle timeout resumes on the next traffic that reaches it | No; a stopped sandbox is started by API |
| Desktop, browser and computer use | VNC desktop (xfce4) and a computer-use API on Linux and Windows | Guides to install GNOME or Xvfb, VNC and Chromium yourself | Linux desktop streamed at 60fps, Chromium and computer use built in, embeddable stream |
| Coding agents | Guides install agents and run them through process exec | claude, codex, opencode and openclaw preinstalled, driven through exec or a terminal | 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 | Credentials injected at the edge for HTTPS headers, Postgres and S3; the VM trusts the Freestyle CA | Credentials proxy for model providers and any HTTPS API; switch a credential to another account when credits run out |
| Reaching the sandbox | HTTPS preview URLs on any port, token-protected or public; SSH; no raw TCP | HTTPS on free style.dev names or your own domain, forward auth, other public protocols | HTTPS URLs for up to 50 ports, token-protected by default; raw TCP |
| Outbound internet | Tier 1 and 2 reach only registries, git hosts and AI APIs; Tier 3 and up get open internet plus allowlists | Default-deny firewall with allow rules by IP, VM, VPC or exact domain | Open internet on every plan; no provider-side allowlist |
| GPUs and Windows | Nvidia and AMD GPUs on demand or preemptible; Windows VM sandboxes | Private GPU sandboxes on Enterprise; no Windows | No GPUs; no Windows guests, Wine for Windows apps |
| Idle billing | Disk is billed while stopped; archived containers are free | A paused VM bills for its storage; no idle timeout unless you set one | Disk saved every minute and on stop; a stopped sandbox costs nothing |
| Regions | US and EU, plus dedicated regions or your own machines | Not listed; the docs name a San Jose, US data center | EU only: Germany, Finland, France |
Every feature Battleships tracks (43)
| Feature | Daytona | Freestyle | bochka |
|---|---|---|---|
| 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 | No | 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 | Yes | Yes |
| Public IPv4 | No | No | No |
| Egress allowlist | Yes | Yes | No |
| Secret proxy | Yes | Yes | Yes |
| Secret proxy for any API | Yes | Yes | Yes |
| Preinstalled agents | Yes | Yes | Yes |
| Agent harness API | No | No | Yes |
| MCP server | Yes | No | No |
| GPU | Yes | Yes | 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 | Yes | Yes |
| Spend limits | Not published | Not published | Yes |
| Usage per sandbox (API) | Yes | No | Yes |
| Audit logs | Yes | Yes | No |
| SSO | Yes | Yes | No |
| SOC 2 | Yes | Not published | No |
| HIPAA | Yes | Not published | No |
| EU data residency | Yes | No | Yes |
| Zero data retention | Not published | Not published | Yes |
Performance
On the hpc-sandbox-benchmarks Node.js build-and-test loop at 4 vCPU / 8 GB, bochka did 26.69 runs per second and Daytona's Linux VM class did 21.52 in the same run of 2026-09-29. Freestyle did 9.64 on its default VM in a run of 2026-08-24, so Daytona's score is about 2.2 times Freestyle's, measured on different dates. Daytona's default container class reported no result, and this test measures CPU speed only, not start time.
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 | Daytona, a month | Freestyle, a month | bochka, 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) | $27 · Free | $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) | $159 · Free | $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) | $2,139 · Pro | $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 | $581 · Pro | $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 | $1,305 · Pro · with limits | $2,000 · $2000/mo · with limits |
Daytona: Daytona bills per second for the vCPU, memory and disk you reserve, including while starting or stopping, and keeps billing the disk while 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).
Freestyle: Freestyle bills per second for the vCPU, RAM and disk allocated to a VM, busy or idle, after monthly allowances of 200 vCPU-hours, 400 GiB-hours of RAM and 60,000 GiB-hours of storage. On Free those allowances are hard stops; Hobby and Pro set a $50 or $500 monthly minimum that counts as usage.
Freestyle: 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 (10, 100, 250 or 500 from Tier 1 to 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. Freestyle Pro allows 400 concurrent VMs, which is why it does not fit 1,000 short jobs at once, and on Free the monthly allowances are hard stops, so an agent running all month pauses when they run out. bochka has no concurrency problem there, but the $2,000 plan queues starts above 90 a minute.
| Scenario | Daytona | Freestyle | bochka |
|---|---|---|---|
| One coding agent, workdays |
| None that bite | None that bite |
| One agent that never stops |
| None that bite | None that bite |
| 50 agents in parallel |
| None that bite | None that bite |
| Sandboxes for your users |
| None that bite | None that bite |
| 1,000 short jobs at once |
|
|
|
Which one should you use?
Use Daytona when
your agents need GPUs or Windows, Docker image builds, or must run in the US, the EU or on your own machines.
- GPUs and Windows. Useful if your agents test models or need Windows: Daytona rents Nvidia and AMD GPUs by the hour and runs Windows VM sandboxes.
- US, EU or your own machines. Useful if data must stay in a region you choose: Daytona runs in the US and the EU and can manage sandboxes on your machines.
- More CPU per vCPU. Useful for build-heavy agents: Daytona's Linux VM class scored 21.52 runs/s on the CPU benchmark, against 9.64 for Freestyle.
Use Freestyle when
you want a full VM for every sandbox that pauses with its memory and wakes on request, a default-deny firewall per VM, or more than 16 vCPU in one machine.
- A full VM every time. Useful if you want a kernel per sandbox without picking a class: every Freestyle sandbox is a KVM VM with Docker and systemd.
- Memory pause, live fork and wake on request. Useful for VMs that sleep between requests: they resume the same processes and wake on the next incoming traffic.
- Network rules and big machines. Every VM starts behind a default-deny firewall on any plan, and Pro VMs go up to 32 vCPU / 64 GiB.
Where bochka fits
If your agents spend hours on installs, builds, tests, Docker and browsers, bochka gives every sandbox a full VM on faster CPUs, with a desktop and coding agents built in. bochka runs only in the EU and has no GPUs, Windows or memory pause, so those needs point back to Daytona or Freestyle.
Faster CPUs in the same benchmark
bochka scored 26.69 runs/s, Daytona's Linux VM class 21.52 and Freestyle 9.64. Every build and test waits about a quarter longer on Daytona and almost three times as long on Freestyle, billed the whole time.
Agents you drive from outside
On Daytona and Freestyle you start agent CLIs through exec and parse their output yourself. bochka adds a prompt, steer and events API, and switches a credential to another account when one runs out of credits.
Files saved, stops free
Daytona bills the disk of a stopped sandbox unless it is archived, and Freestyle bills a paused VM's storage and has no idle timeout by default. bochka saves the disk every minute and charges nothing while stopped.
Use bochka when your agents do real work for hours: builds, tests, Docker, emulators, a desktop and a browser, on fast CPUs, with an API to drive the agents inside from outside. Compare it one to one: bochka vs Daytona and bochka vs Freestyle.
Questions people ask
Is Daytona cheaper than Freestyle?
In the scenarios we priced, Freestyle comes out lower: one coding agent on workdays is $27 on Freestyle against $56 on Daytona, one agent all month is $159 against $245, and 50 agents in parallel are $2,139 against $2,682. On bochka those come to $20, $26 and $317 a month.
Which is faster, Daytona or Freestyle?
On the hpc-sandbox-benchmarks CPU test at 4 vCPU / 8 GB, Daytona's Linux VM class did 21.52 runs per second and Freestyle did 9.64, measured on different dates. bochka did 26.69 in the same run as Daytona. Freestyle advertises VM starts in about 65 ms, which this test does not measure.
Are Daytona sandboxes VMs like Freestyle's?
Not by default. A Daytona sandbox is a container unless you pick its Linux VM or Windows VM class, which have their own kernel and add pause, fork and memory snapshots. Every Freestyle sandbox is a full KVM VM, and so is every bochka sandbox.
Can Daytona and Freestyle run Docker and Android emulators?
Both run Docker. Freestyle has full KVM support on every VM, while Daytona gives /dev/kvm only on its Linux VM class once KVM is turned on for your organization. bochka has Docker and /dev/kvm on every machine.
Which one has GPUs or Windows?
Daytona rents Nvidia and AMD GPUs from RTX 4090 to B300 and runs Windows VM sandboxes. Freestyle offers private GPU sandboxes only on Enterprise and has no Windows. bochka has neither.
Where do Daytona and Freestyle run?
Daytona runs in the US and the EU, plus dedicated regions and your own machines. Freestyle does not list regions, and its docs name a San Jose, US data center. bochka runs only in the EU: Germany, Finland and France.
Try bochka
Install the CLI, then run bochka new.
Product preview