Replit vs OpenAI Containers
Replit is an AI app builder: Replit Agent writes an app in a browser workspace and Replit hosts it. OpenAI Containers are short-lived boxes inside OpenAI's model API, where the model runs code and the box expires after 20 idle minutes.
The companies and products
Replit
Replit is an AI app builder and hosting platform: you describe an app in chat, Replit Agent writes it, and Replit publishes it.
You work in a browser workspace where Replit Agent sets up the project, writes the code, tests it and fixes problems, with system packages managed by Nix. When the app is ready you publish it as an Autoscale, Static, Scheduled or Reserved VM deployment, with Postgres and object storage next to it. It is built for people and teams who want a working app, not for programs that need to create many machines by API, so this page compares the parts where the two overlap.
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. “181st cheapest of 367” means 180 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 | Replit: 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 A software factory starts many agents from code; Replit drives one Replit Agent app at a time through its MCP server, and OpenAI containers expire after 20 idle minutes. | 181st of 367, with limits $2,000 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 is a Reserved VM app on Replit, while an OpenAI container must be touched every 20 minutes or it is deleted. | 202nd of 366, with limits $2,033 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: the model writes Python and runs it in the same API call; Replit's Autoscale is a web host, not a code runner. | 228th of 345, with limits $146 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 Neither publishes how many machines can run at once; Replit apps are published one by one, and OpenAI containers accept no inbound connections from your users. | 233rd of 361, with limits $825 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 | 258th of 360, with limits $4,226 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 | 265th of 364, with limits $685 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 that build containers need Docker, which neither Replit's Nix setup nor OpenAI's no-sudo containers document; bochka has Docker on every machine. | 275th of 377, with limits $425 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 Replit gives you a workspace you can SSH into on paid plans, while OpenAI containers have no SSH and no persistent disk. | 165th of 368, with limits $109 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 for the Agents API computer_use tool, Replit's VNC pane is for a person to watch, and bochka streams a 60fps desktop agents can drive. | 190th of 369, with limits $619 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 OpenAI's hosted browser is driven by its own Codex harness; on bochka you run Chromium on your machine and drive it with any agent or library. | 229th of 367, with limits $317 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 | 234th of 346, with limits $217 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 | 150th of 338, with limits $4,378 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 | 208th of 360, with limits $215 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 | Replit | OpenAI Containers | bochka |
|---|---|---|---|
| Kind of product | AI app builder with browser workspaces and app hosting | A sandbox tool the model uses inside OpenAI's API | Sandboxes you create, stop and fork by API, SDK or CLI |
| Isolation | Not documented; the security page says strong logical separation between users | 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 | System packages come from Nix; Docker, systemd and /dev/kvm are not described | Commands do not run with sudo; no Docker or /dev/kvm documented | Root, systemd, Docker and /dev/kvm on every machine |
| Files over time | Workspace files and Agent checkpoints at milestones; published apps should not rely on their filesystem | Data is discarded when the container expires; Agents API keeps only files in /workspace/outputs | Disk saved every minute and on stop; a stopped sandbox costs nothing and comes back |
| Lifetime | A Reserved VM runs continuously at a fixed monthly price per size | Expires after 20 minutes without use; Agents API sandboxes after an hour without activity | No session cap on paid plans; stopping a sandbox ends the bill |
| Creating machines from code | MCP server tools to create, update and publish apps; no API to start many machines | Containers API, or a Responses call that makes one for the model | API, SDK and CLI to create, stop, resume and fork many sandboxes |
| Fork | Projects can be copied; no fork of a running machine | No fork; templates save configuration, not a running workspace | Fork a running sandbox with its disk |
| Reaching the machine | Published apps on HTTPS domains, custom domains; SSH into the workspace on paid plans | None; you reach the container only through the API | SSH, HTTPS URLs for up to 50 ports, token-protected, and raw TCP |
| Outbound internet | Open internet | Code Interpreter and Hosted Shell: off until an admin sets an org domain allowlist; Agents API sandboxes open by default | Open internet on every plan; no provider-side allowlist |
| Keeping keys out of the sandbox | Replit manages keys for OpenAI, Anthropic, Google and OpenRouter models; other keys are secrets in the app | domain_secrets: a sidecar adds the real header for approved domains, the model sees a placeholder | Credentials proxy for model providers and any HTTPS API; switch a credential to another account when credits run out |
| Coding agents | Replit Agent, which you can also drive from an MCP client | Agents API (beta) drives a managed Codex harness from outside, with steering, events and webhooks | Claude Code, Codex, OpenCode and more preinstalled, with a prompt, steer and events API |
| Desktop and computer use | VNC pane that streams a native desktop to your browser; no computer-use API | Hosted browser for the Agents API computer_use tool | 60fps desktop and Chromium, computer use and browser control, embeddable stream |
| Hosting and databases | Autoscale apps that sleep when idle, Reserved VMs, Postgres and App Storage | No hosting; containers have no ports | Host on HTTPS ports from a running sandbox; no hosted databases or wake on request |
| Regions | North America, Europe, Asia, South America and Australia for published apps on Core and up | US or EU processing for Code Interpreter; Agents API data residency only in the US | EU only: Germany, Finland, France |
Every feature Battleships tracks (43)
| Feature | Replit | OpenAI Containers | bochka |
|---|---|---|---|
| Full VM (own kernel) | Yes | Yes | Yes |
| Docker inside | No | No | Yes |
| Nested virtualization | No | No | Yes |
| Root | Not published | No | Yes |
| Systemd | No | Not published | Yes |
| Desktop GUI | Yes | Yes | Yes |
| Browser | No | Yes | Yes |
| Computer-use API | No | Yes | Yes |
| SSH | Yes | No | Yes |
| Persistent disk | Yes | No | Yes |
| Pause/resume | No | No | Yes |
| Automatic snapshots | Yes | No | Yes |
| Fork/clone | Yes | No | Yes |
| Live fork (no pause) | No | No | Yes |
| Memory fork | No | 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 | Not published | No | Yes |
| Public IPv4 | No | No | No |
| Egress allowlist | No | Yes | No |
| Secret proxy | Yes | Yes | Yes |
| Secret proxy for any API | No | Yes | Yes |
| Preinstalled agents | Yes | No | Yes |
| Agent harness API | Yes | Yes | Yes |
| MCP server | Yes | No | No |
| GPU | No | No | No |
| Windows | No | No | No |
| Arm64 | Not published | No | No |
| Self-hosting | No | Yes | No |
| BYOC | No | No | No |
| Open source | No | No | No |
| Scoped API keys | Not published | Not published | Yes |
| Spend limits | Yes | Not published | Yes |
| Usage per sandbox (API) | Yes | No | Yes |
| Audit logs | Yes | Not published | No |
| SSO | Yes | Yes | No |
| SOC 2 | Yes | Yes | No |
| HIPAA | No | Yes | No |
| EU data residency | Yes | Yes | Yes |
| Zero data retention | Not published | Not published | Yes |
Performance
There is no comparable measurement for either. Replit and OpenAI Containers are not in the public CPU benchmark, and OpenAI does not publish how many vCPU each container size gets. bochka did 26.69 Node.js build-and-test runs per second at 4 vCPU / 8 GB in StarSling's hpc-sandbox-benchmarks.
Node.js build-and-test loop at 4 vCPU / 8 GB, higher is better. Measured with the open hpc-sandbox-benchmarks suite. Replit and OpenAI Containers 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 | Replit, 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 | $122 · Pro $100 (annual) · with limits | $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 | $122 · Pro $100 (annual) · with limits | $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 | $1,330 · Pro $1,000 (annual) · 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 | $403 · Pro $250 (annual) · with limits | $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 | $825 · Pro $1,000 (annual) · with limits | $6,000 · API pay as you go · with limits | $2,000 · $2000/mo · with limits |
Replit: Replit plans (Core $20, Pro from $100) turn into monthly credits for Agent work and hosting, then usage is pay-as-you-go. A Reserved VM has a fixed monthly price per size and bills whether busy or idle; our scenarios price agents as Reserved VMs.
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; vCPU per size is not published, so the scenarios match on memory.
OpenAI Containers: You pick a monthly plan from $20, and all of it becomes usage credit spent per second on running sandboxes. A stopped sandbox costs nothing and keeps its disk.
Limits in those scenarios
Neither fits any of the five scenarios as written. Replit is an app platform: one Reserved VM is one published app that runs all month, and Docker is not documented. OpenAI Containers have no persistent disk and no Docker, Code Interpreter and Hosted Shell start with no internet, and a container expires after 20 idle minutes. Neither publishes how many machines can run at once, so 300 user sandboxes and 1,000 jobs at once are unconfirmed for both; on bochka that burst is queued above 90 starts a minute.
| Scenario | Replit | OpenAI Containers | bochka |
|---|---|---|---|
| One coding agent, workdays |
|
| None that bite |
| One agent that never stops |
|
| None that bite |
| 50 agents in parallel |
|
| None that bite |
| Sandboxes for your users |
|
| None that bite |
| 1,000 short jobs at once |
|
|
|
Which one should you use?
Use Replit when
you want Replit Agent to build a web app from a description and host it for you, with databases, sleeping when idle, or regions outside Europe.
- An app built and hosted for you. Useful if you want a working app from a description: Replit Agent builds, tests and publishes it with a domain and Postgres.
- A machine that stays. Useful if you need a workspace you come back to: files stay, and paid plans let you SSH in.
- Regions on five continents. Useful if your users are outside Europe: published apps run in North America, Europe, Asia, South America or Australia.
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.
- Pay by the minute, no plan. Useful for short code runs: sessions bill by the minute with a 5-minute minimum, and there is no plan fee.
- Locked-down network by default. Useful if code must only reach chosen hosts: Code Interpreter and Hosted Shell stay offline until an admin allows domains.
Where bochka fits
Neither of these is a machine your code rents for an agent. Replit hosts apps that Replit Agent builds, and OpenAI Containers are boxes the model borrows for a few minutes. If what you are really running is agents that need their own machines, bochka gives each one a full VM it keeps, started by your code.
Root, Docker and KVM on its own kernel
An agent that runs docker compose or a database under systemd gets stuck on both: Replit sets up Nix packages with no Docker documented, and OpenAI runs commands without sudo. On OpenAI the way around it is hosting a sandbox yourself.
A disk that stays, and stops that are free
An OpenAI container throws its files away after 20 idle minutes, so your code uploads everything again. Replit keeps files, but a Reserved VM bills all month. bochka saves the disk every minute and a stopped sandbox costs nothing.
Machines your code starts, forks and drives
Replit's MCP server drives Replit Agent one app at a time, and OpenAI containers accept no inbound connections. bochka starts and forks VMs by API, with Claude Code or Codex you steer from outside and HTTPS on 50 ports.
Use bochka when your own code needs to start machines for agents: full VMs with root, Docker and a disk that persists, ports you can reach, and coding agents you drive by API. Compare it one to one: bochka vs Replit and bochka vs OpenAI Containers.
Questions people ask
Is Replit cheaper than OpenAI Containers?
In the scenarios we priced, yes, though neither fits them as written. One coding agent on workdays comes to $122 on Replit and $228 on OpenAI, and one agent running all month comes to $122 versus $1,051. OpenAI also bills model tokens on top. On bochka those two come to $20 and $26.
Which is faster, Replit or OpenAI Containers?
We cannot say. Neither is in the public CPU benchmark, and OpenAI does not publish the vCPU behind each container size. bochka did 26.69 runs per second at 4 vCPU / 8 GB in the same benchmark.
Can Replit or OpenAI Containers run Docker?
Neither documents it. Replit sets up environments with Nix packages, and OpenAI's hosted shell runs commands without sudo. Every bochka sandbox is a full VM with root, systemd, Docker and /dev/kvm.
Do my files stay between sessions?
On Replit, workspace files stay, though published apps should not rely on their filesystem. An OpenAI container discards its data when it expires after 20 idle minutes. bochka saves the disk every minute and when a sandbox stops.
Can I open a web app running inside them?
On Replit, yes: you publish the app to an HTTPS domain. OpenAI containers have no ports, URLs or SSH; you reach them only through the API. bochka gives each sandbox HTTPS URLs for up to 50 ports, raw TCP and SSH.
Where does my data run?
Replit hosts data mainly on Google Cloud in the United States, and publishes apps on five continents on Core and up. OpenAI's Code Interpreter can process data in the US or Europe. bochka runs only in the EU, in Germany, Finland and France.
Try bochka
Install the CLI, then run bochka new.
Product preview