bochka vs GitHub Codespaces

GitHub Codespaces is a cloud dev environment: a Linux dev container on its own VM, opened from a repository in VS Code or the browser, that stops after at most 12 hours. bochka is a sandbox you drive from code: full VMs with /dev/kvm, a desktop and coding agents built in, that run until you stop them and fork while running.

Where bochka stands out

Machines that keep running and keep their work

A bochka sandbox runs until you stop it, with no session cap on paid plans. Its disk is snapshotted every minute and on stop, a stopped sandbox costs nothing, and you can fork a running one into copies. A codespace stops after 12 hours at most, even while in use, and after 30 idle minutes by default; there is no way to copy one.

A full VM with /dev/kvm and a desktop

Every bochka machine has root, systemd, Docker and /dev/kvm, plus a 60fps desktop with Chromium for computer use, HTTPS on up to 50 ports and raw TCP. A codespace is a dev container with Docker and an editor, but GitHub documents no /dev/kvm, no graphical desktop and no public address.

Coding agents you drive from outside

bochka ships Claude Code, Codex, OpenCode and other agents in each sandbox, and you drive them from outside with a prompt, steer and events API. Its credentials proxy keeps real AI keys out of the sandbox and can switch to another account when one runs out of credits. Codespaces gives you Copilot as an editor extension and copies secrets in as environment variables.

The companies and products

bochka

bochka.xyz 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.

Isolation: Full VM per sandbox, own kernel
Hardware: Dedicated AMD Ryzen 9 9950X (Zen 5) hosts
Regions: EU: Germany, Finland, France
Plans: From $20 a month, all of it usage credit, 7-day trial

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.

Isolation: A Docker container on its own newly built VM, with its own virtual network
Operating system: Linux only; Windows and macOS are not supported for the remote container
Machine sizes: 2, 4, 8, 16 or 32 cores, with 4 GB of memory per core
Lifetime: Stops after 30 idle minutes by default (5 to 240), and after 12 hours at most even while in use
Regions: US East, US West, Europe West and Southeast Asia
Free usage: Personal Free accounts get 120 core-hours and 15 GB-month a month, Pro 180 and 20; organizations get no free quota
Compliance: GitHub Enterprise Cloud lists SOC 1, SOC 2 and SOC 3 reports and ISO 27001

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. “3rd cheapest of 367” means 2 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	bochka: price rank	GitHub Codespaces: price rank
Software factory 100 at once · 4 vCPU / 8 GB · 2,200 sessions of 8 h a month An agent on Codespaces gets Docker in a dev container, but no documented /dev/kvm and a hard stop at 12 hours, so long build-and-test loops must be restarted.	3rd cheapest of 367 $634 a month	274th of 367, with limits $4,618 a month
Always-on AI employees 50 machines 24/7 · 2 vCPU / 4 GB An always-on assistant does not fit Codespaces well: every codespace stops after 12 hours at most, and after 30 idle minutes by default if nothing prints to a terminal.	5th cheapest of 366 $657 a month	309th of 366, with limits $6,970 a month
Code interpreter bursts 100 at once · 1 vCPU / 2 GB · 200,000 sessions of 1 min a month Neither is built for one-minute runs; each codespace builds a dev container on a new VM, which prebuilds speed up but do not remove.	186th of 345, with limits $2,000 a month	288th of 345, with limits $619 a month
Sandboxes for your users 300 at once · 2 vCPU / 4 GB · 30,000 sessions of 23 min a month Codespaces are created for GitHub users on a repository, and GitHub does not publish how many can run at once, so handing 300 machines to your own users is a compromise.	Cheapest of 361 $209 a month	281st of 361, with limits $1,964 a month
RL rollouts 1,000 at once · 2 vCPU / 4 GB · 1,000,000 sessions of 3 min a month	34th of 360, with limits $2,000 a month	282nd of 360, with limits $9,489 a month
Agent evals 250 at once · 4 vCPU / 8 GB · 15,000 sessions of 20 min a month	10th cheapest of 364 $200 a month	295th of 364, with limits $1,519 a month
CI runners 40 at once · 8 vCPU / 16 GB · 6,000 sessions of 12 min a month Codespaces has no fork and no snapshot API, so each run starts from a repo or a prebuild built by GitHub Actions instead of a copy of a warm machine.	4th cheapest of 377 $86 a month	314th of 377, with limits $909 a month
24/7 dev boxes 1 machine 24/7 · 4 vCPU / 8 GB Codespaces is a polished VS Code environment per repo but only a compromise for a 24/7 box, since it stops after 12 hours at most, while bochka is a full VM that keeps running.	18th cheapest of 368 $26 a month	130th of 368, with limits $270 a month
Computer-use agents 50 at once · 4 vCPU / 8 GB · 20,000 sessions of 15 min a month A codespace has an editor and a terminal but no graphical desktop, while bochka streams a 60fps desktop with Chromium for computer use.	6th cheapest of 369 $200 a month	267th of 369, with limits $1,367 a month
Browser-use agents 50 at once · 2 vCPU / 4 GB · 30,000 sessions of 10 min a month	7th cheapest of 367 $200 a month	275th of 367, with limits $678 a month
Scraping & bots (startup scale) 50 at once · 1 vCPU / 2 GB · 100,000 sessions of 3 min a month	6th cheapest of 346 $90 a month	310th of 346, with limits $922 a month
Mass scraping & bots (undetectable) 1,000 at once · 1 vCPU / 2 GB · 3,000,000 sessions of 2 min a month	71st of 338, with limits $1,800 a month	280th of 338, with limits $18,637 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; on Codespaces every copy is created again from the repository.	2nd cheapest of 360 $200 a month	267th of 360, with limits $445 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
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

