boat vs OpenAI Containers

OpenAI Containers are the short-lived boxes behind Code Interpreter and Hosted Shell. The model runs code there, then the box expires: by default after 20 minutes without use. boat gives each agent a full VM with root, Docker and a disk that stays between sessions. You can reach it from outside, and boat keeps its disk for at least 14 days after a stop.

Where boat stands out

A whole machine with root

A boat sandbox is a full VM with root, systemd, Docker and /dev/kvm, so an agent can install system packages, run databases and start Android emulators. OpenAI's hosted shell runs commands without sudo on a fixed Debian 12 image, and no Docker or nested virtualization is documented.

A disk that stays

boat saves the disk every minute while the sandbox runs and once more at each stop. A stopped sandbox has no compute charge and keeps its disk for at least 14 days; a saved snapshot keeps it longer. By default an OpenAI container expires after 20 minutes without use (expires_after can set a longer idle time), and its data is discarded.

Reachable from outside, open to the internet

Each boat sandbox has SSH, HTTPS URLs for up to 50 ports and raw TCP ports (IPv6 only on sandboxes without their own IPv4). You can open the app an agent built or give a user a preview link. OpenAI documents no inbound ports for hosted containers. Code Interpreter and Hosted Shell containers have no outbound access until an admin sets an allowlist.

The companies and products

boat

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

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 a Responses call makes one. The model runs Python or shell commands in it on a fixed Debian 12 image without sudo. By default the container expires after 20 minutes without use; the create call can set a different idle time. 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. “5th cheapest of 365” means 4 of the other 364 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 workloadboat: price rankOpenAI Containers: price rank
Software factory
100 at once · 4 vCPU / 8 GB · 2,200 sessions of 8 h a month
A coding agent that installs packages, runs Docker and keeps a repo for days needs root and a disk that persists. Hosted OpenAI containers run without sudo, document no Docker and discard files when they expire. You set it up on OpenAI: connect the Agents API to a self-hosted sandbox on a machine you run.
5th cheapest of 365
$634 a month
357th of 365, with limits
$17,371 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. By default an OpenAI container expires after 20 minutes without use; expires_after can set a longer idle time, but its files go when it expires.
6th cheapest of 361
$657 a month
344th of 361, with limits
$13,140 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: the model writes Python and runs it in the same API call, with no machine to manage.
189th of 336, with limits
$2,000 a month
198th of 336, with limits
$6,000 a month
Sandboxes for your users
300 at once · 2 vCPU / 4 GB · 30,000 sessions of 23 min a month
Your users can open a preview URL or SSH into a boat sandbox. OpenAI documents no inbound ports for hosted containers; you reach them through the API.
3rd cheapest of 349
$209 a month
349th of 349, with limits
$3,780 a month
RL rollouts
1,000 at once · 2 vCPU / 4 GB · 1,000,000 sessions of 3 min a month
39th of 349, with limits
$2,000 a month
195th of 349, with limits
$30,000 a month
Agent evals
250 at once · 4 vCPU / 8 GB · 15,000 sessions of 20 min a month
10th cheapest of 359
$200 a month
355th of 359, with limits
$5,760 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. OpenAI documents no Docker or root for hosted containers, and Code Interpreter and Hosted Shell containers have no outbound access until an admin allows domains.
2nd cheapest of 374
$86 a month
347th of 374, with limits
$1,728 a month
24/7 dev boxes
1 machine 24/7 · 4 vCPU / 8 GB
A dev box you SSH into and keep is what boat is. Hosted OpenAI containers document no SSH, and their files go when they expire. Codex Cloud keeps a task VM state for up to 7 days, but it has no public API.
19th cheapest of 371
$26 a month
365th of 371, with limits
$1,051 a month
Computer-use agents
50 at once · 4 vCPU / 8 GB · 20,000 sessions of 15 min a month
Both have a hosted browser for computer use. boat streams a 1920x1080, 60 fps desktop you can embed; OpenAI's browser runs inside the Agents API beta.
7th cheapest of 367
$200 a month
353rd of 367, with limits
$5,280 a month
Browser-use agents
50 at once · 2 vCPU / 4 GB · 30,000 sessions of 10 min a month
OpenAI's hosted browser is driven by its own Codex harness. On boat you run Chrome inside the sandbox and drive it with any agent or library.
7th cheapest of 356
$200 a month
335th of 356, with limits
$1,440 a month
Scraping & bots (startup scale)
50 at once · 1 vCPU / 2 GB · 100,000 sessions of 3 min a month
6th cheapest of 343
$90 a month
334th of 343, with limits
$1,755 a month
Mass scraping & bots (undetectable)
1,000 at once · 1 vCPU / 2 GB · 3,000,000 sessions of 2 min a month
73rd of 327, with limits
$1,800 a month
307th of 327, with limits
$35,100 a month
Parallel red teaming
200 at once · 2 vCPU / 4 GB · 5,000 sessions of 30 min a month
3rd cheapest of 351
$200 a month
310th of 351, with limits
$870 a month
GPU eval jobs
10 at once · 8 vCPU / 32 GB · 500 sessions of 30 min a month
Not ranked: misses a requirementNot ranked: misses a requirement
macOS agents
5 at once · 4 vCPU / 8 GB · 1,000 sessions of 20 min a month
Not ranked: misses a requirementNot ranked: misses a requirement

