bochka vs Freestyle
Both give each agent a full Linux VM with root, systemd, Docker and nested virtualization. bochka gives it faster CPUs, a desktop and browser for computer use, and an API to drive the coding agents inside, while Freestyle is strongest at pausing, forking and waking VMs with their memory.
Where bochka stands out
Almost three times the CPU speed
bochka runs on dedicated AMD Ryzen 9 9950X hosts. On the same Node.js build-and-test benchmark at 4 vCPU / 8 GB, bochka did 26.69 runs per second and Freestyle did 9.64. Freestyle's own docs say it oversubscribes hosts and that sustained heavy CPU work is better served elsewhere.
A desktop and a browser, ready
Every bochka sandbox has a Linux desktop streamed at 60fps, Chromium, and computer use built in, and you can embed the stream in your app. Freestyle has guides for installing GNOME or Xvfb, VNC, noVNC and Chromium yourself, then wiring up screenshots and clicks.
Agents you drive from outside
Both preinstall coding agent CLIs. bochka adds an API to prompt, steer and follow the agents inside from outside, and a credentials proxy that can switch a credential to another account of the same type when one runs out of credits.
The companies and products
bochka
bochka.xyz runs sandboxes for AI agents: each one is a full Linux VM with its own kernel.
You start a machine with one command or one API call, then SSH in, run Docker, open a desktop, or let a built-in agent (Claude Code, Codex, OpenCode and others) work in it. The disk stays between sessions, and a stopped sandbox costs nothing.
- Isolation
- Full VM per sandbox, own kernel
- Regions
- EU: Germany, Finland, France
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. “3rd cheapest of 367” means 2 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 | bochka: price rank | Freestyle: price rank |
|---|---|---|
| Software factory 100 at once · 4 vCPU / 8 GB · 2,200 sessions of 8 h a month Both run Docker, systemd and emulators; bochka's faster CPUs shorten every install, build and test, and Freestyle's own docs send sustained heavy CPU work elsewhere. | 3rd cheapest of 367 $634 a month | 241st of 367, with limits $3,311 a month |
| Always-on AI employees 50 machines 24/7 · 2 vCPU / 4 GB An assistant that lives on its machine all month runs on either; bochka's runs on faster CPUs and a stopped bochka sandbox costs nothing. | 5th cheapest of 366 $657 a month | 263rd of 366, with limits $4,195 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 well: VMs that pause with their memory, wake on the next request and resume the same processes. | 186th of 345, with limits $2,000 a month | 40th cheapest of 345 $482 a month |
| Sandboxes for your users 300 at once · 2 vCPU / 4 GB · 30,000 sessions of 23 min a month Both fit; Freestyle wakes a paused user VM on its next request, while bochka gives each user a faster machine with a desktop and hosting built in. | Cheapest of 361 $209 a month | 16th cheapest of 361 $1,358 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. | 34th of 360, with limits $2,000 a month | 107th of 360, with limits $6,600 a month |
| Agent evals 250 at once · 4 vCPU / 8 GB · 15,000 sessions of 20 min a month | 10th cheapest of 364 $200 a month | 53rd cheapest of 364 $1,046 a month |
| CI runners 40 at once · 8 vCPU / 16 GB · 6,000 sessions of 12 min a month Freestyle's docs say CPU-heavy jobs like kernel builds are better served elsewhere, and bochka did 2.8 times the work on the CPU benchmark. | 4th cheapest of 377 $86 a month | 168th of 377, with limits $625 a month |
| 24/7 dev boxes 1 machine 24/7 · 4 vCPU / 8 GB | 18th cheapest of 368 $26 a month | 98th cheapest of 368 $151 a month |
| Computer-use agents 50 at once · 4 vCPU / 8 GB · 20,000 sessions of 15 min a month bochka ships a Linux desktop streamed at 60fps with computer use built in; on Freestyle you install the desktop, VNC and input tools yourself. | 6th cheapest of 369 $200 a month | 234th of 369, with limits $940 a month |
| Browser-use agents 50 at once · 2 vCPU / 4 GB · 30,000 sessions of 10 min a month bochka has Chromium ready inside every sandbox; Freestyle has a guide for installing Chromium and a headed display yourself. | 7th cheapest of 367 $200 a month | 257th of 367, with limits $482 a month |
| Scraping & bots (startup scale) 50 at once · 1 vCPU / 2 GB · 100,000 sessions of 3 min a month | 6th cheapest of 346 $90 a month | 278th of 346, with limits $482 a month |
| Mass scraping & bots (undetectable) 1,000 at once · 1 vCPU / 2 GB · 3,000,000 sessions of 2 min a month | 71st of 338, with limits $1,800 a month | 183rd of 338, with limits $6,560 a month |
| Parallel red teaming 200 at once · 2 vCPU / 4 GB · 5,000 sessions of 30 min a month | 2nd cheapest of 360 $200 a month | 272nd of 360, with limits $482 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 |
| 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 |
Key features
| Feature | bochka | Freestyle |
|---|---|---|
| Isolation | Full VM with its own kernel on dedicated AMD Ryzen 9 9950X hosts | Full KVM VM with its own kernel on bare metal servers |
| CPU benchmark (4 vCPU / 8 GB) | 26.69 runs/s | 9.64 runs/s |
| Root, systemd, Docker, nested virtualization | Yes, with /dev/kvm for Android emulators and VMs | Yes; systemd is pid 1, Docker runs from boot, full KVM support |
| Biggest machine | Up to 16 vCPU / 32 GB on the $100 plan and above | Up to 32 vCPU / 64 GiB on Pro, 64 / 128 with custom limits |
| Pause and resume | Disk is saved every minute and on stop; resume boots the machine again | Pause saves memory and disk; the same processes resume where they left off |
| Fork | Fork a running sandbox with its disk | Clone a running VM without pausing it; snapshots capture memory and disk |
| Wake on request | No; a stopped sandbox is started by API | Yes; a VM paused by idle timeout resumes on the next traffic that reaches it |
| Desktop, browser and computer use | Linux desktop streamed at 60fps, Chromium and computer use built in | Guides to install GNOME or Xvfb, VNC and Chromium yourself |
| Coding agents | Seven agents preinstalled, with a prompt, steer and events API | claude, codex, opencode and openclaw preinstalled, driven through exec or a terminal |
| Keeping API keys out of the sandbox | Credentials proxy for model providers and any HTTPS API; switch a credential to another account when credits run out | Credentials injected at the edge for HTTPS headers, Postgres and S3; the VM must trust the Freestyle CA |
| Inbound access | HTTPS URLs for up to 50 ports, token-protected by default; raw TCP | HTTPS on free style.dev names or your own domain, forward auth, other public protocols |
| Outbound rules | Open internet, no provider-side allowlist | Default-deny firewall with allow rules by IP, VM, VPC or exact domain |
| Idle billing | A stopped sandbox costs nothing and keeps its disk | A paused VM bills for its storage; no idle timeout unless you set one |
| Regions and data | EU only (Germany, Finland, France), zero data retention | Not listed; the docs name a San Jose, US data center |
| Compliance and transparency | SOC 2 is in progress. We're open about where we stand: live status and data retention policy. | Not published |
Every feature Battleships tracks (43)
| Feature | bochka | Freestyle |
|---|---|---|
| Full VM (own kernel) | Yes | Yes |
| Docker inside | Yes | Yes |
| Nested virtualization | Yes | Yes |
| Root | Yes | Yes |
| Systemd | Yes | Yes |
| Desktop GUI | Yes | No |
| Browser | Yes | No |
| Computer-use API | Yes | No |
| SSH | Yes | Yes |
| Persistent disk | Yes | Yes |
| Pause/resume | Yes | Yes |
| Automatic snapshots | Yes | Yes |
| Fork/clone | Yes | Yes |
| Live fork (no pause) | Yes | Yes |
| Memory fork | No | Yes |
| Custom image (Docker or snapshot) | Yes | Yes |
| ≥24 h sessions | Yes | Yes |
| Idle auto-stop | No | Yes |
| Wake on request | No | Yes |
| HTTPS preview URLs | Yes | Yes |
| Raw TCP inbound | Yes | Yes |
| Public IPv4 | No | No |
| Egress allowlist | No | Yes |
| Secret proxy | Yes | Yes |
| Secret proxy for any API | Yes | Yes |
| Preinstalled agents | Yes | Yes |
| Agent harness API | Yes | No |
| MCP server | No | No |
| GPU | No | Yes |
| Windows | No | No |
| Arm64 | No | No |
| Self-hosting | No | No |
| BYOC | No | No |
| Open source | No | No |
| Scoped API keys | Yes | Yes |
| Spend limits | Yes | Not published |
| Usage per sandbox (API) | Yes | No |
| Audit logs | No | Yes |
| SSO | No | Yes |
| SOC 2 | No | Not published |
| HIPAA | No | Not published |
| EU data residency | Yes | No |
| Zero data retention | Yes | Not published |
Performance
Both 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 and Freestyle did 9.64, so bochka finished about 2.8 times as much CPU work in the same time. 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.
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 | bochka, a month | Freestyle, 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 | $20 · $20/mo | $27 · Free |
| One agent that never stops 4 vCPU / 8 GB, 50 GB disk, running 24/7 all month | $26 · $20/mo | $159 · Free |
| 50 agents in parallel 50 machines of 4 vCPU / 8 GB at once, 8-hour sessions, 1,100 sessions a month, Docker inside | $317 · $20/mo × 3 seats | $2,139 · Pro |
| Sandboxes for your users 2 vCPU / 4 GB, 30,000 sessions of 10 minutes a month, up to 300 at once | $200 · $100/mo × 2 seats | $581 · Pro |
| 1,000 short jobs at once 2 vCPU / 4 GB, 1,000 at once, 3 minutes each, 200,000 jobs a month | $2,000 · $2000/mo · with limits | $1,305 · Pro · with limits |
bochka: Plans start at $20 a month, and the whole fee is usage credit. You pay per second while a sandbox runs, and a stopped sandbox costs nothing and keeps its disk.
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.
Limits in those scenarios
Freestyle has no idle timeout by default, so a VM bills until you pause it or set one. On Free the monthly allowances are hard stops, so an agent that runs all month pauses once they run out unless you move to Hobby. Fifty agents in parallel need Pro, which allows 400 concurrent VMs, and that cap is why Freestyle does not fit 1,000 short jobs at once. bochka has no concurrency problem there, but its start limits are lower: the $2,000 plan queues starts above 90 a minute.
| Scenario | bochka | Freestyle |
|---|---|---|
| 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 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 can 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 and GPUs on Enterprise. Pro VMs go up to 32 vCPU / 64 GiB, and Enterprise adds larger sizes and private GPU sandboxes.
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.
- Almost three times the CPU speed. Coding agents spend most of their time on installs, builds and tests. At about a third of the speed, each of those waits takes almost three times as long, and Freestyle bills for the allocated vCPUs the whole time.
- A desktop and a browser, ready. On Freestyle you build and maintain that display stack in your own snapshot, and you build the screenshot and click layer your agent needs before it can use a single web page.
- Agents you drive from outside. On Freestyle you start the CLI through exec or a terminal session and parse its output yourself, and an agent that runs out of credits stops until your code swaps the key.
Questions people ask
Is bochka cheaper than Freestyle?
In four of the five scenarios on this page, yes. For one agent running all month it is $26 on bochka against $159 on Freestyle, and the gap grows with 50 agents. For 1,000 short jobs at once neither fits: Freestyle Pro caps at 400 concurrent VMs and bochka queues the starts.
Is bochka faster than Freestyle?
On the hpc-sandbox-benchmarks CPU test at 4 vCPU / 8 GB, bochka did 26.69 runs per second and Freestyle did 9.64. That is about 2.8 times the CPU work in the same time. Freestyle advertises VM starts in about 65 ms, which this test does not measure.
Can bochka pause a sandbox with its memory like Freestyle?
No. bochka saves the disk every minute and when the sandbox stops, so files survive, but resuming boots the machine again. Freestyle pauses with memory and resumes the same processes, and can wake a paused VM on the next request.
Do both run Docker and Android emulators?
Yes. Both are full VMs with root, systemd, Docker and nested virtualization, so Android emulators and VMs inside the sandbox work on either.
Can I run a browser agent on Freestyle?
Yes, but you build it: Freestyle's guides install Chromium, a virtual display and VNC inside the VM. bochka ships a 60fps desktop, Chromium and computer use in every sandbox.
Is bochka SOC 2 compliant?
SOC 2 is in progress. We're open about where we stand: live status at status.bochka.xyz and our data retention policy at docs.bochka.xyz/data-retention.
Start a sandbox
Install the CLI, then run bochka new.
Product preview
More comparisons
- bochka vs E2B
- bochka vs Daytona
- bochka vs Modal
- bochka vs Vercel Sandbox
- bochka vs Blaxel
- bochka vs Runloop
- bochka vs Tensorlake
- bochka vs Cloudflare Sandbox
- bochka vs exe.dev
- bochka vs Agent 37
- bochka vs Oracle Cloud
- bochka vs IONOS Cloud
- E2B vs Freestyle
- Daytona vs Freestyle
- Modal vs Freestyle
- Vercel Sandbox vs Freestyle
- Cloudflare Sandbox vs Freestyle
- Blaxel vs Freestyle
- Runloop vs Freestyle
- Tensorlake vs Freestyle