Key features

Feature	bochka	GitHub Codespaces
Isolation	Every sandbox is a full VM with its own kernel	A Docker container on its own newly built VM, with its own virtual network
How long it runs	Runs until you stop it; no session cap on paid plans	Stops after 30 idle minutes by default (up to 240) and after 12 hours at most, even while in use
Docker and nested virtualization	Docker, root, systemd and /dev/kvm on every machine	Docker and sudo inside the dev container; /dev/kvm and nested virtualization are not documented
Desktop and computer use	60fps desktop and Chromium, computer use and browser control, embeddable stream	VS Code in the browser or on your machine, JupyterLab and a terminal; no graphical desktop
Files after a stop	Snapshots every minute and on stop; a stopped sandbox keeps its disk and costs nothing	Saved files are kept and storage is billed; stopped codespaces are deleted after 30 days by default
Fork and snapshots	Fork a running sandbox into copies with its files; named snapshots as templates	No copy or snapshot endpoint; new codespaces start from a repo, branch, pull request or prebuild
Starting point	Named snapshots (templates), shareable by code; no Dockerfile builds	Dev container config in the repository, with prebuilds built by GitHub Actions
Driving it from code	API and SDK to create, fork, stop and run commands, on every plan	REST API and GitHub CLI to create, start, stop and delete; commands run over SSH
Coding agents	Claude Code, Codex, OpenCode and more preinstalled, with a prompt, steer and events API	GitHub Copilot as a VS Code extension; other agents you install and run yourself
Keeping keys out of the sandbox	AI credentials proxy for model providers and any HTTPS API you register; switch a credential to another account when credits run out	Secrets are copied into the codespace as environment variables
Reaching the sandbox	HTTPS URLs for up to 50 ports, token-protected; raw TCP; dedicated IPv6 or IPv4	A URL per forwarded port, private, organization or public; SSH and CLI tunnels to your own machine; no public IP
Outbound internet	Open internet on every plan; no provider-side allowlist	Open internet; GitHub says there is no way to restrict it
Regions	EU only: Germany, Finland, France	US East, US West, Europe West and Southeast Asia
Compliance and transparency	SOC 2 is in progress. We're open about where we stand: live status and data retention policy.	SOC 2

Every feature Battleships tracks (43)

Feature	bochka	GitHub Codespaces
Full VM (own kernel)	Yes	Yes
Docker inside	Yes	Yes
Nested virtualization	Yes	No
Root	Yes	Yes
Systemd	Yes	Not published
Desktop GUI	Yes	No
Browser	Yes	No
Computer-use API	Yes	No
SSH	Yes	Yes
Persistent disk	Yes	Yes
Pause/resume	Yes	Yes
Automatic snapshots	Yes	No
Fork/clone	Yes	No
Live fork (no pause)	Yes	No
Memory fork	No	No
Custom image (Docker or snapshot)	Yes	Yes
≥24 h sessions	Yes	No
Idle auto-stop	No	Yes
Wake on request	No	No
HTTPS preview URLs	Yes	Yes
Raw TCP inbound	Yes	No
Public IPv4	No	No
Egress allowlist	No	No
Secret proxy	Yes	No
Secret proxy for any API	Yes	No
Preinstalled agents	Yes	No
Agent harness API	Yes	No
MCP server	No	No
GPU	No	No
Windows	No	No
Arm64	No	No
Self-hosting	No	No
BYOC	No	No
Open source	No	No
Scoped API keys	Yes	Not published
Spend limits	Yes	Yes
Usage per sandbox (API)	Yes	No
Audit logs	No	Yes
SSO	No	Yes
SOC 2	No	Yes
HIPAA	No	No
EU data residency	Yes	Yes
Zero data retention	Yes	Not published

Performance

bochka26.69 runs/s

GitHub CodespacesNot measured