Key features

FeatureboatOpenAI Containers
What it isA cloud VM you create, keep, stop and reach from outsideA sandbox tool the model uses inside OpenAI's API
IsolationFull VM with its own kernel, on physical hosts dedicated to boat (AMD Ryzen 7 9700X and Ryzen 9 9950X); vCPUs are sharedA fully sandboxed virtual machine; hypervisor not named
Root, Docker and nested virtualizationRoot, systemd, Docker and /dev/kvm on every sandboxCommands do not run with sudo; Docker and /dev/kvm are not documented. You set it up: connect the Agents API to a self-hosted sandbox where you control the machine
Machine size4 vCPU / 8 GB by default, up to 16 vCPU / 32 GB (xlarge needs the $100 plan)1, 4, 16 or 64 GB of memory; vCPU not published. Agents API sandboxes: 1 vCPU / 1 GB, 2 vCPU / 4 GB or 4 vCPU / 16 GB
Files after the sessionDisk saved every minute and at each stop. A stopped sandbox has no compute charge and keeps its disk for at least 14 days; saved snapshots keep it longerData is discarded when the container expires. Agents API publishes files in /workspace/outputs as artifacts that stay downloadable
LifetimeAuto-stop defaults to 1 hour; set up to 30 days, or turn it off on a paid plan for no session capBy default expires after 20 minutes without use (expires_after can be set; no maximum published). Agents API sandboxes can be deleted after an hour without activity
ForkFork a running sandbox with its diskNo fork call documented. You set it up: create a new container and upload the same files
Custom imageSaved snapshots of a set-up sandbox, reused as templates; you cannot boot your own Docker imageFixed Debian 12 image; you upload files or skills into each container
Inbound accessSSH, token-gated HTTPS URLs for up to 50 ports, raw TCP ports (IPv6 only on sandboxes without their own IPv4)No inbound ports documented for hosted containers; you reach them through the API
Outbound internetOpen internet on every plan; no provider-side allowlistCode Interpreter and Hosted Shell: off until an admin sets an org domain allowlist. Agents API sandboxes: on by default, can be limited to 1 to 100 hosts
Keeping API keys out of the sandboxOptional AI credentials proxy ($1 per day on, plus $1 per 1,000 requests) for model providers and custom HTTPS APIs; switch a credential to another account when credits run outdomain_secrets: a sidecar adds the real header for approved domains, the model sees a placeholder
Coding agentsSeven harnesses installed, including Claude Code, Codex and OpenCode, with a prompt, steer and events APIAgents API (beta) drives a managed Codex harness from outside, with steering, events and webhooks
Desktop and computer use1920x1080, 60 fps desktop and Chrome, computer tools for agents, embeddable streamHosted browser for the Agents API computer_use tool
Regions and your own computeGermany, Finland and France; you cannot pick a region, and there is no US or Asia regionUS or EU processing for Code Interpreter; Agents API can also drive a sandbox you host
Compliance and transparencySOC 2 is in progress. We're open about where we stand: live status and data retention policy.SOC 2
Every feature Battleships tracks (43)
FeatureboatOpenAI Containers
Full VM (own kernel)YesYes
Docker insideYesNo documented way
Nested virtualizationYesNo documented way
RootYesNo documented way
SystemdYesNot published
Desktop GUIYesYes
BrowserYesYes
Computer-use APIYesYes
SSHYesNo documented way
Persistent diskYesNo documented way
Pause/resumeYesNo documented way
Automatic snapshotsYesNo documented way
Fork/cloneYesNo documented way
Live fork (no pause)YesNo documented way
Memory forkNo documented wayNo documented way
Custom image (Docker or snapshot)YesNo documented way
≥24 h sessionsYesYes
Idle auto-stopNo documented wayYes
Wake on requestNo documented wayNo documented way
HTTPS preview URLsYesNo documented way
Raw TCP inboundYesNo documented way
Public IPv4No documented wayNo documented way
Egress allowlistNo documented wayYes
Secret proxyYesYes
Secret proxy for any APIYesYes
Preinstalled agentsYesNo documented way
Agent harness APIYesYes
MCP serverNo documented wayNo documented way
GPUNo documented wayNo documented way
WindowsNo documented wayNo documented way
Arm64No documented wayNo documented way
Self-hostingNo documented wayYes
BYOCNo documented wayNo documented way
Open sourceNo documented wayNo documented way
Scoped API keysYesNot published
Spend limitsYesNot published
Usage per sandbox (API)YesNo documented way
Audit logsNo documented wayNot published
SSONo documented wayYes
SOC 2No documented wayYes
HIPAANo documented wayYes
EU data residencyNo documented wayYes
Zero data retentionYesNot published

