OpenAI Containers vs smol machines

OpenAI Containers are short-lived boxes inside OpenAI's model API, where the model runs code and the box expires after 20 minutes without use. smol machines gives you Linux microVMs that you create, keep, stop and branch, in its cloud or on your own machines.

The companies and products

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 boat: 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.

Isolation: Each container is described as a fully sandboxed virtual machine; the hypervisor is not named
Runtime: Debian 12 with Python 3.11, Node.js 22.16, Java 17, PHP 8.2, Ruby 3.1 and Go 1.23; commands do not run with sudo
Sizes: Picked by memory: 1 GB (default), 4 GB, 16 GB or 64 GB; vCPU per size not published for Responses containers
Lifetime: A container expires after 20 minutes without use, and its data is discarded
Billing: By the minute with a 5-minute minimum per session, on top of model tokens
Regions: Code Interpreter processing in the United States or Europe; the Agents API supports data residency only in the US
Compliance: API Platform audited for SOC 2 Type 2; HIPAA BAA on request

smol machines

smol machines makes fast, isolated Linux microVMs that run the same way on your laptop, in their hosted cloud, or on your own servers.

The core is smolvm, an open-source microVM engine built on libkrun, where each machine has its own guest kernel. smol cloud is the paid hosted service that runs fleets of those machines behind a REST API and Node, Python and Rust SDKs. It is built for developers who want one VM model from local development to production, with live branching of running machines.

