Ona vs Replit
Ona, formerly Gitpod and now part of OpenAI, gives engineering teams an isolated cloud dev environment per task, shared with its Codex agent and sold through sales. Replit is a self-serve app builder: you describe an app, Replit Agent writes it, and Replit hosts it.
The companies and products
Ona
Ona, formerly Gitpod, is a platform for cloud dev environments and background coding agents, and is now part of OpenAI.
Ona is a different kind of product from bochka: a dev-environment platform, not a sandbox API. Each task or developer gets an isolated VM built from a Dev Container config, which people open in a browser IDE, VS Code or JetBrains, and where Ona's Codex Agent can plan, code, test and open pull requests. It is built for engineering teams who want the same governed environment for every developer and agent; new customers run it in their own AWS or GCP account on an Enterprise contract.
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.
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. “324th cheapest of 367” means 323 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 | Ona: price rank | Replit: 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: Ona's SDK is Enterprise only, Replit's MCP server drives Replit Agent one app at a time, and bochka fits fully with an API on every plan. | 324th of 367, with limits $7,315 a month | 181st of 367, with limits $2,000 a month | 3rd cheapest of 367 $634 a month |
| Always-on AI employees 50 machines 24/7 · 2 vCPU / 4 GB An always-on assistant needs Ona's auto-stop set to Never, because background work does not count as activity, and on Replit it means a Reserved VM that bills all month. | 83rd of 366, with limits $8,504 a month | 202nd of 366, with limits $2,033 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 Replit's Autoscale scales to zero and bills only while it serves requests, so short runs cost less there than on Ona, though neither is a code runner. | 335th of 345, with limits $5,320 a month | 228th of 345, with limits $146 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 is built to hand machines to your users: Ona's per-user policy defaults to 10 running environments, and Replit does not publish how many deployments can run at once. | 330th of 361, with limits $5,988 a month | 233rd of 361, with limits $825 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 | 283rd of 360, with limits $9,773 a month | 258th of 360, with limits $4,226 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 | 334th of 364, with limits $5,768 a month | 265th of 364, with limits $685 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 Ona has inside its Dev Container and Replit's Nix-based environments do not document; neither can copy a warm machine. | 365th of 377, with limits $5,461 a month | 275th of 377, with limits $425 a month | 4th cheapest of 377 $86 a month |
| 24/7 dev boxes 1 machine 24/7 · 4 vCPU / 8 GB Both suit coding by hand: Ona is a full cloud IDE with Dev Containers and prebuilds, and a Replit workspace is quick to start but has no documented Docker or systemd. | 368th of 368, with limits $5,140 a month | 165th of 368, with limits $109 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 Ona environments have no graphical desktop, and Replit's VNC pane shows one to a person with no API for an agent, while bochka streams a 60fps desktop for computer use. | 353rd of 369, with limits $5,691 a month | 190th of 369, with limits $619 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 | 150th of 367, with limits $5,346 a month | 229th of 367, with limits $317 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 | 146th of 346, with limits $5,468 a month | 234th of 346, with limits $217 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 | 261st of 338, with limits $14,360 a month | 150th of 338, with limits $4,378 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 bochka can fork one prepared machine into many while it runs; Ona starts new environments from a config or prebuild, and Replit has no API to start many machines. | 93rd of 360, with limits $5,228 a month | 208th of 360, with limits $215 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 | Ona | Replit | bochka |
|---|---|---|---|
| Kind of product | Cloud dev environments for engineers and a Codex agent | AI app builder with browser workspaces and app hosting | Sandboxes you create, stop and fork by API, SDK or CLI |
| Isolation | Every environment is an isolated VM with dedicated compute, built from a Dev Container config | Not documented; the security page says strong logical separation between users | Every sandbox is a full VM with its own kernel |
| Docker and nested virtualization | Docker and root inside the Dev Container; nested virtualization is not documented | System packages come from Nix; Docker, systemd and /dev/kvm are not documented | Docker, root, systemd and /dev/kvm on every machine |
| Driving it from code | Python, TypeScript and Go SDK on the Enterprise plan only | MCP server tools to create, update and publish apps; no API to start many machines | API, SDK and CLI on every plan, including the trial |
| Coding agents | Codex Agent started from chat, a Linear issue or an automation; Claude Code you run yourself | Replit Agent, which you can also drive from an MCP client (create, update, ask, publish) | Claude Code, Codex, OpenCode and more preinstalled, with a prompt, steer and events API |
| Starting point | Dev Container config per repo, with prebuilds that snapshot the filesystem on a schedule | Replit Agent sets up the project, with system packages managed by Nix | Named snapshots (templates), shareable by code; no Dockerfile builds |
| Files after a stop | Disk persists across stops; in your own cloud it is billed while stopped, and Core archives a stopped environment after 3 days | Workspace files and Agent checkpoints at milestones; published apps should not rely on their filesystem | Snapshots every minute and on stop; a stopped sandbox keeps its disk and costs nothing |
| Fork | No environment copy; you can create a project from an environment's config | No API to copy a running machine | Fork a running sandbox into copies with its files |
| Long-running work | Stops after 30 minutes without SSH, IDE or agent activity by default; can be set to Never | Reserved VM runs continuously at a fixed monthly price per size | Runs until you stop it; no session cap on paid plans, and stopping ends the bill |
| Hosting that sleeps when idle | Not an app host; ports are shared as HTTPS URLs from a running environment | Autoscale starts on the first request and goes idle after 15 minutes, costing nothing while idle | No wake on request; you stop and resume sandboxes yourself |
| Desktop and computer use | Browser IDE plus VS Code and JetBrains; no graphical desktop inside the environment | VNC pane that streams a native desktop to your browser; no computer-use API | 60fps desktop and Chromium, computer use and browser control, embeddable stream |
| Reaching the machine | HTTPS URL per port for you, your organization or everyone; SSH; no raw TCP or public IP documented | Published apps on HTTPS and custom domains, private deployments; SSH into the workspace on paid plans | HTTPS URLs for up to 50 ports, token-protected; raw TCP; dedicated IPv6 or IPv4; SSH |
| Keeping keys out of the sandbox | Secrets are injected into the environment as environment variables or files | Replit manages keys for OpenAI, Anthropic, Google and OpenRouter models; other keys are secrets in the app | AI credentials proxy for model providers and any HTTPS API you register; switch a credential to another account when credits run out |
| Regions and GPUs | Enterprise runners in your own AWS or GCP account, in many regions, with GPU types such as an NVIDIA A10G | Published apps in North America, Europe, Asia, South America and Australia on Core and up; no GPUs | EU only: Germany, Finland, France; no GPUs |
Every feature Battleships tracks (43)
| Feature | Ona | Replit | bochka |
|---|---|---|---|
| Full VM (own kernel) | Yes | Yes | Yes |
| Docker inside | Yes | No | Yes |
| Nested virtualization | No | No | Yes |
| Root | Yes | Not published | Yes |
| Systemd | Not published | No | Yes |
| Desktop GUI | No | Yes | Yes |
| Browser | Yes | No | Yes |
| Computer-use API | No | No | Yes |
| SSH | Yes | Yes | Yes |
| Persistent disk | Yes | Yes | Yes |
| Pause/resume | Yes | No | Yes |
| Automatic snapshots | No | Yes | Yes |
| Fork/clone | No | Yes | Yes |
| Live fork (no pause) | No | No | Yes |
| Memory fork | No | No | No |
| Custom image (Docker or snapshot) | Yes | Yes | Yes |
| ≥24 h sessions | Yes | Yes | Yes |
| Idle auto-stop | Yes | Yes | No |
| Wake on request | No | Yes | No |
| HTTPS preview URLs | Yes | Yes | Yes |
| Raw TCP inbound | No | Not published | Yes |
| Public IPv4 | No | No | No |
| Egress allowlist | No | No | No |
| Secret proxy | No | Yes | Yes |
| Secret proxy for any API | No | No | Yes |
| Preinstalled agents | Yes | Yes | Yes |
| Agent harness API | Yes | Yes | Yes |
| MCP server | No | Yes | No |
| GPU | Yes | No | No |
| Windows | No | No | No |
| Arm64 | No | Not published | No |
| Self-hosting | No | No | No |
| BYOC | Yes | No | No |
| Open source | No | No | No |
| Scoped API keys | Not published | Not published | Yes |
| Spend limits | Yes | Yes | Yes |
| Usage per sandbox (API) | No | Yes | Yes |
| Audit logs | No | Yes | No |
| SSO | Yes | Yes | No |
| SOC 2 | Yes | Yes | No |
| HIPAA | No | No | No |
| EU data residency | Yes | Yes | Yes |
| Zero data retention | Not published | Not published | Yes |
Performance
There is no comparable measurement for Ona or Replit: neither is in the public benchmark runs we use, so we cannot say which of the two is faster. bochka did 26.69 Node.js build-and-test runs per second at 4 vCPU / 8 GB in StarSling's run of 2026-09-29, on dedicated AMD Ryzen 9 9950X hosts.
Node.js build-and-test loop at 4 vCPU / 8 GB, higher is better. Measured with the open hpc-sandbox-benchmarks suite. Ona and Replit 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 | Ona, a month | Replit, 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 | $5,030 · Enterprise (AWS Marketplace 12-month contract) · with limits | $122 · Pro $100 (annual) · with limits | $20 · $20/mo |
| One agent that never stops 4 vCPU / 8 GB, 50 GB disk, running 24/7 all month | $5,140 · Enterprise (AWS Marketplace 12-month contract) · with limits | $122 · Pro $100 (annual) · 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 | $6,521 · Enterprise (AWS Marketplace 12-month contract) · with limits | $1,330 · Pro $1,000 (annual) · 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 | $5,432 · Enterprise (AWS Marketplace 12-month contract) · with limits | $403 · Pro $250 (annual) · 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 | $5,955 · Enterprise (AWS Marketplace 12-month contract) · with limits | $825 · Pro $1,000 (annual) · with limits | $2,000 · $2000/mo · with limits |
Ona: New Core subscriptions are closed, so the Ona prices here use its Enterprise listing on AWS Marketplace: a 12-month, $60,000 contract (about $5,000 a month), plus compute on your own AWS bill. Real Enterprise prices are negotiated with sales.
Replit: Replit plans (Core $20, Pro from $100) turn into monthly credits for Agent work and hosting, then pay-as-you-go. A Reserved VM has a fixed monthly price per size and bills whether busy or idle; Autoscale charges only while it serves requests.
Replit: 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
No Ona scenario fits as published, because a new customer can only buy Enterprise through sales, and with no published concurrency limit the table assumes 3 environments at once, so 50 agents, 300 user sandboxes and 1,000 jobs show as too big. Replit is not a fit either, because one Reserved VM is one published app that runs all month, its concurrency limit is not published, and the 50-agent fleet has no documented Docker or persistent disk. On bochka the 1,000-job burst is queued above 90 starts a minute and needs more starts per day than the $2,000 plan allows.
| Scenario | Ona | Replit | 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 Ona when
your engineers want a governed cloud IDE shared with a Codex agent, inside your own AWS or GCP account or with a GPU.
- A full cloud IDE for your team. Useful if engineers work beside their agents: Ona has browser, VS Code and JetBrains IDEs with Dev Containers and prebuilds.
- Runs in your own cloud. Useful if environments must stay inside your own AWS or GCP account: Ona's Enterprise runners provision them there.
- GPU environments. Useful if agents need a GPU: Ona's Enterprise runners can use GPU instance types, such as an A10G VM with 16 vCPU.
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 and 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 Postgres and storage.
- Hosting that costs nothing when idle. Useful for web apps with uneven traffic: Autoscale wakes on the first request and costs nothing while idle.
- Sign up and start today. Useful if you cannot wait for a sales call: Replit has a free plan and self-serve Core and Pro plans.
Where bochka fits
Ona is a dev environment platform for engineers, and Replit is an app builder for people, so neither is built for programs that start machines for agents. If what you are really running is agents your own code starts, steers and stops, bochka gives each one a full VM by API on every plan, with Docker, a desktop and its disk kept between runs.
Machines your code starts on any plan
Ona's SDK to create environments is Enterprise only, through sales. Replit's MCP server drives Replit Agent one app at a time, and each always-on machine is a published Reserved VM. bochka has an API on every plan.
Root, Docker and /dev/kvm
Ona gives Docker in a Dev Container but documents no /dev/kvm, and Replit's Nix setup documents no Docker or systemd. An agent that boots an Android emulator or runs docker compose gets stuck on one or both.
Work kept and forked
On Ona Enterprise a stopped disk stays on your cloud bill, Core archives it after 3 days, and there is no copy. Replit apps should not rely on their filesystem. bochka snapshots every minute, stops for free and forks running sandboxes.
Use bochka when your own code starts and drives the agents: full VMs with Docker and /dev/kvm, a desktop and open ports, an API on every plan, and machines that keep their work and fork while running. Compare it one to one: bochka vs Ona and bochka vs Replit.
Questions people ask
Is Ona cheaper than Replit?
In the scenarios we priced, Replit comes out lower, mostly because Ona is sold as an Enterprise contract: one coding agent on workdays is $122 on Replit against $5,030 on Ona, and 50 agents in parallel are $1,330 against $6,521. Neither fits those scenarios as published. On bochka the same two come to $20 and $317 a month.
Which is faster, Ona or Replit?
We cannot say. Neither Ona nor Replit is in the public benchmark we use. bochka did 26.69 Node.js build-and-test runs per second at 4 vCPU / 8 GB in that benchmark.
Can Ona or Replit run Docker?
Ona gives you Docker and root inside each Dev Container, but documents no nested virtualization. Replit sets up environments with Nix packages and does not describe running Docker inside a workspace or a published app. Every bochka sandbox has root, systemd, Docker and /dev/kvm.
Can I drive them from my own code?
Ona has a Python, TypeScript and Go SDK, but only on the Enterprise plan. Replit's MCP server lets an MCP client create, update and publish apps through Replit Agent, with no API to start many machines. bochka has an API, SDK and CLI on every plan.
Is Ona the same as Gitpod?
Yes. Gitpod renamed itself Ona in 2025 and is now part of OpenAI. New Core subscriptions are no longer available, so new customers go through sales, while Replit and bochka both have self-serve plans.
Where does my data run?
New Ona customers run Enterprise runners in their own AWS or GCP account. Replit hosts data mainly on Google Cloud in the United States, and on Core and up you can publish apps on five continents. bochka runs only in the EU (Germany, Finland and France).
Try bochka
Install the CLI, then run bochka new.
Product preview