Morph Cloud vs CodeSandbox SDK
Both give each sandbox its own kernel and can save a running machine with its memory. Morph Cloud sells full VMs that branch into many copies and wake on demand, while CodeSandbox SDK sells Firecracker microVMs that hibernate by themselves when idle and wake on the next HTTP request.
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
CodeSandbox SDK
CodeSandbox SDK is an API from CodeSandbox, now a Together AI company, that starts sandboxed development VMs on the same infrastructure as the CodeSandbox editor.
Each sandbox is a Firecracker microVM built from a template or any Dockerfile. When it goes idle it hibernates with a memory snapshot, and it resumes or forks from that snapshot in seconds. You drive it from a TypeScript SDK through terminals, commands, files and HTTPS hosts. Together's docs now call it the legacy offering and point new users to its successor, the together-sandbox SDK.
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 | CodeSandbox SDK: price rank | bochka: price rank |
|---|---|---|---|
| Software factory 100 at once · 4 vCPU / 8 GB · 2,200 sessions of 8 h a month Both run Docker and full builds, but you install and drive the coding agent yourself, through tmux on Morph or the command API on CodeSandbox SDK. | 198th of 367, with limits $2,288 a month | 178th of 367, with limits $1,939 a month | 3rd cheapest of 367 $634 a month |
| Always-on AI employees 50 machines 24/7 · 2 vCPU / 4 GB | 235th of 366, with limits $3,014 a month | 215th of 366, with limits $2,478 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 Both suit short code runs on machines that sleep with their memory, and Morph Cloud ranks 16th here against 46th for CodeSandbox SDK. | 16th cheapest of 345 $154 a month | 46th cheapest of 345 $642 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 Cloud ranks 12th and fits; CodeSandbox SDK's Scale plan caps at 250 VMs at once, and bochka ranks 1st with HTTPS on up to 50 ports and raw TCP per user. | 12th cheapest of 361 $905 a month | 140th of 361, with limits $1,707 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 Both can branch rollouts from one running state with its memory; Morph Cloud ranks 86th and CodeSandbox SDK 348th, mostly on price at this scale. | 86th of 360, with limits $4,847 a month | 348th of 360, with limits $3,861 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 | 64th cheapest of 364 $1,335 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; on CodeSandbox SDK and on bochka you run your own runner, and only bochka exposes /dev/kvm for emulator builds. | 39th cheapest of 377 $355 a month | 92nd cheapest of 377 $860 a month | 4th cheapest of 377 $86 a month |
| 24/7 dev boxes 1 machine 24/7 · 4 vCPU / 8 GB A dev box that runs all month fits Morph Cloud fully, while CodeSandbox SDK is a compromise here; bochka adds SSH, a desktop and preinstalled coding agents. | 85th cheapest of 368 $116 a month | 310th of 368, with limits $240 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 desktop with a browser for computer use; bochka streams a 60fps Linux desktop with Chromium and a computer use API in every sandbox. | 182nd of 369, with limits $595 a month | 206th of 369, with limits $691 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 On Morph you run headless Chrome yourself in Docker, and CodeSandbox SDK offers a headless Chromium template; bochka has Chromium ready on its desktop. | 214th of 367, with limits $250 a month | 251st of 367, with limits $443 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 | 281st of 346, with limits $508 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 | 193rd of 338, with limits $7,390 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 | 214th of 360, with limits $228 a month | 240th of 360, with limits $326 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 | CodeSandbox SDK | bochka |
|---|---|---|---|
| Isolation | Full VM with its own kernel | Firecracker microVM with its own kernel | Full VM with its own kernel on dedicated AMD Ryzen 9 9950X hosts |
| Root and Docker | Yes, including Docker in Docker and local Kubernetes | Yes; sandboxes are built from a template or any Dockerfile | Root, Docker and systemd |
| Nested virtualization | Experimental | Not documented | Yes, /dev/kvm for Android emulators and VMs |
| Pause with memory | Pause keeps every process and memory; a paused VM bills only its snapshot, with no default expiry | Hibernates with a memory snapshot at no cost; after about 7 days it is archived and resume takes 20 to 60 seconds | No; disk is saved every minute and on stop, and resume boots the machine again |
| Fork a running machine | Branch with its memory into as many copies as you ask for, in under 250 ms | Fork a hibernated sandbox from its snapshot, or a running one sharing its memory | Fork a running sandbox with its disk |
| Sleep and wake | A time to live you set can pause it; it wakes on the next HTTP request, SSH or exec call | Hibernates by itself after an idle timeout of up to one day; an HTTP request to a host wakes it | Stops on a time to live you set; a stopped sandbox is free and is started again by API |
| Shell access | SSH through Morph's gateway, plus an exec API | Terminals, commands and files through the SDK; no SSH | SSH, plus exec and files over the API |
| Inbound access | Named HTTP services with optional API key auth; no raw TCP | HTTPS host per port, public by default, signed tokens for private hosts; no raw TCP or public IP | HTTPS URLs for up to 50 ports, token-protected by default; raw TCP |
| Desktop and browser | Browser-based remote desktop; you install the browser and any computer use agent | No desktop; a headless Chromium template | 60fps Linux desktop with Chromium and a computer use API |
| Coding agents | You install the agent and drive it through a tmux API that sends keys and reads the screen | You run your own agent through the command API | Claude Code, Codex and others preinstalled, with a prompt, steer and events API |
| Keeping API keys out of the sandbox | Responses Proxy for model APIs; other secrets are handed to the machine | Secrets passed in as environment variables | Credentials proxy for model providers and any HTTPS API; switch a credential to another account when credits run out |
| Guest systems | Linux, with experimental Windows and macOS (x86) | Linux | Linux |
| Machines at once | Account-wide pools: 64 vCPU on Developer up to 1,024 vCPU on Scale | 10 VMs on Build, 250 on Scale, more on Enterprise | No session cap on paid plans; starts are rate-limited, so big bursts are queued |
| Where data lives | Regions not published | A country hint steers scheduling, for example to Europe, but placement is not guaranteed | EU only (Germany, Finland, France), with zero data retention |
Every feature Battleships tracks (43)
| Feature | Morph Cloud | CodeSandbox SDK | 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 | No | Yes |
| Persistent disk | Yes | Yes | Yes |
| Pause/resume | Yes | Yes | Yes |
| Automatic snapshots | Yes | Yes | Yes |
| Fork/clone | Yes | Yes | Yes |
| Live fork (no pause) | Yes | Yes | Yes |
| Memory fork | Yes | Yes | No |
| Custom image (Docker or snapshot) | Yes | Yes | Yes |
| ≥24 h sessions | Yes | Yes | Yes |
| Idle auto-stop | Yes | Yes | No |
| Wake on request | Yes | Yes | 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 | Not published | Yes |
| Usage per sandbox (API) | Yes | No | Yes |
| Audit logs | Yes | Not published | No |
| SSO | Not published | Yes | No |
| SOC 2 | Not published | Yes | No |
| HIPAA | Not published | No | No |
| EU data residency | Not published | No | Yes |
| Zero data retention | Not published | Not published | Yes |
Performance
There is no comparable CPU measurement for Morph Cloud or CodeSandbox SDK: neither is in the StarSling hpc-sandbox-benchmarks run. bochka did 26.69 runs per second on that Node.js build-and-test loop at 4 vCPU / 8 GB, on dedicated AMD Ryzen 9 9950X hosts. Morph's under-250 ms figure is snapshot restore 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 CodeSandbox SDK 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 | CodeSandbox SDK, 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 | $193 · Scale | $20 · $20/mo |
| One agent that never stops 4 vCPU / 8 GB, 50 GB disk, running 24/7 all month | $121 · Team | $341 · Scale | $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 | $2,500 · Scale | $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 | $815 · Scale · 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,632 · Scale · 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 storage.
CodeSandbox SDK: You buy VM credits and each size burns a fixed number per hour, billed per started minute while the VM runs, including the idle time before it hibernates. Scale adds a $170 monthly platform fee that is not usage credit, and a hibernated VM costs nothing.
CodeSandbox SDK: Plans start at $20 a month, and the whole fee is usage credit. You pay per second while a sandbox runs, and a stopped sandbox costs nothing and keeps its disk.
Limits in those scenarios
CodeSandbox SDK's Scale plan allows 250 VMs at once, so the user-sandboxes and 1,000-job scenarios do not fit it without Enterprise, while Morph Scale fits both. 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 on Morph and beyond 20 GB on CodeSandbox SDK has no published price, and neither publishes egress prices. bochka has no session cap, but at 1,000 short jobs at once even its $2,000 plan queues starts.
| Scenario | Morph Cloud | CodeSandbox SDK | bochka |
|---|---|---|---|
| One coding agent, workdays |
|
| 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, need experimental Windows or macOS guests, or you want managed CI runners and many machines at once on the same bill.
- Memory branching in under 250 ms. For agents that fan out from one running state: Morph copies a live VM with its memory into many branches at once.
- Windows and macOS guests. Morph lists experimental Windows and macOS (x86) guests for agents that must test software on those systems.
- Managed CI runners and a shared filesystem. Morph also sells GitHub Actions runners from the same MCU balance, and a filesystem many machines can mount at once.
Use CodeSandbox SDK when
you run previews or code runs that should sleep on their own when idle and wake with their memory on the next HTTP request, and you are fine building on what Together now calls its legacy SDK.
- Hibernates by itself, wakes on a request. For previews and code runs used in bursts: an idle sandbox sleeps with its memory and the next HTTP request wakes it.
- Built from any Dockerfile. Teams with an existing Dockerfile can turn it into a sandbox template without building a separate VM image.
- Bigger single machines on Enterprise. Teams that need one very large machine can get up to 64 cores and 128 GB through Enterprise sales.
Where bochka fits
Morph Cloud and CodeSandbox SDK are both strongest at saving a machine with its memory and waking it fast. If your agents work for hours instead, installing, building and browsing, bochka gives them a full VM with the coding agent, a desktop and their keys already set up, and keeps the disk saved every minute.
Coding agents you drive from outside
On Morph you install the agent and drive it by keystrokes through tmux; on CodeSandbox SDK you wire it through the command API. Both mean parsing terminal output to know when it is done. bochka ships seven agents with a prompt, steer and events API.
A desktop and a browser, ready to use
Morph has a remote desktop but no browser or computer use API, and CodeSandbox SDK has no desktop at all. A computer use agent on either starts with you building the desktop, the browser and the click loop. bochka streams one at 60fps.
Real keys stay outside the machine
Morph's Responses Proxy covers model APIs only, and CodeSandbox SDK passes secrets in as environment variables, so keys like GitHub or Stripe sit where one prompt injection can leak them. bochka's credentials proxy covers any HTTPS API.
Use bochka when your agents do real work for hours: coding agents you prompt and steer by API, a desktop with Chromium, /dev/kvm, real keys kept outside the machine, and hosting on many ports in the EU. Compare it one to one: bochka vs Morph Cloud and bochka vs CodeSandbox SDK.
Questions people ask
Is Morph Cloud cheaper than CodeSandbox SDK?
In all five scenarios on this page, yes. One coding agent on workdays is $32 a month on Morph against $193 on CodeSandbox SDK, and 50 agents in parallel is $1,459 against $2,500. bochka comes in lower than both in four of the five.
Which is faster, Morph Cloud or CodeSandbox SDK?
Neither has a comparable CPU measurement, so there is no fair speed answer. Morph says it restores a snapshot in under 250 ms, which is start time. bochka did 26.69 runs per second on the StarSling Node.js benchmark at 4 vCPU / 8 GB.
Can Morph Cloud and CodeSandbox SDK run Docker?
Yes, both run Docker with root inside the sandbox, and CodeSandbox SDK builds sandboxes from any Dockerfile. Morph lists nested virtualization as experimental and CodeSandbox SDK does not document it, while bochka exposes /dev/kvm for Android emulators and VMs.
Can I SSH into each?
Morph Cloud gives SSH through its gateway. CodeSandbox SDK connects only through its SDK, Node and browser clients, with terminals, commands and files but no SSH. Every bochka sandbox has SSH as well as an exec and files API.
Is CodeSandbox SDK still maintained?
CodeSandbox is now part of Together AI. Together's docs call the CodeSandbox-based SDK deprecated and name together-sandbox as its successor, while self-serve sign-up still runs through CodeSandbox.
Do both keep a sandbox's memory when it sleeps?
Yes. Morph pauses a VM with its memory and bills only the snapshot, and CodeSandbox SDK hibernates with a memory snapshot at no cost, archiving it after about 7 days. bochka keeps the disk, not the memory, so resume boots the machine again.
Try bochka
Install the CLI, then run bochka new.
Product preview