Koyeb vs OpenAI Containers

A Koyeb sandbox is a microVM you start from any Docker image, expose on a port and can put to sleep. An OpenAI container is a tool inside OpenAI's model API. The model runs Python or shell there on a fixed image. By default the box expires after 20 minutes without use, and the create call can set a longer idle time.

The companies and products

Koyeb

Koyeb is a serverless cloud for apps, inference and sandboxes. In February 2026 it agreed to join Mistral AI.

A Koyeb sandbox is a Koyeb service: a microVM that starts from any Docker image. You drive it from Python or JavaScript SDKs or the Koyeb CLI: run commands, read files, expose a port and take snapshots. The default image comes with four coding agents. A sandbox can scale to zero when idle and wake on the next request, on CPU or GPU instance types. It suits teams that run AI agents or untrusted code next to apps they already host on Koyeb.

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. “6th cheapest of 336” means 5 of the other 335 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 workloadKoyeb: price rankOpenAI Containers: price rankboat: price rank
Software factory
100 at once · 4 vCPU / 8 GB · 2,200 sessions of 8 h a month
A software factory needs Docker, root and a disk that survives. Hosted OpenAI containers run without sudo and document no Docker; you can connect the Agents API to a sandbox you host. Koyeb does not document Docker inside, and you keep files with SDK snapshots or a small volume. boat runs Docker and saves its disk with no code.
92nd of 365, with limits
$366 a month
357th of 365, with limits
$17,371 a month
5th cheapest of 365
$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 its files to stay. An OpenAI container discards its data when it expires. On Koyeb, keep the sandbox awake or take an SDK snapshot before Deep Sleep. On boat, turn auto-stop off on a paid plan.
194th of 361, with limits
$923 a month
344th of 361, with limits
$13,140 a month
6th cheapest of 361
$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: the model writes code and runs it in the same API call, with no machine to manage. Koyeb also fits short code runs well, with small instances that scale to zero and wake on the next request.
6th cheapest of 336
$66 a month
198th of 336, with limits
$6,000 a month
189th of 336, 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
Koyeb gives each user an HTTPS port and wakes a sleeping sandbox on request. OpenAI documents no inbound ports for hosted containers. boat gives each sandbox up to 50 HTTPS URLs and SSH.
8th cheapest of 349
$495 a month
349th of 349, with limits
$3,780 a month
3rd cheapest of 349
$209 a month
RL rollouts
1,000 at once · 2 vCPU / 4 GB · 1,000,000 sessions of 3 min a month
233rd of 349, with limits
$1,631 a month
195th of 349, with limits
$30,000 a month
39th of 349, with limits
$2,000 a month
Agent evals
250 at once · 4 vCPU / 8 GB · 15,000 sessions of 20 min a month
27th cheapest of 359
$429 a month
355th of 359, with limits
$5,760 a month
10th cheapest of 359
$200 a month
CI runners
40 at once · 8 vCPU / 16 GB · 6,000 sessions of 12 min a month
CI needs Docker, root and open internet. Hosted OpenAI containers document no Docker or root, and Code Interpreter has no outbound access until an admin allows domains. Koyeb documents neither Docker inside nor /dev/kvm. boat has all of them.
143rd of 374, with limits
$88 a month
347th of 374, with limits
$1,728 a month
2nd cheapest of 374
$86 a month
24/7 dev boxes
1 machine 24/7 · 4 vCPU / 8 GB
A dev box you keep all month needs SSH and a disk that stays. Koyeb runs commands through its SDKs and CLI. Hosted OpenAI containers document no SSH, and their files go when they expire. A boat sandbox has SSH and a disk saved every minute.
232nd of 371, with limits
$37 a month
365th of 371, with limits
$1,051 a month
19th cheapest of 371
$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 for computer use in its Agents API beta. On Koyeb you add a desktop and VNC to your own Docker image. boat streams a 60 fps desktop with Chrome.
128th of 367, with limits
$123 a month
353rd of 367, with limits
$5,280 a month
7th cheapest of 367
$200 a month
Browser-use agents
50 at once · 2 vCPU / 4 GB · 30,000 sessions of 10 min a month
237th of 356, with limits
$123 a month
335th of 356, with limits
$1,440 a month
7th cheapest of 356
$200 a month
Scraping & bots (startup scale)
50 at once · 1 vCPU / 2 GB · 100,000 sessions of 3 min a month
242nd of 343, with limits
$89 a month
334th of 343, with limits
$1,755 a month
6th cheapest of 343
$90 a month
Mass scraping & bots (undetectable)
1,000 at once · 1 vCPU / 2 GB · 3,000,000 sessions of 2 min a month
67th of 327, with limits
$1,683 a month
307th of 327, with limits
$35,100 a month
73rd of 327, with limits
$1,800 a month
Parallel red teaming
200 at once · 2 vCPU / 4 GB · 5,000 sessions of 30 min a month
261st of 351, with limits
$299 a month
310th of 351, with limits
$870 a month
3rd cheapest of 351
$200 a month
GPU eval jobs
10 at once · 8 vCPU / 32 GB · 500 sessions of 30 min a month
Koyeb runs GPU instances from an RTX 4000 SFF Ada up to H100, H200 and B200. OpenAI containers and boat have no GPUs.
3rd cheapest of 102
$628 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 requirementNot ranked: misses a requirement

