Morph Cloud vs Koyeb
Morph Cloud gives each agent a full VM that you can snapshot and branch with its memory, then pause and wake on demand. Koyeb runs each sandbox as a microVM started from a Docker image, with GPUs, scale to zero and regions in the EU, US and Asia.
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
Koyeb
Koyeb is a serverless cloud for apps, inference and sandboxes, and in February 2026 it agreed to join Mistral AI.
A Koyeb sandbox is a Koyeb service: a microVM started from any Docker image and driven from Python or JavaScript SDKs that run commands, read files and expose a port. It can scale to zero when idle and wake on the next request, and it can run on CPU or GPU instance types. It is built for teams that run AI agents or untrusted code next to apps they already host on Koyeb.
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 | Koyeb: price rank | bochka: price rank |
|---|---|---|---|
| Software factory 100 at once · 4 vCPU / 8 GB · 2,200 sessions of 8 h a month A software factory needs Docker and a disk that stays; bochka ranks 3rd because it keeps the disk by default and ships coding agents, while both others need extra setup. | 198th of 367, with limits $2,288 a month | 54th of 367, with limits $366 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 | 135th of 366, with limits $923 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, and both can sleep when idle and wake on the next request; Koyeb ranks 4th and Morph Cloud ranks 16th here. | 16th cheapest of 345 $154 a month | 4th cheapest of 345 $66 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 All three fit; Morph wakes each user's paused machine with its memory, Koyeb wakes a sleeping sandbox in more regions, and bochka ranks first with up to 50 HTTPS ports per sandbox. | 12th cheapest of 361 $905 a month | 6th cheapest of 361 $495 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, which is why it ranks well ahead of Koyeb here. | 86th of 360, with limits $4,847 a month | 237th of 360, with limits $1,631 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 | 19th cheapest of 364 $429 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; Koyeb does not document /dev/kvm, and bochka ranks 4th with nested virtualization for Android and VM builds. | 39th cheapest of 377 $355 a month | 142nd of 377, with limits $88 a month | 4th cheapest of 377 $86 a month |
| 24/7 dev boxes 1 machine 24/7 · 4 vCPU / 8 GB Morph fits a dev box that stays up as a full VM with SSH, while Koyeb's local disk is lost on redeploy unless you add a volume. | 85th cheapest of 368 $116 a month | 217th of 368, with limits $37 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 Morph nor Koyeb ships a browser or a computer use API; bochka streams a 60fps desktop with Chromium in every sandbox. | 182nd of 369, with limits $595 a month | 81st of 369, with limits $123 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 | 172nd of 367, with limits $123 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 | 172nd of 346, with limits $89 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 | 65th of 338, with limits $1,683 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 | 233rd of 360, with limits $299 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 Koyeb runs GPUs, from RTX 4000 cards up to H100 and H200; Morph Cloud and bochka are CPU only. | Can't run it | 3rd cheapest of 98 $628 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 | Koyeb | bochka |
|---|---|---|---|
| Isolation | Full VM with its own kernel | MicroVM per instance, started from a Docker image | 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 | Starts from any Docker image; root and systemd not documented | Yes, root, systemd and Docker inside |
| Nested virtualization | Experimental | Not documented | Yes, /dev/kvm for Android emulators and VMs |
| Snapshots and branching | Snapshot, branch and restore a running VM with its memory in under 250 ms | SDK snapshots of the filesystem or with running processes, then new sandboxes from them (experimental) | Fork a running sandbox with its disk, not its memory |
| Sleep and wake on request | A paused VM keeps its memory, bills only its snapshot, and wakes on the next HTTP request, SSH or exec call | Scales to zero after an idle period (5 minutes minimum) and wakes on the next request; Light Sleep wakes in about 200 ms | Stop and start by API; a stopped sandbox costs nothing and keeps its disk |
| Saving work automatically | Saved when you pause or snapshot; a plain stop deletes the instance | Local disk is lost on redeploy; volumes (preview, 1 to 10 GB, Frankfurt and Washington) persist | Disk saved every minute and on every stop |
| GPUs | No | RTX 4000 SFF Ada up to H100, H200 and multi-GPU | No |
| Desktop and browser | Browser-based remote desktop; you install the browser and any computer use agent yourself | No desktop or browser in the sandbox SDK | 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 | Tutorials that run agents through the command API; an MCP server lets agents manage Koyeb | 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 set as environment variables inside the service | 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 | One exposed HTTPS port at a time, plus an optional TCP proxy to one port; no dedicated IP | HTTPS URLs for up to 50 ports, token-protected by default; raw TCP; dedicated IPv4 or IPv6 |
| Outbound rules | No provider-side allowlist documented | Block all outbound traffic, or allow only listed IPs and CIDRs | Open internet, no provider-side allowlist |
| Guest systems | Linux, with experimental Windows and macOS (x86) | Linux | Linux |
| Regions | Not published | Frankfurt, Paris, Washington D.C., AWS US East, Singapore, Tokyo | EU only (Germany, Finland, France), with zero data retention |
Every feature Battleships tracks (43)
| Feature | Morph Cloud | Koyeb | bochka |
|---|---|---|---|
| Full VM (own kernel) | Yes | Yes | Yes |
| Docker inside | Yes | Yes | Yes |
| Nested virtualization | Yes | No | Yes |
| Root | Yes | Not published | 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 | Not published | 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 | Yes | 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 | Yes | 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 | No | No |
| Scoped API keys | Yes | Not published | Yes |
| Spend limits | Not published | No | 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 Koyeb: neither is in the 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. Koyeb publishes a CPU share of at least 0.25 dedicated vCPU per GB of memory, so its speed depends on how busy the host is.
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 Koyeb 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 | Koyeb, 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 | $29 · Pro | $20 · $20/mo |
| One agent that never stops 4 vCPU / 8 GB, 50 GB disk, running 24/7 all month | $121 · Team | $57 · Pro | $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 | $475 · 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 | $325 · Scale | $329 · Scale | $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 | $485 · 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.
Koyeb: Koyeb bills each instance per second at a fixed price per instance type, and Deep Sleep costs nothing. Pro costs $29 a month with $10 of usage included and Scale $299 a month with $100 included; bandwidth above 1 TB is extra.
Koyeb: 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 prices disk beyond 16 GiB per vCPU by raising the MCU count, does not publish egress prices, and its Developer pool of 64 vCPU holds only 16 machines at 4 vCPU. Koyeb's priced shape is eco-xlarge, with a 20 GiB disk and no published price for more, and eco instances guarantee only half of each vCPU. At 1,000 short jobs at once, Morph's Scale plan fits while Koyeb's burstable CPU throttles under load. bochka's $2,000 plan does not fit that one either, because it queues starts above 90 a minute.
| Scenario | Morph Cloud | Koyeb | bochka |
|---|---|---|---|
| One coding agent, workdays |
|
| None that bite |
| One agent that never stops |
|
| None that bite |
| 50 agents in parallel |
| None that bite | None that bite |
| Sandboxes for your users |
| None that bite | 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, pause and wake on demand, or need a full VM with experimental Windows and macOS guests.
- Branch a running machine with its memory. For agents that fan out from one running state: Morph copies a VM with its memory in under 250 ms.
- A full VM, plus Windows and macOS guests. For agents that need Docker in Docker, local Kubernetes, or experimental Windows and macOS (x86) guests.
- Managed CI runners and a shared filesystem. Morph also sells GitHub Actions runners and a filesystem many machines can mount at once.
Use Koyeb when
your sandboxes need GPUs, sleep most of the time and wake on a request, must run in the US or Asia, or need outbound traffic locked down.
- GPUs in the same platform. For agents or evals that need a GPU: Koyeb runs instances from RTX 4000 cards up to H100 and H200.
- Sleep when idle, in many regions. For sandboxes that sit idle between requests, or that must run in the US or Asia as well as the EU.
- Outbound traffic rules. For untrusted code: the Koyeb SDK can cut a sandbox off the internet or allow only listed IPs.
Where bochka fits
If your agents work for hours on one machine, bochka is worth a look next to both. It keeps the disk on its own, ships coding agents and a desktop, and keeps real keys outside the sandbox, so there is less to build before the agent can start.
A disk that stays without extra steps
On Morph a plain stop deletes the instance, so you must pause or snapshot first. On Koyeb the local disk is lost on redeploy, and lasting files need a preview volume of 1 to 10 GB. bochka saves the disk every minute.
Agents and a desktop that arrive ready
On Morph you install the agent and drive it with tmux keystrokes; on Koyeb you build the harness on top of exec. Neither ships a browser. bochka has seven agents with a prompt API and a 60fps desktop with Chromium.
Keys outside, many ports in
Morph's Responses Proxy covers model APIs only, and Koyeb keeps secrets as environment variables the agent can read. Koyeb exposes one HTTPS port at a time and Morph has no raw TCP. bochka proxies any HTTPS API and serves 50 ports.
Use bochka when your agents do hours of real work on a machine that keeps its disk: builds, Docker, emulators, a desktop browser and preview servers, with agents and keys handled for you. Compare it one to one: bochka vs Morph Cloud and bochka vs Koyeb.
Questions people ask
Is Morph Cloud cheaper than Koyeb?
Usually not in our scenarios: one agent that never stops is $57 on Koyeb against $121 on Morph, and 50 agents in parallel are $475 against $1,459. Sandboxes for your users cost about the same on both. For 1,000 short jobs at once, Morph's Scale plan fits and Koyeb's burstable CPU does not.
Which is faster, Morph Cloud or Koyeb?
Neither has a CPU score in the hpc-sandbox-benchmarks run, so there is no fair speed comparison. Morph restores a snapshot in under 250 ms and Koyeb's Light Sleep wakes in about 200 ms, but those are start times, not CPU speed. bochka did 26.69 runs per second on that benchmark.
Can Morph Cloud and Koyeb run Docker?
Morph is a full VM with root, Docker in Docker and local Kubernetes, and lists nested virtualization as experimental. Koyeb starts each sandbox from a Docker image in a microVM and does not document nested virtualization. bochka runs Docker with root and systemd and exposes /dev/kvm.
Do they keep my files when a sandbox stops?
On Morph, pausing or snapshotting keeps everything, but a plain stop deletes the instance. On Koyeb the local disk is lost on redeploy, so lasting files need a volume (in preview) or an SDK snapshot. bochka keeps the disk across stops and saves it every minute.
Does Morph Cloud or Koyeb have GPUs?
Koyeb does, from an RTX 4000 SFF Ada up to H100 and H200, billed per second. Morph Cloud and bochka are CPU only.
Can I branch a running sandbox on each?
Morph branches a running VM with its memory, so every copy continues with its processes running. Koyeb's SDK can snapshot a sandbox with running processes and start new ones from it, labelled experimental. bochka forks a running sandbox with its disk, and the copy boots fresh.
Try bochka
Install the CLI, then run bochka new.
Product preview