Isolation: Hardware-isolated microVM with its own guest kernel (libkrun)
Company: Founded 2026, Y Combinator Spring 2026, San Francisco, team of one listed
Open source: smolvm engine and smol SDK are open source and run on macOS, Linux and Windows hosts
Guests: Linux only; no Windows or macOS guests
Regions: No region field in the cloud create API
Uptime SLA: 99.95% on Pro, Startup and 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. “356th cheapest of 367” means 355 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	OpenAI Containers: price rank	smol machines: price rank	boat: price rank
Software factory 100 at once · 4 vCPU / 8 GB · 2,200 sessions of 8 h a month An OpenAI container has no root or Docker and expires when idle; smol machines runs Docker and keeps its files, and boat adds /dev/kvm, SSH and coding agents you drive through an API.	356th of 367, with limits $17,371 a month	73rd of 367, with limits $604 a month	3rd cheapest of 367 $634 a month
Always-on AI employees 50 machines 24/7 · 2 vCPU / 4 GB An OpenAI container is deleted after 20 idle minutes; a smol machine stays, but has no desktop or browser and its secrets are readable inside, while boat has all three built in.	341st of 366, with limits $13,140 a month	148th of 366, with limits $1,038 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 same API call as the model; smol machines also fits well, with a one-minute minimum and a /code endpoint for Python and JavaScript.	194th of 345, with limits $6,000 a month	12th cheapest of 345 $140 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 smol machines fits, and starts a stopped machine on the next command; OpenAI containers take no inbound connections, while boat gives each user a desktop, URLs on up to 50 ports and a credentials proxy.	361st of 361, with limits $3,780 a month	7th cheapest of 361 $531 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 smol machines can branch a running machine with its memory and processes, so many rollouts start from one prepared state; OpenAI containers cannot be forked.	191st of 360, with limits $30,000 a month	111th of 360, with limits $6,978 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	360th of 364, with limits $5,760 a month	36th cheapest of 364 $670 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 OpenAI documents no Docker or root, and its Code Interpreter containers start with no internet; smol machines runs Docker but not nested virtualization, which boat has for Android builds and VMs.	345th of 377, with limits $1,728 a month	66th cheapest of 377 $514 a month	4th cheapest of 377 $86 a month
24/7 dev boxes 1 machine 24/7 · 4 vCPU / 8 GB OpenAI containers have no SSH and no disk that lasts; smol machines keeps the disk but has no SSH and caps a terminal connection at one hour, while boat takes SSH.	362nd of 368, with limits $1,051 a month	216th of 368, with limits $29 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, smol machines has no hosted desktop, and boat streams a full Linux desktop at 60fps with computer use.	351st of 369, with limits $5,280 a month	90th of 369, with limits $156 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	328th of 367, with limits $1,440 a month	176th of 367, with limits $136 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	328th of 346, with limits $1,755 a month	241st of 346, with limits $242 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	311th of 338, with limits $35,100 a month	148th of 338, with limits $4,344 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	308th of 360, with limits $870 a month	252nd of 360, with limits $377 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	OpenAI Containers	smol machines	boat
What it is	A sandbox tool the model uses inside OpenAI's API	Linux microVMs you run through a REST API and SDKs, in smol cloud or locally	A cloud VM you create, keep, stop and reach from outside
Isolation	A fully sandboxed virtual machine; hypervisor not named	libkrun microVM with its own guest kernel	Full VM with its own kernel on dedicated AMD Ryzen 9 9950X hosts
Root, Docker and nested virtualization	Commands do not run with sudo; no Docker or /dev/kvm documented	Docker runs inside the VM; nested virtualization not exposed in the cloud	Root, systemd, Docker and /dev/kvm on every machine
Machine size	1, 4, 16 or 64 GB of memory; vCPU not published	Up to 8 vCPU / 16 GB on Standard, 16 vCPU / 24 GB on Pro, 32 vCPU / 32 GB on Startup	4 vCPU / 8 GB by default, up to 16 vCPU / 32 GB
Files after the session	Data is discarded when the container expires after 20 minutes without use	Filesystem survives a stop; stopped disk keeps billing	Disk saved every minute and on stop; a stopped sandbox costs nothing and comes back
Fork	No fork	Branch a running machine with its memory and processes	Fork a running sandbox with its disk
Wake on request	No; a new container is made for new work	A command starts a stopped machine; idle apps wake on the next request	No; a stopped sandbox is started by API
Inbound access	None; you reach the container only through the API	Up to 16 published ports and a WebSocket terminal capped at one hour per connection; no SSH	SSH, HTTPS URLs for up to 50 ports, raw TCP
Outbound internet	Code Interpreter and Hosted Shell: off until an admin sets a domain allowlist; Agents API sandboxes: on by default	Blocked, open, or an allowlist of hosts and CIDR ranges	Open internet on every plan; no provider-side allowlist
Desktop and computer use	Hosted browser for the Agents API computer_use tool	No hosted desktop; a guide shows running your own Chromium inside a machine	60fps Linux desktop and Chromium, computer use, embeddable stream
Coding agents	Agents API (beta) drives a managed Codex harness from outside	Registry images with the Codex CLI and the Harbor eval harness, run through the command API	Claude Code, Codex, OpenCode and more preinstalled, with a prompt, steer and events API
Keeping API keys out of the sandbox	domain_secrets: a sidecar adds the real header for approved domains	Cloud secrets are environment variables the guest can read	Credentials proxy for any HTTPS API; switch a credential to another account when credits run out
Regions	US or EU processing for Code Interpreter; Agents API data residency in the US only	No region choice in the cloud API	EU only (Germany, Finland, France), with EU data residency
Your own machines	Agents API can drive an executor you host	Open-source smolvm runs on your laptop or servers with the same .smolmachine artifact	No; hosted only

Every feature Battleships tracks (43)

