Freestyle vs OpenAI Containers
Freestyle gives each agent a full Linux VM with root and Docker that you keep, pause with its memory and fork. OpenAI Containers are a tool inside OpenAI's model API: the model runs code in a short-lived box without sudo, and the box and its files are gone 20 minutes after last use.
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.
OpenAI Containers
OpenAI Containers are the sandboxes OpenAI runs for its own model tools: Code Interpreter, Hosted Shell and the Agents API's hosted sandbox.
This is a different kind of product from bochka: a tool inside OpenAI's model API, not a machine you rent. You create a container through the API or let a Responses call make one, and the model runs Python or shell commands in it on a fixed Debian 12 image without sudo, until it expires after 20 minutes without use. It is built for apps that already call OpenAI models and want them to run code, read files and make charts without running any servers.
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 | OpenAI Containers: price rank | bochka: price rank |
|---|---|---|---|
| Software factory 100 at once · 4 vCPU / 8 GB · 2,200 sessions of 8 h a month Freestyle and bochka both give a coding agent root, Docker and a disk that stays; an OpenAI container has no sudo, no Docker documented, and expires after 20 idle minutes. | 241st of 367, with limits $3,311 a month | 356th of 367, with limits $17,371 a month | 3rd cheapest of 367 $634 a month |
| Always-on AI employees 50 machines 24/7 · 2 vCPU / 4 GB An assistant that lives on its machine all month needs a disk that survives, which Freestyle and bochka give and an OpenAI container does not. | 263rd of 366, with limits $4,195 a month | 341st of 366, with limits $13,140 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 This is what OpenAI Containers are built for, inside the model call; Freestyle also fits well, with VMs that pause with their memory and wake on the next request. | 40th cheapest of 345 $482 a month | 194th of 345, with limits $6,000 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 can wake a paused user VM on its next request and give it an HTTPS name; an OpenAI container has no inbound access at all, only the API. | 16th cheapest of 361 $1,358 a month | 361st of 361, with limits $3,780 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 | 107th of 360, with limits $6,600 a month | 191st of 360, with limits $30,000 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 can snapshot a running VM and boot copies from it, so each eval starts from the same state; OpenAI containers have no snapshots or fork. | 53rd cheapest of 364 $1,046 a month | 360th of 364, with limits $5,760 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 need Docker, root and open internet, which OpenAI does not document; Freestyle runs them, though its own docs send sustained heavy CPU work elsewhere. | 168th of 377, with limits $625 a month | 345th of 377, with limits $1,728 a month | 4th cheapest of 377 $86 a month |
| 24/7 dev boxes 1 machine 24/7 · 4 vCPU / 8 GB A dev box you SSH into and keep all month works on Freestyle and bochka; OpenAI containers have no SSH and no persistent disk. | 98th cheapest of 368 $151 a month | 362nd of 368, with limits $1,051 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 OpenAI has a hosted browser inside the Agents API beta, Freestyle has guides to install a desktop yourself, and bochka ships a 60fps desktop with computer use built in. | 234th of 369, with limits $940 a month | 351st of 369, with limits $5,280 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 | 328th of 367, with limits $1,440 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 | 328th of 346, with limits $1,755 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 | 311th of 338, with limits $35,100 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 | 308th of 360, with limits $870 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 | OpenAI Containers | bochka |
|---|---|---|---|
| What it is | Full Linux VMs you create, keep, pause and fork | A sandbox tool the model uses inside OpenAI's API | A cloud VM you create, keep, stop and reach from outside |
| Isolation | Full KVM VM with its own kernel on bare metal servers | A fully sandboxed virtual machine; hypervisor not named | Full VM with its own kernel on dedicated AMD Ryzen 9 9950X hosts |
| Root, Docker and nested virtualization | Yes; systemd is pid 1, Docker runs from boot, full KVM support | Commands do not run with sudo; no Docker or /dev/kvm documented | Root, systemd, Docker and /dev/kvm on every machine |
| CPU benchmark (4 vCPU / 8 GB) | 9.64 runs/s | Not measured; vCPU per size not published | 26.69 runs/s |
| Machine size | Up to 4 vCPU / 8 GiB on Free, 32 / 64 on Pro, 64 / 128 with custom limits | 1, 4, 16 or 64 GB of memory; vCPU not published | 4 vCPU / 8 GB by default, up to 16 vCPU / 32 GB |
| Files after the session | Disk persists; pause keeps memory and disk | Data is discarded when the container expires | Disk saved every minute and on stop; a stopped sandbox comes back with its files |
| Lifetime | No default limit; a VM runs until you pause it or set a timeout | Expires after 20 minutes without use; Agents API sandboxes after an hour without activity | No session cap on paid plans; you set the time to live |
| Pause, fork and wake | Pause with memory, clone a running VM, wake on the next request | No snapshots or fork | Fork a running sandbox with its disk; resume boots the machine again |
| Inbound access | SSH, HTTPS on free style.dev names or your own domain, other public protocols | None; you reach the container only through the API | SSH, 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 | Code Interpreter and Hosted Shell: off until an admin sets an org domain allowlist | Open internet, no provider-side allowlist |
| Keeping API keys out of the sandbox | Credentials injected at the edge for HTTPS headers, Postgres and S3 | domain_secrets: a sidecar adds the real header for approved domains | Credentials proxy for model providers and any HTTPS API; switch a credential to another account when credits run out |
| Coding agents | claude, codex, opencode and openclaw preinstalled, driven through exec or a terminal | Agents API (beta) drives a managed Codex harness from outside | Seven agents preinstalled, with a prompt, steer and events API |
| Desktop, browser and computer use | Guides to install GNOME or Xvfb, VNC and Chromium yourself | Hosted browser for the Agents API computer_use tool | Linux desktop streamed at 60fps, Chromium and computer use built in |
| Regions | Not listed; the docs name a San Jose, US data center | US or EU processing for Code Interpreter; Agents API US only | EU only (Germany, Finland, France), zero data retention |
Every feature Battleships tracks (43)
| Feature | Freestyle | OpenAI Containers | bochka |
|---|---|---|---|
| Full VM (own kernel) | Yes | Yes | Yes |
| Docker inside | Yes | No | Yes |
| Nested virtualization | Yes | No | Yes |
| Root | Yes | No | Yes |
| Systemd | Yes | Not published | Yes |
| Desktop GUI | No | Yes | Yes |
| Browser | No | Yes | Yes |
| Computer-use API | No | Yes | Yes |
| SSH | Yes | No | Yes |
| Persistent disk | Yes | No | Yes |
| Pause/resume | Yes | No | Yes |
| Automatic snapshots | Yes | No | Yes |
| Fork/clone | Yes | No | Yes |
| Live fork (no pause) | Yes | No | Yes |
| Memory fork | Yes | No | No |
| Custom image (Docker or snapshot) | Yes | No | Yes |
| ≥24 h sessions | Yes | Yes | Yes |
| Idle auto-stop | Yes | Yes | No |
| Wake on request | Yes | No | No |
| HTTPS preview URLs | Yes | No | Yes |
| Raw TCP inbound | Yes | No | 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 | No | Yes |
| Agent harness API | No | Yes | Yes |
| MCP server | No | No | No |
| GPU | Yes | No | No |
| Windows | No | No | No |
| Arm64 | No | No | No |
| Self-hosting | No | Yes | 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 | No | Yes |
| Audit logs | Yes | Not published | 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
Freestyle and bochka were measured on the hpc-sandbox-benchmarks Node.js build-and-test loop at 4 vCPU / 8 GB: Freestyle did 9.64 runs per second and bochka did 26.69, about 2.8 times as much work. OpenAI Containers have no comparable measurement, and OpenAI does not publish how many vCPU each container size gets.
Node.js build-and-test loop at 4 vCPU / 8 GB, higher is better. Measured with the open hpc-sandbox-benchmarks suite. OpenAI Containers 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 | OpenAI Containers, 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 | $228 · API pay as you go · with limits | $20 · $20/mo |
| One agent that never stops 4 vCPU / 8 GB, 50 GB disk, running 24/7 all month | $159 · Free | $1,051 · API pay as you go · 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 | $11,405 · API pay as you go · 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 | $1,620 · API pay as you go · 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 | $6,000 · API pay as you go · 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, and a paused VM bills only for storage.
OpenAI Containers: OpenAI bills each container session by the minute for the memory size you pick, with a 5-minute minimum, and model tokens are billed on top. There is no plan fee.
OpenAI Containers: Plans start at $20 a month, and the whole fee is usage credit spent per second on running sandboxes. A stopped sandbox costs nothing and keeps its disk.
Limits in those scenarios
OpenAI Containers do not fit any of the five scenarios as written: no persistent disk, no Docker, no internet until an admin sets an allowlist, and the vCPU behind each size is not published. Freestyle fits four of them, but 1,000 short jobs at once is more than the 400 concurrent VMs Pro allows, and on Free the monthly allowances are hard stops. bochka fits four too; for the burst its $2,000 plan queues starts above 90 a minute.
| Scenario | Freestyle | OpenAI Containers | 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 Freestyle when
your agents need a full VM they keep, that pauses with its memory, forks while running and wakes on the next request, or when you need more than 16 vCPU in one machine.
- A whole machine you keep. For agents that need root, Docker and systemd on a disk that stays between sessions, for days or months.
- Memory pause, live fork and wake on request. For VMs that sleep between requests: they resume the same processes and can wake on the next incoming traffic.
- Big machines and fine network rules. For heavy jobs and locked-down code: Pro VMs reach 32 vCPU / 64 GiB, behind a default-deny firewall you open rule by rule.
Use OpenAI Containers when
your app already calls OpenAI models and the model only needs to run short pieces of code or shell commands on files you give it.
- Built into the model call. For apps that already call OpenAI models: one tool line in a request gives the model a place to run code.
- Nothing to run or clean up. For short code runs: no plan fee, billing by the minute, and the container goes away on its own.
- US or EU processing. For teams that need a choice of region: Code Interpreter can process data in the United States or Europe.
Where bochka fits
If your agents do real work for hours, such as builds, tests, Docker and browsing, look at bochka. Like Freestyle it is a full VM that keeps its disk, unlike an OpenAI container, and it adds faster CPUs, a desktop and an API to drive the agents inside from outside.
Faster CPUs for builds and tests
On the same benchmark bochka did 26.69 runs per second and Freestyle did 9.64, so each install and test waits almost three times as long on Freestyle. OpenAI does not publish the vCPU behind its container sizes.
A desktop and a browser, ready
On Freestyle you install GNOME or Xvfb, VNC and Chromium yourself and build the screenshot and click layer. OpenAI's hosted browser works only inside the Agents API beta. bochka streams a 60fps desktop with computer use built in.
Any coding agent, driven from outside
On Freestyle you start the agent CLIs through exec and parse their output yourself. OpenAI's Agents API drives only its own Codex harness. bochka has a prompt, steer and events API for seven agents and swaps a credential when credits run out.
Use bochka when your agents do real work for hours: builds, tests, Docker, 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 OpenAI Containers.
Questions people ask
Is Freestyle cheaper than OpenAI Containers?
In the scenarios on this page, yes. One agent running all month comes to $159 on Freestyle against $1,051 on OpenAI, and OpenAI also bills model tokens on top. On bochka the same agent comes to $26 a month.
Which is faster, Freestyle or OpenAI Containers?
Only Freestyle has a CPU measurement: 9.64 runs per second at 4 vCPU / 8 GB. OpenAI does not publish the vCPU behind its container sizes, so there is no fair comparison. bochka did 26.69 runs per second on the same test.
Can OpenAI Containers run Docker?
No Docker support is documented, and hosted shell commands do not run with sudo. Freestyle and bochka both give each sandbox root, systemd, Docker and nested virtualization.
Do files survive between sessions?
On Freestyle, yes: the disk persists, and a paused VM keeps its memory too. An OpenAI container expires after 20 minutes without use and its data is discarded. bochka saves the disk every minute and on stop.
Can I open a web app running inside the sandbox?
On Freestyle, yes, through HTTPS on a free style.dev name or your own domain. OpenAI containers have no ports, URLs or SSH. bochka gives each sandbox HTTPS URLs for up to 50 ports, raw TCP and SSH.
Try bochka
Install the CLI, then run bochka new.
Product preview