Key features

FeatureKoyebOpenAI Containersboat
What it isA sandbox service you start from any Docker image and drive with SDKs or the Koyeb CLIA sandbox tool the model uses inside OpenAI's APIA cloud VM you create, keep, stop and reach from outside
IsolationCloud Hypervisor microVM per instanceA fully sandboxed virtual machine; hypervisor not namedFull VM with its own kernel, on AMD Ryzen 7 9700X and Ryzen 9 9950X hosts dedicated to boat; vCPUs are shared
Docker, root and nested virtualizationStarts from any Docker image; Docker inside and /dev/kvm not documentedCommands do not run with sudo on a fixed Debian 12 image; Docker and /dev/kvm not documented. You can connect the Agents API to a self-hosted sandboxRoot, systemd, Docker and /dev/kvm on every sandbox
Machine sizeInstance types up to 40 vCPU / 128 GB, and GPU types larger still1, 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 GB4 vCPU / 8 GB by default, up to 16 vCPU / 32 GB (xlarge needs the $100 plan)
Files after the sessionLocal disk is lost on redeploy and in Deep Sleep. You set it up: SDK snapshots save the filesystem; volumes (preview, 1 to 10 GB, not on eco instances) persistData is discarded when the container expires. Agents API publishes files in /workspace/outputs as downloadable artifactsDisk saved every minute and at each stop, with no code; a stopped disk is kept at least 14 days
Lifetime and sleepNo forced session cap; scales to zero after an idle period (5 minutes minimum) and wakes on the next requestBy 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 activityNo cap once auto-stop is off on a paid plan; auto-stop defaults to 1 hour, up to 30 days
Snapshots and forkSDK snapshots of the filesystem, or with running processes, then new sandboxes from a snapshotNo fork call documented. You set it up: create a new container and upload the same filesFork a running sandbox from its last 1-minute snapshot
Inbound accessOne exposed HTTPS port at a time, plus an optional TCP proxy to one port (preview)No inbound ports documented for hosted containers; you reach them through the APIUp to 50 HTTPS URLs, token-protected by default; SSH; raw ports over IPv6 only on sandboxes with no IPv4 of their own
Outbound internetOpen by default; can block all outbound traffic or allow only listed IPs and CIDRsCode 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 hostsOpen internet; no provider-side allowlist
Keeping API keys out of the sandboxSecrets are set as environment variables inside the servicedomain_secrets: a sidecar adds the real header for approved domains; the model sees a placeholderOptional paid proxy ($1 a day plus $1 per 1,000 requests) for model providers and custom HTTPS APIs; other secrets still enter the sandbox
Coding agentsDefault image preinstalls Mistral Vibe, Codex, Gemini and OpenCode, run through the command API; no prompt or steer APIAgents API (beta) drives a managed Codex harness from outside, with steering, events and webhooksSeven harnesses installed, including Claude Code, Codex and OpenCode, with a prompt, steer and events API
Desktop and computer useNo desktop or browser preinstalled; you can add them to a custom Docker imageHosted browser for the Agents API computer_use tool1920x1080, 60 fps desktop and Chrome, computer tools for agents, embeddable stream
GPUsRTX 4000 SFF Ada up to H100, H200 and B200, and multi-GPUNoneNone
RegionsFrankfurt, Paris, Washington D.C., Singapore, Tokyo and more; you pick the regionUS or EU processing for Code Interpreter; Agents API data residency in the US onlyGermany, Finland and France; no region choice, no US or Asia region
Every feature Battleships tracks (43)
FeatureKoyebOpenAI Containersboat
Full VM (own kernel)YesYesYes
Docker insideNot publishedNo documented wayYes
Nested virtualizationNo documented wayNo documented wayYes
RootNot publishedNo documented wayYes
SystemdNot publishedNot publishedYes
Desktop GUINo documented wayYesYes
BrowserNo documented wayYesYes
Computer-use APINo documented wayYesYes
SSHNo documented wayNo documented wayYes
Persistent diskWith your own setupNo documented wayYes
Pause/resumeYesNo documented wayYes
Automatic snapshotsYesNo documented wayYes
Fork/cloneYesNo documented wayYes
Live fork (no pause)Not publishedNo documented wayYes
Memory forkYesNo documented wayNo documented way
Custom image (Docker or snapshot)YesNo documented wayYes
≥24 h sessionsYesYesYes
Idle auto-stopYesYesNo documented way
Wake on requestYesNo documented wayNo documented way
HTTPS preview URLsYesNo documented wayYes
Raw TCP inboundYesNo documented wayYes
Public IPv4No documented wayNo documented wayNo documented way
Egress allowlistYesYesNo documented way
Secret proxyNo documented wayYesYes
Secret proxy for any APINo documented wayYesYes
Preinstalled agentsYesNo documented wayYes
Agent harness APINo documented wayYesYes
MCP serverYesNo documented wayNo documented way
GPUYesNo documented wayNo documented way
WindowsNo documented wayNo documented wayNo documented way
Arm64No documented wayNo documented wayNo documented way
Self-hostingYesYesNo documented way
BYOCYesNo documented wayNo documented way
Open sourceNo documented wayNo documented wayNo documented way
Scoped API keysNot publishedNot publishedYes
Spend limitsNo documented wayNot publishedYes
Usage per sandbox (API)No documented wayNo documented wayYes
Audit logsYesNot publishedNo documented way
SSOYesYesNo documented way
SOC 2YesYesNo documented way
HIPAANo documented wayYesNo documented way
EU data residencyYesYesNo documented way
Zero data retentionNot publishedNot publishedYes

