Freestyle vs exe.dev
Both give each agent a real KVM virtual machine with root, systemd and Docker. Freestyle bills per second and pauses VMs with their memory, while exe.dev rents flat pools of vCPUs in nine regions and boots VMs from your own Docker image.
The companies and products
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.
exe.dev
exe.dev, made by Bold Software, Inc., rents Linux VMs for developers and AI agents that you reach over SSH and HTTPS.
You reserve a pool of vCPUs and memory, and your VMs share it; you can also start standalone VMs billed by the second. Each VM is KVM-isolated (they use Cloud Hypervisor), boots from a container image in about two seconds, and has root, systemd and Docker. It comes with Claude Code, Codex, Pi and exe.dev's own Shelley agent, and is aimed at developers who want a persistent dev box or a sandbox for their agents.
- Company
- Bold Software, Inc.
- Preinstalled agents
- claude, codex, pi and the Shelley web agent
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. “40th cheapest of 345” means 39 of the other 344 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 | Freestyle: price rank | exe.dev: price rank | bochka: price rank |
|---|---|---|---|
| Software factory 100 at once · 4 vCPU / 8 GB · 2,200 sessions of 8 h a month | 241st of 367, with limits $3,311 a month | 253rd of 367, with limits $3,701 a month | 3rd cheapest of 367 $634 a month |
| Always-on AI employees 50 machines 24/7 · 2 vCPU / 4 GB exe.dev fits an assistant that lives on its machine all month on one flat pool fee; Freestyle bills that VM every second it runs, and bochka fits too. | 263rd of 366, with limits $4,195 a month | 15th cheapest of 366 $3,833 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 Freestyle fits short code runs fully, with VMs that pause with their memory and wake on the next request; exe.dev pools bill whether jobs run or not. | 40th cheapest of 345 $482 a month | 235th of 345, with limits $175 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 sandboxes for your users and wakes a paused VM on its next request; exe.dev Personal stops at 50 VMs at once, and bochka fits with the most room. | 16th cheapest of 361 $1,358 a month | 257th of 361, with limits $1,226 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, which suits rollouts that branch from one state; exe.dev has no snapshots. | 107th of 360, with limits $6,600 a month | 265th of 360, with limits $5,250 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 Freestyle fits evals fully with snapshots of memory and disk to start each run from; exe.dev has no snapshots and caps Personal at 50 VMs at once. | 53rd cheapest of 364 $1,046 a month | 283rd of 364, with limits $1,050 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 Freestyle's docs send sustained heavy CPU work elsewhere and exe.dev pools bill when idle; bochka bills per second on CPUs measured at 26.69 runs/s. | 168th of 377, with limits $625 a month | 288th of 377, with limits $504 a month | 4th cheapest of 377 $86 a month |
| 24/7 dev boxes 1 machine 24/7 · 4 vCPU / 8 GB Both make good 24/7 dev boxes with root, SSH and a disk that lasts; exe.dev's flat pool is the steadier bill, and bochka adds a desktop in the browser. | 98th cheapest of 368 $151 a month | 25th cheapest of 368 $35 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 Neither has a screen: Freestyle has guides to install a desktop and VNC yourself and exe.dev VMs are headless, while bochka streams a 60fps desktop. | 234th of 369, with limits $940 a month | 240th of 369, with limits $1,055 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 | 257th of 367, with limits $482 a month | 130th of 367, with limits $530 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 | 278th of 346, with limits $482 a month | 124th of 346, with limits $278 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 | 183rd of 338, with limits $6,560 a month | 166th of 338, with limits $5,490 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 | 272nd of 360, with limits $482 a month | 60th of 360, with limits $263 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 | Can't run it | 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 | Freestyle | exe.dev | bochka |
|---|---|---|---|
| Isolation | Full KVM VM with its own kernel on bare metal servers | KVM VM with Cloud Hypervisor on rented bare metal; you can't choose the kernel | Full VM with its own kernel on dedicated AMD Ryzen 9 9950X hosts |
| CPU benchmark (4 vCPU / 8 GB) | 9.64 runs/s | Not measured | 26.69 runs/s |
| Root, systemd, Docker, nested virtualization | Yes; systemd is pid 1, Docker runs from boot, full KVM support | Root, systemd and Docker; nested virtualization on Enterprise only | Yes, with /dev/kvm on every plan for Android emulators and VMs |
| Biggest machine | Up to 32 vCPU / 64 GiB on Pro, 64 / 128 with custom limits | Personal pools up to 16 vCPU shared by your VMs | Up to 16 vCPU / 32 GB on the $100 plan and above |
| Pause and saved state | Pause saves memory and disk; the same processes resume where they left off | Disk persists and is streamed to a second server; no snapshots | Disk saved every minute and on stop; resume boots the machine again |
| Fork | Clone a running VM without pausing it; snapshots capture memory and disk | cp copies a VM's disk and config into a new VM | Fork a running sandbox with its disk; named snapshots as templates |
| Wake on request | Yes; a VM paused by idle timeout resumes on the next traffic | No | No; a stopped sandbox is started by API |
| Custom images | Boot from your own snapshots; no Docker image boot | Boot from your own Docker image in about two seconds | Templates from named snapshots; no Dockerfile or OCI images |
| Desktop, browser and computer use | Guides to install GNOME or Xvfb, VNC and Chromium yourself | Headless; no desktop or screen streaming | Linux desktop streamed at 60fps, Chromium and computer use built in |
| Coding agents | claude, codex, opencode and openclaw preinstalled, driven through exec or a terminal | Claude Code, Codex, Pi and Shelley; only Shelley takes prompts through the API; MCP server | Seven agents preinstalled, with a prompt, steer and events API |
| Inbound access | HTTPS on free style.dev names or your own domain, forward auth, other public protocols | HTTPS proxy for ports 3000 to 9999, one of them public; SSH; no raw TCP | HTTPS URLs for up to 50 ports, token-protected by default; raw TCP |
| Outbound rules | Default-deny firewall with allow rules by IP, VM, VPC or exact domain | Open internet | Open internet, no provider-side allowlist |
| Regions | Not listed; the docs name a San Jose, US data center | 9 regions in the US, Europe, Asia and Australia | EU only (Germany, Finland, France), zero data retention |
| Idle billing | A paused VM bills for its storage; no idle timeout unless you set one | A pool bills the same busy or idle; a stopped standalone VM pays only for disk | A stopped sandbox costs nothing and keeps its disk |
Every feature Battleships tracks (43)
| Feature | Freestyle | exe.dev | bochka |
|---|---|---|---|
| Full VM (own kernel) | Yes | Yes | Yes |
| Docker inside | Yes | Yes | Yes |
| Nested virtualization | Yes | Yes | Yes |
| Root | Yes | Yes | Yes |
| Systemd | Yes | Yes | Yes |
| Desktop GUI | No | No | Yes |
| Browser | No | Yes | Yes |
| Computer-use API | No | No | Yes |
| SSH | Yes | Yes | Yes |
| Persistent disk | Yes | Yes | Yes |
| Pause/resume | Yes | Yes | Yes |
| Automatic snapshots | Yes | No | Yes |
| Fork/clone | Yes | Yes | Yes |
| Live fork (no pause) | Yes | 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 | No | No |
| Wake on request | Yes | No | No |
| HTTPS preview URLs | Yes | Yes | Yes |
| Raw TCP inbound | Yes | No | Yes |
| Public IPv4 | No | No | No |
| Egress allowlist | Yes | No | No |
| Secret proxy | Yes | Yes | Yes |
| Secret proxy for any API | Yes | Yes | Yes |
| Preinstalled agents | Yes | Yes | Yes |
| Agent harness API | No | Yes | Yes |
| MCP server | No | Yes | No |
| GPU | Yes | No | No |
| Windows | No | No | No |
| Arm64 | No | No | No |
| Self-hosting | No | No | No |
| BYOC | No | Yes | No |
| Open source | No | No | No |
| Scoped API keys | Yes | Yes | Yes |
| Spend limits | Not published | Not published | Yes |
| Usage per sandbox (API) | No | Yes | Yes |
| Audit logs | Yes | Not published | No |
| SSO | Yes | Yes | No |
| SOC 2 | Not published | No | No |
| HIPAA | Not published | No | No |
| EU data residency | No | Yes | 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 Freestyle did 9.64, so bochka finished about 2.8 times as much CPU work in the same time. exe.dev is not in that benchmark, so there is no comparable CPU score for it, and we don't guess one.
Node.js build-and-test loop at 4 vCPU / 8 GB, higher is better. Measured with the open hpc-sandbox-benchmarks suite. exe.dev 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 | Freestyle, a month | exe.dev, 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 | $27 · Free | $35 · Personal | $20 · $20/mo |
| One agent that never stops 4 vCPU / 8 GB, 50 GB disk, running 24/7 all month | $159 · Free | $35 · Personal | $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,139 · Pro | $1,848 · Personal | $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 | $581 · Pro | $530 · Personal · 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 | $1,305 · Pro · with limits | $1,050 · Personal · with limits | $2,000 · $2000/mo · with limits |
Freestyle: Freestyle bills per second for the vCPU, RAM and disk allocated to a VM, busy or idle, after monthly allowances. On Free those allowances are hard stops; Hobby and Pro set a $50 or $500 monthly minimum that counts as usage.
exe.dev: exe.dev rents reserved pools that your VMs share for a flat fee, such as $35 a month for a 4 vCPU Personal pool, billed whether used or not. Standalone VMs bill per second at $0.105 per 2 vCPU / 4 GiB per hour.
exe.dev: Plans start at $20 a month, and the whole fee is usage credit. Sandboxes bill per second while they run, and a stopped sandbox costs nothing and keeps its disk.
Limits in those scenarios
exe.dev Personal allows 50 VMs at once, so 300 user sandboxes at once and 1,000 short jobs at once don't fit there. Freestyle Pro allows 400 concurrent VMs, enough for the user sandboxes but not for 1,000 jobs at once. Freestyle has no idle timeout by default, so a VM bills until you pause it or set one. bochka has room for the concurrency, but its start-rate limits queue a burst of 1,000 starts too.
| Scenario | Freestyle | exe.dev | 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 | 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 Freestyle when
your VMs sleep between requests and must resume with their memory, when you need a default-deny firewall per VM, or when you need more than 16 vCPU in one machine.
- 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 controls. Every VM starts with no network access, and you allow exactly the IPs, VMs, VPCs or domains it may reach.
- Bigger machines. Pro VMs go up to 32 vCPU / 64 GiB, and custom limits reach 64 vCPU / 128 GiB.
Use exe.dev when
you want a few always-on boxes on a flat monthly bill, your users are outside Europe, or you want VMs booted from your own Docker image.
- Regions around the world. Useful if your users are spread out: exe.dev runs in nine regions across the US, Europe, Asia and Australia.
- Your own Docker image. exe.dev boots each VM straight from your own container image in about two seconds.
- A flat bill for always-on machines. A reserved pool costs the same every month, so a box that runs all the time has a steady, known bill.
Where bochka fits
Freestyle and exe.dev both hand an agent a real VM, but neither gives it a screen, and neither has one API to drive Claude Code or Codex from outside. If your agents do hours of builds, tests, emulators and web work, bochka gives them all three on CPUs measured at 26.69 runs/s.
A screen your agents can use
Computer-use agents work by looking at a screen. exe.dev VMs are headless, and on Freestyle you install GNOME or Xvfb, VNC and Chromium in your own snapshot, then build the screenshot and click layer yourself.
Agents driven from outside
On Freestyle you start the agent CLI through exec and parse its output, and on exe.dev only Shelley takes prompts by API. bochka prompts, steers and streams events for seven agents, and its credentials proxy can switch an account when credits run out.
Fast CPUs with /dev/kvm on every plan
Freestyle did 9.64 runs/s on the CPU benchmark against bochka's 26.69, so builds take almost three times as long. exe.dev has no measurement, and its nested virtualization for Android emulators needs the Enterprise plan.
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 Freestyle and bochka vs exe.dev.
Questions people ask
Is Freestyle cheaper than exe.dev?
It depends on how long machines run. For one agent on workdays Freestyle comes to $27 against $35 on exe.dev, but for one agent running all month exe.dev's flat pool is $35 against $159 on Freestyle. For 50 agents in parallel it is $2,139 on Freestyle against $1,848 on exe.dev, and bochka is $317 a month for the same load.
Which is faster, Freestyle or exe.dev?
Freestyle scored 9.64 runs per second on the hpc-sandbox-benchmarks CPU test at 4 vCPU / 8 GB. exe.dev has not been measured on it, so we can't compare them. bochka scored 26.69 on the same test.
Can Freestyle and exe.dev run Docker?
Yes. Both are full VMs with root, systemd and Docker. Freestyle also has nested virtualization on every plan, while exe.dev offers it only on Enterprise, which matters for Android emulators.
Can exe.dev pause a VM with its memory like Freestyle?
No. exe.dev keeps a VM's disk and streams it to a second server, and cp copies a VM, but it has no snapshots. Freestyle pauses with memory, resumes the same processes and can wake a paused VM on the next request.
Do Freestyle or exe.dev have a desktop for computer use?
Neither ships one. Freestyle has guides for installing GNOME or Xvfb, VNC and Chromium yourself, and exe.dev VMs are headless. bochka gives every sandbox a 60fps desktop with Chromium and computer use built in.
Where do Freestyle and exe.dev run?
Freestyle does not list regions; its docs name a San Jose, US data center. exe.dev runs in nine regions across the US, Europe, Asia and Australia. bochka runs only in the EU, in Germany, Finland and France.
Try bochka
Install the CLI, then run bochka new.
Product preview