GitHub Codespaces vs Together Code Sandbox
GitHub Codespaces is a cloud dev environment for people working on a GitHub repository, open to anyone and capped at 12 hours per run. Together Code Sandbox is a sandbox API for code from models and agents, with memory snapshots, but its VMs must be enabled for your organization and the only self-serve option is a Python interpreter.
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.
Together Code Sandbox
Together AI is a cloud for running and training AI models, and Code Sandbox is its product for running code in isolated VMs.
You build a snapshot from a Docker image or Dockerfile on Together's builder, then start sandboxes from it and run commands and file operations through the together-sandbox SDK or CLI. When a sandbox ends you can save its disk, and its memory too, as a new snapshot to start more sandboxes from. It is aimed at model-generated code, agent tool calls and reinforcement learning rollouts, and it must be enabled for your organization by Together. Together also sells Code Interpreter, a separate API that runs Python code in short sessions.
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 | Together Code Sandbox: price rank | boat: price rank |
|---|---|---|---|
| Software factory 100 at once · 4 vCPU / 8 GB · 2,200 sessions of 8 h a month Codespaces gives an agent Docker and sudo in a dev container but stops it after 12 hours, Together does not document Docker inside its VMs, and boat has Docker, root and /dev/kvm on every machine. | 274th of 367, with limits $4,618 a month | 65th of 367, with limits $528 a month | 3rd cheapest of 367 $634 a month |
| Always-on AI employees 50 machines 24/7 · 2 vCPU / 4 GB Neither fits an assistant that lives on its machine all month: a codespace stops after 12 hours at most, and Together sandboxes have no idle detection or wake on request, while a boat sandbox runs until you stop it. | 309th of 366, with limits $6,970 a month | 152nd of 366, with limits $1,095 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 For short Python runs, Together's Code Interpreter is the simpler fit, billed per 60-minute session, while each codespace builds a dev container on a new VM before it can run anything. | 288th of 345, with limits $619 a month | 326th of 345, with limits $2,190 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 Codespaces are made for GitHub users on a repository, and every port on a Together sandbox is public, so neither hands private machines to your own users as easily as boat's token-protected HTTPS URLs. | 281st of 361, with limits $1,964 a month | 234th of 361, with limits $900 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 Together can save a sandbox with its memory and start many copies from that warm state, which suits rollouts, while Codespaces has no copy or snapshot endpoint at all. | 282nd of 360, with limits $9,489 a month | 315th of 360, with limits $21,900 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 | 258th of 364, with limits $450 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 | 314th of 377, with limits $909 a month | 251st of 377, with limits $180 a month | 4th cheapest of 377 $86 a month |
| 24/7 dev boxes 1 machine 24/7 · 4 vCPU / 8 GB For a developer's own box, Codespaces is the polished choice with VS Code built in, though it stops after 12 hours, and boat is a full VM that keeps running. | 130th of 368, with limits $270 a month | 210th of 368, with limits $22 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 Codespaces nor Together has a graphical desktop, while boat streams a 60fps desktop with Chromium for computer use. | 267th of 369, with limits $1,367 a month | 184th of 369, with limits $600 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 | 301st of 367, with limits $900 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 | 219th of 346, with limits $180 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 | 124th of 338, with limits $3,600 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 boat forks one prepared machine into many while it keeps running; Together starts copies from a snapshot after the parent stops, and Codespaces creates each copy again from the repository. | 267th of 360, with limits $445 a month | 167th of 360, with limits $150 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 | Together Code Sandbox | boat |
|---|---|---|---|
| What it is | A dev environment per GitHub repository, opened in VS Code, the browser or JupyterLab | A sandbox API for model-generated code, agent tool calls and rollouts, on Together's AI cloud | A sandbox you drive from code: full VMs for agents, with an API, SDK and CLI |
| Getting started | Open a codespace from any repo, branch or pull request with a GitHub account | The VM SDK and CLI must be enabled for your organization by Together; only Code Interpreter is self-serve | Sign up and start a sandbox from the API, CLI or dashboard |
| Isolation | A Docker container on its own newly built VM, with its own virtual network | A VM per sandbox on Together's infrastructure | A full VM with its own kernel on dedicated AMD Ryzen 9 9950X hosts |
| Machine size | 2, 4, 8, 16 or 32 cores, with 4 GB of memory per core | 0.1 to 16 cores, 1 to 8 GB of memory per core; disk size fixed | 2 to 16 vCPU with 2 GB per vCPU, up to 16 vCPU / 32 GB on the $100 plan and above |
| How long it runs | Stops after 30 idle minutes by default and after 12 hours at most, even while in use | Runs until you end it or its time to live, counted from creation, runs out; no idle detection or wake on request | Runs until you stop it; no session cap on paid plans |
| Docker, root and nested virtualization | Docker and sudo inside the dev container; /dev/kvm not documented | Commands run as user 1000 by default, root on request; Docker inside and nested virtualization not documented | Docker, root, systemd and /dev/kvm on every machine |
| Shell access | SSH, the GitHub CLI and a terminal in the editor | Commands, interactive shells and files through the SDK and CLI; no SSH | SSH, plus exec and files over the API |
| Saving state | Files kept while the codespace exists, storage billed; stopped codespaces deleted after 30 days by default | End a sandbox with a snapshot of its disk, or disk and memory; a new sandbox resumes with its processes running | Disk saved every minute and on stop; a stopped sandbox keeps its disk and costs nothing |
| Fork and copies | No copy or snapshot endpoint; new codespaces start from a repo, branch, pull request or prebuild | No live fork: the parent stops, then many sandboxes start from its snapshot | Fork a running sandbox; the original keeps running |
| Reaching the sandbox | A URL per forwarded port, private, organization or public; no public IP | All ports public; preview URLs coming soon; an experimental inbound allowlist | HTTPS URLs for up to 50 ports, token-protected; raw TCP; dedicated IPv6 or IPv4 |
| Desktop and computer use | VS Code, JupyterLab and a terminal; no graphical desktop | None; headless command and file access only | 60fps desktop and Chromium, computer use and browser control |
| Coding agents | GitHub Copilot as a VS Code extension; other agents you install yourself | Run your own agent through execs; a Harbor guide for agent evals | Claude Code, Codex, OpenCode and more preinstalled, with a prompt, steer and events API |
| Keeping API keys out of the sandbox | Secrets are copied into the codespace as environment variables | No credentials proxy documented | AI credentials proxy for model providers and any HTTPS API; switch a credential to another account when credits run out |
| 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 | Together Code Sandbox | boat |
|---|---|---|---|
| Full VM (own kernel) | Yes | Yes | Yes |
| Docker inside | Yes | Not published | 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 | No | Yes |
| Persistent disk | Yes | Yes | Yes |
| Pause/resume | Yes | Yes | Yes |
| Automatic snapshots | No | No | Yes |
| Fork/clone | No | Yes | Yes |
| Live fork (no pause) | No | No | 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 | 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 | No | Yes |
| Agent harness API | No | No | Yes |
| MCP server | No | Yes | No |
| GPU | No | No | No |
| Windows | No | No | No |
| Arm64 | No | No | 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 | Yes | Yes |
| Usage per sandbox (API) | No | Yes | Yes |
| Audit logs | Yes | Not published | No |
| SSO | Yes | Yes | No |
| SOC 2 | Yes | Yes | No |
| HIPAA | No | No | No |
| EU data residency | Yes | Not published | Yes |
| Zero data retention | Not published | Not published | Yes |
Performance
There is no comparable CPU measurement for GitHub Codespaces or Together Code Sandbox: neither was in the public benchmark runs we use. 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 Together Code Sandbox 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 | Together Code Sandbox, 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 | $5 · Together pay-as-you-go (prepaid credits; Code Interpreter only) · 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 | $22 · Together pay-as-you-go (prepaid credits; Code Interpreter only) · 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 | $264 · Together pay-as-you-go (prepaid credits; Code Interpreter only) · 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 | $900 · Together pay-as-you-go (prepaid credits; Code Interpreter only) · 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 | $6,000 · Together pay-as-you-go (prepaid credits; Code Interpreter only) · 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. There is no 4-core machine with 8 GB, so 4 vCPU / 8 GB jobs are priced on the 4-core 16 GB machine; personal accounts get a free monthly quota and organizations do not.
Together Code Sandbox: Together lists Code Sandbox at $0.0446 per vCPU-hour and $0.0149 per GiB-hour, but the VMs must be enabled for your organization, so the table prices Together with Code Interpreter: $0.03 per 60-minute session from prepaid credits. Code Interpreter runs only Python and keeps no disk, so it does not fit these scenarios.
Together Code Sandbox: Plans start at $20 a month, and the whole fee 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 misses the always-on scenario, and GitHub does not publish how many can run at once, so 300 user sandboxes and 1,000 short jobs are not confirmed. The Together column is Code Interpreter, and its 60-minute sessions, lack of a disk and unpublished machine size rule it out of every scenario, even where it looks cheap. On boat the limit that bites is starts: 1,000 short jobs at once need more starts per hour and per day than even the $2,000 plan allows, so they are queued.
| Scenario | GitHub Codespaces | Together Code Sandbox | boat |
|---|---|---|---|
| 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, opened from a branch or pull request, in the US, EU or Asia.
- Built into GitHub. Best for teams on GitHub: open a ready dev container from any repo, branch or pull request, in VS Code or the browser.
- Open to anyone today. Any GitHub account can start one, and a personal Free account gets 120 core-hours and 15 GB-month of storage each month.
- Regions in the US, EU and Asia. Useful for teams spread out: codespaces run in US East, US West, Europe West and Southeast Asia at one price.
Use Together Code Sandbox when
you already run models on Together, can get its VMs enabled, and want light sandboxes you save with their memory and branch from, or a simple Python runner.
- Memory snapshots to branch from. Good for rollouts and test variants: save a sandbox with its memory and start many copies with processes still running.
- Sandboxes next to your models. Handy if you already run inference or fine-tuning on Together: sandboxes and models share one account and API key.
- Very small machines and a Python runner. Good for many light jobs: sandboxes start at a tenth of a core, and a Python interpreter API bills per session.
Where boat fits
If what you are really running is agents that work for hours, neither is a clean fit: Codespaces is a dev box for people that stops at 12 hours, and Together's VMs need Together to switch them on. boat gives each agent a full VM you can start today, with the agent, a desktop and its keys already set up.
A whole machine that keeps running
A codespace stops at 12 hours and its processes end, so you script restarts; Together does not document Docker inside or /dev/kvm. A boat sandbox has Docker, systemd and /dev/kvm and runs until you stop it.
Fork a running machine
Codespaces cannot copy a machine at all, and Together copies only after the parent stops. boat forks a running sandbox into copies with its files while the original keeps working, and saves its disk every minute.
Agents, desktop and private hosting built in
On both you install and wire up agents yourself, with keys inside the machine and no desktop. boat ships coding agents driven from outside, a 60fps desktop, a credentials proxy and token-protected HTTPS on 50 ports.
Use boat when your agents do real work for hours: builds, Docker, emulators, a browser and servers other people reach, on a full machine you can start today that keeps running and forks while it runs. Compare it one to one: boat vs GitHub Codespaces and boat vs Together Code Sandbox.
Questions people ask
Is GitHub Codespaces cheaper than Together Code Sandbox?
It depends on what you compare. The only self-serve Together price is Code Interpreter, which looks far cheaper for 50 agents in parallel ($264 against $3,019 a month) but does not fit, since sessions end after 60 minutes and keep no disk. For 300 user sandboxes the two are close, $850 on Codespaces against $900, and boat is $200.
Which is faster, Codespaces or Together Code Sandbox?
Neither has a comparable CPU measurement in the public benchmarks we use, so we cannot say. boat did 26.69 Node.js build-and-test runs per second at 4 vCPU / 8 GB on StarSling's benchmark.
Can GitHub Codespaces and Together Code Sandbox run Docker?
Codespaces runs Docker inside the dev container, with sudo. Together builds sandboxes from Docker images, but its new SDK documents neither Docker inside a sandbox nor nested virtualization. boat has Docker, systemd and /dev/kvm on every machine.
Can I run an AI agent 24/7 on either?
Not easily on Codespaces: every codespace stops after 12 hours at most, even while in use. Together sandboxes run until you end them, but the VMs must be enabled by Together and have no idle detection or wake on request. A boat sandbox runs until you stop it, with no session cap on paid plans.
Can I copy a running machine?
Codespaces has no copy or snapshot endpoint, so each codespace starts from the repository or a prebuild. Together saves a sandbox's disk and memory when it ends and starts copies from that. boat forks a running sandbox while the original keeps running.
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 Together Code Sandbox
- 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