Morph Cloud vs GitHub Codespaces
Morph Cloud sells full VMs for AI agents that you can snapshot, branch and wake on request with their memory intact. GitHub Codespaces is a dev environment for people working on a GitHub repository, a dev container on its own VM that stops after 12 hours at most.
The companies and products
Morph Cloud
Morph Cloud sells full virtual machines for AI agents that can be snapshotted, branched and restored with their memory, which it calls Infinibranch.
You get MorphVM instances as low-level building blocks and Devboxes as ready workspaces on top of them, with SSH, preview URLs and a tmux API for running coding agents you install yourself. Everything is billed in MCUs, where one MCU is 1 vCPU, 4 GB of RAM or 16 GB of disk for an hour. It is built for teams that fan agents out from one saved state, and it also sells managed GitHub Actions runners and a shared filesystem.
- Regions
- Not published
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. “16th cheapest of 345” means 15 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 | Morph Cloud: 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 | 198th of 367, with limits $2,288 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 Morph can keep an assistant running all month with no time limit, while every codespace stops after 12 hours at most; bochka adds a desktop, agents and a credentials proxy on top. | 235th of 366, with limits $3,014 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 Morph fits short code runs well, since a paused machine keeps its memory, bills only its snapshot and wakes on the next request; Codespaces builds a dev container on a new VM each time. | 16th cheapest of 345 $154 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 Morph can pause each user's machine and wake it on request, while Codespaces is made for GitHub users and does not publish how many can run at once. | 12th cheapest of 361 $905 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 Morph's memory branching suits rollouts that all start from the same running state; Codespaces has no fork or snapshot endpoint. | 86th of 360, with limits $4,847 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 | 38th cheapest of 364 $675 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 Morph also sells managed GitHub Actions runners; Codespaces starts each machine from a repo or prebuild, and on bochka you run your own runner inside a sandbox. | 39th cheapest of 377 $355 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 setup per repo but stops after 12 hours, while Morph and bochka machines keep running until you stop them. | 85th cheapest of 368 $116 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 ships a ready desktop agent: Morph has browser-based remote desktop you set up yourself and Codespaces has no graphical desktop, while bochka streams a 60fps desktop with Chromium. | 182nd of 369, with limits $595 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 | 214th of 367, with limits $250 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 | 239th of 346, with limits $234 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 | 154th of 338, with limits $4,750 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 Morph and bochka can fork a prepared running machine into many copies; on Codespaces every copy is created again from the repository. | 214th of 360, with limits $228 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 | Morph Cloud | GitHub Codespaces | bochka |
|---|---|---|---|
| What it is | Full VMs for AI agents, driven by API and SDK | A cloud dev environment for a GitHub repository, opened in VS Code, the browser or the CLI | Full VMs for agents, driven by API and SDK, with agents and a desktop built in |
| Isolation | Full VM 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 |
| How long it runs | No time limit unless you set one per machine | 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 |
| Docker and nested virtualization | Root and Docker, including Docker in Docker; nested virtualization is experimental | Docker and sudo inside the dev container; /dev/kvm is not documented | Root, Docker, systemd and /dev/kvm on every machine |
| Pause with memory and wake on request | Yes; a paused VM keeps its processes, bills only its snapshot and wakes on the next HTTP request, SSH or exec call | No; a stopped codespace keeps its files but not its processes | No; disk is saved and a stopped sandbox is started again by API |
| Fork a running machine | Yes, with its memory, as many copies as you ask for, in under 250 ms | No copy or snapshot endpoint; each codespace starts from a repo, branch, pull request or prebuild | Yes, with its disk; named snapshots as templates |
| Saving work | Saved when you pause or snapshot; a plain stop deletes the instance | Files kept and storage billed after a stop; stopped codespaces are deleted after 30 days by default | Disk saved every minute and on every stop; a stopped sandbox keeps its disk and costs nothing |
| Starting point | Your own images and snapshots | 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 | Browser-based remote desktop; you install the browser and any computer use agent yourself | VS Code, JupyterLab and a terminal; no graphical desktop | 60fps Linux desktop with Chromium and a computer use API |
| Coding agents | You install the agent, then drive it through a tmux API that sends keys and reads the screen | GitHub Copilot as a VS Code extension; other agents you install and run yourself | Claude Code, Codex, OpenCode and more preinstalled, with a prompt, steer and events API |
| Keeping API keys out of the machine | Responses Proxy for model APIs; other secrets are handed to the machine | Secrets are copied into the codespace as environment variables | Credentials proxy for model providers and any HTTPS API; switch a credential to another account when credits run out |
| Reaching the machine | Named HTTP services with optional API key auth; SSH through Morph's gateway; no raw TCP | 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 |
| Guest systems | Linux, with experimental Windows and macOS (x86) | Linux only | Linux |
| Regions | Not published | US East, US West, Europe West and Southeast Asia | EU only: Germany, Finland, France |
Every feature Battleships tracks (43)
| Feature | Morph Cloud | GitHub Codespaces | bochka |
|---|---|---|---|
| Full VM (own kernel) | Yes | Yes | Yes |
| Docker inside | Yes | Yes | Yes |
| Nested virtualization | Yes | No | Yes |
| Root | Yes | Yes | Yes |
| Systemd | Yes | Not published | Yes |
| Desktop GUI | Yes | No | Yes |
| Browser | No | No | Yes |
| Computer-use API | No | No | Yes |
| SSH | Yes | 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 | No | No | No |
| Secret proxy | Yes | No | Yes |
| Secret proxy for any API | No | No | Yes |
| Preinstalled agents | No | No | Yes |
| Agent harness API | Yes | No | Yes |
| MCP server | No | No | No |
| GPU | No | No | No |
| Windows | Yes | No | No |
| Arm64 | No | No | No |
| Self-hosting | No | No | No |
| BYOC | No | No | No |
| Open source | No | No | No |
| Scoped API keys | Yes | Not published | Yes |
| Spend limits | Not published | Yes | Yes |
| Usage per sandbox (API) | Yes | No | Yes |
| Audit logs | Yes | Yes | No |
| SSO | Not published | Yes | No |
| SOC 2 | Not published | Yes | No |
| HIPAA | Not published | No | No |
| EU data residency | Not published | Yes | Yes |
| Zero data retention | Not published | Not published | Yes |
Performance
There is no comparable CPU measurement for Morph Cloud or GitHub Codespaces: neither is in the hpc-sandbox-benchmarks run. 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. Morph says it restores a snapshot in under 250 ms, which measures start time, not CPU speed.
Node.js build-and-test loop at 4 vCPU / 8 GB, higher is better. Measured with the open hpc-sandbox-benchmarks suite. Morph Cloud and GitHub Codespaces 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 | Morph Cloud, 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 | $32 · Developer | $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 | $121 · Team | $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,459 · Scale | $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 | $325 · Scale | $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 | $869 · Scale | $1,889 · Personal account: GitHub Free · with limits | $2,000 · $2000/mo · with limits |
Morph Cloud: Morph bills MCUs at $0.05 each: per hour, a machine uses the largest of its vCPUs, its RAM in 4 GiB steps or its disk in 16 GiB steps. Team ($40 a month) and Scale ($250 a month) are prepaid MCU bundles at a discount, and a paused VM bills only its snapshot.
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 jobs are priced on the 16 GB machine; personal accounts get a free monthly quota and organizations do not.
GitHub Codespaces: Plans start at $20 a month, and the whole fee is 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 does not fit the always-on scenario, and GitHub does not publish how many codespaces can run at once, so 300 user sandboxes and 1,000 short jobs are not confirmed. Morph's limits are account-wide resource pools: the Developer pool of 64 vCPU holds only 16 machines at 4 vCPU, disk beyond 16 GiB per MCU raises the bill, and egress prices are not published. At 1,000 short jobs at once, Morph Scale fits while bochka's $2,000 plan queues starts.
| Scenario | Morph Cloud | GitHub Codespaces | bochka |
|---|---|---|---|
| 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 Morph Cloud when
your agents branch from one running state with its memory, sleep between requests and wake on demand, or need experimental Windows and macOS guests.
- Branch and wake with memory. For agents that fan out from one running state or sleep between requests: Morph copies memory and wakes paused VMs on demand.
- Built for agents, with no time limit. For long agent jobs: a Morph VM runs until you stop it or set a time limit, instead of stopping at 12 hours.
- Windows and macOS guests. For agents that must test in other systems: Morph lists experimental Windows and macOS (x86) guests next to Linux.
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 that live on GitHub: open a ready codespace from any repo, branch or pull request, with the dev container set up.
- Free hours for personal accounts. For occasional personal work: a GitHub Free account gets 120 core-hours and 15 GB-month of storage each month.
- Regions in the US and Asia. For developers outside Europe: codespaces run in US East, US West, Europe West and Southeast Asia.
Where bochka fits
If you are comparing these two because you want somewhere to run AI agents, bochka is built for that job with the agents, desktop and key handling already inside. Morph gives you a strong VM but leaves the agent harness, the browser and most secrets to you, and Codespaces is a developer workspace that stops after 12 hours.
Coding agents you drive from outside
On Morph you install the agent and drive it through tmux keystrokes, and on Codespaces you start and watch it over SSH. Either way you write and maintain a harness that reads terminal output to know when the agent is done or stuck.
A full VM with /dev/kvm and a desktop
Codespaces documents no /dev/kvm and no graphical desktop, and Morph lists nested virtualization as experimental with a desktop you set up yourself. Android emulators, microVMs and computer use agents need both, and bochka ships them on every machine.
Real keys never enter the machine
Codespaces copies secrets in as environment variables, and Morph's proxy covers model APIs only, so a GitHub or Stripe key sits where the agent can read it. bochka's credentials proxy keeps keys outside for any HTTPS API.
Use bochka when your code starts and drives agents that work for hours or days: full VMs with /dev/kvm, a desktop with Chromium, preinstalled coding agents with keys kept outside, and hosting on many ports in the EU. Compare it one to one: bochka vs Morph Cloud and bochka vs GitHub Codespaces.
Questions people ask
Is Morph Cloud cheaper than GitHub Codespaces?
In every scenario we priced, yes. One coding agent on workdays is $32 a month on Morph against $51 on Codespaces, and 50 agents in parallel are $1,459 against $3,019. bochka comes in at $20 and $317 for the same two.
Which is faster?
We have no comparable CPU measurement for either Morph Cloud or GitHub Codespaces. bochka did 26.69 runs per second on StarSling's Node.js build-and-test loop at 4 vCPU / 8 GB.
Can I run an agent 24/7 on each?
On Morph, yes: a VM runs until you stop it unless you set a time limit. A codespace stops after 12 hours at most, even while in use, so it needs a restart script and its processes end at each stop. A bochka sandbox runs until you stop it, with no session cap on paid plans.
Can Morph Cloud and GitHub Codespaces run Docker?
Both run Docker with root or sudo. Morph lists nested virtualization as experimental, and GitHub does not document /dev/kvm in a codespace. Every bochka machine has Docker, systemd and /dev/kvm.
Can I copy a running machine?
Morph can branch a running VM with its memory into many copies in under 250 ms. Codespaces has no copy or snapshot endpoint, so each new one starts from the repository or a prebuild. bochka forks a running sandbox with its disk.
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