Blaxel vs GitHub Codespaces
Blaxel is a sandbox API for agent products: Firecracker microVMs that go to standby seconds after the last connection and wake in under 25 ms with their memory. 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
Blaxel
Blaxel is a San Francisco company that runs cloud infrastructure for AI agents, and since September 2026 it is part of Baseten.
You get sandboxes, batch jobs, MCP server hosting and a model gateway. Each sandbox is a Firecracker microVM with its own kernel that drops to standby when nothing is connected and resumes in under 25 ms with its memory and running processes. It is built for agent products that start many sandboxes and want them asleep most of the time.
- Headquarters
- San Francisco, founded 2024
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.
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. “10th cheapest of 367” means 9 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 | Blaxel: 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 Blaxel fits a coding agent with Docker and no session cap, while Codespaces stops every 12 hours; bochka adds /dev/kvm for emulators and a real disk. | 10th cheapest of 367 $2,373 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 Blaxel's sleep and wake on request suits mostly idle assistants, while a codespace stops after 30 idle minutes by default and 12 hours at most. | 12th cheapest of 366 $2,832 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 Blaxel is built for short runs that sleep right away, while each codespace builds a dev container on a new VM first. | 14th cheapest of 345 $144 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 Blaxel's public tiers stop at 200 sandboxes at once and GitHub does not publish its limit, while bochka fits 300 at once on a self-serve plan. | 101st of 361, with limits $926 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 | 77th of 360, with limits $4,378 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 | 136th of 364, with limits $704 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 Blaxel and bochka can both fork a prepared sandbox, while Codespaces has no fork or snapshot API and starts each run from a repo or a prebuild. | 57th cheapest of 377 $431 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 the nicer editor for a person on a repo, Blaxel has no native SSH, and bochka is a plain VM you SSH into and leave on. | 265th of 368, with limits $114 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 Blaxel and bochka both run a desktop and a browser for computer use, while a codespace has an editor and a terminal but no graphical desktop. | 14th cheapest of 369 $634 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 | 16th cheapest of 367 $317 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 | 16th cheapest of 346 $215 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 | 147th of 338, with limits $4,292 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 Blaxel adds domain-level egress rules and bochka gives root with raw TCP, while on Codespaces every copy is created again from the repository. | 3rd cheapest of 360 $217 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 | Blaxel | GitHub Codespaces | bochka |
|---|---|---|---|
| What it is | Sandbox API for agent products | Cloud dev environment for people working on a GitHub repository | Sandbox API and SDK for agents, with full VMs |
| Isolation | Firecracker microVM, own kernel | A Docker container on its own newly built VM, with its own virtual network | Full VM, own kernel, on dedicated AMD Ryzen 9 9950X hosts |
| How long it runs | No session cap; Tier 0 and 1 delete sandboxes after 7 or 30 days | Stops after 30 idle minutes by default (up to 240) and after 12 hours at most, even while in use | Runs until you stop it; no session cap on paid plans |
| Sleep and wake | Standby a few seconds after the last connection, wakes in under 25 ms with memory and processes | Stop and restart; files are kept, running processes end | Stop keeps the disk and costs nothing; resume boots the VM again |
| Docker and nested virtualization | Docker with a Docker-in-sandbox image; no /dev/kvm | Docker and sudo inside the dev container; /dev/kvm is not documented | Docker, root, systemd and /dev/kvm on every machine |
| Files | Files live in memory (about half the RAM); one block volume can be attached at creation | Saved files are kept while stopped and storage is billed; stopped codespaces are deleted after 30 days by default | A real disk, snapshotted every minute and on stop |
| Fork | Fork with memory and running processes (private preview) | No copy or snapshot endpoint; new codespaces start from a repo, branch, pull request or prebuild | Fork a running sandbox (disk) into copies; named snapshots as templates |
| Starting point | Custom images built from Docker images | Dev container config in the repository, with prebuilds built by GitHub Actions | Templates from named snapshots, shareable by code; no Dockerfile builds |
| Access | Root, terminal through the bl connect command, no native SSH | VS Code in the browser or on your machine, JupyterLab, SSH and the GitHub CLI | Real SSH, root and systemd |
| Desktop and computer use | Desktop, browser and computer use | No graphical desktop | 60fps desktop and Chromium, computer use and browser control, embeddable stream |
| Coding agents | Claude Code image you drive from its terminal or your own harness | GitHub Copilot as a VS Code extension; other agents you install yourself | Claude Code, Codex, OpenCode and more preinstalled, driven by a prompt, steer and events API |
| Keeping keys out of the sandbox | Proxy fills secrets into outbound HTTPS requests (public preview) | Secrets are copied into the codespace as environment variables | AI credentials proxy for model providers and any HTTPS API you register |
| Network | Preview URL per port; domain allow and deny lists and static egress IPs; no raw TCP | A URL per forwarded port; open outbound internet with no way to restrict it; no public IP | HTTPS URLs for up to 50 ports, raw TCP, own IPv6 or IPv4; filter outbound inside the VM |
| Regions | Oregon, North Virginia, London, Frankfurt | US East, US West, Europe West and Southeast Asia | EU only: Germany, Finland, France |
Every feature Battleships tracks (43)
| Feature | Blaxel | 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 | No | Not published | Yes |
| Desktop GUI | Yes | No | Yes |
| Browser | Yes | No | Yes |
| Computer-use API | Yes | 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 | Yes | No | No |
| Custom image (Docker or snapshot) | Yes | Yes | Yes |
| ≥24 h sessions | Yes | No | Yes |
| Idle auto-stop | Yes | Yes | No |
| Wake on request | Yes | 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 | Yes | No | No |
| Open source | No | No | No |
| Scoped API keys | Yes | Not published | Yes |
| Spend limits | No | Yes | Yes |
| Usage per sandbox (API) | Yes | 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 | Yes | Not published | Yes |
Performance
In StarSling's hpc-sandbox-benchmarks run of September 29, 2026, at 4 vCPU and 8 GB, bochka did 26.69 Node.js build-and-test runs per second and Blaxel 19.48, so bochka does about 1.4 times the work in the same time. GitHub Codespaces was not in the benchmark runs, so there is no comparable measurement for it.
Node.js build-and-test loop at 4 vCPU / 8 GB, higher is better. Measured with the open hpc-sandbox-benchmarks suite. Blaxel measured on: Sandbox (active time, RAM-only pricing, CPU bundled). 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 | Blaxel, 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 | $33 · Pay-as-you-go Tier 1 | $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 | $120 · Pay-as-you-go Tier 1 | $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 | $1,489 · Pay-as-you-go Tier 1 | $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 | $396 · Pay-as-you-go Tier 2 · 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 | $876 · Pay-as-you-go Tier 2 · with limits | $1,889 · Personal account: GitHub Free · with limits | $2,000 · $2000/mo · with limits |
Blaxel: Blaxel charges for allocated RAM per second while a sandbox is active, with CPU included (8 GB comes with 4 cores). In standby you pay only snapshot storage.
GitHub Codespaces: Codespaces bills $0.09 per core-hour while a codespace is active, used or not, plus $0.07 per GB-month for storage while it exists. There is no 4-core machine with 8 GB, so 4 vCPU / 8 GB jobs are priced on the 4-core 16 GB machine.
GitHub Codespaces: Your plan payment (from $20 a month) is all usage credit, billed per second while a machine 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. Blaxel's self-serve tiers allow 10, 50 or 200 sandboxes at once, counting those in standby, so those two scenarios need a sales tier. bochka allows 100 to 2,000 at once by plan but limits starts per minute, so the 1,000-job burst gets queued.
| Scenario | Blaxel | GitHub Codespaces | bochka |
|---|---|---|---|
| One coding agent, workdays | None that bite | None that bite | None that bite |
| One agent that never stops | None that bite |
| None that bite |
| 50 agents in parallel | None that bite |
| None that bite |
| Sandboxes for your users |
|
| None that bite |
| 1,000 short jobs at once |
|
|
|
Which one should you use?
Use Blaxel when
your product starts many agent sandboxes from code that sit idle most of the time and must wake in milliseconds, or must run in the US.
- Built for agents, not people. Useful if your product starts sandboxes from code: an API, no session cap, and a desktop for computer use.
- Sleeps in seconds, wakes in milliseconds. Useful if sandboxes sit idle most of the time: standby seconds after the last connection, back in under 25 ms with memory.
- Network rules on the provider side. Useful if you must limit what agents reach: domain allow lists, method and path rules, and static egress IPs.
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 ready dev container from any repo, branch or pull request.
- A real editor for people. Useful when a person does the work: VS Code in the browser or on your machine, JupyterLab and SSH.
- Free hours and regions in Asia. Useful for occasional personal work: GitHub Free includes 120 core-hours a month, in the US, Europe or Southeast Asia.
Where bochka fits
If what you are running is coding agents that work for hours, Codespaces stops them at 12 hours and Blaxel keeps their files in memory on a microVM without /dev/kvm. bochka gives each agent a full VM with a real disk, a faster CPU than Blaxel, and agents built in that you drive from outside.
A whole Linux machine with /dev/kvm
Android emulators and microVMs need /dev/kvm. Blaxel's Firecracker guests do not get it and Codespaces does not document it, so on both that work does not start. Every bochka machine has Docker, systemd and /dev/kvm.
Long runs on a disk that stays
A codespace stops at 12 hours and its processes end, so you need a restart script. Blaxel keeps files in memory, about half the RAM, unless you attach a volume at creation. bochka runs until you stop it, snapshotting the disk every minute.
Agents driven from outside
On Codespaces you install agents and drive them over SSH, with keys as environment variables. On Blaxel you build your own harness. bochka ships Claude Code, Codex and more with a prompt, steer and events API, and keeps real keys outside.
Use bochka when your agents do real work for hours: builds, tests, Docker and emulators on a full VM with a real disk, a faster CPU and coding agents built in. Compare it one to one: bochka vs Blaxel and bochka vs GitHub Codespaces.
Questions people ask
Is Blaxel cheaper than GitHub Codespaces?
In every scenario we priced, yes: one coding agent on workdays is $33 a month on Blaxel against $51 on Codespaces, and 50 agents in parallel $1,489 against $3,019. bochka comes in at $20 and $317 for the same two.
Which is faster, Blaxel or GitHub Codespaces?
We can't say: Codespaces was not in the benchmark. At 4 vCPU and 8 GB, Blaxel did 19.48 build-and-test runs per second and bochka 26.69.
Can I run an AI agent 24/7 on Blaxel or Codespaces?
On Blaxel, yes: sandboxes have no session cap, though Tier 0 and 1 delete them after 7 or 30 days. A codespace stops after 12 hours at most, even while in use, so it needs a restart script. A bochka sandbox runs until you stop it on paid plans.
Can Blaxel and Codespaces run Docker?
Both do: Blaxel with a Docker-in-sandbox image and Codespaces inside the dev container. Neither offers /dev/kvm for Android emulators or VMs, while every bochka machine has it.
Is Blaxel or Codespaces better for computer-use agents?
Blaxel, since it runs a desktop and a browser, while a codespace has no graphical desktop. bochka streams a 60fps desktop with Chromium that you can embed in your app.
Where do Blaxel and Codespaces run?
Blaxel runs in Oregon, North Virginia, London and Frankfurt. 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