Modal vs Freestyle
Modal runs short-lived sandboxes under gVisor inside a big AI compute platform, with GPUs and regions around the world, and each sandbox lasts at most 24 hours. Freestyle gives each agent a full KVM virtual machine with Docker and systemd that can pause with its memory, fork while running and wake on the next request.
The companies and products
Modal
Modal is a serverless cloud for AI work: inference, training, batch jobs and sandboxed code, all driven from Python, TypeScript or Go code.
Modal Sandboxes are containers you create from code, run commands in, and then terminate. By default they run under gVisor, a user-space kernel from Google; since October 2026 you can also pick a VM runtime with its own Linux kernel for Docker and FUSE (Battleships tracks that as a separate card, Modal VM Sandboxes). It suits teams that already run models on Modal and want short-lived, scalable code execution next to their GPUs.
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. “19th cheapest of 345” means 18 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 | Modal: 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 Software factories need Docker and a disk that lasts, which Freestyle's VMs have and Modal's default sandboxes do not; bochka adds a desktop and faster CPUs on top. | Can't run it | 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 An always-on agent hits Modal's 24-hour sandbox limit, while Freestyle and bochka VMs can run all month, and a stopped bochka sandbox costs nothing. | 196th of 366, with limits $1,924 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 huge numbers of short code runs well; Modal ranks 19th here and Freestyle 40th, ahead of bochka, whose start limits bite. | 19th cheapest of 345 $181 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 All three fit sandboxes for your users; Freestyle wakes a paused user VM on its next request, and bochka ranks first here. | 11th cheapest of 361 $811 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 Modal is built for big bursts of short sandboxes and ranks 5th for RL rollouts, while Freestyle ranks 107th as only a partial fit. | 5th cheapest of 360 $19,038 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 | 59th cheapest of 364 $1,244 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 CI jobs that build Docker images need Modal's VM runtime, Freestyle's docs send heavy CPU work elsewhere, and bochka runs Docker on faster CPUs. | 126th cheapest of 377 $1,793 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 | 138th of 368, with limits $23 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 Neither Modal nor Freestyle ships a desktop, so you set up VNC yourself on both; bochka has a 60fps desktop and computer use built in. | 98th of 369, with limits $183 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 | 177th of 367, with limits $136 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 | 267th of 346, with limits $394 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 | 223rd of 338, with limits $8,795 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 | Can't run it | 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 Modal rents GPUs from T4 to B300 next to its sandboxes; Freestyle offers GPUs only as private Enterprise sandboxes, and bochka has none. | 19th cheapest of 98 $1,187 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 | Modal | Freestyle | bochka |
|---|---|---|---|
| Isolation | gVisor by default; a VM runtime with its own kernel since October 2026 | Full KVM VM with its own kernel | Full VM with its own kernel on dedicated AMD Ryzen 9 9950X hosts |
| CPU benchmark (4 vCPU / 8 GB) | 12.79 runs/s (default sandbox) | 9.64 runs/s | 26.69 runs/s |
| Docker and nested virtualization | Only with the VM runtime; nested virtualization on Team and Enterprise, on request | Yes; Docker runs from boot, full KVM support | Yes, in every sandbox, with /dev/kvm for Android emulators and VMs |
| Longest session | 24 hours (default 5 minutes) | No provider cap; runs until you pause it or a timeout you set | No cap on paid plans (default TTL 1 h, changeable) |
| Pause and resume | No paused state; a finished sandbox is gone, only Volumes keep files | Pause saves memory and disk; the same processes resume | Disk saved every minute and on stop; resume boots the machine again |
| Fork | Snapshot the filesystem into an image and boot new sandboxes from it | Clone a running VM without pausing it, with memory and disk | Fork a running sandbox with its disk, without stopping it |
| Wake on request | No | Yes; a paused VM resumes on the next traffic that reaches it | No; a stopped sandbox is started by API |
| GPUs | T4 to B300; 10 at once on Starter, 50 on Team | Private GPU sandboxes on Enterprise only | None |
| Biggest machine | Maximum not published | 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 |
| Desktop, browser and computer use | Not offered; an example shows how to set up VNC yourself | Guides to install GNOME or Xvfb, VNC and Chromium yourself | Linux desktop streamed at 60fps, Chromium and computer use built in |
| Coding agents | Examples only | claude, codex, opencode and openclaw preinstalled, run through exec or a terminal | Seven agents preinstalled, with an API to prompt, steer and follow them from outside |
| Keeping API keys out of the sandbox | Secrets are environment variables, or you run your own proxy in a sidecar | Credentials injected at the edge for HTTPS, Postgres and S3 | Credentials proxy for model providers and any HTTPS API; switch to another account when credits run out |
| Outbound rules | Block all, IP-range allowlist, domain allowlist (beta) | Default-deny firewall with allow rules by IP, VM, VPC or exact domain | Open internet, no provider-side allowlist |
| Regions | US, EU and Asia-Pacific; pinning a region costs 1.15x to 1.75x | Not listed; the docs name a San Jose, US data center | EU only: Germany, Finland, France |
Every feature Battleships tracks (43)
| Feature | Modal | Freestyle | bochka |
|---|---|---|---|
| Full VM (own kernel) | No | Yes | Yes |
| Docker inside | No | Yes | Yes |
| Nested virtualization | No | 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 | No | Yes | Yes |
| Automatic snapshots | No | 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 | Yes | Yes | Yes |
| Public IPv4 | No | No | No |
| Egress allowlist | Yes | Yes | No |
| Secret proxy | No | Yes | Yes |
| Secret proxy for any API | No | Yes | Yes |
| Preinstalled agents | No | Yes | Yes |
| Agent harness API | No | No | Yes |
| MCP server | No | No | No |
| GPU | Yes | Yes | 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 | Not published | Yes | Yes |
| Spend limits | Not published | Not published | Yes |
| Usage per sandbox (API) | Not published | 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
All three were measured 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 default gVisor sandbox 12.79 and Freestyle 9.64. So Modal did about 1.3 times the work of Freestyle, and bochka about twice Modal's and 2.8 times Freestyle's. Modal and bochka ran in the same run on 29 September 2026, Freestyle in an earlier run on 24 August 2026, and the 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. Modal measured on: Sandbox (gVisor), request = size, any region.
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 | Modal, 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 | $15 · Starter · with limits | $27 · Free | $20 · $20/mo |
| One agent that never stops 4 vCPU / 8 GB, 50 GB disk, running 24/7 all month | $178 · Starter · with limits | $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,229 · Starter · with limits | $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 | $792 · Team | $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 | $3,193 · Team · with limits | $1,305 · Pro · with limits | $2,000 · $2000/mo · with limits |
Modal: Modal bills by the second for the higher of the CPU and memory you request or what you use, and an idle sandbox pays until it 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.
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 the allowances are hard stops; Hobby and Pro have a $50 or $500 monthly minimum that counts as usage, and a paused VM bills only for storage.
Freestyle: bochka charges one hourly rate per machine size, by the second, only while a 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
On Modal a sandbox lives at most 24 hours and its root disk is wiped when it ends, so the workday, always-on and fleet scenarios keep only files in a Volume, and the 50-agent fleet needs the VM runtime for Docker. Freestyle fits those scenarios, but it has no idle timeout by default, so a VM bills until you pause it, and its Pro plan caps you at 400 concurrent VMs. That cap is why Freestyle does not fit 1,000 short jobs at once; Modal fits the count but on shared vCPUs, and bochka queues starts above 90 a minute on its $2,000 plan.
| Scenario | Modal | 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 | None that bite |
| 1,000 short jobs at once |
|
|
|
Which one should you use?
Use Modal when
your sandboxes need GPUs, must run in many regions, or are huge bursts of short jobs that finish well inside 24 hours.
- GPUs on the same platform. Useful if your agent trains or runs models: Modal rents GPUs from T4 to B300 right next to its sandboxes.
- Regions around the world. Modal runs in the US, EU and Asia-Pacific and can pin a sandbox to a region, while Freestyle names only a US data center.
- Very large bursts of short jobs. Useful for RL rollouts and code runs: Modal allows 5,000 containers on Team and builds images from any registry.
Use Freestyle when
each agent or user needs its own full VM that sleeps between requests and resumes with its memory, behind a default-deny firewall.
- A full VM with no 24-hour limit. Each Freestyle VM has its own kernel, Docker and systemd, and runs as long as you want, unlike Modal's 24-hour sandboxes.
- 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 and bigger machines. Every VM starts behind a default-deny firewall, and Pro VMs go up to 32 vCPU / 64 GiB.
Where bochka fits
If your agents work for hours on installs, builds, tests and web apps, look at bochka as well. Every bochka sandbox is a full VM with Docker and /dev/kvm on fast CPUs, with a desktop, a browser and the coding agents ready to drive from outside. Its disk is saved every minute, and a stopped sandbox costs nothing and comes back days later.
About twice the CPU speed
On the same benchmark at 4 vCPU / 8 GB, bochka did 26.69 runs per second, Modal's default sandbox 12.79 and Freestyle 9.64. Every install, build and test waits two to three times as long on them, and you pay for the waiting.
A desktop and a browser, ready
Neither Modal nor Freestyle ships a screen. On both you install a display, VNC and Chromium yourself and build the screenshot and click layer. bochka has a 60fps desktop, Chromium and computer use in every sandbox.
Agents you drive from outside
On Modal you set up the agent CLIs yourself and keys sit in environment variables unless you run a sidecar proxy. On Freestyle you parse CLI output from exec. bochka has an API to prompt and steer agents inside, plus a credentials proxy.
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 Modal and bochka vs Freestyle.
Questions people ask
Is Modal cheaper than Freestyle?
It depends on the job. For one agent on workdays Modal is $15 a month against $27 on Freestyle, but Modal's files reset between days unless you use a Volume. For one agent running all month Freestyle is $159 against $178 on Modal, and for sandboxes for your users it is $581 against $792 on Modal; bochka costs $26 and $200 for those two.
Which is faster, Modal or Freestyle?
On the hpc-sandbox-benchmarks CPU test at 4 vCPU / 8 GB, Modal's default sandbox did 12.79 runs per second and Freestyle 9.64, so Modal did about 1.3 times the work. bochka did 26.69 on the same test. Start time is a separate question this test does not measure.
Can Modal and Freestyle run Docker?
Freestyle runs Docker in every VM from boot. Modal runs Docker only with its VM runtime, chosen with runtime="vm"; the default gVisor sandbox does not document Docker support. bochka runs Docker in every sandbox.
How long can a Modal sandbox or a Freestyle VM run?
A Modal sandbox has a default timeout of 5 minutes and a maximum of 24 hours. Freestyle sets no maximum: a VM runs until you pause, stop or delete it, or until a timeout you set. bochka has no session cap on paid plans.
Does Freestyle have GPUs like Modal?
Only as private GPU sandboxes on the Enterprise plan. Modal rents GPUs from T4 to B300 on its normal plans, on the gVisor runtime. bochka has no GPUs.
Can either one pause a sandbox and resume it later?
Freestyle can: it pauses a VM with its memory and resumes the same processes, and can wake it on the next request. Modal has no paused state, so a finished sandbox is gone and only Volumes keep files. bochka saves the disk every minute and on stop, and resuming boots the machine again.
Try bochka
Install the CLI, then run bochka new.
Product preview