CodeSandbox SDK vs GitHub Codespaces

CodeSandbox SDK is an API that starts Firecracker VMs from code. They hibernate with their memory and wake on the next request. GitHub Codespaces is a dev environment for people: a dev container per repository, opened in VS Code or the browser, that stops after 12 hours at most.

The companies and products

CodeSandbox SDK

CodeSandbox SDK is an API from CodeSandbox, now a Together AI company, that starts sandboxed development VMs on the same infrastructure as the CodeSandbox editor.

Each sandbox is a Firecracker microVM built from a template or any Dockerfile. When it goes idle, it hibernates with a memory snapshot, and it resumes or forks from that snapshot in seconds. You drive it from a TypeScript SDK through terminals, commands, files and HTTPS hosts. Together's docs call it the deprecated offering and point new users to its successor, the together-sandbox SDK.

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 who work on a GitHub repository, not a sandbox API for agents. Each codespace is a Docker container built from the repo's dev container config. It runs 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. “32nd cheapest of 365” means 31 of the other 364 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 workloadCodeSandbox SDK: price rankGitHub Codespaces: price rankboat: price rank
Software factory
100 at once · 4 vCPU / 8 GB · 2,200 sessions of 8 h a month
32nd cheapest of 365
$3,731 a month
290th of 365, with limits
$4,618 a month
5th cheapest of 365
$634 a month
Always-on AI employees
50 machines 24/7 · 2 vCPU / 4 GB
An always-on assistant fits CodeSandbox SDK, which has no hard session cap and bills while busy. A codespace stops after 12 hours at most, so it needs a restart script. On boat, turn auto-stop off on a paid plan (default 1 hour).
50th cheapest of 361
$4,811 a month
320th of 361, with limits
$6,970 a month
6th cheapest of 361
$657 a month
Code interpreter bursts
100 at once · 1 vCPU / 2 GB · 200,000 sessions of 1 min a month
CodeSandbox SDK suits short code runs: its VMs hibernate with their memory and wake on the next request. It bills per started minute, including idle time before it hibernates. Each codespace builds a dev container on a new VM, which prebuilds speed up.
54th cheapest of 336
$642 a month
283rd of 336, with limits
$619 a month
189th of 336, 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
CodeSandbox SDK wakes a user's sandbox on their next HTTP request, but Scale caps at 250 VMs at once. Codespaces are made for GitHub users, and GitHub does not publish how many can run at once. boat allows 100 to 2,000 sandboxes at once, by plan.
140th of 349, with limits
$1,707 a month
276th of 349, with limits
$1,964 a month
3rd cheapest of 349
$209 a month
RL rollouts
1,000 at once · 2 vCPU / 4 GB · 1,000,000 sessions of 3 min a month
CodeSandbox SDK's memory forks let many rollouts branch from the same running state. Codespaces has no fork, so each copy starts from the repository. A boat fork copies the disk only, and each fork counts as a start.
341st of 349, with limits
$3,861 a month
276th of 349, with limits
$9,489 a month
39th of 349, with limits
$2,000 a month
Agent evals
250 at once · 4 vCPU / 8 GB · 15,000 sessions of 20 min a month
CodeSandbox SDK fits evals: each run can fork from one warm memory snapshot. Codespaces has no fork or snapshot API, so every run starts from the repository or a prebuild.
77th cheapest of 359
$1,335 a month
295th of 359, with limits
$1,519 a month
10th cheapest of 359
$200 a month
CI runners
40 at once · 8 vCPU / 16 GB · 6,000 sessions of 12 min a month
CodeSandbox SDK suits CI jobs started from code. On Codespaces each run builds from the repo or a prebuild. CI that builds Android apps or VM images needs /dev/kvm, which boat exposes and neither of the other two documents.
96th cheapest of 374
$860 a month
317th of 374, with limits
$909 a month
2nd cheapest of 374
$86 a month
24/7 dev boxes
1 machine 24/7 · 4 vCPU / 8 GB
Codespaces is a polished VS Code environment per repo, but it stops after 12 hours at most. CodeSandbox SDK hibernates after its idle timeout and documents no SSH. A boat sandbox runs until you stop it once auto-stop is off (default 1 hour).
316th of 371, with limits
$240 a month
144th of 371, with limits
$270 a month
19th cheapest of 371
$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 desktop. On CodeSandbox SDK you add a VNC desktop to your own Dockerfile. On Codespaces you add the desktop-lite dev container feature, a noVNC desktop you configure. boat streams a 60 fps desktop with Chrome, built in.
54th cheapest of 367
$1,236 a month
297th of 367, with limits
$1,367 a month
7th cheapest of 367
$200 a month
Browser-use agents
50 at once · 2 vCPU / 4 GB · 30,000 sessions of 10 min a month
125th of 356, with limits
$741 a month
306th of 356, with limits
$678 a month
7th cheapest of 356
$200 a month
Scraping & bots (startup scale)
50 at once · 1 vCPU / 2 GB · 100,000 sessions of 3 min a month
119th cheapest of 343
$871 a month
324th of 343, with limits
$922 a month
6th cheapest of 343
$90 a month
Mass scraping & bots (undetectable)
1,000 at once · 1 vCPU / 2 GB · 3,000,000 sessions of 2 min a month
194th of 327, with limits
$7,390 a month
279th of 327, with limits
$18,637 a month
73rd of 327, with limits
$1,800 a month
Parallel red teaming
200 at once · 2 vCPU / 4 GB · 5,000 sessions of 30 min a month
29th cheapest of 351
$505 a month
284th of 351, with limits
$445 a month
3rd cheapest of 351
$200 a month
GPU eval jobs
10 at once · 8 vCPU / 32 GB · 500 sessions of 30 min a month
Not ranked: misses a requirementNot ranked: misses a requirementNot ranked: misses a requirement
macOS agents
5 at once · 4 vCPU / 8 GB · 1,000 sessions of 20 min a month
Not ranked: misses a requirementNot ranked: misses a requirementNot ranked: misses a requirement

