Freestyle vs Modal VM Sandboxes
Both give an agent a real Linux VM with its own kernel, root and Docker. Freestyle VMs can sleep with their memory and wake on the next request, while Modal VM Sandboxes are short-lived machines, gone within 24 hours, inside a big serverless AI platform.
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.
Modal VM Sandboxes
Modal is a serverless cloud for AI work, and VM Sandboxes are the version of its sandboxes that run in a virtual machine with their own Linux kernel.
You create a VM Sandbox from Python, TypeScript or Go code with runtime="vm", run commands in it, and terminate it when the job is done. Modal built the runtime on the Rust-based Cloud Hypervisor, so Docker, FUSE, systemd and nested cgroups work, with the same API, images and prices as its gVisor sandboxes. It became generally available on 1 October 2026 and suits teams that want many short-lived agent machines next to Modal's inference and training.
- Funding
- Over $466M raised
- Generally available
- 1 October 2026; early customers launched over 20 million VMs before that
- Session length
- Default 5 minutes, maximum 24 hours
- Compliance
- SOC 2 on every plan; HIPAA on Enterprise
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 | Modal VM Sandboxes: price rank | bochka: price rank |
|---|---|---|---|
| Software factory 100 at once · 4 vCPU / 8 GB · 2,200 sessions of 8 h a month Both run Docker in a real VM, but a Modal VM ends within 24 hours and loses files outside a Volume, Freestyle's docs send sustained heavy CPU work elsewhere, and bochka keeps its disk on the fastest CPUs of the three. | 241st of 367, with limits $3,311 a month | 84th of 367, with limits $759 a month | 3rd cheapest of 367 $634 a month |
| Always-on AI employees 50 machines 24/7 · 2 vCPU / 4 GB An agent that lives on its machine all month fits Freestyle, which has no session cap, but not Modal VM Sandboxes, which stop at 24 hours; bochka also has no cap on paid plans and a stopped bochka sandbox costs nothing. | 263rd of 366, with limits $4,195 a month | Can't run it | 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 Short code runs suit Freestyle well, since VMs pause with their memory and wake on the next request, and Modal's fast starts and per-second billing also fit short runs. | 40th cheapest of 345 $482 a month | Can't run it | 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 Users who come back to the same machine fit Freestyle, which wakes a paused VM on its next request, and bochka, which keeps a stopped sandbox's disk for free; a Modal VM is gone after 24 hours. | 16th cheapest of 361 $1,358 a month | Can't run it | 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, and Modal is built for huge bursts of short rollouts, while bochka's start limits queue very large bursts. | 107th of 360, with limits $6,600 a month | 171st of 360, with limits $16,322 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 | 53rd cheapest of 364 $1,046 a month | Can't run it | 10th cheapest of 364 $200 a month |
| CI runners 40 at once · 8 vCPU / 16 GB · 6,000 sessions of 12 min a month All three run Docker builds in a VM; Modal offers nested virtualization only on Team and Enterprise on request, and bochka did the most work on the CPU benchmark. | 168th of 377, with limits $625 a month | 188th of 377, with limits $1,064 a month | 4th cheapest of 377 $86 a month |
| 24/7 dev boxes 1 machine 24/7 · 4 vCPU / 8 GB | 98th cheapest of 368 $151 a month | Can't run it | 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 Freestyle nor Modal ships a desktop: both point to guides for installing a display, VNC and a browser yourself, while bochka has a 60fps desktop and computer use built in. | 234th of 369, with limits $940 a month | Can't run it | 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 | Can't run it | 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 | Can't run it | 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 | Can't run it | 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 parallel agents fit all three, and Freestyle and Modal can both block outbound traffic or allow only chosen domains, which bochka does not do on the provider side. | 272nd of 360, with limits $482 a month | 294th of 360, with limits $642 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 | Modal VM Sandboxes | bochka |
|---|---|---|---|
| Isolation | Full KVM VM with its own kernel on bare metal servers | VM with its own Linux kernel on Cloud Hypervisor | Full VM with its own kernel on dedicated AMD Ryzen 9 9950X hosts |
| CPU benchmark (4 vCPU / 8 GB) | 9.64 runs/s | 15.54 runs/s | 26.69 runs/s |
| Docker, systemd, root | Yes; systemd is pid 1 and Docker runs from boot | Yes; start dockerd yourself as the entrypoint | Yes, in every sandbox |
| Nested virtualization | Yes, full KVM support | Team and Enterprise plans only, on request | Yes, /dev/kvm on every plan for Android emulators and VMs |
| Longest session | No provider cap; a VM runs until you pause, stop or delete it | 24 hours (default 5 minutes); continue from a filesystem snapshot | No cap on paid plans; you set the time to live |
| Pause and resume | Pause saves memory and disk; the same processes resume where they left off | No paused state; a finished sandbox is gone, only Volumes and snapshots keep files | Disk is saved every minute and on stop; resume boots the machine again |
| Wake on request | Yes; a VM paused by idle timeout resumes on the next traffic that reaches it | No | No; a stopped sandbox is started by API |
| Fork and memory snapshots | Clone a running VM without pausing it; snapshots capture memory and disk | Filesystem snapshots boot any number of copies; memory snapshots are alpha, end the sandbox and expire after 7 days | Fork a running sandbox with its disk; no memory snapshots |
| Desktop, browser, computer use | Guides to install GNOME or Xvfb, VNC and Chromium yourself | Not offered; an example shows how to set up Xvfb and VNC yourself | 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 | Examples only; you install the agent harness | Seven agents preinstalled, with a prompt, steer and events API |
| Keeping API keys out of the sandbox | Credentials injected at the edge for HTTPS headers, Postgres and S3; the VM must trust the Freestyle CA | Secrets are environment variables, or you run your own proxy in a sidecar | Credentials proxy for model providers and any HTTPS API; switch a credential to another account when credits run out |
| Outbound network rules | Default-deny firewall with allow rules by IP, VM, VPC or exact domain | Block all, IP-range allowlist, domain allowlist (beta) | Open internet, no provider-side allowlist |
| Idle billing | A paused VM bills for its storage; no idle timeout unless you set one | Billed until the sandbox is terminated; there is no paused state | A stopped sandbox costs nothing and keeps its disk |
| Regions | Not listed; the docs name a San Jose, US data center | US, EU and Asia-Pacific plus narrower regions; pinning costs 1.15x to 1.75x | EU only: Germany, Finland, France |
Every feature Battleships tracks (43)
| Feature | Freestyle | Modal VM Sandboxes | 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 | No | Yes |
| Computer-use API | No | 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) | Yes | 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 | Yes | No | No |
| HTTPS preview URLs | Yes | Yes | Yes |
| Raw TCP inbound | Yes | Yes | 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 | No | No | No |
| GPU | Yes | No | No |
| Windows | No | No | No |
| Arm64 | No | No | No |
| Self-hosting | No | No | No |
| BYOC | No | No | No |
| Open source | No | No | No |
| Scoped API keys | Yes | Not published | Yes |
| Spend limits | Not published | Not published | Yes |
| Usage per sandbox (API) | No | Not published | Yes |
| Audit logs | Yes | Yes | No |
| SSO | Yes | Yes | No |
| SOC 2 | Not published | Yes | No |
| HIPAA | Not published | Yes | 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, Modal's VM runtime 15.54 and Freestyle 9.64. Modal and bochka ran in the same run on 29 September 2026, and Freestyle was measured on 24 August 2026 on the same test. This measures CPU speed only, not start time, where Freestyle advertises about 65 ms.
Node.js build-and-test loop at 4 vCPU / 8 GB, higher is better. Measured with the open hpc-sandbox-benchmarks suite. Modal VM Sandboxes measured on: VM Sandbox, request = size.
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 | Modal VM Sandboxes, 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 | $15 · Starter · with limits | $20 · $20/mo |
| One agent that never stops 4 vCPU / 8 GB, 50 GB disk, running 24/7 all month | $159 · Free | $178 · Starter · with limits | $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 | $2,229 · Starter · with limits | $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 | $792 · 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 | $1,305 · Pro · with limits | $3,193 · Team · 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 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, and a paused VM bills only for storage.
Modal VM Sandboxes: Modal bills VM Sandboxes by the second for whichever is higher, the CPU and memory you request or what you use, until the sandbox is terminated. Starter is free with $30 of monthly credit, Team is $250 a month with $100 of credit, and pinning a region multiplies the price by 1.15x to 1.75x.
Modal VM Sandboxes: bochka charges one hourly rate per machine size, by the second, only while the sandbox runs. Plans start at $20 a month and the whole fee becomes usage credit; a stopped sandbox costs nothing and keeps its disk.
Limits in those scenarios
A Modal VM Sandbox lives at most 24 hours and keeps files only in a Volume or a snapshot, so the workday, always-on and 50-agent scenarios do not fit on Modal. Freestyle fits those, but for 1,000 short jobs at once its Pro plan caps at 400 concurrent VMs, and Modal's burst runs on shared CPU above a small request. bochka does not fit that burst either: even the $2,000 plan queues starts above 90 a minute.
| Scenario | Freestyle | Modal VM Sandboxes | 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 | 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 an agent keeps one machine for weeks, or when you need a default-deny firewall per VM.
- Memory pause and wake on request. Useful for VMs that sleep between requests: they resume the same processes and can wake on the next incoming traffic.
- No session cap. A Freestyle VM runs as long as you want on every plan, so an agent can stay on one machine for weeks.
- Default-deny networking. Every VM starts with no network access, and you allow exactly the IPs, VMs, VPCs or domains it may reach.
Use Modal VM Sandboxes when
you run huge bursts of short jobs that finish within a day, need regions outside the US and Europe, or already run your models on Modal.
- Very large bursts. Useful for huge bursts of short jobs: Modal runs 5,000 containers at once on Team and more on Enterprise.
- Regions around the world. Modal runs in the US, EU and Asia-Pacific, and you can pin a sandbox to a broad or narrow region.
- One platform with inference and training. Useful if you already serve or train models on Modal: sandboxes, GPUs and models sit on one account and one bill.
Where bochka fits
If your agents do hours of real work in one machine, look at bochka. It is a full VM like both of them, on faster CPUs, with a disk that is saved every minute, free stops, no session cap on paid plans, and a desktop, browser and agent API already inside.
Faster CPUs for builds and tests
On the same benchmark at 4 vCPU / 8 GB, bochka did 26.69 runs per second, Modal's VM runtime 15.54 and Freestyle 9.64. Every install, build and test waits about 1.7 times as long on Modal and 2.8 times as long on Freestyle.
A machine that keeps its work
A Modal VM ends within 24 hours and its root disk goes with it unless you add Volumes or snapshots. Freestyle keeps state, but has no idle timeout by default, so a forgotten VM bills until you pause it.
Desktop, browser and agents ready
On both, a browser agent means installing a display, VNC and Chromium yourself, and you drive coding agents through exec and parse their output. bochka ships a 60fps desktop, computer use and an API to drive agents inside from outside.
Use bochka when your agents work for hours or days in a machine they come back to: builds, tests, Docker, emulators, a desktop and a browser, on faster CPUs, with an API to drive the agents inside from outside. Compare it one to one: bochka vs Freestyle and bochka vs Modal VM Sandboxes.
Questions people ask
Is Freestyle cheaper than Modal VM Sandboxes?
In most of our scenarios, a little: one always-on agent is $159 on Freestyle against $178 on Modal, and sandboxes for your users are $581 against $792. For one agent on workdays Modal is cheaper ($15 against $27), but its files reset between days unless you use a Volume. On bochka those three cost $26, $200 and $20.
Which is faster, Freestyle or Modal VM Sandboxes?
On the hpc-sandbox-benchmarks CPU test at 4 vCPU / 8 GB, Modal's VM runtime did 15.54 runs per second and Freestyle did 9.64, measured about a month apart. bochka did 26.69 on the same test. Start time was not measured, and Freestyle advertises about 65 ms.
Can Freestyle and Modal VM Sandboxes run Docker?
Yes. Both are VMs with their own kernel, root and systemd. Freestyle runs Docker from boot, while on Modal you start dockerd yourself, and nested virtualization for Android emulators is on Team and Enterprise only, on request.
How long can a sandbox run on each?
A Modal VM Sandbox defaults to 5 minutes and stops at 24 hours at most; for longer work you snapshot the filesystem and start a new one. Freestyle has no provider cap, so a VM runs and bills until you pause, stop or delete it. bochka has no session cap on paid plans.
Can they pause a VM with its memory?
Freestyle can: it pauses with memory, resumes the same processes and can wake a paused VM on the next request. Modal has no paused state; its memory snapshots are in alpha, end the sandbox and expire after 7 days. bochka saves the disk every minute, and resuming boots the machine again.
Try bochka
Install the CLI, then run bochka new.
Product preview