GitHub Codespaces vs smol machines

GitHub Codespaces is a dev environment for people: a dev container opened from a GitHub repository in VS Code, which stops after 12 hours at most. smol machines is a microVM service you drive from code, with live branching and an open-source engine you can also run on your own servers.

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.

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

smol machines

smol machines makes fast, isolated Linux microVMs that run the same way on your laptop, in their hosted cloud, or on your own servers.

The core is smolvm, an open-source microVM engine built on libkrun, where each machine has its own guest kernel. smol cloud is the paid hosted service that runs fleets of those machines behind a REST API and Node, Python and Rust SDKs. It is built for developers who want one VM model from local development to production, with live branching of running machines.

Isolation: Hardware-isolated microVM with its own guest kernel (libkrun)
Company: Founded 2026, Y Combinator Spring 2026, San Francisco, team of one listed
Open source: smolvm engine and smol SDK are open source and run on macOS, Linux and Windows hosts
Guests: Linux only; no Windows or macOS guests
Regions: No region field in the cloud create API
Uptime SLA: 99.95% on Pro, Startup and Enterprise

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	smol machines: price rank	boat: price rank
Software factory 100 at once · 4 vCPU / 8 GB · 2,200 sessions of 8 h a month Both run Docker, but a codespace stops after 12 hours and smol cloud has no nested virtualization; boat runs until stopped and has /dev/kvm.	274th of 367, with limits $4,618 a month	73rd of 367, with limits $604 a month	3rd cheapest of 367 $634 a month
Always-on AI employees 50 machines 24/7 · 2 vCPU / 4 GB An always-on assistant fits smol machines better than Codespaces, which stops every 12 hours; boat adds a desktop, a browser and keys kept outside the machine.	309th of 366, with limits $6,970 a month	148th of 366, with limits $1,038 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 smol machines suits short code runs with a one-minute minimum and a /code endpoint, while each codespace builds a dev container on a new VM.	288th of 345, with limits $619 a month	12th cheapest of 345 $140 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 smol machines holds up to 1,000 machines on Startup, while GitHub does not publish how many codespaces can run at once.	281st of 361, with limits $1,964 a month	7th cheapest of 361 $531 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 smol machines can branch a running machine with its memory and processes, while Codespaces has no copy or snapshot endpoint at all.	282nd of 360, with limits $9,489 a month	111th of 360, with limits $6,978 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	36th cheapest of 364 $670 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 smol machines starts each job from an image or a branch of a warm machine; Codespaces starts from a repo or a prebuild built by GitHub Actions.	314th of 377, with limits $909 a month	66th cheapest of 377 $514 a month	4th cheapest of 377 $86 a month
24/7 dev boxes 1 machine 24/7 · 4 vCPU / 8 GB Codespaces gives a polished VS Code setup per repo but stops after 12 hours; smol machines and boat both keep running until you stop them.	130th of 368, with limits $270 a month	216th of 368, with limits $29 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 smol cloud has a hosted graphical desktop, while boat streams a 60fps desktop with Chromium for computer use.	267th of 369, with limits $1,367 a month	90th of 369, with limits $156 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	176th of 367, with limits $136 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	241st of 346, with limits $242 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	148th of 338, with limits $4,344 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	252nd of 360, with limits $377 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	smol machines	boat
What it is	A cloud dev environment opened from a GitHub repository in VS Code, the browser or the CLI	A hosted microVM service with a REST API and Node, Python and Rust SDKs	A sandbox API for agents: full VMs you create, fork and drive from code
Isolation	A Docker container on its own newly built VM	libkrun microVM with its own guest kernel	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	Runs until you stop it; an optional lifetime you set yourself	Runs until you stop it; no session cap on paid plans
Files after a stop	Files kept and storage billed; stopped codespaces are deleted after 30 days by default	Filesystem survives a stop, memory paths like /tmp are emptied; stopped disk keeps billing	Disk saved every minute and on stop; a stopped sandbox costs nothing
Fork	No copy or snapshot endpoint; new codespaces start from a repo, branch or prebuild	Branch a running machine with its memory and processes	Fork a running sandbox with its disk; named snapshots as templates
Starting point	Dev container config in the repo, with prebuilds built by GitHub Actions	Registry images in amd64 and arm64, or your own .smolmachine artifact	Named snapshots (templates), shareable by code
Docker and nested virtualization	Docker and sudo in the dev container; /dev/kvm not documented	Docker inside the VM; nested virtualization not exposed on hosted machines	Docker, root, systemd and /dev/kvm on every machine
Shell access	SSH and the GitHub CLI	Command API, sessions and a WebSocket terminal; no SSH	SSH, plus a command API and terminal
Desktop and computer use	VS Code, JupyterLab and a terminal; no graphical desktop	No hosted desktop; a guide shows running your own Chromium	60fps Linux desktop with Chromium and computer use built in
Coding agents	GitHub Copilot as a VS Code extension; others you install yourself	Registry images with the Codex CLI and the Harbor eval harness	Claude Code, Codex, OpenCode and more preinstalled, with a prompt, steer and events API
Keeping keys out of the sandbox	Secrets copied in as environment variables	Cloud secrets are environment variables the guest can read	Credentials proxy for model providers and any HTTPS API
Reaching the machine	A URL per forwarded port, private, organization or public; no public IP	Up to 16 published ports through a URL or an authenticated route; no dedicated IP	HTTPS URLs for up to 50 ports, raw TCP, dedicated IPv4 or IPv6
Outbound rules	Open internet; GitHub says there is no way to restrict it	Blocked, open, or an allowlist of hosts and CIDR ranges	Open internet, no provider-side allowlist
Where it runs	US East, US West, Europe West and Southeast Asia	No region choice in the cloud API; open-source smolvm on your own servers	EU only (Germany, Finland, France), with EU data residency