Performance

boat28.06 runs/s
OpenAI ContainersNot measured

There is no comparable measurement. OpenAI Containers are not in the public benchmarks we use, so we cannot say which is faster, and OpenAI does not publish the vCPU behind each Responses container size. For reference, boat did 28.06 runs/s on the V8 Web Tooling Benchmark at 4 vCPU / 8 GB, second of 15 in StarSling's run of 3 October 2026 (run 37073680030). That boat sandbox ran on an AMD Ryzen 9 9950X host; boat also places some sandboxes on AMD Ryzen 7 9700X hosts.

V8 Web Tooling Benchmark at a 4 vCPU / 8 GB target, runs per second, higher is better. Source: StarSling's run of 3 October 2026 (run 37073680030), median of 5 sandboxes. Providers ran on different hardware in different regions. StarSling gives a shared rank when the run cannot separate two providers. Every boat sandbox in this run ran on an AMD Ryzen 9 9950X host. boat also places some sandboxes on AMD Ryzen 7 9700X hosts, which this run did not measure. OpenAI Containers is not in the public benchmarks we use, so we cannot say which is faster.

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. Start limits, per-start fees and plan minimums are in the price, boat's included.

Scenarioboat, a monthOpenAI Containers, 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$228 · API pay as you go · with limits
One agent that never stops
4 vCPU / 8 GB, 50 GB disk, running 24/7 all month
$26 · $20/mo$1,051 · API pay as you go · with limits
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$11,405 · API pay as you go · with limits
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$1,620 · API pay as you go · with limits
1,000 short jobs at once
2 vCPU / 4 GB, 1,000 at once, 3 minutes each, 200,000 jobs a month
$8,800 · $2000/mo · with limits$6,000 · API pay as you go · with limits

boat: Plans cost $20, $100, $500 or $2,000 a month, and the whole plan price comes back as VM time for that month. A default sandbox costs $0.036 an hour, billed per second while it runs. The $20 plan includes 200 starts a day and 100 sandboxes running at once; extra starts cost $0.03 to $0.07 each. A stopped sandbox has no compute charge and keeps its disk for at least 14 days. Saved snapshots above the included count and the AI credentials proxy still charge while sandboxes are stopped.

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. The scenarios use the 16 GB size ($1.44 an hour) for 8 GB needs and the 4 GB size for 4 GB needs, because OpenAI does not publish the vCPU per size.

Limits in those scenarios

OpenAI Containers do not fit any of the five scenarios as written. Hosted containers discard their files when they expire, document no Docker or root, and do not publish the vCPU behind each size. Code Interpreter and Hosted Shell containers have no outbound access until an admin allows domains. By default a container expires after 20 minutes without use; expires_after can set a longer idle time. OpenAI does not publish how many containers can run at once, so the 300 user sandboxes and the 1,000-job burst are unconfirmed. boat has its own limits: the $20 plan includes 200 starts a day, and boat never queues a start. In the burst, the $2,000 plan charges for starts above 90 a minute and refuses them above 270. boat keeps a stopped sandbox's disk for at least 14 days, and a machine failure loses what was written after the last snapshot. boat has no GPU on any size.

ScenarioboatOpenAI Containers
One coding agent, workdaysNone for this scenario
  • 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
One agent that never stopsNone for this scenario
  • 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
50 agents in parallelNone for this scenario
  • 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
Sandboxes for your usersNone for this scenario
  • 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)