Feature	OpenAI Containers	smol machines	boat
Full VM (own kernel)	Yes	Yes	Yes
Docker inside	No	Yes	Yes
Nested virtualization	No	No	Yes
Root	No	Not published	Yes
Systemd	Not published	Not published	Yes
Desktop GUI	Yes	No	Yes
Browser	Yes	No	Yes
Computer-use API	Yes	No	Yes
SSH	No	No	Yes
Persistent disk	No	Yes	Yes
Pause/resume	No	Yes	Yes
Automatic snapshots	No	No	Yes
Fork/clone	No	Yes	Yes
Live fork (no pause)	No	Yes	Yes
Memory fork	No	Yes	No
Custom image (Docker or snapshot)	No	Yes	Yes
≥24 h sessions	Yes	Yes	Yes
Idle auto-stop	Yes	Yes	No
Wake on request	No	Yes	No
HTTPS preview URLs	No	Yes	Yes
Raw TCP inbound	No	Not published	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	No	Yes	Yes
Agent harness API	Yes	No	Yes
MCP server	No	Yes	No
GPU	No	No	No
Windows	No	No	No
Arm64	No	Yes	No
Self-hosting	Yes	Yes	No
BYOC	No	Yes	No
Open source	No	Yes	No
Scoped API keys	Not published	Not published	Yes
Spend limits	Not published	Yes	Yes
Usage per sandbox (API)	No	Yes	Yes
Audit logs	Not published	Not published	No
SSO	Yes	Yes	No
SOC 2	Yes	No	No
HIPAA	Yes	No	No
EU data residency	Yes	No	Yes
Zero data retention	Not published	Not published	Yes

Performance

OpenAI ContainersNot measured

smol machinesNot measured

boat26.69 runs/s

There is no comparable measurement for either: OpenAI Containers and smol cloud have not been run on the StarSling hpc-sandbox-benchmarks CPU test, and OpenAI does not publish the vCPU behind each container size. boat did 26.69 runs per second on that Node.js build-and-test loop at 4 vCPU / 8 GB. smol machines publishes a boot time under 200ms for smolvm, which is a start-time figure, not CPU speed.

Node.js build-and-test loop at 4 vCPU / 8 GB, higher is better. Measured with the open hpc-sandbox-benchmarks suite. OpenAI Containers and smol machines have 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	OpenAI Containers, a month	smol machines, a month	boat, 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	$228 · API pay as you go · with limits	$25 · Standard	$20 · $20/mo
One agent that never stops 4 vCPU / 8 GB, 50 GB disk, running 24/7 all month	$1,051 · API pay as you go · with limits	$93 · Standard	$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	$11,405 · API pay as you go · with limits	$1,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	$1,620 · API pay as you go · with limits	$465 · Startup	$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	$6,000 · API pay as you go · with limits	$1,389 · Startup	$2,000 · $2000/mo · with limits

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 separately on top. There is no plan fee.

smol machines: smol cloud charges a base fee for every hour a machine runs, plus the CPU and memory the guest actually uses, with a one-minute minimum and disk billed even while stopped. Pro ($20 a month) and Startup ($150 a month) are fees added on top of usage, not credit.

smol machines: Plans start at $20 a month, and the whole fee becomes 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 disk that lasts, no Docker, no internet by default in Code Interpreter and Hosted Shell, and no published vCPU or limit on how many can run at once. smol machines fits all five, but caps machines by plan (20 on Standard, 100 on Pro, 1,000 on Startup, with stopped machines still holding a slot), so 50 agents need Pro and 1,000 short jobs need Startup. On boat the 1,000-job burst is limited by starts, so the $2,000 plan queues starts above 90 a minute.

Scenario	OpenAI Containers	smol machines	boat
One coding agent, workdays	no open internet: sandboxes reach only an allowlist (domains your org admin adds to the allow list) missing persistent disk machine size not published different kind of product: code interpreter	None that bite	None that bite
One agent that never stops	no open internet: sandboxes reach only an allowlist (domains your org admin adds to the allow list) missing persistent disk machine size not published different kind of product: code interpreter	None that bite	None that bite
50 agents in parallel	no open internet: sandboxes reach only an allowlist (domains your org admin adds to the allow list) missing persistent disk, Docker inside machine size not published different kind of product: code interpreter	None that bite	None that bite
Sandboxes for your users	no open internet: sandboxes reach only an allowlist (domains your org admin adds to the allow list) machine size not published different kind of product: code interpreter not confirmed: how many machines can run at once (you need 300; the typical published limit is 50)	None that bite	None that bite
1,000 short jobs at once	no open internet: sandboxes reach only an allowlist (domains your org admin adds to the allow list) machine size not published different kind of product: code interpreter not confirmed: how many machines can run at once (you need 1,000; the typical published limit is 50)	None that bite	max 2,400 starts/day (needs ~6,667) max 600 starts/hour (needs ~1,000) bursts above 90 starts/min are queued (a burst of 333 takes ~4 min to start)