Every feature Battleships tracks (43)

Feature	GitHub Codespaces	smol machines	boat
Full VM (own kernel)	Yes	Yes	Yes
Docker inside	Yes	Yes	Yes
Nested virtualization	No	No	Yes
Root	Yes	Not published	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	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	Yes	No
Wake on request	No	Yes	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	No	Yes
Secret proxy for any API	No	No	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	Yes	No
BYOC	No	Yes	No
Open source	No	Yes	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	No	No
HIPAA	No	No	No
EU data residency	Yes	No	Yes
Zero data retention	Not published	Not published	Yes

Performance

GitHub CodespacesNot measured

smol machinesNot measured

boat26.69 runs/s

There is no comparable CPU measurement for GitHub Codespaces or smol machines: neither was in the StarSling hpc-sandbox-benchmarks runs we use. boat did 26.69 Node.js build-and-test runs per second at 4 vCPU / 8 GB in the 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 smol machines 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	smol machines, 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	$25 · Standard	$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	$93 · Standard	$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	$1,139 · Pro	$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	$465 · Startup	$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,389 · Startup	$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 4 vCPU / 8 GB work is priced on the 4-core 16 GB machine.

smol machines: smol cloud charges $0.04 for every hour a machine runs plus the CPU and memory the guest actually uses, with a one-minute minimum and disk billed while stopped. Pro ($20) and Startup ($150) are monthly fees on top of usage.

smol machines: Plans start at $20 a month and the whole fee is usage credit, spent per second while a sandbox runs. A stopped sandbox costs nothing and keeps its disk.

Limits in those scenarios

Every codespace stops after 12 hours at most, so it does not fit the always-on scenario without a restart script, and GitHub does not publish how many can run at once, so 300 user sandboxes and 1,000 short jobs are not confirmed. smol machines caps machines held by plan (20 on Standard, 100 on Pro, 1,000 on Startup, stopped ones included), so 50 agents need Pro and the 1,000-job burst needs Startup. On boat the 1,000-job burst gets queued above 90 starts a minute.

Scenario	GitHub Codespaces	smol machines	boat
One coding agent, workdays	None that bite	None that bite	None that bite
One agent that never stops	Personal account: GitHub Free: sessions capped at 12 h	None that bite	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)	None that bite	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)	None that bite	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)	None that bite	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. For teams on GitHub: open a ready codespace from any repo, branch or pull request, with the dev container already set up.
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 smol machines when

your code needs microVMs that run until stopped, branch with their memory, limit outbound hosts, or also run on your own servers.

Live branches with memory. For RL and test fan-out: branch a running machine with its memory and processes, paying the one-minute minimum once.
Open source, laptop to your own servers. For teams that want one VM engine locally, in a hosted cloud and on their own servers.
Outbound allowlists and arm64. For teams that must limit which hosts a machine reaches, or that need arm64 images.

Where boat fits

If you are comparing these two because you want somewhere for agents to work, look at boat too. It gives each agent a full VM that runs until you stop it, with /dev/kvm, a desktop and coding agents you drive from outside. Codespaces is built for people in an editor, and smol cloud gives you a bare microVM to build on.

A full machine with /dev/kvm and SSH

Android emulators and microVMs need /dev/kvm, which GitHub does not document and smol cloud does not expose. smol cloud also has no SSH, so tools that expect it must be rewired to an exec API.

A desktop for computer use

Neither has a hosted graphical desktop. A computer-use agent on either needs you to build, package and maintain a desktop, browser and screen stream yourself; boat streams one at 60fps with Chromium.

Agents driven from outside, keys kept out

Both put secrets in environment variables any code the agent runs can read, and on both you write the harness that prompts and watches each agent. boat ships the agents, one API to steer them, and a credentials proxy.

Use boat when your agents need a whole machine for long work: Docker, /dev/kvm, SSH, a desktop and open ports, with coding agents you drive from outside and keys that never enter the sandbox. Compare it one to one: boat vs GitHub Codespaces and boat vs smol machines.

Questions people ask

Is GitHub Codespaces cheaper than smol machines?

Not in the scenarios we priced. One coding agent on workdays is $51 a month on Codespaces against $25 on smol machines, and 50 agents in parallel come to $3,019 against $1,139. boat is $20 and $317 for the same two.

Which is faster?

We have no comparable CPU measurement for either one. boat did 26.69 runs per second on the StarSling Node.js test at 4 vCPU / 8 GB.

Can I run an agent 24/7 on GitHub Codespaces or smol machines?

On smol machines, yes: a machine runs until you stop it unless you set a lifetime. A codespace stops after 12 hours at most, even while in use, so it needs a restart and its processes end. boat runs until you stop it, with no session cap on paid plans.

Can GitHub Codespaces and smol machines run Docker?

Both run Docker: Codespaces inside the dev container with sudo, smol machines inside the VM. Neither offers /dev/kvm on its hosted machines, so Android emulators and nested VMs are out. Every boat machine has Docker, systemd and /dev/kvm.

Can either fork a running machine?

smol machines can branch a running machine with its memory and processes. Codespaces has no copy or snapshot endpoint, so each new codespace starts from a repo or a prebuild. boat forks a running sandbox with its disk.

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