Key features

FeatureCodeSandbox SDKGitHub Codespacesboat
What it isA TypeScript SDK that starts sandbox VMs from codeA cloud dev environment for a GitHub repository, opened in VS Code, the browser or the CLIA sandbox API with full VMs, an SDK, a CLI and installed coding agents
IsolationFirecracker microVM with its own kernelA Docker container on its own newly built VM, with its own virtual networkFull VM with its own kernel, on hosts dedicated to boat (AMD Ryzen 7 9700X and Ryzen 9 9950X); vCPUs are shared
How long it runsNo hard cap; hibernates after an idle timeout (30 minutes by default on paid plans, up to 1 day) and bills until thenStops after 30 idle minutes by default (up to 240) and after 12 hours at most, even while in useAuto-stop defaults to 1 hour; set up to 30 days, or turn it off on a paid plan for no session cap. A running sandbox bills busy or idle
Pause and resumeHibernates with a memory snapshot and resumes with processes running in about 0.5 to 2 s; after long inactivity the snapshot is archived and resume takes longerFiles are kept and storage is billed; processes end at each stop; a stopped codespace is deleted after 30 days by defaultDisk saved every minute and at each stop, kept at least 14 days; memory is not saved, so a resume is like a reboot
ForkFork a hibernated sandbox from its memory snapshot, or a running one that shares memory with its parentNo copy or snapshot endpoint; new codespaces start from a repo, branch, pull request or prebuildFork a running sandbox from its last 1-minute disk snapshot; memory is not copied; saved snapshots as templates
Wake on requestYes; an HTTP request to a host wakes a hibernated VMNo; you restart a stopped codespaceNo; you start a stopped sandbox by API
Starting pointA template or any DockerfileDev container config in the repository, with prebuilds built by GitHub Actionsboat's image or a saved snapshot; you cannot boot your own Docker or OCI image
Machine sizesUp to 16 cores / 32 GB on Scale, 64 cores / 128 GB on Enterprise; 20 GB disk2, 4, 8, 16 or 32 cores, with 4 GB of memory per coreUp to 16 vCPU / 32 GB on the $100 plan and above; disk fixed per size, 51 to 251 GB
Docker and nested virtualizationDocker and root; nested virtualization not documentedDocker inside through a dev container feature, and sudo; /dev/kvm not documentedDocker, root, systemd and /dev/kvm on every sandbox
Shell accessTerminals, commands and files through the SDK; SSH is not documentedSSH and the GitHub CLI, plus a terminal in the editorSSH, plus exec and files over the API
Inbound accessHTTPS host per port, public by default, signed tokens for private sandboxes; raw TCP and a public IP are not documentedA URL per forwarded port, private, organization or public; no public IPUp to 50 HTTPS URLs, token-gated by default; raw ports on the public IPv6 address (some sandboxes also have IPv4); the IP changes at each resume
Desktop and browserNo built-in desktop; a headless Chromium template, and you can install a VNC desktop in your own DockerfileVS Code, JupyterLab and a terminal; a noVNC desktop through the desktop-lite dev container feature, which you configureBuilt-in desktop and Chrome streamed at 1920x1080, 60 fps, with computer-use tools; no GPU
Coding agentsYou install your own agent in the template and run it through the commands APIGitHub Copilot as a VS Code extension; other agents you install yourselfSeven harnesses installed, including Claude Code and Codex, with a prompt, steer and events API
Keeping API keys out of the sandboxSecrets passed in as environment variables; no credentials proxy documentedSecrets copied into the codespace as environment variablesOptional credentials proxy ($1 a day while on, plus $1 per 1,000 requests): real keys of supported model providers stay outside; other secrets still enter the sandbox
RegionsA country hint steers scheduling, but placement is not guaranteedUS East, US West, Europe West and Southeast AsiaGermany, Finland and France; you cannot pick a region; no US or Asia region
ComplianceSOC 2 Type II listed on the Enterprise planGitHub Enterprise Cloud lists SOC 1, SOC 2 and SOC 3 reports and ISO 27001SOC 2 in progress; no SOC 2 report today
Every feature Battleships tracks (43)
FeatureCodeSandbox SDKGitHub Codespacesboat
Full VM (own kernel)YesYesYes
Docker insideYesYesYes
Nested virtualizationNo documented wayNot publishedYes
RootYesYesYes
SystemdNot publishedNot publishedYes
Desktop GUIWith your own setupWith your own setupYes
BrowserWith your own setupNo documented wayYes
Computer-use APINo documented wayNo documented wayYes
SSHNo documented wayYesYes
Persistent diskYesYesYes
Pause/resumeYesYesYes
Automatic snapshotsYesNo documented wayYes
Fork/cloneYesNo documented wayYes
Live fork (no pause)YesNo documented wayYes
Memory forkYesNo documented wayNo documented way
Custom image (Docker or snapshot)YesYesYes
≥24 h sessionsYesNo documented wayYes
Idle auto-stopYesYesNo documented way
Wake on requestYesNo documented wayNo documented way
HTTPS preview URLsYesYesYes
Raw TCP inboundNo documented wayNo documented wayYes
Public IPv4No documented wayNo documented wayNo documented way
Egress allowlistNo documented wayNo documented wayNo documented way
Secret proxyNo documented wayNo documented wayYes
Secret proxy for any APINo documented wayNo documented wayYes
Preinstalled agentsNo documented wayNo documented wayYes
Agent harness APINo documented wayNo documented wayYes
MCP serverNo documented wayNo documented wayNo documented way
GPUNo documented wayNo documented wayNo documented way
WindowsNo documented wayNo documented wayNo documented way
Arm64No documented wayNo documented wayNo documented way
Self-hostingNo documented wayNo documented wayNo documented way
BYOCNo documented wayNo documented wayNo documented way
Open sourceNo documented wayNo documented wayNo documented way
Scoped API keysNot publishedNot publishedYes
Spend limitsNot publishedYesYes
Usage per sandbox (API)No documented wayNo documented wayYes
Audit logsNot publishedYesNo documented way
SSOYesYesNo documented way
SOC 2YesYesNo documented way
HIPAANo documented wayNo documented wayNo documented way
EU data residencyNo documented wayYesNo documented way
Zero data retentionNot publishedNot publishedYes

