exe.dev vs GitHub Codespaces
exe.dev rents KVM virtual machines with root, systemd and Docker that run until you stop them, reached over SSH and an HTTPS proxy. GitHub Codespaces opens a ready VS Code dev container for a GitHub repository, and every codespace stops after 12 hours at most.
The companies and products
exe.dev
exe.dev, made by Bold Software, Inc., rents Linux VMs for developers and AI agents that you reach over SSH and HTTPS.
You reserve a pool of vCPUs and memory, and your VMs share it; you can also start standalone VMs billed by the second. Each VM is KVM-isolated (they use Cloud Hypervisor), boots from a container image in about two seconds, and has root, systemd and Docker. It comes with Claude Code, Codex, Pi and exe.dev's own Shelley agent, and is aimed at developers who want a persistent dev box or a sandbox for their agents.
- Company
- Bold Software, Inc.
- Preinstalled agents
- claude, codex, pi and the Shelley web agent
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.
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. “15th cheapest of 366” means 14 of the other 365 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 | exe.dev: price rank | GitHub Codespaces: price rank | bochka: price rank |
|---|---|---|---|
| Software factory 100 at once · 4 vCPU / 8 GB · 2,200 sessions of 8 h a month Both can run Docker for build-and-test loops, but neither has snapshots or a desktop for checking UIs, and Codespaces stops at 12 hours; bochka fits this fully. | 253rd of 367, with limits $3,701 a month | 274th of 367, with limits $4,618 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 fits exe.dev well, since its VMs have no time limit, while a codespace stops after 12 hours at most; exe.dev ranks 15th here and bochka ranks 5th. | 15th cheapest of 366 $3,833 a month | 309th of 366, with limits $6,970 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 | 235th of 345, with limits $175 a month | 288th of 345, with limits $619 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 fits 300 sandboxes at once for your own users: exe.dev Personal stops at 50 VMs, and GitHub does not publish its limit. | 257th of 361, with limits $1,226 a month | 281st of 361, with limits $1,964 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 | 265th of 360, with limits $5,250 a month | 282nd of 360, with limits $9,489 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 | 283rd of 364, with limits $1,050 a month | 295th of 364, with limits $1,519 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 exe.dev pools bill whether jobs run or not, though standalone VMs bill per second; Codespaces starts each run from a repo or a prebuild instead of a copy of a warm machine. | 288th of 377, with limits $504 a month | 314th of 377, with limits $909 a month | 4th cheapest of 377 $86 a month |
| 24/7 dev boxes 1 machine 24/7 · 4 vCPU / 8 GB Both work as a cloud dev box, but exe.dev VMs keep running all month while a codespace must be restarted every 12 hours; bochka ranks 18th, just ahead of exe.dev at 25th. | 25th cheapest of 368 $35 a month | 130th of 368, with limits $270 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 computer-use agents: exe.dev VMs are headless and a codespace gives you an editor and a terminal, while bochka streams a 60fps desktop. | 240th of 369, with limits $1,055 a month | 267th of 369, with limits $1,367 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 On both you install and run a headless browser yourself; bochka gives agents a visible Chromium with browser control. | 130th of 367, with limits $530 a month | 275th of 367, with limits $678 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 | 124th of 346, with limits $278 a month | 310th of 346, with limits $922 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 | 166th of 338, with limits $5,490 a month | 280th of 338, with limits $18,637 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 exe.dev can copy a VM with cp, while every codespace is created again from the repository; bochka forks one prepared machine into many while it runs. | 60th of 360, with limits $263 a month | 267th of 360, with limits $445 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 | exe.dev | GitHub Codespaces | bochka |
|---|---|---|---|
| What it is | Linux VMs for developers and AI agents, reached over SSH and HTTPS | A cloud dev environment for a GitHub repository, opened in VS Code, the browser or the CLI | A sandbox you drive from code: full VMs for agents, with an API and SDKs |
| Isolation | KVM VM with Cloud Hypervisor; you can't choose the kernel | A Docker container on its own newly built VM, with its own virtual network | Full VM with its own kernel on dedicated AMD Ryzen 9 9950X hosts |
| How long it runs | No cap; VMs run until you stop them | Stops after 30 idle minutes by default (up to 240) and after 12 hours at most, even while in use | Runs until you stop it; no session cap on paid plans |
| Docker and nested virtualization | Root, systemd and Docker; nested virtualization on Enterprise only | Docker and sudo inside the dev container; /dev/kvm is not documented | Docker, root, systemd and /dev/kvm on every plan |
| Desktop and computer use | Headless; no desktop or screen streaming | VS Code in the browser or on your machine, JupyterLab and a terminal; no graphical desktop | 60fps desktop and Chromium, computer use, browser control, embeddable stream |
| Saved state | Disk persists and is streamed to a second server; no snapshots | Files kept after a stop; stopped codespaces are deleted after 30 days by default | Snapshots every minute while running and on stop; a stopped sandbox keeps its disk and costs nothing |
| Copies and forks | cp copies a VM's disk and config into a new VM | No copy or snapshot endpoint; new codespaces start from a repo, branch, pull request or prebuild | Fork a running sandbox; named snapshots as templates, shareable by code |
| Starting point | Boot from your own Docker image | Dev container config in the repository, with prebuilds built by GitHub Actions | Templates from named snapshots; no Dockerfile or OCI images |
| Coding agents | Claude Code, Codex, Pi and Shelley preinstalled; only Shelley takes prompts through the API | GitHub Copilot as a VS Code extension; other agents you install and run yourself | Claude Code, Codex, pi, OpenCode and more preinstalled, with a prompt, steer and events API |
| Secrets | Integrations inject secrets at the network edge for any HTTP host | Secrets are copied into the codespace as environment variables | Credentials proxy for model providers and any HTTPS API you register; switch accounts when one runs out of credits |
| Inbound traffic | HTTPS proxy for ports 3000 to 9999, one of them public; SSH; no public IP or raw TCP | A URL per forwarded port, private, organization or public; SSH; no public IP | HTTPS URLs for up to 50 ports, token-protected by default; raw TCP; dedicated IPv6 or IPv4 |
| Regions | 9 regions in the US, Europe, Asia and Australia | US East, US West, Europe West and Southeast Asia | EU only: Germany, Finland, France |
| Teams and access | Work plan covers a whole team with SSO and roles; MCP server for controlling VMs | Opens from any repo, branch or pull request; billing sits on your GitHub account | Org seats, scoped API keys, spend limits, usage per sandbox |
| Free usage | No free compute tier | Personal Free accounts get 120 core-hours and 15 GB-month a month; organizations get none | Monthly plan from $20, all of it usage credit |
Every feature Battleships tracks (43)
| Feature | exe.dev | GitHub Codespaces | bochka |
|---|---|---|---|
| Full VM (own kernel) | Yes | Yes | Yes |
| Docker inside | Yes | Yes | Yes |
| Nested virtualization | Yes | No | Yes |
| Root | Yes | Yes | Yes |
| Systemd | Yes | Not published | Yes |
| Desktop GUI | No | No | Yes |
| Browser | Yes | No | 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 | Yes | No | Yes |
| Live fork (no pause) | Yes | No | Yes |
| Memory fork | No | No | No |
| Custom image (Docker or snapshot) | Yes | Yes | Yes |
| ≥24 h sessions | Yes | No | Yes |
| Idle auto-stop | No | 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 | Yes | No | Yes |
| Secret proxy for any API | Yes | No | Yes |
| Preinstalled agents | Yes | No | Yes |
| Agent harness API | Yes | No | Yes |
| MCP server | Yes | No | No |
| GPU | No | No | No |
| Windows | No | No | No |
| Arm64 | No | No | No |
| Self-hosting | No | No | No |
| BYOC | Yes | No | No |
| Open source | No | No | No |
| Scoped API keys | Yes | Not published | Yes |
| Spend limits | Not published | Yes | Yes |
| Usage per sandbox (API) | Yes | No | Yes |
| Audit logs | Not published | Yes | No |
| SSO | Yes | Yes | No |
| SOC 2 | No | Yes | No |
| HIPAA | No | No | No |
| EU data residency | Yes | Yes | Yes |
| Zero data retention | Not published | Not published | Yes |
Performance
Neither exe.dev nor GitHub Codespaces was in the public benchmark run we use, so there is no comparable CPU measurement for either. 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. We don't guess how the other two would score.
Node.js build-and-test loop at 4 vCPU / 8 GB, higher is better. Measured with the open hpc-sandbox-benchmarks suite. exe.dev and GitHub Codespaces 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 | exe.dev, a month | GitHub Codespaces, 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 | $35 · Personal | $51 · Personal account: GitHub Free | $20 · $20/mo |
| One agent that never stops 4 vCPU / 8 GB, 50 GB disk, running 24/7 all month | $35 · Personal | $270 · Personal account: GitHub Free · 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,848 · Personal | $3,019 · Personal account: GitHub Free | $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 | $530 · Personal · with limits | $850 · Personal account: GitHub Free · 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,050 · Personal · with limits | $1,889 · Personal account: GitHub Free · with limits | $2,000 · $2000/mo · with limits |
exe.dev: exe.dev pools are reserved capacity your VMs share, billed the same whether they are busy or idle; the Personal 4 vCPU / 8 GiB pool is a flat monthly fee. Standalone VMs bill per second at $0.105 per 2 vCPU / 4 GiB per hour.
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. 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.
GitHub Codespaces: 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 it does not fit the always-on scenario without a restart script, and running processes end at each stop. exe.dev Personal allows 50 VMs at once, so the 300-at-once and 1,000-at-once scenarios don't fit there, and GitHub does not publish how many codespaces can run at once. On bochka, start-rate limits mean even the top plan queues 1,000 short jobs at once.
| Scenario | exe.dev | GitHub Codespaces | 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 |
| None that bite |
| Sandboxes for your users |
|
| None that bite |
| 1,000 short jobs at once |
|
|
|
Which one should you use?
Use exe.dev when
you want Linux VMs that run until you stop them, booted from your own Docker image, in regions across the US, Europe, Asia and Australia.
- Machines with no time limit. Useful for always-on agents and dev boxes: exe.dev VMs run until you stop them, with no 12-hour cap.
- Your own Docker image. Useful if your setup is already a Dockerfile: exe.dev boots each VM straight from your own container image.
- Regions around the world. Useful if your users are spread out: exe.dev runs in nine regions across the US, Europe, Asia and Australia.
Use GitHub Codespaces when
your developers want a ready VS Code environment for a GitHub repository, opened from a branch or pull request, for work that fits in 12 hours.
- Built into GitHub. Useful if your team lives on GitHub: open a codespace from any repo, branch or pull request, 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.
- A full editor in the browser. Useful for people who code by hand: each codespace opens in VS Code, the browser or JupyterLab.
Where bochka fits
exe.dev is a VM you reach over SSH, and Codespaces is an editor for one repository. If what you are really running is agents that your own code starts and drives, bochka gives each one a full VM with /dev/kvm, a desktop, saved state and an API built for that job.
State saved every minute, and forks while running
Agents sometimes wreck an install or delete files. exe.dev has no snapshots to roll back to, and Codespaces has no copy or snapshot endpoint, so one bad step can cost a session and every parallel try starts over.
A screen and /dev/kvm on every machine
Computer-use agents need a screen, and Android emulators and microVMs need /dev/kvm. exe.dev VMs are headless with nested virtualization on Enterprise only, and a codespace has an editor but no desktop and no documented /dev/kvm.
Agents driven from outside
On exe.dev only Shelley takes prompts through the API, and Codespaces offers Copilot as an editor extension. To run Claude Code or Codex from your app on either, you script shell sessions yourself, with no clean way to steer or stream them.
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, state saved every minute, forks of running machines and one API to drive agents inside from outside. Compare it one to one: bochka vs exe.dev and bochka vs GitHub Codespaces.
Questions people ask
Is exe.dev cheaper than GitHub Codespaces?
In every scenario we priced, yes. One coding agent on workdays is $35 a month on exe.dev against $51 on Codespaces, and 50 agents in parallel come to $1,848 against $3,019. bochka comes in lower than both in four of the five scenarios, at $20 and $317 for those two.
Can I run an agent 24/7 on exe.dev or GitHub Codespaces?
On exe.dev, yes: VMs run until you stop them, at $35 a month for the 4 vCPU pool. A codespace stops after 12 hours at most, even while in use, so it needs a restart every 12 hours. A bochka sandbox runs until you stop it, with no session cap on paid plans.
Which is faster?
We can't say: neither exe.dev nor GitHub Codespaces is in the public benchmark run we use. bochka scored 26.69 Node.js build-and-test runs per second at 4 vCPU / 8 GB in that run.
Can they run Docker?
Yes, both. exe.dev VMs have root, systemd and Docker, and Codespaces runs Docker inside the dev container with sudo. Nested virtualization is Enterprise only on exe.dev and not documented on Codespaces, while every bochka machine has /dev/kvm.
Can I run Claude Code on both?
Yes. exe.dev preinstalls Claude Code, Codex, Pi and its own Shelley agent. On Codespaces you install it yourself, with your API key as a secret that arrives as an environment variable. bochka preinstalls Claude Code and other agents, keeps real keys outside the sandbox and gives you one API to prompt and steer them.
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.
Try bochka
Install the CLI, then run bochka new.
Product preview