Tensorlake vs Koyeb
Both run each sandbox in its own microVM. Tensorlake is built to freeze a sandbox's memory and fan it out into warm clones, while Koyeb is a serverless cloud whose sandboxes sleep when idle, wake on a request and can run on GPUs in the EU, US and Asia.
The companies and products
Tensorlake
Tensorlake is a San Francisco company that sells infrastructure for AI agents, with sandboxes as its main product.
Tensorlake Sandboxes are microVMs, backed by Firecracker and Cloud Hypervisor, that you create through an API and that boot in a few hundred milliseconds. Named sandboxes suspend when idle and keep their memory and running processes, and you can copy a running sandbox into several warm clones. Around them Tensorlake sells versioned file systems, hosted Git, an orchestration layer and a bring-your-own-cloud option, aimed at teams running coding agents, evals and RL rollouts.
- Headquarters
- San Francisco
- Investors shown
- Redpoint and Amplify Partners
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. “5th cheapest of 367” means 4 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 | Tensorlake: 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 Tensorlake is a full fit for a software factory while Koyeb is a compromise, since its local disk is lost on redeploy; bochka adds /dev/kvm and preinstalled coding agents. | 5th cheapest of 367 $1,010 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 | 9th cheapest of 366 $1,381 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 Koyeb fits lots of short code runs best of the three, with small instances that scale to zero and wake on the next request. | 24th cheapest of 345 $250 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 Both fit sandboxes for your users; Koyeb wakes a sleeping sandbox on request and runs in more regions, while bochka gives each user HTTPS on up to 50 ports and raw TCP. | 5th cheapest of 361 $471 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 Tensorlake is built for RL rollouts, with up to 1,000 sandboxes at once on Pro and warm clones from one memory snapshot; on Koyeb it is a compromise. | Cheapest of 360 $5,637 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 | 24th cheapest of 364 $506 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 | 54th cheapest of 377 $424 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 natural 24/7 dev box: Tensorlake is built around suspending idle sandboxes and Koyeb's eco disk stops at 20 GiB, while bochka keeps one on with its disk saved every minute. | 185th of 368, with limits $250 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 Tensorlake ships an XFCE desktop with Firefox and computer-use calls, Koyeb sandboxes have no desktop, and bochka streams a 60fps desktop with Chromium. | 9th cheapest of 369 $294 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 | 13th cheapest of 367 $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 | 22nd cheapest of 346 $250 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 | 121st of 338, with limits $3,484 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 Tensorlake gives root in a real kernel with outbound allow and deny lists, which fits parallel red teaming better than Koyeb; bochka adds raw TCP inbound and /dev/kvm. | 4th cheapest of 360 $250 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 up to H100 and H200 with published prices; Tensorlake offers GPU sandboxes only by request, and bochka has no 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 | Tensorlake | Koyeb | bochka |
|---|---|---|---|
| Isolation | Firecracker and Cloud Hypervisor microVMs; GPU sandboxes use gVisor | MicroVM per instance | Full VM with its own kernel on dedicated AMD Ryzen 9 9950X hosts |
| Memory snapshots and clones | Memory snapshots and suspend keep running processes; copy a sandbox into many warm clones | SDK snapshots of the filesystem or with running processes, then new sandboxes from them (experimental) | Fork a running sandbox with its disk; resume reboots the machine |
| Keeping files | Named sandboxes suspend with memory, billed as snapshot storage; ephemeral ones end on idle | Local disk is lost on redeploy; volumes (preview, 1 to 10 GB, two regions) persist | Disk kept across stops and saved every minute; a stopped sandbox costs nothing |
| Sleep and wake | Idle timeout (600 s by default), then suspend or terminate | Scales to zero after 5 idle minutes and wakes on the next request; Light Sleep wakes in about 200 ms | Stop and start by API, with a time-to-live (1 h by default, changeable or off) |
| Nested virtualization | No: sandboxes set SANDBOX_KVM_AVAILABLE=0 | Not documented | Yes, /dev/kvm for Android emulators and VMs |
| Docker inside | Yes, on the tensorlake/ubuntu-systemd image | Sandboxes start from any Docker image | Yes, with root and systemd |
| Desktop and computer use | XFCE desktop with Firefox over VNC, with screenshot, mouse and keyboard calls | No desktop or browser in the sandbox SDK | 60fps desktop with Chromium, computer use and browser control |
| Coding agents | You bring and run your own agent | Tutorials that run agents through the command API | Claude Code, Codex, OpenCode and more preinstalled, with a prompt, steer and events API |
| API keys | Stored secrets are injected into the sandbox | Secrets set as environment variables inside the service | Credentials proxy for any HTTPS API: real keys never enter the sandbox |
| Inbound access | HTTP, WebSocket and gRPC through an authenticated proxy | One exposed HTTPS port at a time, plus an optional TCP proxy to one port | HTTPS URLs for up to 50 ports, raw TCP and a dedicated IP per machine |
| Outbound rules | Allow and deny lists by domain, IP or CIDR, or no internet | Block all outbound traffic, or allow only listed IPs and CIDRs | No provider-side allowlist; you set your own firewall as root |
| GPUs | GPU sandboxes by request, no published rate | RTX 4000 SFF Ada up to H100, H200 and multi-GPU, billed per second | None |
| Where it runs | US and EU, or your own cloud account through BYOC | EU, US and Asia; edge and on-premise for Enterprise | EU only: Germany, Finland, France |
| Sandboxes at once | 1,000 on Pro | 100 services on Pro, 1,000 on Scale | No session cap on paid plans; start rate limited (bursts above 90 starts a minute are queued) |
Every feature Battleships tracks (43)
| Feature | Tensorlake | Koyeb | bochka |
|---|---|---|---|
| Full VM (own kernel) | Yes | Yes | Yes |
| Docker inside | Yes | Yes | Yes |
| Nested virtualization | No | No | Yes |
| Root | Yes | Not published | Yes |
| Systemd | Yes | Not published | Yes |
| Desktop GUI | Yes | No | Yes |
| Browser | Yes | No | Yes |
| Computer-use API | Yes | 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 | Yes | Yes | No |
| Secret proxy | No | No | Yes |
| Secret proxy for any API | No | No | Yes |
| Preinstalled agents | No | Yes | Yes |
| Agent harness API | No | No | Yes |
| MCP server | No | Yes | No |
| GPU | Yes | 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 | Not published | Not published | Yes |
| Spend limits | Not published | No | Yes |
| Usage per sandbox (API) | No | 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
Neither Tensorlake nor Koyeb was part of the hpc-sandbox-benchmarks run, so there is no comparable CPU measurement between them. bochka did 26.69 runs per second on that Node.js build-and-test loop at 4 vCPU / 8 GB. Koyeb publishes a CPU share of at least 0.25 dedicated vCPU per GB of memory, and its eco instances guarantee only half of each vCPU.
Node.js build-and-test loop at 4 vCPU / 8 GB, higher is better. Measured with the open hpc-sandbox-benchmarks suite. Tensorlake 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 | Tensorlake, 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 | $250 · Pro | $29 · Pro | $20 · $20/mo |
| One agent that never stops 4 vCPU / 8 GB, 50 GB disk, running 24/7 all month | $250 · Pro | $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,030 · Pro | $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 | $293 · Pro | $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 | $1,127 · Pro | $485 · Scale · with limits | $2,000 · $2000/mo · with limits |
Tensorlake: Pro is $250 per billing cycle, which includes $250 of usage, then $0.01 per CU. CPU is billed only while it works, RAM and disk on what you allocate while running, and small users can buy prepaid packs from $5 instead.
Koyeb: Koyeb bills each instance per second at a fixed price per instance type, and Deep Sleep costs nothing. Pro is $29 a month with $10 of usage included and Scale $299 a month with $100 included; the rest of the fee is not credit.
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
Koyeb's priced shape is eco-xlarge, which has a 20 GiB disk with no published price for more, so the 50 GB scenarios are not fully priced, and eco instances guarantee only half of each vCPU, which is why it does not fit 1,000 short jobs at once. Tensorlake fits that burst on Pro, at $1,127 a month, with 1,000 sandboxes at once. On Tensorlake, the $250 Pro fee is the floor, so one agent on workdays costs $250 a month there against $29 on Koyeb. bochka queues bursts above 90 starts a minute, so it does not fit the burst either.
| Scenario | Tensorlake | Koyeb | bochka |
|---|---|---|---|
| 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 | None that bite |
| 1,000 short jobs at once | None that bite |
|
|
Which one should you use?
Use Tensorlake when
you fan out many short rollouts at once from one warm memory state, need outbound rules by domain, or want sandboxes in your own cloud account.
- Memory snapshots and warm clones. Useful when an agent must pick up mid-process, or when you fan out many rollouts from one prepared state.
- Big bursts of short jobs. Pro allows 1,000 sandboxes at once, and it is the only one of the three that fits 1,000 short jobs at once as priced.
- Domain-level egress rules and your own cloud. Tensorlake can allow or deny outbound traffic by domain, and can run sandboxes in your own AWS, GCP or Azure account.
Use Koyeb when
your sandboxes sit idle and must wake on a request, need GPUs with published prices, or have to run in Asia.
- GPUs with published prices. Useful when an agent or eval needs a GPU: Koyeb runs instances from RTX 4000 cards up to H100 and H200.
- Sleep when idle, wake on request. Good for sandboxes that sit idle between requests: they scale to zero and wake on the next one.
- Regions in Asia too. Koyeb runs in Frankfurt, Paris, Washington D.C., Singapore, Tokyo and more, for teams whose users are spread out.
Where bochka fits
If your agents do real work for hours, like installs, builds, Docker, emulators and a browser, look at bochka. It gives each agent a full VM that keeps its disk, with coding agents built in and keys kept outside the machine. For GPUs or a thousand short jobs at once, Tensorlake or Koyeb fit better.
Run emulators and VMs inside
Tensorlake sets SANDBOX_KVM_AVAILABLE=0 and Koyeb does not document nested virtualization, so an Android emulator or a VM has nowhere to start. bochka exposes /dev/kvm in every sandbox.
A disk that stays without extra wiring
On Koyeb a redeploy or deep sleep wipes the local disk unless you add a preview volume; on Tensorlake only named sandboxes suspend, and ephemeral ones end after 10 idle minutes. bochka saves the disk every minute.
Agents, keys and hosting built in
On both you install the agent yourself and put secrets inside the sandbox it controls. Koyeb exposes one HTTPS port at a time and Tensorlake has no raw TCP; bochka has 50 HTTPS ports, raw TCP and a credentials proxy.
Use bochka when your agents do real work for hours 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 Tensorlake and bochka vs Koyeb.
Questions people ask
Is Tensorlake cheaper than Koyeb?
Usually not in the scenarios we price: one agent that never stops is $250 a month on Tensorlake Pro against $57 on Koyeb, and 50 agents in parallel is $1,030 against $475. Sandboxes for your users is the exception, at $293 on Tensorlake against $329 on Koyeb. bochka is $26, $317 and $200 for those three.
Which is faster, Tensorlake or Koyeb?
There is no comparable CPU measurement: neither ran in the hpc-sandbox-benchmarks test, where bochka scored 26.69 runs per second. Koyeb guarantees at least 0.25 dedicated vCPU per GB of memory, so its speed depends on how busy the host is.
Can Tensorlake and Koyeb run Docker?
Tensorlake runs Docker inside a sandbox on its tensorlake/ubuntu-systemd image, and Koyeb starts each sandbox from any Docker image. Neither documents /dev/kvm, so Android emulators and VMs do not run; bochka runs Docker with root and systemd and exposes /dev/kvm.
Which one keeps a sandbox's memory?
Tensorlake: named sandboxes suspend with memory and running processes and can be copied into warm clones. Koyeb has SDK snapshots with running processes, but they are labelled experimental. bochka keeps the disk, saved every minute, and a resume reboots the machine.
Which has GPUs?
Koyeb runs GPU instances from an RTX 4000 SFF Ada up to H100 and H200, billed per second. Tensorlake offers GPU sandboxes by request, running on gVisor, with no published rate. bochka has no GPUs.
Where do Tensorlake and Koyeb run?
Tensorlake runs in the US and the EU, and in your own cloud through BYOC. Koyeb runs in the EU, the US and Asia. bochka runs only in the EU (Germany, Finland, France).
Try bochka
Install the CLI, then run bochka new.
Product preview