Performance

CodeSandbox SDKNot measured
GitHub CodespacesNot measured
boat28.06 runs/s

Neither CodeSandbox SDK nor GitHub Codespaces is in the public CPU benchmarks we use, so we cannot say which is faster. In StarSling's run of 3 October 2026 (run 37073680030), boat did 28.06 runs/s on the V8 Web Tooling Benchmark at 4 vCPU / 8 GB, second of 15. Every boat sandbox in this run ran on an AMD Ryzen 9 9950X host. boat also places some sandboxes on AMD Ryzen 7 9700X hosts, which this run did not measure. For start time, ComputeSDK measured CodeSandbox SDK at its default size: 11.76 s median with 100 starts at once (6 November 2026) and 2.33 s one at a time in its latest published run. Codespaces and boat are not in ComputeSDK.

V8 Web Tooling Benchmark at a 4 vCPU / 8 GB target, runs per second, higher is better. Source: StarSling's run of 3 October 2026 (run 37073680030), median of 5 sandboxes. Providers ran on different hardware in different regions. StarSling gives a shared rank when the run cannot separate two providers. Every boat sandbox in this run ran on an AMD Ryzen 9 9950X host. boat also places some sandboxes on AMD Ryzen 7 9700X hosts, which this run did not measure. CodeSandbox SDK and GitHub Codespaces are not in the public benchmarks we use, so we cannot say which is faster.

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. Start limits, per-start fees and plan minimums are in the price, boat's included.