Performance

KoyebNot measured
OpenAI ContainersNot measured
boat28.06 runs/s

Neither Koyeb nor OpenAI Containers is in the public benchmarks we use, so we cannot say which is faster. OpenAI does not publish the vCPU behind each container size. Koyeb publishes a CPU share of at least 0.25 dedicated vCPU per GB of memory, bursting to all cores. In StarSling's run of 3 October 2026 (run 37073680030), boat did 28.06 runs/s on the V8 Web Tooling Benchmark at 4 vCPU / 8 GB, second of 15. 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.

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. Koyeb and OpenAI Containers are 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.

ScenarioKoyeb, a monthOpenAI Containers, a monthboat, 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
$29 · Pro$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
$57 · Pro$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
$475 · Pro · with limits$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
$329 · Scale$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
$485 · Scale · with limits$6,000 · API pay as you go · with limits$8,800 · $2000/mo · with limits

Koyeb: Koyeb bills each instance per second at a fixed price per instance type: eco-xlarge (4 vCPU / 8 GB, 20 GB disk) costs $0.0576 an hour. Deep Sleep costs nothing. Pro costs $29 a month with $10 of usage included, and Scale $299 with $100 included; the rest of the fee is not credit.

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

OpenAI Containers: Plans cost $20, $100, $500 or $2,000 a month, and the whole plan price comes back as VM time for that month. A 4 vCPU / 8 GB sandbox costs $0.036 an hour, per second while it runs. The $20 plan includes 12 starts a minute, 60 an hour and 200 a day; extra starts cost $0.03 to $0.07. A stopped sandbox has no compute charge and keeps its disk for at least 14 days; extra saved snapshots and the AI credentials proxy still charge.

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 per size. Code Interpreter and Hosted Shell containers have no outbound access until an admin allows domains. Koyeb's priced shape for 4 vCPU / 8 GB is eco-xlarge, with a 20 GB local disk that takes no volume, and Koyeb does not document Docker inside, so the 50-agent fleet is marked as not fitting. At 1,000 short jobs at once nothing fits as priced: OpenAI's concurrency is not published, and boat's $2,000 plan includes 90 starts a minute and refuses starts above 270 a minute.

ScenarioKoyebOpenAI Containersboat
One coding agent, workdays
  • disk beyond 20 GiB: price unknown
  • 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 for this scenario
One agent that never stops
  • disk beyond 20 GiB: price unknown
  • 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 for this scenario
