Morph Cloud vs Beam
Morph Cloud gives each agent a full VM that can be snapshotted and branched with its memory, and woken on the next request. Beam is a serverless GPU platform whose sandboxes are fast gVisor containers, with a separate line of CPU VMs.
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
Beam
Beam is a serverless cloud for GPU inference, sandboxes and background jobs, built on its open-source runtime Beta9.
Beam runs functions, REST endpoints, task queues, pods, sandboxes and VMs on CPUs and GPUs, all from a Python or TypeScript SDK. A sandbox is a container isolated with gVisor that starts in a second or two, lives until you terminate it or its time to live runs out, and can be saved as a filesystem image or a memory snapshot. Beam VMs are a separate CPU product: a microVM with its own kernel, systemd and a root disk that stays when it stops. Much of Beam is a GPU serverless platform for AI teams.
- Bring your own cloud
- Management fee per vCPU and GB of RAM, on top of your own cloud bill
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 | Beam: price rank | bochka: price rank |
|---|---|---|---|
| Software factory 100 at once · 4 vCPU / 8 GB · 2,200 sessions of 8 h a month Morph Cloud runs Docker in Docker and local Kubernetes in a full VM, while a Beam sandbox is a container that ends with its time to live; bochka adds preinstalled coding agents and /dev/kvm. | 198th of 367, with limits $2,288 a month | 69th of 367, with limits $551 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 | 115th of 366, with limits $651 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 fit short code runs: Beam ranks 8th and Morph Cloud ranks 16th, with Beam sandboxes billed per second and Morph machines pausing with their memory between requests. | 16th cheapest of 345 $154 a month | 8th cheapest of 345 $117 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 Both fit; Beam gives each user a quick container, Morph Cloud a full VM that can pause and wake on request, and bochka ranks 1st with hosting on up to 50 ports per sandbox. | 12th cheapest of 361 $905 a month | 3rd cheapest of 361 $290 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 Cloud's memory branching suits rollouts that all start from one running state, which is why it ranks well above Beam here. | 86th of 360, with limits $4,847 a month | 341st of 360, with limits $939 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 | 13th cheapest of 364 $251 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 Cloud sells managed GitHub Actions runners; on Beam or bochka you run your own runner, and only bochka exposes /dev/kvm for Android builds. | 39th cheapest of 377 $355 a month | 12th cheapest of 377 $171 a month | 4th cheapest of 377 $86 a month |
| 24/7 dev boxes 1 machine 24/7 · 4 vCPU / 8 GB A Beam VM keeps its 50 GiB root disk while stopped, Morph Cloud keeps a paused VM with its memory, and bochka saves the disk every minute. | 85th cheapest of 368 $116 a month | 13th cheapest of 368 $21 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 browser or computer use API, so you build that yourself; bochka has a 60fps desktop with Chromium in every sandbox. | 182nd of 369, with limits $595 a month | 111th of 369, with limits $237 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 | 195th of 367, with limits $176 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 | 200th of 346, with limits $131 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 | 42nd of 338, with limits $923 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 | 175th of 360, with limits $155 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 Only Beam has GPUs, from RTX 4090 to H100 and B200; Morph Cloud and bochka are CPU only. | Can't run it | Cheapest of 98 $458 a month | 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 | Beam | bochka |
|---|---|---|---|
| Isolation | Full VM with its own kernel | gVisor container by default for sandboxes; separate Beam VMs are CPU microVMs with their own kernel | Full VM with its own kernel on dedicated AMD Ryzen 9 9950X hosts |
| Root, Docker and systemd | Yes, including Docker in Docker and local Kubernetes | Docker inside sandboxes with docker_enabled; systemd only in Beam VMs, not in sandboxes | Docker, systemd and root, like a normal Ubuntu server |
| Nested virtualization | Experimental | Not documented | Yes, /dev/kvm for Android emulators and VMs |
| Snapshot and fork with memory | Branch a running VM with its memory into many copies in under 250 ms | Memory snapshot of a running sandbox with its processes, restored into new sandboxes | Fork a running sandbox with its disk; the copy boots fresh |
| Pause and wake on request | Pause keeps memory and bills only the snapshot; wakes on the next HTTP request, SSH or exec call | No pause for sandboxes; they run until terminated or their time to live ends, and the idle tail is billed | No; a stopped sandbox is free, keeps its disk and is started by API |
| Saving work automatically | Saved when you pause or snapshot; a plain stop deletes the instance | A sandbox ends with its time to live unless you save an image or use a volume; a Beam VM keeps a 50 GiB root disk while stopped | Disk saved every minute and on every stop; a stopped sandbox is free |
| GPUs | No | GPU sandboxes and serverless GPUs up to H100, H200 and B200 | No, CPU only |
| Desktop and browser | Browser-based remote desktop; you install the browser and any computer use agent yourself | No desktop or browser product | 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 | None preinstalled; you install and run them through process exec | Seven agents 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 are exposed as environment variables inside the sandbox | Credentials proxy for model providers and any HTTPS API; switch a credential to another account when credits run out |
| Inbound access | Named HTTP services with optional API key auth; SSH through Morph's gateway; no raw TCP | A public HTTPS URL per exposed port with no built-in auth; no raw TCP or dedicated IP | HTTPS URLs for up to 50 ports, token-protected by default; raw TCP; dedicated IPv4 or IPv6 |
| Outbound rules | No outbound allowlist documented | Block all outbound traffic, or allow up to 10 CIDR ranges, changeable while running | Open internet, no provider-side allowlist |
| Guest systems | Linux, with experimental Windows and macOS (x86) | Linux | Linux |
| Open source and self-hosting | SDKs under Apache-2.0; the platform is hosted only | Beta9 runtime is AGPL-3.0 and free to self-host; bring your own cloud for a fee | No |
Every feature Battleships tracks (43)
| Feature | Morph Cloud | Beam | bochka |
|---|---|---|---|
| Full VM (own kernel) | Yes | No | Yes |
| Docker inside | Yes | Yes | Yes |
| Nested virtualization | Yes | No | Yes |
| Root | Yes | Yes | Yes |
| Systemd | Yes | No | 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 | No | Yes |
| Automatic snapshots | Yes | No | 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 | No | 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 | Yes | 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 | Yes | No |
| GPU | No | Yes | No |
| Windows | Yes | No | No |
| Arm64 | No | No | No |
| Self-hosting | No | Yes | No |
| BYOC | No | Yes | No |
| Open source | No | Yes | 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 | No | No |
| SOC 2 | Not published | Yes | No |
| HIPAA | Not published | Yes | No |
| EU data residency | Not published | Not published | Yes |
| Zero data retention | Not published | Not published | Yes |
Performance
There is no comparable CPU measurement for Morph Cloud or Beam: neither is in the StarSling hpc-sandbox-benchmarks run, so we cannot say which is faster at CPU work. bochka did 26.69 runs per second on that Node.js test at 4 vCPU / 8 GB. Morph says it restores a snapshot in under 250 ms and Beam says its sandboxes cold-boot in 1 to 3 seconds, which measure 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 Beam 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 | Beam, 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 | $5 · Developer | $20 · $20/mo |
| One agent that never stops 4 vCPU / 8 GB, 50 GB disk, running 24/7 all month | $121 · Team | $22 · Developer | $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 | $410 · Team | $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 | $191 · Team | $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 | $259 · Team | $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.
Beam: Beam sandboxes bill per second for each CPU core (two vCPU) and each GiB of RAM until you terminate them or their time to live ends, so an idle tail is billed too. Developer has no fee; Team costs $89 a month plus usage, with no usage credit, and there are no egress fees.
Beam: 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
Morph's limits are account-wide pools: the Developer pool of 64 vCPU holds only 16 machines at 4 vCPU, and more than 16 GiB of disk per vCPU raises the bill, with egress prices not published. Beam's Developer plan allows 30 CPU containers at once, so 50 parallel agents need its Team plan, and Beam publishes no disk price, so its figures count no disk cost. At 1,000 short jobs at once, both Morph Scale and Beam Team fit, while bochka's $2,000 plan queues starts.
| Scenario | Morph Cloud | Beam | 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, sleep between requests and wake on demand, or need a full VM with experimental Windows and macOS guests.
- Branch a running VM with its memory. For agents that fan out from one running state: Morph copies a VM with its memory and processes in under 250 ms.
- Sleep between requests, wake on demand. A paused Morph VM keeps its memory, bills only its snapshot, and wakes on the next HTTP request, SSH or exec call.
- A full VM with Windows and macOS options. Every Morph instance is a full VM with Docker in Docker and Kubernetes, with experimental Windows and macOS (x86) guests.
Use Beam when
your work needs GPUs, when short sandboxes at a low price matter most, when you want outbound traffic locked down, or when you must self-host.
- GPUs in the same platform. For work that needs a GPU, Beam offers GPU sandboxes and serverless GPUs from RTX 4090 to H100, H200 and B200.
- Lower bills in every scenario here. Beam costs less than Morph Cloud in all five scenarios on this page, from one workday agent to 1,000 short jobs.
- Open source and outbound rules. Its Beta9 runtime is free to self-host, and a sandbox can block outbound traffic or allow only up to 10 CIDR ranges.
Where bochka fits
Morph Cloud and Beam both hand you a machine and leave the agent, the desktop and the key handling to you. If your agents do long coding, browsing or computer use work, bochka gives every sandbox a full VM with /dev/kvm, agents preinstalled, a 60fps desktop and a disk saved every minute. Pick Morph or Beam instead for memory branching or GPUs.
Coding agents you drive from outside
On Morph you install the agent and drive it by sending keystrokes to tmux; on Beam you run it through process exec. Either way you parse terminal output to learn when it is done. bochka ships seven agents with a prompt, steer and events API.
A desktop and a browser, ready to use
Beam has no desktop or browser product, and Morph's remote desktop comes without a browser or computer use API. A computer use agent on either starts with you building the image and the click loop. bochka streams a 60fps desktop with Chromium.
Real keys never enter the machine
Beam puts secrets in environment variables inside the sandbox, and Morph's Responses Proxy covers model APIs only. Keys for GitHub or Stripe then sit where one prompt injection can leak them. bochka's credentials proxy covers any HTTPS API.
Use bochka when your agents do real work over hours or days: coding agents you prompt 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 Beam.
Questions people ask
Is Morph Cloud cheaper than Beam?
No, not on this page. Beam costs less in all five scenarios, such as $22 against $121 a month for one agent that never stops, and $410 against $1,459 a month for 50 agents in parallel. Beam's figures count no disk cost, and Morph's always-on price drops if the VM pauses when idle.
Which is faster, Morph Cloud or Beam?
Neither has a result on the hpc-sandbox-benchmarks CPU test, so there is no fair CPU comparison. Morph says it restores a snapshot in under 250 ms, and Beam says its sandboxes cold-boot in 1 to 3 seconds. bochka did 26.69 runs per second on that CPU test.
Is a Beam sandbox a VM like Morph Cloud?
Not by default. Beam's sandboxes are containers using gVisor, with an opt-in microVM mode for CPU sandboxes, and Beam sells separate CPU VMs. Every Morph Cloud instance is a full VM, as is every bochka sandbox.
Can Morph Cloud and Beam run Docker?
Yes. Morph runs Docker in Docker and local Kubernetes in its VMs, and Beam supports Docker inside a sandbox with docker_enabled. bochka runs Docker with systemd and /dev/kvm in its full VM.
Does Morph Cloud have GPUs like Beam?
No. Morph Cloud is CPU only, while Beam offers GPU sandboxes and serverless GPUs up to H100, H200 and B200. bochka is CPU only too, so pick Beam for GPU work.
Can I run Claude Code on Morph Cloud or Beam?
Yes, but you install it yourself on both: Morph has you drive it through a tmux API, and on Beam you run it through process exec. On bochka, Claude Code and six other agents come preinstalled with a prompt and steer API.
Try bochka
Install the CLI, then run bochka new.
Product preview