ScenarioCodeSandbox SDK, a monthGitHub Codespaces, a monthboat, 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
$193 · Scale$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
$341 · Scale$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
$2,500 · Scale$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
$815 · Scale · 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,632 · Scale · with limits$1,889 · Personal account: GitHub Free · with limits$8,800 · $2000/mo · with limits

CodeSandbox SDK: You buy VM credits at $0.01486 each, and each size burns a fixed number per hour: 20 for a 4 vCPU / 8 GB VM, about $0.30. Billing is per started minute while the VM runs, including idle time before it hibernates. A hibernated VM has no VM charge. Larger teams pay a $170 monthly Scale platform fee, which is not usage credit. Prices as checked on 28 September 2026; CodeSandbox's pricing pages blocked our automated check on 8 November 2026.

GitHub Codespaces: Codespaces bills $0.09 per core-hour for the whole time a codespace is active, used or not, 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.

GitHub Codespaces: Plans cost $20, $100, $500 or $2,000 a month, and the whole plan price comes back as VM time for that month. A 4 vCPU / 8 GB sandbox costs $0.036 an hour, billed per second while it runs, busy or idle. The $20 plan includes 200 starts a day; each extra start costs $0.03 to $0.07. A stopped sandbox has no compute charge and keeps its disk for at least 14 days. Saved snapshots above the included count and the credentials proxy, while it is on, still charge.

Limits in those scenarios

CodeSandbox SDK's Scale plan allows 250 VMs at once, so 300 user sandboxes and 1,000 short jobs need Enterprise. Its price for disk beyond 20 GB and for egress is not published. Every codespace stops after 12 hours at most, so the always-on scenario needs restarts, and running processes end at each stop. GitHub does not publish how many codespaces can run at once, so 300 user sandboxes and 1,000 short jobs show as not confirmed. boat does not fit the 1,000-job burst either: the $2,000 plan includes 90 starts a minute and 2,400 a day, extra starts are paid, and starts above 270 a minute fail with 429. boat never queues a start. boat sandboxes stop after 1 hour by default until you change auto-stop.

ScenarioCodeSandbox SDKGitHub Codespacesboat
One coding agent, workdays
  • disk beyond 20 GiB: price unknown
  • egress price not published
None for this scenarioNone for this scenario
One agent that never stops
  • disk beyond 20 GiB: price unknown
  • egress price not published
  • Personal account: GitHub Free: sessions capped at 12 h
None for this scenario
50 agents in parallel
  • egress price not published
  • how many machines can run at once: limit not published, probably fine at 50 (the typical published limit is 50)
None for this scenario
Sandboxes for your users
  • Scale: max 250 concurrent
  • egress price not published
  • not confirmed: how many machines can run at once (you need 300; the typical published limit is 50)
None for this scenario
1,000 short jobs at once
  • Scale: max 250 concurrent
  • egress price not published
  • not confirmed: how many machines can run at once (you need 1,000; the typical published limit is 50)
  • 2,400 starts/day included, paid above that (needs ~6,667)
  • 600 starts/hour included, paid above that (needs ~1,000)
  • starts above 90/min are paid, and starts above 270/min fail with 429

Which one should you use?

Use CodeSandbox SDK when

your code starts sandboxes that sleep between visits and wake on the next HTTP request with their memory intact, when you need your own Dockerfile image, and when you accept that Together calls this SDK deprecated.

  • Built to be driven from code. Good for products that start sandboxes for their own users or jobs, through a TypeScript SDK for commands, files and hosts.
  • Memory hibernation and wake on request. Useful for previews and code runs used in bursts: an HTTP request wakes a hibernated VM with its processes still running.
  • Forks that share memory. Good for branching many runs, such as rollouts or test variants, from one warm state instead of setting up again.

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, with compliance reports available today.

  • Built into GitHub. Useful if your team lives on GitHub: open a codespace from any repo, branch or pull request, with the dev container ready.
  • 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. Organizations get no free quota.
  • Regions in the US, EU and Asia. Useful if your developers are spread out: you pick US East, US West, Europe West or Southeast Asia.

Where boat fits

If you run coding agents, each of these needs setup. CodeSandbox SDK gives you a VM, but you add the agent, the desktop and the shell access. Codespaces is an editor for people that stops after 12 hours. boat gives each agent a full VM with the agents and a desktop installed. Turn auto-stop off on a paid plan (default 1 hour) and it runs until you stop it.

