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 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

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.

Company: Together AI, a cloud for model inference, fine-tuning and GPU clusters
Isolation: A virtual machine per sandbox on Together's infrastructure
Access: The SDK and CLI must be enabled for your organization; you ask Together for access
Machine size: 0.1 to 16 cores, 1 to 8 GB of memory per core; disk size is not configurable
History: Built on CodeSandbox, now a Together company; the CodeSandbox-based SDK is deprecated and together-sandbox is its successor
Source code: The SDKs and CLI are MIT-licensed on GitHub; the platform itself is not

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

GitHub CodespacesNot measured

Together Code SandboxNot measured

bochka26.69 runs/s

There is no comparable CPU measurement for GitHub Codespaces or Together Code Sandbox: neither was 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 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	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	$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 bochka 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	bochka
One coding agent, workdays	None that bite	Together pay-as-you-go (prepaid credits; Code Interpreter only): sessions capped at 1 h missing persistent disk machine size not published different kind of product: code interpreter	None that bite
One agent that never stops	Personal account: GitHub Free: sessions capped at 12 h	Together pay-as-you-go (prepaid credits; Code Interpreter only): sessions capped at 1 h missing persistent disk machine size not published different kind of product: code interpreter	None that bite
50 agents in parallel	how many machines can run at once: limit not published, probably fine at 50 (the typical published limit is 50)	Together pay-as-you-go (prepaid credits; Code Interpreter only): sessions capped at 1 h missing persistent disk, Docker inside machine size not published different kind of product: code interpreter	None that bite
Sandboxes for your users	not confirmed: how many machines can run at once (you need 300; the typical published limit is 50)	machine size not published different kind of product: code interpreter machine size per session not published egress price not published	None that bite
1,000 short jobs at once	not confirmed: how many machines can run at once (you need 1,000; the typical published limit is 50)	machine size not published different kind of product: code interpreter machine size per session not published egress price not published	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)

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 bochka 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. bochka 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 bochka 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. bochka 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. bochka ships coding agents driven from outside, a 60fps desktop, a credentials proxy and token-protected HTTPS on 50 ports.

Use bochka 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: bochka vs GitHub Codespaces and bochka 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 bochka 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. bochka 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. bochka 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 bochka 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. bochka forks a running sandbox while the original keeps running.

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