1,000 short jobs at once
  • 2,400 starts/day included, paid above that (needs ~6,667)
  • 600 starts/hour included, paid above that (needs ~1,000)
  • starts above 90/min are paid, and starts above 270/min fail with 429
  • 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)
boat's own limits
  • Plans start at $20 a month. The plan price comes back as VM time for that month. Unused time does not carry over. Source
  • Starts (create, fork, resume): the $20 plan includes 12 a minute, 60 an hour and 200 a day. The $2,000 plan includes 90 a minute, 600 an hour and 2,400 a day. Extra starts cost $0.03 to $0.07. A start fails with 429 above 3 times the included starts per minute, or 6 times per hour or per day. Source
  • A stopped sandbox has no compute charge. boat keeps its disk for at least 14 days. A saved snapshot keeps it longer; extra saved snapshots and the AI credentials proxy are paid. Source
  • Auto-stop defaults to 1 hour. You can turn it off on a paid plan. The trial allows 2 hours at most. Source
  • boat saves the disk every minute and at each stop. Memory, running programs and /tmp are not saved: a resume is like a reboot. A machine failure loses writes after the last good snapshot. Source
  • Machines run in Germany, Finland and France only. Snapshot copies can be stored outside the EU. Source
  • Public IPv6 and outbound IPv4. No dedicated IPv4. The IP changes at each resume. Source
  • Hosts are AMD Ryzen 7 9700X and Ryzen 9 9950X. vCPUs are shared. No GPU. You cannot boot your own Docker image. Source

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. Useful if code must only reach chosen hosts: Code Interpreter and Hosted Shell have no outbound access until an admin allows domains.
  • US processing and your own compute. Code Interpreter can process data in the US or Europe, and the Agents API can drive a sandbox on machines you run.
  • A 64 GB size. Useful if code needs a lot of memory: OpenAI offers a 64 GB container.

Use boat when

your agent needs a real machine it keeps: root, Docker, a disk that stays between sessions, open internet and ports you can reach, with seven coding agents installed.

  • A whole machine with root. Most real repos need apt installs, a database in Docker or a service under systemd. Without root the agent stops at the first one. On OpenAI you set it up: connect the Agents API to a sandbox you host yourself.
  • A disk that stays. An agent that pauses for a human review, or works over several days, loses its clone, its installs and its build cache when the container expires. Your code has to upload files again into a fresh container. On boat, a machine failure loses only what was written after the last snapshot.
  • Reachable from outside, open to the internet. An agent that builds a web app cannot show it to anyone from an OpenAI container, and in Code Interpreter or Hosted Shell every package registry or API it needs has to be added to the org allowlist first.

Questions people ask

Is boat cheaper than OpenAI Containers?

In the scenarios on this page, at list prices, yes: one coding agent on workdays comes to $20 a month on boat and $228 on OpenAI, and one agent running all month comes to $26 versus $1,051. OpenAI is priced at its 16 GB size because it does not publish vCPU, and it bills model tokens on top. boat needs a plan from $20 a month, so for a few short code runs a month OpenAI, with no plan fee, can cost less.

Can I run Docker or install packages with sudo in an OpenAI container?

OpenAI's docs say hosted shell commands do not run with sudo, and Docker is not documented. You can connect the Agents API to a self-hosted sandbox where you control the machine. boat gives you root, systemd, Docker and /dev/kvm on every sandbox.

How long does an OpenAI container last?

By default a container expires after 20 minutes without use, and its data is discarded. The create call can set a different idle time with expires_after; no maximum is published. Agents API sandboxes can be deleted after an hour without activity. A boat sandbox has no session cap once you turn auto-stop off (default 1 hour), and boat keeps its disk for at least 14 days after a stop.

Can I open a web app running inside an OpenAI container?

Not on a hosted container: OpenAI documents no ports, URLs or SSH for them, and you reach them through the API. With a self-hosted Agents API environment the machine is yours, so you set up access yourself. boat gives each sandbox HTTPS URLs for up to 50 ports, raw TCP and SSH.

Can I use boat with OpenAI models?

Yes. Codex is installed in every boat sandbox. With the optional AI credentials proxy on ($1 per day plus $1 per 1,000 requests), the agent calls the OpenAI API while your real key stays outside the sandbox.

Is boat SOC 2 compliant?

SOC 2 is in progress. We're open about where we stand: live status at status.ascii.dev and our data retention policy at docs.boat.dev/data-retention.

Start a sandbox

Install the CLI, then run boat new.

7-day free trial

More comparisons