A whole machine with /dev/kvm

Neither CodeSandbox SDK nor Codespaces documents /dev/kvm, so Android emulators and microVMs are not documented there. boat gives every sandbox root, systemd, Docker and /dev/kvm.

Long runs and forks of a running sandbox

A codespace stops after 12 hours even while in use and has no copy endpoint, so long jobs need a restart script. CodeSandbox SDK keeps memory across hibernation, which boat does not. boat forks a running sandbox from its last 1-minute disk snapshot; writes from the last minute can be missing.

Agents, desktop and keys set up

On both, you install the agent and build the desktop yourself, and keys sit in environment variables that code in the sandbox can read. boat installs seven agent harnesses and a 60 fps desktop. Its optional paid credentials proxy keeps model keys outside.

Use boat when your code drives agents that work for hours or days: full VMs with /dev/kvm, a desktop and public HTTPS URLs, installed coding agents, and sandboxes that fork while running. Turn auto-stop off on a paid plan; it defaults to 1 hour. Compare it one to one: boat vs CodeSandbox SDK and boat vs GitHub Codespaces.

boat's own limits
  • Plans start at $20 a month. The plan price comes back as VM time for that month. Unused time does not carry over. Source
  • Starts (create, fork, resume): the $20 plan includes 12 a minute, 60 an hour and 200 a day. The $2,000 plan includes 90 a minute, 600 an hour and 2,400 a day. Extra starts cost $0.03 to $0.07. A start fails with 429 above 3 times the included starts per minute, or 6 times per hour or per day. Source
  • A stopped sandbox has no compute charge. boat keeps its disk for at least 14 days. A saved snapshot keeps it longer; extra saved snapshots and the AI credentials proxy are paid. Source
  • Auto-stop defaults to 1 hour. You can turn it off on a paid plan. The trial allows 2 hours at most. Source
  • boat saves the disk every minute and at each stop. Memory, running programs and /tmp are not saved: a resume is like a reboot. A machine failure loses writes after the last good snapshot. Source
  • Machines run in Germany, Finland and France only. Snapshot copies can be stored outside the EU. Source
  • Public IPv6 and outbound IPv4. No dedicated IPv4. The IP changes at each resume. Source
  • Hosts are AMD Ryzen 7 9700X and Ryzen 9 9950X. vCPUs are shared. No GPU. You cannot boot your own Docker image. Source

Questions people ask

Is CodeSandbox SDK cheaper than GitHub Codespaces?

It depends on the job. One coding agent on workdays is $193 a month on CodeSandbox SDK against $51 on Codespaces. One agent running all month is $341 against $270, and Codespaces gets there only with a restart every 12 hours. 50 agents in parallel come to $2,500 against $3,019. boat is $20, $26 and $317 for the same three. For 1,000 short jobs at once, none of the three fits as-is: CodeSandbox SDK is $1,632, Codespaces $1,889 and boat $8,800 with paid extra starts. Below about $20 of use a month, the free Codespaces quota on a personal account costs less than boat.

Which is faster?

Neither is in the public CPU benchmarks we use, so we cannot say. In StarSling's run of 3 October 2026, boat did 28.06 runs/s on the V8 Web Tooling Benchmark at 4 vCPU / 8 GB, on an AMD Ryzen 9 9950X host. boat also places some sandboxes on slower hosts.

Can I run an agent 24/7 on either?

Not on Codespaces without restarts, since a codespace stops after 12 hours even while in use. CodeSandbox SDK has no hard cap; it hibernates after an idle timeout of up to one day and bills until then. A boat sandbox stops after 1 hour by default. On a paid plan you can turn auto-stop off, and it then runs until you stop it.

Can CodeSandbox SDK and Codespaces run Docker?

Yes, both run Docker inside the sandbox; Codespaces needs a dev container feature for it. Neither documents /dev/kvm for Android emulators or nested VMs. Every boat sandbox has Docker, systemd and /dev/kvm.

Can I SSH into them?

Codespaces supports SSH and the GitHub CLI. CodeSandbox SDK connects through its SDK clients with terminals, commands and files; SSH is not documented. boat has SSH as well as an exec and files API.

Is CodeSandbox SDK still maintained?

CodeSandbox is now part of Together AI. Together's docs call this SDK deprecated and name together-sandbox as its successor. The last SDK release was 2.4.2 in December 2025. Self-serve sign-up still runs through CodeSandbox.

Try boat

Install the CLI, then run boat new.

7-day free trial

More comparisons