There is no comparable measurement for GitHub Codespaces: it was not 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 has 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	bochka, a month	GitHub Codespaces, 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	$51 · Personal account: GitHub Free
One agent that never stops 4 vCPU / 8 GB, 50 GB disk, running 24/7 all month	$26 · $20/mo	$270 · Personal account: GitHub Free · 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	$3,019 · Personal account: GitHub Free
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	$850 · Personal account: GitHub Free · with limits
1,000 short jobs at once 2 vCPU / 4 GB, 1,000 at once, 3 minutes each, 200,000 jobs a month	$2,000 · $2000/mo · with limits	$1,889 · Personal account: GitHub Free · with limits

bochka: 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.

GitHub Codespaces: Codespaces bills $0.09 per core-hour for the whole time a codespace is active, used or not, until it is stopped or times out, plus $0.07 per GB-month for storage while it exists, stopped too. There is no 4-core machine with 8 GB, so a 4 vCPU / 8 GB job is priced on the 4-core 16 GB machine; personal accounts get a free monthly quota and organizations do not.

Limits in those scenarios

Every codespace stops after 12 hours at most and after 30 idle minutes by default, so it does not fit the always-on scenario: its price there assumes a script that restarts it, and running processes end at each stop. GitHub says there are limits on how many codespaces you can create and run at once but does not publish them, so 300 user sandboxes and 1,000 short jobs show as not confirmed, and 50 agents are likely but not certain. 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	bochka	GitHub Codespaces
One coding agent, workdays	None that bite	None that bite
One agent that never stops	None that bite	Personal account: GitHub Free: sessions capped at 12 h
50 agents in parallel	None that bite	how many machines can run at once: limit not published, probably fine at 50 (the typical published limit is 50)
Sandboxes for your users	None that bite	not confirmed: how many machines can run at once (you need 300; the typical published limit is 50)
1,000 short jobs at once	max 2,400 starts/day (needs ~6,667) max 600 starts/hour (needs ~1,000) bursts above 90 starts/min are queued (a burst of 333 takes ~4 min to start)	not confirmed: how many machines can run at once (you need 1,000; the typical published limit is 50)

Which one should you use?

Use GitHub Codespaces when

your developers want a ready VS Code environment for a GitHub repository, opened from a branch or pull request, in the US, EU or Asia.

Built into GitHub. Useful if your team lives on GitHub: open a codespace from any repo, branch or pull request, with the dev container already set up.
Free hours for personal accounts. Useful for occasional personal work: a GitHub Free account includes 120 core-hours and 15 GB-month of storage each month.
Regions in the US and Asia. Useful if your developers sit in the US or Asia: codespaces run in US East, US West, Europe West and Southeast Asia.

Use bochka when

your code starts and drives agents that work for hours or days: full VMs with /dev/kvm, a desktop and open ports, built-in coding agents with keys kept outside, and machines that keep their work and fork while running.

Machines that keep running and keep their work. An agent left on a long task on Codespaces is stopped at 12 hours and its processes end, so you need a script that restarts it and resumes the job. Every parallel attempt starts again from the repository.
A full VM with /dev/kvm and a desktop. Android emulators and microVMs need /dev/kvm, computer-use agents need a screen, and other services need raw TCP. On Codespaces an agent doing that work has none of the three.
Coding agents you drive from outside. On Codespaces you write the code that starts, prompts and watches each agent over SSH, and an API key in an environment variable can be read by any code the agent runs.

Questions people ask

Is bochka cheaper than GitHub Codespaces?

In most scenarios we priced, yes: one coding agent on workdays is $20 a month on bochka against $51, and one agent running all month is $26 against $270, though Codespaces only gets there with a restart every 12 hours. 50 agents in parallel come to $317 against $3,019, and 300 user sandboxes to $200 against $850. For 1,000 short jobs at once, bochka lands at $2,000 and Codespaces at $1,889, and neither fits without higher limits.

Can I run an AI agent in GitHub Codespaces 24/7?

Not without restarts. A codespace has a maximum lifetime of 12 hours, even while you use it, and stops after 30 idle minutes by default if nothing types or prints to a terminal. A bochka sandbox runs until you stop it, with no session cap on paid plans.

Can I run Claude Code in GitHub Codespaces?

Yes, you can install it yourself and run it in the terminal, with your API key as a Codespaces secret, which arrives as an environment variable. bochka ships Claude Code, Codex, OpenCode and others preinstalled, keeps the real keys outside the sandbox, and gives you one API to prompt, steer and watch them.

Does Codespaces support Docker and nested virtualization?

Docker works inside a codespace through dev container features, and you have sudo. GitHub does not document /dev/kvm, so Android emulators and microVMs that need it are not a supported setup. Every bochka machine has Docker, systemd and /dev/kvm.

Where does my data run?

bochka runs only in the EU (Germany, Finland and France), with EU data residency and a zero data retention option. Codespaces runs in US East, US West, Europe West and Southeast Asia, and you pick the region when you create one.

Is bochka SOC 2 compliant?

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

Start a sandbox

Install the CLI, then run bochka new.

Product preview