Which one should you use?

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. Useful if your app already calls OpenAI models: one tool line in a request gives the model a place to run code.
Locked-down network by default. Code Interpreter and Hosted Shell reach nothing until an admin allows domains, and secrets reach the model only as placeholders.
US or EU processing. Teams that need data processed in the US can get it, since Code Interpreter offers US or EU processing.

Use smol machines when

you want VMs you keep and branch with their memory, one open-source engine from your laptop to your own servers, or tight outbound rules.

Open source, laptop to your servers. Teams that want the same VM locally, in a hosted cloud and on their own servers get it from one open-source engine.
Live branches with memory. Useful for RL and test fan-out: branch a running machine with its memory, and wake stopped machines on the next command.
Bigger machines and outbound rules. Startup goes up to 32 vCPU per machine, and each machine can block outbound traffic or allow listed hosts only.

Where boat fits

If what you are running is coding or computer-use agents that need a whole machine, look at boat. OpenAI Containers are a short-lived tool for the model, and smol machines gives you a lean VM; boat gives each agent root, a desktop, SSH and coding agents you drive from outside.

Root, Docker and /dev/kvm

An OpenAI container runs commands without sudo and documents no Docker. smol machines runs Docker but exposes no nested virtualization in its cloud, so an Android emulator or a VM inside cannot start on either.

Reachable from outside

An OpenAI container takes no inbound connections, so nobody can open the app an agent built. smol machines has no SSH and caps a terminal connection at one hour; boat has SSH, HTTPS on 50 ports and raw TCP.

Desktop and keys built in

smol machines has no hosted desktop and its secrets are readable inside the guest, and OpenAI's browser lives in the Agents API beta. boat streams a 60fps desktop and keeps keys for any HTTPS API outside the sandbox.

Use boat when your agents need a whole machine for real work: root, Docker and /dev/kvm, SSH and ports you can reach, a desktop and a browser, coding agents you drive from outside and keys that never enter the sandbox. Compare it one to one: boat vs OpenAI Containers and boat vs smol machines.

Questions people ask

Is OpenAI Containers cheaper than smol machines?

Not in the scenarios on this page: one coding agent on workdays comes to $228 a month on OpenAI and $25 on smol machines, and one agent running all month comes to $1,051 versus $93. OpenAI also bills model tokens on top, and its containers do not fully fit these scenarios.

Which is faster, OpenAI Containers or smol machines?

There is no comparable CPU measurement for either one, and OpenAI does not publish how many vCPU each container size gets. smol machines publishes a boot time under 200ms for smolvm, which is about start time, not CPU speed.

Can OpenAI Containers or smol machines run Docker?

OpenAI's docs say hosted shell commands do not run with sudo, and no Docker support is documented. smol machines runs Docker inside the VM, with Docker data on the machine's ext4 disk. boat gives root, systemd, Docker and /dev/kvm on every sandbox.

Do files survive between sessions?

Not on OpenAI: a container expires after 20 minutes without use and its data is discarded. On smol machines the filesystem survives a stop, and the stopped disk keeps billing. On boat the disk is saved every minute and a stopped sandbox costs nothing.

Can I run either one on my own machines?

smol machines' engine, smolvm, is open source and runs on macOS, Linux and Windows hosts. OpenAI's Agents API can drive an executor you host, but Code Interpreter containers run only on OpenAI. boat is a hosted service only.

Can I open a web app running inside the sandbox?

Not on OpenAI: its containers have no ports, URLs or SSH. smol machines publishes up to 16 ports through a returned URL. boat gives each sandbox HTTPS URLs for up to 50 ports, raw TCP and SSH.

Try boat

Install the CLI, then run boat new.

7-day free trial