GitHub Codespaces vs Docker Cloud Sandboxes
GitHub Codespaces gives a developer a ready VS Code environment for a GitHub repository, and stops it after 12 hours at most. Docker Cloud Sandboxes give each coding agent its own microVM with Docker inside, started from the same sbx CLI as on your laptop, and end it 24 hours after creation.
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 boat: 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.
Docker Cloud Sandboxes
Docker Cloud Sandboxes runs Docker's sbx coding-agent microVMs on Docker-managed compute instead of your laptop.
Each sandbox is a microVM with its own Linux kernel and its own Docker Engine, started from the same sbx CLI you use locally, with Claude Code, Codex and other agents ready to run. You can move a sandbox from your laptop to the cloud and back, publish HTTPS ports and SSH in. It launched on September 24, 2026, is billed pay-as-you-go on a personal Docker account, and is built for developers who want their local agent sandboxes to keep going off their machine.
- Launched
- September 24, 2026
- Session length
- 1 hour by default, extendable to 24 hours from creation
- Default quota
- 10 concurrent and 50 stored sandboxes per account
- Regions
- Not published
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 | Docker Cloud Sandboxes: price rank | boat: price rank |
|---|---|---|---|
| Software factory 100 at once · 4 vCPU / 8 GB · 2,200 sessions of 8 h a month Both are compromises for a software factory: Codespaces stops every machine at 12 hours and Docker at 24 hours, while boat runs full VMs with /dev/kvm until you stop them. | 274th of 367, with limits $4,618 a month | 280th of 367, with limits $4,928 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 fits neither: a codespace stops after 12 hours and a Docker sandbox 24 hours after creation, while boat has no session cap on paid plans. | 309th of 366, with limits $6,970 a month | 276th of 366, with limits $5,110 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 Docker fits short code runs better than Codespaces: small microVMs billed by the second, where each codespace first builds a dev container on a new VM. | 288th of 345, with limits $619 a month | 119th of 345, with limits $233 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 Serving your own users needs many machines at once; Docker allows 10 by default and GitHub does not publish its limit, while boat runs 100 to 2,000 by plan. | 281st of 361, with limits $1,964 a month | 136th of 361, with limits $1,628 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 | 114th of 360, with limits $7,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 | 295th of 364, with limits $1,519 a month | 167th of 364, with limits $1,400 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 offers /dev/kvm for Android or VM image builds, and Codespaces has no way to copy a warm machine; boat has both. | 314th of 377, with limits $909 a month | 172nd of 377, with limits $672 a month | 4th cheapest of 377 $86 a month |
| 24/7 dev boxes 1 machine 24/7 · 4 vCPU / 8 GB Codespaces is the more polished editor for a person, Docker the closer fit for an agent, but both stop within a day, while boat keeps a dev box running all month. | 130th of 368, with limits $270 a month | 127th of 368, with limits $204 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 Computer-use agents need a screen: a codespace has an editor and terminal, Docker's sandboxes are terminal only, and boat streams a 60fps desktop with Chromium. | 267th of 369, with limits $1,367 a month | 268th of 369, with limits $1,400 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 Neither ships a browser in the machine for an agent to drive; boat does, on its desktop. | 275th of 367, with limits $678 a month | 277th of 367, with limits $700 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 | 262nd of 346, with limits $350 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 | 190th of 338, with limits $7,000 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 | 267th of 360, with limits $445 a month | 248th of 360, with limits $350 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 | Docker Cloud Sandboxes | boat |
|---|---|---|---|
| Isolation | A Docker container on its own newly built VM, with its own virtual network | MicroVM with its own Linux kernel and its own Docker Engine | Full VM with its own kernel on dedicated AMD Ryzen 9 9950X hosts |
| How long it runs | Stops after 30 idle minutes by default and after 12 hours at most, even while in use | 1 hour by default, at most 24 hours from creation; resuming starts a new timer | Runs until you stop it; no session cap on paid plans |
| Machines at once | Limits exist but GitHub does not publish them | 10 concurrent and 50 stored by default; no published way to raise it | 100 on the $20 plan, up to 2,000 on higher plans, self-serve |
| Stop and resume | Files kept, storage billed while it exists; stopped codespaces are deleted after 30 days by default | Stop keeps memory and files and costs nothing; resume picks up where it left off | Disk saved every minute and on stop; a stopped sandbox costs nothing; resume boots again |
| Fork and snapshots | No copy or snapshot endpoint; new codespaces start from a repo, branch, pull request or prebuild | Snapshot a running sandbox with disk or disk and memory, then restore it as a new sandbox | Fork a running sandbox with its disk; named snapshots as templates |
| Docker inside | Docker and sudo inside the dev container | Its own Docker Engine; the agent runs as a non-root user with sudo | Docker, root and systemd on every machine |
| Nested virtualization | /dev/kvm is not documented | Not documented | /dev/kvm for Android emulators and VMs |
| Desktop and browser | VS Code in the browser or on your machine, JupyterLab and a terminal; no graphical desktop | Terminal sessions only | 60fps Linux desktop with Chromium, computer use and browser control |
| Coding agents | GitHub Copilot as a VS Code extension; other agents you install and run yourself | Claude Code, Codex, Copilot, OpenCode and more, run and attached to from the sbx CLI | Seven agents preinstalled, with a prompt, steer and events API to drive them from outside |
| Keeping API keys out of the sandbox | Secrets are copied into the codespace as environment variables | Cloud proxy sets the auth header for built-in AI services and custom hosts; the sandbox sees a placeholder | Credentials proxy for model providers and any HTTPS API; switch a credential to another account when credits run out |
| Reaching the sandbox | A URL per forwarded port, private, organization or public; SSH and CLI tunnels; no public IP | Public HTTPS URL per published port, not protected by Docker sign-in; not a TCP tunnel; SSH | HTTPS URLs for up to 50 ports, token-protected by default; raw TCP; dedicated IPv4 or IPv6 |
| Outbound rules | Open internet; GitHub says there is no way to restrict it | Allow and deny rules by host, with allow-all, balanced and deny-all presets | Open internet, no provider-side allowlist |
| Laptop and cloud | Cloud only; open it from VS Code on your machine or the browser | Same microVM and CLI locally or in the cloud; move a sandbox either way | Cloud only |
| Regions | US East, US West, Europe West and Southeast Asia | Not published | EU only: Germany, Finland, France |
Every feature Battleships tracks (43)
| Feature | GitHub Codespaces | Docker Cloud Sandboxes | boat |
|---|---|---|---|
| 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 | 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 | Yes | Yes |
| Fork/clone | No | Yes | Yes |
| Live fork (no pause) | No | Yes | Yes |
| Memory fork | No | Yes | No |
| Custom image (Docker or snapshot) | Yes | Yes | Yes |
| ≥24 h sessions | No | Yes | Yes |
| Idle auto-stop | Yes | No | No |
| Wake on request | No | Not published | No |
| HTTPS preview URLs | Yes | Yes | Yes |
| Raw TCP inbound | No | Not published | Yes |
| Public IPv4 | No | No | No |
| Egress allowlist | No | Yes | No |
| Secret proxy | No | Yes | Yes |
| Secret proxy for any API | No | Yes | Yes |
| Preinstalled agents | No | Yes | Yes |
| Agent harness API | No | No | Yes |
| MCP server | No | Yes | No |
| GPU | No | No | No |
| Windows | No | No | No |
| Arm64 | No | Yes | No |
| Self-hosting | No | No | 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) | No | No | Yes |
| Audit logs | Yes | Not published | No |
| SSO | Yes | Yes | No |
| SOC 2 | Yes | No | No |
| HIPAA | No | No | No |
| EU data residency | Yes | No | Yes |
| Zero data retention | Not published | Not published | Yes |
Performance
There is no comparable measurement for GitHub Codespaces or Docker Cloud Sandboxes: neither is in the public benchmark runs we use, and Docker does not say what hardware it runs on. boat 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. GitHub Codespaces and Docker Cloud Sandboxes 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 | Docker Cloud Sandboxes, a month | boat, 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 | $49 · Docker Agentic Platform (pay-as-you-go) | $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 | $204 · Docker Agentic Platform (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 | $3,019 · Personal account: GitHub Free | $2,464 · Docker Agentic Platform (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 | $850 · Personal account: GitHub Free · with limits | $700 · Docker Agentic Platform (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 | $1,889 · Personal account: GitHub Free · with limits | $1,400 · Docker Agentic Platform (pay-as-you-go) · 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 of 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 16 GB one; personal accounts get a free monthly quota and organizations do not.
Docker Cloud Sandboxes: Docker bills per second for the size you pick, from $0.07 an hour for 1 vCPU / 2 GiB to $1.12 an hour for 16 vCPU / 32 GiB, with no monthly fee. A stopped sandbox costs nothing; model calls are billed by your model provider.
Docker Cloud Sandboxes: Plans start at $20 a month, and the whole fee is usage credit spent per second on running sandboxes. A stopped sandbox costs nothing and keeps its disk.
Limits in those scenarios
Neither fits one agent that never stops: Codespaces needs a restart every 12 hours and Docker every 24 hours from creation. Docker's default of 10 sandboxes at once rules it out for 50 agents in parallel, sandboxes for your users and 1,000 short jobs, while GitHub does not publish its limit, so 50 agents are likely fine and 300 or 1,000 at once are not confirmed. boat has no session cap, but its start limits queue a 1,000-job burst even on the $2,000 plan.
| Scenario | GitHub Codespaces | Docker Cloud Sandboxes | boat |
|---|---|---|---|
| One coding agent, workdays | None that bite | 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, opened from a branch or pull request, in the US, EU or Asia.
- Built into GitHub. For teams that live on GitHub: open a ready dev container from any repo, branch or pull request, in VS Code or the browser.
- Free hours for personal accounts. 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. For developers in the US or Asia: codespaces run in US East, US West, Europe West and Southeast Asia.
Use Docker Cloud Sandboxes when
you already run agents in sbx on your laptop and want a few of them to keep going in the cloud for up to a day, with memory kept across stops and strict outbound rules.
- Stop and fork with memory. For agents that pause between steps: a stopped sandbox comes back with its memory and running processes, and can be copied with them.
- Outbound rules at the proxy. For teams that must limit where an agent connects: allow and deny rules by host, enforced outside the VM.
- The same sandbox on your laptop. For people already using sbx locally: the cloud runs the same microVM and CLI, and you can move work between them.
Where boat fits
If what you are really running is agents that work for days, many at once, or need a screen, both stop short: Codespaces ends each machine at 12 hours and Docker at 24. boat gives each agent a full VM with /dev/kvm, a desktop and open ports that runs until you stop it, and lets you drive the agents inside from outside through one API.
No session cap
A codespace stops at 12 hours even while in use, and its processes end; a Docker sandbox ends 24 hours after creation. On either, your code must restart the agent and resume its job. boat sandboxes run until you stop them on paid plans.
A whole machine, screen included
Neither documents /dev/kvm, so Android emulators and microVMs are out, and neither has a graphical desktop, so computer-use agents need a separate browser service. Every boat machine has /dev/kvm, systemd and a 60fps desktop with Chromium.
Agents you drive from outside
On Codespaces you write the code that starts and watches each agent over SSH; on Docker you attach to its terminal from the sbx CLI and parse its text. boat ships seven agents with a prompt, steer and events API.
Use boat when your agents run for days or by the dozen, need /dev/kvm, a desktop or a browser, or have to be driven from your own app through an API. Compare it one to one: boat vs GitHub Codespaces and boat vs Docker Cloud Sandboxes.
Questions people ask
Is GitHub Codespaces cheaper than Docker Cloud Sandboxes?
Docker is a little cheaper in every scenario we priced: one coding agent on workdays is $49 a month on Docker against $51 on Codespaces, and 50 agents in parallel $2,464 against $3,019, though Docker only allows 10 at once by default. boat comes to $20 and $317 for the same two.
Which is faster, Codespaces or Docker Cloud Sandboxes?
There is no comparable CPU measurement for either one. boat did 26.69 Node.js build-and-test runs per second at 4 vCPU / 8 GB in the same public benchmark, on dedicated AMD Ryzen 9 9950X hosts.
Can I run Docker inside GitHub Codespaces or Docker Cloud Sandboxes?
Yes, both. A codespace is a dev container with Docker and sudo, and each Docker cloud sandbox has its own Docker Engine. Neither documents /dev/kvm; every boat machine has Docker, systemd and /dev/kvm.
Can either run an AI agent 24/7?
Not in one session. A codespace stops after 12 hours at most and after 30 idle minutes by default, and a Docker sandbox ends 24 hours after creation. A boat sandbox runs until you stop it, with no session cap on paid plans.
How many can I run at once?
Docker allows 10 concurrent and 50 stored sandboxes per account by default. GitHub says there are limits on how many codespaces you can run but does not publish them. boat's $20 plan runs 100 at once, and higher plans go up to 2,000.
Is boat SOC 2 compliant?
SOC 2 is in progress. We're open about where we stand: live status at status.ascii.dev and our data retention policy at docs.boat.dev/data-retention.
Try boat
Install the CLI, then run boat new.
7-day free trial
More comparisons
- boat vs GitHub Codespaces
- boat vs Docker Cloud Sandboxes
- 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