GitHub Codespaces vs Ona
GitHub Codespaces opens a ready Linux dev container from any GitHub repository, self-serve, and stops it after 12 hours at most. Ona, formerly Gitpod and now part of OpenAI, runs governed dev environments with its Codex Agent in your own AWS or GCP account, sold only through sales to new customers.
The companies and products
GitHub Codespaces
GitHub Codespaces is GitHub's cloud development environment: a ready-to-code Linux machine for a repository, opened in the browser, VS Code or the GitHub CLI.
Codespaces is a different kind of product from bochka: a dev environment for people working on a GitHub repository, not a sandbox API for agents. Each codespace is a Docker container built from the repo's dev container config, running on its own newly built VM on Azure, with 2 to 32 cores. It is built for developers and teams who want every contributor to start from the same setup, with prebuilds, port forwarding and GitHub billing.
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.
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. “274th cheapest of 367” means 273 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 | GitHub Codespaces: price rank | Ona: price rank | bochka: price rank |
|---|---|---|---|
| Software factory 100 at once · 4 vCPU / 8 GB · 2,200 sessions of 8 h a month Both give an agent Docker in a dev container but document no /dev/kvm; Codespaces also stops at 12 hours, while bochka is a full VM that keeps running. | 274th of 367, with limits $4,618 a month | 324th of 367, with limits $7,315 a month | 3rd cheapest of 367 $634 a month |
| Always-on AI employees 50 machines 24/7 · 2 vCPU / 4 GB Ona can keep an environment up if auto-stop is set to Never, while every codespace stops after 12 hours at most; bochka runs until you stop it. | 309th of 366, with limits $6,970 a month | 83rd of 366, with limits $8,504 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 | 288th of 345, with limits $619 a month | 335th of 345, with limits $5,320 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 own users: GitHub does not publish how many codespaces can run at once, and Ona's per-user policy defaults to 10 running environments. | 281st of 361, with limits $1,964 a month | 330th of 361, with limits $5,988 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 | 282nd of 360, with limits $9,489 a month | 283rd of 360, with limits $9,773 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 | 295th of 364, with limits $1,519 a month | 334th of 364, with limits $5,768 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 Neither can copy a warm machine: both start each run from a dev container config or a prebuild, while bochka forks a running sandbox. | 314th of 377, with limits $909 a month | 365th of 377, with limits $5,461 a month | 4th cheapest of 377 $86 a month |
| 24/7 dev boxes 1 machine 24/7 · 4 vCPU / 8 GB Both are full cloud IDEs with dev containers and prebuilds; Codespaces is self-serve but stops at 12 hours, and Ona needs an Enterprise contract for new customers. | 130th of 368, with limits $270 a month | 368th of 368, with limits $5,140 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 Neither has a graphical desktop for an agent to drive, while bochka streams a 60fps desktop with Chromium for computer use. | 267th of 369, with limits $1,367 a month | 353rd of 369, with limits $5,691 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 | 275th of 367, with limits $678 a month | 150th of 367, with limits $5,346 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 | 310th of 346, with limits $922 a month | 146th of 346, with limits $5,468 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 | 280th of 338, with limits $18,637 a month | 261st of 338, with limits $14,360 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 On both, every copy is built again from a config or prebuild; bochka can fork one prepared machine into many while it runs. | 267th of 360, with limits $445 a month | 93rd of 360, with limits $5,228 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 | GitHub Codespaces | Ona | bochka |
|---|---|---|---|
| Isolation | A Docker container on its own newly built VM, with its own virtual network | An isolated VM with dedicated compute, built from a Dev Container config | Every sandbox is a full VM with its own kernel |
| How long it runs | Stops after 30 idle minutes by default (up to 240) and after 12 hours at most, even while in use | Stops after 30 idle minutes by default; background processes do not count; auto-stop can be set to Never | Runs until you stop it; no session cap on paid plans |
| Docker and nested virtualization | Docker and sudo inside the dev container; /dev/kvm is not documented | Docker and root inside the Dev Container; nested virtualization is not documented | Docker, root, systemd and /dev/kvm on every machine |
| Desktop and computer use | VS Code in the browser or on your machine, JupyterLab and a terminal; no graphical desktop | Browser IDE plus VS Code and JetBrains over SSH; no graphical desktop | 60fps desktop and Chromium, computer use and browser control, embeddable stream |
| Files after a stop | Files are kept and storage is billed; stopped codespaces are deleted after 30 days by default | Disk persists; in your own cloud its storage is billed while stopped; Core archives after 3 days | Snapshots every minute and on stop; a stopped sandbox keeps its disk and costs nothing |
| Fork | No copy or snapshot endpoint; new codespaces start from a repo, branch, pull request or prebuild | No environment copy; you can create a project from an environment's config | Fork a running sandbox into copies with its files; named snapshots as templates |
| Starting point | Dev container config in the repository, with prebuilds built by GitHub Actions | Dev Container config per repo, with prebuilds that snapshot the filesystem on a schedule | Named snapshots (templates), shareable by code; no Dockerfile builds |
| Buying it | Self-serve on any GitHub account; personal Free accounts get 120 core-hours a month | New Core subscriptions are closed; new customers buy Enterprise through sales | Self-serve monthly plans from $20, all of it usage credit |
| Driving it from code | REST API and GitHub CLI to create, start, stop and delete; commands run over SSH | Python, TypeScript and Go SDK on the Enterprise plan only | API and SDK to create, fork, stop and run commands, on every plan |
| Coding agents | GitHub Copilot as a VS Code extension; other agents you install yourself | Codex Agent started from chat, a Linear issue or an automation; Claude Code you run yourself | Claude Code, Codex, OpenCode and more preinstalled, with a prompt, steer and events API |
| Keeping keys out of the sandbox | Secrets are copied into the codespace as environment variables | Secrets are injected as environment variables or files | AI credentials proxy for model providers and any HTTPS API you register; switch a credential to another account when credits run out |
| Reaching the sandbox | A URL per forwarded port, private, organization or public; SSH; no public IP | HTTPS URL per port for you, your organization or everyone; SSH; no raw TCP or public IP documented | HTTPS URLs for up to 50 ports, token-protected; raw TCP; dedicated IPv6 or IPv4 |
| GPUs | None | GPU instance types on Enterprise runners, such as one NVIDIA A10G with 16 vCPU and 64 GB | None |
| Regions and deployment | GitHub's cloud in US East, US West, Europe West and Southeast Asia | Enterprise runners in your own AWS or GCP account, in many regions | EU only: Germany, Finland, France |
Every feature Battleships tracks (43)
| Feature | GitHub Codespaces | Ona | bochka |
|---|---|---|---|
| Full VM (own kernel) | Yes | Yes | Yes |
| Docker inside | Yes | Yes | Yes |
| Nested virtualization | No | No | Yes |
| Root | Yes | Yes | Yes |
| Systemd | Not published | Not published | Yes |
| Desktop GUI | No | No | Yes |
| Browser | No | Yes | Yes |
| Computer-use API | No | No | Yes |
| SSH | Yes | Yes | Yes |
| Persistent disk | Yes | Yes | Yes |
| Pause/resume | Yes | Yes | Yes |
| Automatic snapshots | No | No | Yes |
| Fork/clone | No | No | Yes |
| Live fork (no pause) | No | No | Yes |
| Memory fork | No | No | No |
| Custom image (Docker or snapshot) | Yes | Yes | Yes |
| ≥24 h sessions | No | Yes | Yes |
| Idle auto-stop | Yes | Yes | No |
| Wake on request | No | No | No |
| HTTPS preview URLs | Yes | Yes | Yes |
| Raw TCP inbound | No | No | Yes |
| Public IPv4 | No | No | No |
| Egress allowlist | No | No | No |
| Secret proxy | No | No | Yes |
| Secret proxy for any API | No | No | Yes |
| Preinstalled agents | No | Yes | Yes |
| Agent harness API | No | Yes | Yes |
| MCP server | No | No | No |
| GPU | No | Yes | No |
| Windows | No | No | No |
| Arm64 | No | No | No |
| Self-hosting | No | No | No |
| BYOC | No | Yes | No |
| Open source | No | No | No |
| Scoped API keys | Not published | Not published | Yes |
| Spend limits | Yes | Yes | Yes |
| Usage per sandbox (API) | No | No | Yes |
| Audit logs | Yes | No | 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 CPU measurement for GitHub Codespaces or for Ona: neither was in the public benchmark runs we use. 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 (Zen 5) hosts.
Node.js build-and-test loop at 4 vCPU / 8 GB, higher is better. Measured with the open hpc-sandbox-benchmarks suite. GitHub Codespaces and Ona 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 | GitHub Codespaces, a month | Ona, 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 | $51 · Personal account: GitHub Free | $5,030 · Enterprise (AWS Marketplace 12-month contract) · with limits | $20 · $20/mo |
| One agent that never stops 4 vCPU / 8 GB, 50 GB disk, running 24/7 all month | $270 · Personal account: GitHub Free · with limits | $5,140 · Enterprise (AWS Marketplace 12-month contract) · 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 | $3,019 · Personal account: GitHub Free | $6,521 · Enterprise (AWS Marketplace 12-month contract) · 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 | $850 · Personal account: GitHub Free · with limits | $5,432 · Enterprise (AWS Marketplace 12-month contract) · 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 | $1,889 · Personal account: GitHub Free · with limits | $5,955 · Enterprise (AWS Marketplace 12-month contract) · with limits | $2,000 · $2000/mo · with limits |
GitHub Codespaces: Codespaces bills $0.09 per core-hour while a codespace is active, plus $0.07 per GB-month for storage while it exists, stopped too. Personal accounts get a free monthly quota; organizations do not.
Ona: New Core subscriptions are closed, so Ona is priced here on its Enterprise listing on AWS Marketplace: a 12-month, $60,000 contract, plus compute on your own AWS bill. Real Enterprise prices are negotiated with sales.
Ona: 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
Every codespace stops after 12 hours at most, so the always-on price assumes a script that restarts it, and GitHub does not publish how many codespaces can run at once, so 300 user sandboxes and 1,000 short jobs are not confirmed. No Ona scenario fits as published, because new customers can only buy Enterprise through sales, and with no published Enterprise concurrency the table assumes 3 environments at once. On bochka the limit is a sandbox count (100 to 2,000 by plan) plus starts per minute, so the 1,000-job burst gets queued and needs more starts per day than the $2,000 plan allows.
| Scenario | GitHub Codespaces | Ona | bochka |
|---|---|---|---|
| One coding agent, workdays | None that bite |
| 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 GitHub Codespaces when
your developers want a ready VS Code environment for a GitHub repository, self-serve, in the US, EU or Asia, and sessions under 12 hours are fine.
- Built into GitHub. Useful if your team lives on GitHub: open a ready codespace from any repo, branch or pull request.
- Self-serve, with free hours. Useful for small teams and personal work: no sales call, and a GitHub Free account includes 120 core-hours a month.
- Regions in the US and Asia. Useful if your developers sit outside Europe: codespaces run in US East, US West, Europe West and Southeast Asia.
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, and you are ready to sign an Enterprise contract.
- Runs in your own cloud. Useful if environments must stay inside your own AWS or GCP account: Ona's Enterprise runners provision them there.
- No 12-hour stop. Useful for long work: an Ona environment has no hard session cap, and auto-stop can be set to Never.
- GPUs and a managed agent. Useful if agents need a GPU or a managed Codex Agent: Ona runners can use A10G VMs and start Codex from Linear.
Where bochka fits
Codespaces and Ona are both cloud IDEs for engineers who open a repo and code. If what you are really running is agents that your own code starts and watches, bochka gives each one a full VM it keeps, with an API on every plan.
Machines that keep running and keep their work
A codespace stops at 12 hours even while in use, and an Ona environment stops after 30 idle minutes unless set to Never. bochka runs until you stop it, saves the disk every minute and keeps stopped sandboxes free.
Fork a warm machine instead of rebuilding
Neither Codespaces nor Ona can copy an environment, so every parallel attempt starts again from a config or a prebuild. bochka forks a running sandbox into copies with its files.
A full VM with /dev/kvm, a desktop and open ports
Neither documents /dev/kvm, a graphical desktop or raw TCP, so emulators, computer use and game servers do not fit. Every bochka machine has all three, plus HTTPS on up to 50 ports.
Use bochka when your code starts and drives the agents: full VMs with /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 GitHub Codespaces and bochka vs Ona.
Questions people ask
Is GitHub Codespaces cheaper than Ona?
In every scenario we priced, yes: one coding agent on workdays is $51 a month on Codespaces against $5,030 on Ona's Enterprise listing, and 50 agents in parallel are $3,019 against $6,521. On bochka those come to $20 and $317. Ona's real Enterprise price is a sales quote, so yours may differ.
Which is faster, Codespaces or Ona?
We have no comparable CPU measurement for either, since neither was in the public benchmark runs we use. bochka did 26.69 Node.js build-and-test runs per second at 4 vCPU / 8 GB.
Can I run an agent 24/7 on Codespaces or Ona?
Not on Codespaces without restarts: a codespace has a maximum lifetime of 12 hours, even while in use. On Ona you can set auto-stop to Never, because there is no hard session cap. A bochka sandbox runs until you stop it, with no session cap on paid plans.
Can Codespaces and Ona run Docker?
Yes, both run Docker inside the dev container, with sudo or root. Neither documents /dev/kvm, so Android emulators and microVMs are not a supported setup. Every bochka machine has Docker, systemd and /dev/kvm.
Is Ona the same as Gitpod?
Yes. Gitpod renamed itself Ona in 2025 and moved toward background coding agents, and Ona is now part of OpenAI. New Core subscriptions are no longer available, so new customers go through sales.
Can I run Claude Code on Codespaces or Ona?
On both you can install Claude Code yourself, with your API key arriving as an environment variable. Codespaces ships Copilot as an extension and Ona's managed agent is Codex. bochka ships Claude Code, Codex, OpenCode and others preinstalled, with keys kept outside the sandbox.
Try bochka
Install the CLI, then run bochka new.
Product preview
More comparisons
- bochka vs GitHub Codespaces
- bochka vs Ona
- E2B vs GitHub Codespaces
- Daytona vs GitHub Codespaces
- Modal vs GitHub Codespaces
- Vercel Sandbox vs GitHub Codespaces
- Cloudflare Sandbox vs GitHub Codespaces
- Blaxel vs GitHub Codespaces
- Runloop vs GitHub Codespaces
- Tensorlake vs GitHub Codespaces
- Morph Cloud vs GitHub Codespaces
- CodeSandbox SDK vs GitHub Codespaces