Vercel Sandbox vs GitHub Codespaces

Vercel Sandbox is a sandbox you start from code: a Firecracker microVM for short runs of untrusted or agent-written code, in 19 regions, with sessions of up to 24 hours. GitHub Codespaces is a dev environment for people: a Linux dev container per repository, opened in VS Code or the browser, that stops after 12 hours at most.

The companies and products

Vercel Sandbox

Vercel is a cloud platform for web apps and agents, and Vercel Sandbox is its product for running untrusted or agent-written code in isolated Linux microVMs.

Each sandbox is a Firecracker microVM with its own kernel, started from a Vercel image, your own OCI image, or a saved snapshot. You drive it with the JavaScript or Python SDK or the sandbox CLI: run commands, move files, open ports, and set network rules. It is aimed at code interpreters, app builders, test runs and agent tools, and Vercel's docs say it is not meant to run nonstop.

Isolation: Firecracker microVM with a dedicated kernel per sandbox
Default image: Ubuntu with Node.js 24, Python 3.14, and Claude Code, Codex, OpenCode and pi preinstalled
SDKs: JavaScript/TypeScript, Python, and a CLI
Regions: 19 regions, default iad1 (US East)
Longest session: 24 hours on Pro and Enterprise, 45 minutes on Hobby; a stopped sandbox resumes from its last snapshot
Biggest sandbox: 8 vCPU / 16 GB on Pro, 32 vCPU / 64 GB on Enterprise
Compliance: SOC 2 Type 2, ISO 27001, PCI DSS; HIPAA for Enterprise

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

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. “22nd cheapest of 345” means 21 of the other 344 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	Vercel Sandbox: 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 are compromises for long build-and-test agents: no desktop to check the UI, no /dev/kvm, and a hard session cap on each.	244th of 367, with limits $3,351 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 Neither fits an always-on assistant: Vercel stops each session at 24 hours and Codespaces at 12, while bochka machines run with no session cap.	257th of 366, with limits $3,657 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 Vercel Sandbox fits short code bursts well because it bills CPU only while code uses it; a codespace builds a dev container on a new VM, so it is a compromise here.	22nd cheapest of 345 $216 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 Vercel Sandbox fits sandboxes for your own users and ranks 15th, while Codespaces is made for GitHub users on a repository and does not publish how many can run at once; bochka ranks first.	15th cheapest of 361 $1,267 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 Vercel Sandbox ranks 3rd for many short parallel rollouts thanks to high concurrency and fast starts; Codespaces is a compromise, and bochka's start limits make it one too.	3rd cheapest of 360 $15,761 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	69th cheapest of 364 $1,508 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 Vercel Sandbox fits CI runs, while Codespaces has no fork or snapshot API, so each run starts again from a repo or a prebuild; bochka ranks 4th.	107th cheapest of 377 $1,144 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 Codespaces is a polished VS Code box per repo but stops after 12 hours, and Vercel restarts every 24 hours; bochka keeps one machine running.	276th of 368, with limits $145 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: Vercel is headless and a codespace has an editor and a terminal, while bochka streams a 60fps desktop with Chromium.	235th of 369, with limits $952 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	259th of 367, with limits $486 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	277th of 346, with limits $468 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	234th of 338, with limits $9,960 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	283rd of 360, with limits $554 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	Vercel Sandbox	GitHub Codespaces	bochka
What it is	A sandbox API for running untrusted or agent-written code	A cloud dev environment for a GitHub repository	A sandbox API for agents, with full VMs you drive from code
Isolation	Firecracker microVM with its own 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
Longest session	24 hours on Pro and Enterprise, 45 minutes on Hobby; resume starts a new session	12 hours at most even while in use, and 30 idle minutes by default (5 to 240)	No cap on paid plans (--no-auto-stop); default TTL 1 hour, changeable
Saving files	Filesystem snapshot on stop, billed per GB a month and kept 30 days after last use by default	Files kept while the codespace exists, storage billed; stopped codespaces are deleted after 30 days by default	Snapshot every minute while running and on stop; a stopped sandbox keeps its disk and costs nothing
Fork and copies	Snapshots you can start new sandboxes from	No copy or snapshot endpoint; new codespaces start from a repo, branch, pull request or prebuild	Fork a running sandbox into copies with its files; named snapshots as templates
Docker and nested virtualization	Docker with sudo; no nested virtualization	Docker and sudo in the dev container; /dev/kvm not documented	Docker, root, systemd and /dev/kvm on every machine
Starting image	Your own OCI image from a Dockerfile, via Vercel Container Registry	Dev container config in the repository, with prebuilds built by GitHub Actions	Named snapshots (templates), shareable by code; no Dockerfile builds
Desktop and computer use	None; headless Linux only	VS Code in the browser or on your machine, JupyterLab and a terminal; no graphical desktop	60fps desktop and Chromium, computer-use and browser-control APIs, embeddable stream
Driving it from code	JavaScript and Python SDKs and a CLI to run commands, move files and open ports	REST API and GitHub CLI to create, start, stop and delete; commands run over SSH	API and SDK to create, fork, stop and run commands, on every plan
Coding agents	Claude Code, Codex, OpenCode and pi preinstalled; you start them as commands	GitHub Copilot as a VS Code extension; other agents you install and run yourself	Claude Code, Codex, OpenCode, pi and more preinstalled, with an API to prompt, steer and stream events
Keys kept outside the sandbox	Credentials brokering injects headers for any HTTPS domain you allow	Secrets are copied into the codespace as environment variables	Credentials proxy for model providers and any HTTPS API you register; switch a credential to another account when one runs out
Inbound access	Public URLs for up to 15 ports, no built-in auth; no raw TCP or public IP	A URL per forwarded port, private, organization or public; SSH and CLI tunnels; no public IP	HTTPS URLs for up to 50 ports, token-protected by default; raw TCP; dedicated IPv6 or IPv4
Outbound rules	Allow-all, deny-all or a domain and CIDR allowlist, changeable while running	Open internet; GitHub says there is no way to restrict it	Open internet on every plan; firewall inside the VM, no provider-side allowlist
Regions	19 regions across the US, Europe, Asia, South America, Africa and Australia	US East, US West, Europe West and Southeast Asia	EU only: Germany, Finland, France