50 agents in parallel
  • not confirmed: Docker inside
  • 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 for this scenario
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)
None for this scenario
1,000 short jobs at once
  • burstable CPU: 50% of each vCPU guaranteed, throttled above that
  • 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)
  • 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

Which one should you use?

Use Koyeb when

you want sandboxes from your own Docker images that sleep when idle, wake on a request, use GPUs or run in the US or Asia.

  • A machine you control. Good when you want to pick the image, the size and the port yourself: Koyeb starts any Docker image as a microVM.
  • GPUs and wake on request. Useful when sandboxes need a GPU, or sit idle and must wake on the next request, in about 200 ms with Light Sleep (preview).
  • Many regions. Good for sandboxes that must run in the US or Asia: Koyeb runs in Washington D.C., Singapore, Tokyo and Europe.

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.
  • Nothing to run or clean up. Good for short code runs: OpenAI creates the container, bills it by the minute and lets it expire on its own.
  • Locked-down network by default. Useful if code must reach only chosen domains, with keys for those domains added by a sidecar the model cannot read.

Where boat fits

If you run coding agents that work for hours, look at boat. Koyeb gives you a machine you shape yourself, and OpenAI Containers give the model a short-lived box with no root. boat gives each agent a full VM that saves its disk, with agents, a desktop and hosting built in. boat has no GPU and no US or Asia region, and it caps starts per plan.

A disk saved with no code

An OpenAI container discards its files when it expires. On Koyeb you keep files with SDK snapshots or a preview volume of 1 to 10 GB. boat saves the disk every minute and at each stop, and keeps a stopped disk for at least 14 days.

Root, Docker and /dev/kvm

OpenAI runs hosted commands without sudo and documents no Docker. Koyeb documents neither Docker inside a sandbox nor /dev/kvm. boat has root, systemd, Docker and /dev/kvm on every sandbox.

Agents and ports built in

On Koyeb you run agents through the command API and expose one port at a time. OpenAI's Agents API drives its own Codex harness, and hosted containers take no inbound connections. boat installs seven coding agents you drive from outside, with up to 50 HTTPS URLs and a 60 fps desktop.

Use boat when your agents need a real machine they keep: root, Docker, /dev/kvm, a disk saved every minute, open internet and ports you can reach, with seven coding agents installed. Compare it one to one: boat vs Koyeb and boat vs OpenAI Containers.

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

Questions people ask

Is Koyeb cheaper than OpenAI Containers?

In the scenarios on this page, at list prices, yes. One agent on workdays costs $29 a month on Koyeb against $228 on OpenAI. One agent running all month costs about $42 of Koyeb compute plus the $29 Pro fee ($10 included), against $1,051 on OpenAI. boat costs $20 and $26. OpenAI is priced at its 16 GB size, bills model tokens on top, and does not fit these scenarios as written. For a few short code runs a month, OpenAI has no plan fee and can cost less.

Which is faster?

Neither Koyeb nor OpenAI Containers is in the public benchmarks we use, so we cannot say. boat did 28.06 runs/s on the V8 Web Tooling Benchmark in StarSling's run of 3 October 2026, on a Ryzen 9 9950X host.

Can I run Docker in Koyeb or OpenAI Containers?

Koyeb sandboxes start from Docker images, but Koyeb does not document Docker inside a sandbox. OpenAI's docs say hosted commands do not run with sudo and document no Docker; you can connect the Agents API to a sandbox you host. boat has root, systemd, Docker and /dev/kvm on every sandbox.

Do they keep files between sessions?

An OpenAI container discards its data when it expires, by default after 20 minutes without use. On Koyeb you keep files with SDK snapshots or a preview volume of 1 to 10 GB. A boat sandbox saves its disk every minute and at each stop, and keeps a stopped disk for at least 14 days.

Can I open a web app running inside the sandbox?

On Koyeb you can expose one HTTPS port at a time. OpenAI documents no ports, URLs or SSH for hosted containers. boat gives each sandbox up to 50 HTTPS URLs, token-protected by default, and SSH.

Is boat SOC 2 compliant?

SOC 2 is in progress. OpenAI's API Platform is audited for SOC 2 Type 2, and Koyeb lists ISO 27001 and SOC 2 on its Enterprise plan. Live status is at status.ascii.dev and our data retention policy at docs.boat.dev/data-retention.

Try boat

Install the CLI, then run boat new.

7-day free trial

More comparisons