Blaxel vs Koyeb
Both run each sandbox in its own microVM. Blaxel is built to sleep seconds after the last connection and wake in under 25 ms with its memory, while Koyeb runs sandboxes as services next to your apps, on CPU or GPU, in the EU, the US and Asia.
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
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. “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 | Koyeb: price rank | boat: price rank |
|---|---|---|---|
| Software factory 100 at once · 4 vCPU / 8 GB · 2,200 sessions of 8 h a month | 10th cheapest of 367 $2,373 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 | 12th cheapest of 366 $2,832 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 suit short code runs: Blaxel sleeps seconds after the last connection and wakes in under 25 ms, and Koyeb ranks higher here with small instances that scale to zero. | 14th cheapest of 345 $144 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 Koyeb fits 300 users at once on its Scale plan, while Blaxel's public tiers stop at 200 at once; boat fits it on a self-serve plan and ranks first. | 101st of 361, with limits $926 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 | 77th of 360, with limits $4,378 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 Koyeb fits parallel evals on its plans, Blaxel's public tiers cap how many run at once at 200, and boat starts a fresh VM per task from a named snapshot. | 136th of 364, with limits $704 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 | 57th cheapest of 377 $431 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 Neither is a plain box you SSH into and leave on: Blaxel has no native SSH and Koyeb's local disk is lost on redeploy, while boat keeps its disk and has real SSH. | 265th of 368, with limits $114 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 Blaxel runs a desktop and a browser in its sandboxes and Koyeb has none, while boat streams a 60fps Linux desktop with Chromium. | 14th cheapest of 369 $634 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 Blaxel gives agents a browser in the sandbox; on Koyeb you install and run a headless browser yourself, and boat ships Chromium on a desktop. | 16th cheapest of 367 $317 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 | 16th cheapest of 346 $215 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 | 147th of 338, with limits $4,292 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 Blaxel fits with domain-level egress rules on the provider side, Koyeb only allowlists by IP, and boat gives root with raw TCP and nftables. | 3rd cheapest of 360 $217 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 Koyeb runs GPU instances from RTX 4000 cards up to H100 and H200, while neither Blaxel nor boat has GPUs. | 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 | Blaxel | Koyeb | boat |
|---|---|---|---|
| Isolation | Firecracker microVM per sandbox, own kernel | MicroVM per instance | Full VM with its own kernel on dedicated AMD Ryzen 9 9950X hosts |
| Sleep and wake | Standby a few seconds after the last connection, wakes in under 25 ms with memory and processes | Scales to zero after at least 5 idle minutes and wakes on the next request; Light Sleep wakes in about 200 ms (preview) | Stop and start by API; a stopped sandbox costs nothing and keeps its disk, and resume boots the VM again |
| Disk that survives | Files live in memory (about half the RAM); one block volume can be attached at creation | Local disk is lost on redeploy; volumes (preview, 1 to 10 GB, two regions) persist | A real disk kept across stops and saved every minute, with snapshots |
| Fork and snapshots | Fork with memory and running processes (private preview) | SDK snapshots of the filesystem or running processes, then new sandboxes from them (experimental) | Fork a running sandbox with its disk |
| Nested virtualization | No: Firecracker guests do not get /dev/kvm | Not documented | Yes: /dev/kvm, so Android emulators and VMs run inside |
| Docker inside | Yes, with a Docker-in-sandbox image | Yes, sandboxes start from any Docker image | Yes, with root and systemd |
| Shell access | Root, terminal through the bl connect command, no native SSH | Commands and files through Python or JavaScript SDKs | Real SSH, root and systemd |
| Inbound traffic | Preview URL per port, public or token-protected; no raw TCP or public IP | 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 | Domain allow and deny lists, method and path rules, static egress IPs | Block all outbound traffic, or allow only listed IPs and CIDRs | Open internet; filter inside the VM with nftables |
| Keeping API keys out of the sandbox | Proxy fills secrets into outbound HTTPS requests; sandbox never sees them (public preview) | 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 |
| Desktop and browser | Desktop and browser with computer use | No desktop or browser in the sandbox SDK | 60fps Linux desktop with Chromium and computer use |
| Coding agents | Claude Code image you drive from its terminal or your own harness | Tutorials that run agents through the command API; an MCP server lets agents manage Koyeb | Claude Code, Codex and five other agents preinstalled, with a prompt, steer and events API |
| GPUs | No | RTX 4000 SFF Ada up to H100, H200 and multi-GPU | No |
| Regions | Oregon, North Virginia, London, Frankfurt | Frankfurt, Paris, Washington D.C., AWS US East, Singapore, Tokyo, San Francisco in preview | EU only: Germany, Finland, France |
Every feature Battleships tracks (43)
| Feature | Blaxel | Koyeb | boat |
|---|---|---|---|
| Full VM (own kernel) | Yes | Yes | Yes |
| Docker inside | Yes | Yes | Yes |
| Nested virtualization | No | No | Yes |
| Root | Yes | Not published | Yes |
| Systemd | No | Not published | Yes |
| Desktop GUI | Yes | No | Yes |
| Browser | Yes | No | Yes |
| Computer-use API | Yes | No | Yes |
| SSH | No | 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 | Yes | Yes | No |
| Secret proxy | Yes | No | Yes |
| Secret proxy for any API | Yes | No | Yes |
| Preinstalled agents | Yes | Yes | Yes |
| Agent harness API | No | No | Yes |
| MCP server | Yes | Yes | No |
| GPU | No | Yes | No |
| Windows | No | No | No |
| Arm64 | No | No | No |
| Self-hosting | No | Yes | No |
| BYOC | Yes | Yes | No |
| Open source | No | No | No |
| Scoped API keys | Yes | Not published | Yes |
| Spend limits | No | No | 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
On the hpc-sandbox-benchmarks Node.js build-and-test loop at 4 vCPU and 8 GB, Blaxel did 19.48 runs per second and boat 26.69, about 1.4 times the work in the same time. There is no comparable measurement for Koyeb: it was not part of that run. Koyeb publishes a CPU share of at least 0.25 dedicated vCPU per GB of memory, bursting to all cores.
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). Koyeb 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 | Koyeb, a month | boat, 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 | $29 · Pro | $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 | $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,489 · Pay-as-you-go Tier 1 | $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 | $396 · Pay-as-you-go Tier 2 · with limits | $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 | $876 · Pay-as-you-go Tier 2 · with limits | $485 · Scale · with limits | $2,000 · $2000/mo · with limits |
Blaxel: Blaxel charges for allocated RAM per second while a sandbox is active, with CPU included, and active means a connection is open. In standby you pay only snapshot storage, and volumes are billed on their full size.
Koyeb: Koyeb bills each instance per second from the moment it starts, 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 with $100 included.
Limits in those scenarios
Blaxel's self-serve tiers allow 10, 50 or 200 sandboxes at once, counting those in standby, so 300 users at once needs a sales tier, and the lower tiers delete sandboxes after 7 or 30 days. Koyeb's priced eco-xlarge shape has a 20 GiB disk with no published price for more, and eco instances guarantee only half of each vCPU. At 1,000 short jobs at once none of the three fits as priced: Blaxel hits its 200 cap, Koyeb's burstable CPU throttles, and boat queues starts above 90 a minute.
| Scenario | Blaxel | Koyeb | boat |
|---|---|---|---|
| One coding agent, workdays | 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 | 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 Blaxel when
your sandboxes sit idle most of the time and must wake in milliseconds with their memory, or need domain-level egress rules.
- Wakes in milliseconds with its memory. For sandboxes idle most of the time: Blaxel sleeps seconds after the last connection and wakes in under 25 ms, processes intact.
- Finer outbound rules. For locked-down agents: Blaxel allows or denies by domain, down to methods and paths, and can give static egress IPs.
- A desktop and a secret proxy. For browser agents that call APIs: Blaxel has a desktop and browser in the sandbox and fills secrets into requests from outside.
Use Koyeb when
your sandboxes need GPUs, must run in Asia as well as the EU and US, or should live next to apps you already host on Koyeb.
- GPUs on the same platform. For agents or evals that need a GPU: Koyeb runs instances from RTX 4000 cards up to H100 and H200.
- More regions, including Asia. For users far from Europe and the US: Koyeb runs in Frankfurt, Paris, Washington D.C., Singapore, Tokyo and more.
- Sandboxes next to your apps. For teams already hosting on Koyeb: a sandbox is a Koyeb service, started from any Docker image, with bigger instance types up to 40 vCPU.
Where boat fits
Blaxel and Koyeb are both good at sandboxes that sleep between requests. If your agents instead work for hours on builds, tests, Docker and emulators, boat gives each one a whole Linux machine with a disk that stays and agents built in.
A disk that stays, saved every minute
Blaxel keeps files in memory, about half the RAM, unless you attach a volume at creation. Koyeb loses its local disk on redeploy, and its volumes are in preview at 1 to 10 GB. boat keeps a real disk and forks running sandboxes.
A whole machine with /dev/kvm
Blaxel's Firecracker guests get no /dev/kvm and Koyeb does not document it, so Android emulators and VMs cannot start there. boat runs full VMs with root, systemd, real SSH and nested virtualization.
Agents and hosting built in
On Blaxel and Koyeb you build the agent harness yourself, and Koyeb exposes one port at a time with keys as environment variables. boat ships seven agents with a driving API, HTTPS on 50 ports, raw TCP and a credentials proxy.
Use boat when your agents do real work for hours: builds, Docker, emulators and a desktop browser on a whole Linux machine with a disk that stays, a faster CPU and agents built in. Compare it one to one: boat vs Blaxel and boat vs Koyeb.
Questions people ask
Is Blaxel cheaper than Koyeb?
In the scenarios we priced, Koyeb costs less: $29 against $33 for one coding agent on workdays, and $475 against $1,489 for 50 agents in parallel. boat came in lower than both, at $20 and $317. Blaxel only bills while a connection is open, so a workload that disconnects often pays less.
Which is faster, Blaxel or Koyeb?
Blaxel did 19.48 runs per second on the Node.js build-and-test benchmark at 4 vCPU and 8 GB, and boat did 26.69. Koyeb was not part of that run, so there is no comparable number for it.
Can Blaxel and Koyeb run Docker?
Yes. Blaxel has a Docker-in-sandbox image, and Koyeb sandboxes start from any Docker image. Neither gives you /dev/kvm for Android emulators or VMs, which boat exposes in every sandbox.
Does Blaxel or Koyeb have GPUs?
Koyeb does, from an RTX 4000 SFF Ada up to H100 and H200, billed per second. Blaxel sandboxes run on CPU only, and so does boat.
Do Blaxel and Koyeb sandboxes keep their files?
Blaxel keeps files in memory and saves them with the memory in standby, and a volume can be attached at creation. Koyeb's local disk is lost on redeploy, so lasting files need a volume (in preview) or an SDK snapshot. boat keeps a real disk and saves it every minute.
Who owns Blaxel and Koyeb now?
Blaxel joined Baseten on September 10, 2026, and Baseten says the product stays the same. Koyeb announced on February 17, 2026 that it agreed to join Mistral AI, and its platform keeps running as part of Mistral Compute.
Try boat
Install the CLI, then run boat new.
7-day free trial