Every feature Battleships tracks (43)

Feature	Vercel Sandbox	GitHub Codespaces	bochka
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	No	Yes	Yes
Persistent disk	Yes	Yes	Yes
Pause/resume	Yes	Yes	Yes
Automatic snapshots	Yes	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	Yes	No	No
Secret proxy	Yes	No	Yes
Secret proxy for any API	Yes	No	Yes
Preinstalled agents	Yes	No	Yes
Agent harness API	No	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	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	No	Yes
Audit logs	Not published	Yes	No
SSO	Yes	Yes	No
SOC 2	Yes	Yes	No
HIPAA	Yes	No	No
EU data residency	Yes	Yes	Yes
Zero data retention	Not published	Not published	Yes

Performance

Vercel Sandbox12.96 runs/s

GitHub CodespacesNot measured

bochka26.69 runs/s

On the same hpc-sandbox-benchmarks Node.js build-and-test loop at 4 vCPU / 8 GB, bochka did 26.69 runs per second and Vercel Sandbox did 12.96, so bochka finished about twice as many runs. There is no comparable measurement for GitHub Codespaces: it was not in the public benchmark runs we use. This measures CPU speed only, not start time.

Node.js build-and-test loop at 4 vCPU / 8 GB, higher is better. Measured with the open hpc-sandbox-benchmarks suite. GitHub Codespaces has 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	Vercel Sandbox, 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	$57 · Pro	$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	$236 · Pro · with limits	$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,884 · Pro	$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	$828 · Pro	$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	$3,152 · Pro	$1,889 · Personal account: GitHub Free · with limits	$2,000 · $2000/mo · with limits

Vercel Sandbox: Vercel charges for CPU only while your code uses it, but for memory for the whole time the sandbox runs, idle time included, plus a small fee per sandbox created and a monthly fee per GB of snapshots. The $20 Pro credit is shared with your other Vercel usage.

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 4 vCPU jobs are priced on the 4-core 16 GB machine; organizations get no free quota.

GitHub Codespaces: bochka charges a flat price per size, per second, only while the machine runs; a stopped sandbox costs nothing. Plans start at $20 a month, and all of the fee is usage credit.

Limits in those scenarios

For one agent that never stops, neither fits: Vercel ends each session at 24 hours and Codespaces at 12, and running processes start over after 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, while Vercel fits both. bochka does not fit the 1,000-job burst either: even the $2,000 plan allows 600 starts an hour and 2,400 a day.

Scenario	Vercel Sandbox	GitHub Codespaces	bochka
One coding agent, workdays	None that bite	None that bite	None that bite
One agent that never stops	Pro: sessions capped at 24 h	Personal account: GitHub Free: sessions capped at 12 h	None that bite
50 agents in parallel	None that bite	how many machines can run at once: limit not published, probably fine at 50 (the typical published limit is 50)	None that bite
Sandboxes for your users	None that bite	not confirmed: how many machines can run at once (you need 300; the typical published limit is 50)	None that bite
1,000 short jobs at once	None that bite	not confirmed: how many machines can run at once (you need 1,000; the typical published limit is 50)	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 Vercel Sandbox when

your app runs many short bursts of untrusted or agent-written code from an SDK, or needs to run close to users around the world.

Built for code you start from your app. Useful if your product runs agent or user code: an SDK starts a microVM, runs commands and stops it, with high concurrency.
A firewall you control from outside. A running sandbox can be switched to deny-all, or to a list of allowed domains, without a restart.
Regions all over the world. Useful if your users are far from Europe: Vercel Sandbox runs in 19 regions, from Virginia to Tokyo and Sydney.

Use GitHub Codespaces when

your developers want a ready VS Code environment for a GitHub repository, opened from a branch or pull request.

Built into GitHub. Useful if your team lives on GitHub: open a codespace from any repo, branch or pull request, with the dev container already set up.
A full editor for people. Useful when a developer does the work: VS Code in the browser or on your machine, JupyterLab and a terminal.
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.

Where bochka fits

If what you are really running is coding agents that work for hours on one machine, both caps get in the way: Vercel stops each session at 24 hours and Codespaces at 12. bochka gives each agent a full VM that runs until you stop it, with a desktop, /dev/kvm and an API to drive the agents inside from outside.

No session cap on paid plans

On Vercel a session ends at 24 hours and on Codespaces at 12, and running processes start over each time. A long agent task is cut off, so you write a restart script. bochka saves the disk every minute and keeps running.

A full VM with /dev/kvm and a desktop

Neither gives an agent a screen to check the app it built, and neither offers /dev/kvm for Android emulators or VMs. On both you would build a desktop yourself. bochka streams a 60fps desktop with Chromium on every machine.

Agents driven from outside

Vercel installs agents you start as plain commands, and Codespaces offers Copilot in the editor, with other agents run over SSH. Either way you write the code that prompts and watches each agent. bochka gives you one API to prompt, steer and stream them.

Use bochka when your agents work for hours on one machine: full VMs with Docker, /dev/kvm and a desktop, no session cap on paid plans, and an API to drive the agents inside from outside. Compare it one to one: bochka vs Vercel Sandbox and bochka vs GitHub Codespaces.

Questions people ask

Is Vercel Sandbox cheaper than GitHub Codespaces?

It depends on the job. One coding agent on workdays costs $57 a month on Vercel against $51 on Codespaces, and 50 agents in parallel cost $2,884 against $3,019. For 1,000 short jobs at once Codespaces prices at $1,889 against $3,152, but GitHub does not confirm that many can run at once. bochka comes to $20, $317 and $2,000 for the same three.

Which is faster?

Vercel Sandbox did 12.96 Node.js build-and-test runs per second at 4 vCPU / 8 GB, and bochka did 26.69. GitHub Codespaces was not in the benchmark runs we use, so there is no comparable number for it.

Can they run 24/7?

Not as one session. Vercel Sandbox stops after 24 hours on Pro and Enterprise, and a codespace stops after 12 hours even while in use. Both keep files, but running processes start over. A bochka sandbox runs until you stop it, with no session cap on paid plans.

Can Vercel Sandbox and Codespaces run Docker?

Yes. Vercel Sandbox runs Docker with sudo, and a codespace runs Docker inside its dev container. Neither offers /dev/kvm, so Android emulators and VMs inside are not supported. Every bochka machine has Docker, systemd and /dev/kvm.

Which one is better for AI coding agents?

Vercel Sandbox ships Claude Code, Codex, OpenCode and pi and lets you start sandboxes from code, so it suits agents started by your app. Codespaces is built for a person in VS Code, with Copilot as an extension. bochka adds a desktop, no session cap on paid plans and an API to prompt and steer the agents.

Where do they run?

Vercel Sandbox runs in 19 regions, with iad1 in the US as the default. Codespaces runs in US East, US West, Europe West and Southeast Asia. bochka runs only in the EU, in Germany, Finland and France.

Try bochka

Install the CLI, then run bochka new.

Product preview