Replit vs Koyeb
Replit is an AI app builder: you describe an app, Replit Agent writes it, and Replit hosts it. Koyeb is a serverless cloud whose sandboxes are microVMs your own code starts from a Docker image and drives through Python or JavaScript SDKs.
The companies and products
Replit
Replit is an AI app builder and hosting platform: you describe an app in chat, Replit Agent writes it, and Replit publishes it.
You work in a browser workspace where Replit Agent sets up the project, writes the code, tests it and fixes problems, with system packages managed by Nix. When the app is ready you publish it as an Autoscale, Static, Scheduled or Reserved VM deployment, with Postgres and object storage next to it. It is built for people and teams who want a working app, not for programs that need to create many machines by API, so this page compares the parts where the two overlap.
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. “181st cheapest of 367” means 180 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 | Replit: 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 starts many agents from code; Koyeb can do that through its SDK, Replit only drives Replit Agent one app at a time, and bochka adds Docker, /dev/kvm and a disk that stays. | 181st of 367, with limits $2,000 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 | 202nd of 366, with limits $2,033 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 ranks 4th for short code runs because small instances scale to zero and wake on the next request; Replit's Autoscale also sleeps, but it is a web host, not a code runner. | 228th of 345, with limits $146 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 ranks 6th for sandboxes your users get, with wake on request and many regions, while Replit does not publish how many deployments can run at once; bochka ranks 1st with up to 50 HTTPS ports per sandbox. | 233rd of 361, with limits $825 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 | 258th of 360, with limits $4,226 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 Agent evals need many short, identical machines started by code, which Koyeb's SDK and bochka's API both give; on Replit each machine would be a published app. | 265th of 364, with limits $685 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 | 275th of 377, with limits $425 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 For a dev box people use by hand, Replit's browser workspace places above Koyeb, whose eco instances have a 20 GiB disk; bochka keeps a full VM with Docker and systemd. | 165th of 368, with limits $109 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 Computer-use agents need a desktop an agent can click; Replit's VNC pane is for a person, Koyeb sandboxes have no desktop, and bochka streams a 60fps Linux desktop with Chromium. | 190th of 369, with limits $619 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 | 229th of 367, with limits $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 | 234th of 346, with limits $217 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 | 150th of 338, with limits $4,378 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 | 208th of 360, with limits $215 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 ranks 3rd for GPU eval jobs with instances up to H100 and H200, while Replit and bochka have 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 | Replit | Koyeb | bochka |
|---|---|---|---|
| Kind of product | AI app builder with browser workspaces and app hosting | Serverless cloud for apps, inference and sandboxes driven by Python or JavaScript SDKs | Sandboxes you create, stop and fork by API, SDK or CLI |
| Isolation | Not documented; the security page says strong logical separation between users | MicroVM per instance | Full VM with its own kernel on dedicated AMD Ryzen 9 9950X hosts |
| Creating machines from code | MCP server tools to create, update and publish apps; no API to start many machines | SDKs that start sandboxes, run commands, read files and expose a port | API, SDK and CLI to create, stop, resume and fork many sandboxes |
| Docker | System packages come from Nix; the docs do not describe Docker or systemd | Each sandbox starts from any Docker image | Docker, root and systemd on every machine |
| Nested virtualization | Not documented | Not documented | Yes, /dev/kvm for Android emulators and VMs |
| Files over time | Workspace files and Agent checkpoints at milestones; published apps should not rely on their filesystem | Local disk is lost on redeploy; volumes (preview, 1 to 10 GB, Frankfurt and Washington) persist | Disk kept across stops and saved every minute; a stopped sandbox costs nothing |
| Sleep and wake on request | Autoscale starts on the first request and goes idle after 15 minutes | Scales to zero after an idle period (5 minutes minimum) and wakes on the next request; Light Sleep wakes in about 200 ms | No wake on request; you stop and resume sandboxes yourself |
| Coding agents | Replit Agent, which you can also drive from an MCP client | Tutorials that run agents through the command API; an MCP server lets agents manage Koyeb | Seven agents preinstalled, including Claude Code and Codex, with a prompt, steer and events API |
| Keeping API keys out of the sandbox | Replit manages keys for OpenAI, Anthropic, Google and OpenRouter models; other keys are secrets in the app | 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 computer use | VNC pane that streams a native desktop to your browser; no computer-use API | No desktop or browser in the sandbox SDK | 60fps Linux desktop with Chromium, computer use and browser control |
| Inbound access | Published apps on HTTPS domains and custom domains; SSH into the workspace on paid plans | 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; SSH |
| Outbound rules | No outbound allowlist | Block all outbound traffic, or allow only listed IPs and CIDRs | Open internet, no provider-side allowlist |
| GPUs | No | RTX 4000 SFF Ada up to H100, H200 and multi-GPU | No |
| Regions | North America, Europe, Asia, South America and Australia for published apps on Core and up | Frankfurt, Paris, Washington D.C., AWS US East, Singapore, Tokyo, plus San Francisco in preview | EU only: Germany, Finland, France |
Every feature Battleships tracks (43)
| Feature | Replit | Koyeb | bochka |
|---|---|---|---|
| Full VM (own kernel) | Yes | Yes | Yes |
| Docker inside | No | Yes | Yes |
| Nested virtualization | No | No | Yes |
| Root | Not published | Not published | Yes |
| Systemd | No | 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 | No | Yes | Yes |
| Automatic snapshots | Yes | Yes | Yes |
| Fork/clone | Yes | Yes | Yes |
| Live fork (no pause) | No | Not published | Yes |
| Memory fork | No | 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 | Not published | 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 | Yes | Yes | Yes |
| Agent harness API | Yes | No | Yes |
| MCP server | Yes | Yes | No |
| GPU | No | Yes | No |
| Windows | No | No | No |
| Arm64 | Not published | No | No |
| Self-hosting | No | Yes | No |
| BYOC | No | Yes | No |
| Open source | No | No | No |
| Scoped API keys | Not published | Not published | Yes |
| Spend limits | Yes | No | Yes |
| Usage per sandbox (API) | Yes | No | Yes |
| Audit logs | Yes | Yes | No |
| SSO | Yes | Yes | No |
| SOC 2 | Yes | Yes | No |
| HIPAA | No | No | No |
| EU data residency | Yes | Yes | Yes |
| Zero data retention | Not published | Not published | Yes |
Performance
There is no comparable measurement for Replit or Koyeb: neither was part of StarSling's hpc-sandbox-benchmarks run, so we cannot say which of the two is faster. bochka did 26.69 Node.js build-and-test runs per second at 4 vCPU / 8 GB in that benchmark. Koyeb publishes a CPU share of at least 0.25 dedicated vCPU per GB of memory, bursting to all cores, and its eco instances guarantee 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. Replit 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 | Replit, 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 | $122 · Pro $100 (annual) · with limits | $29 · Pro | $20 · $20/mo |
| One agent that never stops 4 vCPU / 8 GB, 50 GB disk, running 24/7 all month | $122 · Pro $100 (annual) · with limits | $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,330 · Pro $1,000 (annual) · with limits | $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 | $403 · Pro $250 (annual) · 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 | $825 · Pro $1,000 (annual) · with limits | $485 · Scale · with limits | $2,000 · $2000/mo · with limits |
Replit: Replit plans (Core $20, Pro from $100) turn into monthly credits that pay for Agent work and hosting, then usage goes to pay-as-you-go. A Reserved VM has a fixed monthly price per size and bills whether busy or idle, so our bills price agents as Reserved VMs and leave out Agent usage.
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; the rest of the fee is not credit.
Koyeb: Plans start at $20 a month, and the whole fee is usage credit spent per second while sandboxes run. A stopped sandbox costs nothing and keeps its disk.
Limits in those scenarios
Replit is marked as not a fit in every scenario because it is an app platform: one Reserved VM is one published app that runs all month, and Replit does not publish how many deployments can run at once. Koyeb fits four of the five scenarios, but its priced eco-xlarge shape has a 20 GiB disk with no published price for more. At 1,000 short jobs at once nothing fits as priced: Koyeb's burstable CPU throttles above half of each vCPU, and bochka's $2,000 plan queues starts above 90 a minute.
| Scenario | Replit | 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 Replit when
you want Replit Agent to build a web app from a description and host it for you, with Postgres, sleeping when idle, or regions outside Europe and the US.
- An app built and hosted for you. Useful if you want a working app from a description: Replit Agent writes, tests and publishes it with a domain.
- Postgres and storage built in. Useful for small products: each Replit app comes with Postgres and App Storage next to it, with nothing to wire up.
- Regions on five continents. Useful if your users are in South America or Australia: Replit publishes apps there as well as North America, Europe and Asia.
Use Koyeb when
your own code starts sandboxes that sleep most of the time and wake on a request, need GPUs, or must run in the US or Asia.
- Sandboxes your code starts. Useful for agent platforms: Koyeb's SDKs start a microVM from any Docker image, run commands and expose a port.
- GPUs in the same platform. 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: Koyeb scales to zero and wakes, in about 200 ms with Light Sleep.
Where bochka fits
If what you are really running is coding agents that work for hours, neither Replit nor Koyeb was built around that job. bochka gives each agent a full VM with its own kernel that keeps its disk, runs Docker and /dev/kvm, and comes with agents, a desktop and a credentials proxy built in.
A disk that stays, and forks of a running machine
An agent's repo and installs are its working memory. Replit's published apps should not rely on their filesystem, and Koyeb's local disk is lost on redeploy unless you add a volume, in preview at 1 to 10 GB.
Root, Docker and /dev/kvm
Agents run docker compose, start services and boot Android emulators. Replit builds environments from Nix packages with no documented Docker, and neither Replit nor Koyeb documents /dev/kvm, so that work has to run somewhere else.
Agents, desktop and keys handled
Replit's MCP server drives only Replit Agent, and its VNC pane has no computer-use API. On Koyeb you build the harness on exec, keep keys as environment variables the agent can read, and expose one port at a time.
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 Replit and bochka vs Koyeb.
Questions people ask
Is Replit cheaper than Koyeb?
Not for agent machines in the scenarios we priced, mostly because a Replit Reserved VM bills all month. One coding agent on workdays comes to $122 on Replit, $29 on Koyeb and $20 on bochka, and 50 agents in parallel come to $1,330 on Replit, $475 on Koyeb and $317 on bochka.
Which is faster, Replit or Koyeb?
We cannot say: neither is in the public CPU benchmark we use. bochka did 26.69 runs per second there at 4 vCPU / 8 GB, and Koyeb publishes a CPU share of at least 0.25 dedicated vCPU per GB of memory.
Can Replit or Koyeb run Docker?
Replit sets up environments with Nix packages and does not describe Docker in its docs. A Koyeb sandbox starts from any Docker image. bochka runs Docker inside every sandbox with root, systemd and /dev/kvm.
Do Replit and Koyeb keep files between runs?
A Replit workspace keeps its files with Agent checkpoints, but published apps should not rely on their filesystem. Koyeb's local disk is lost on redeploy, so lasting files need a volume, which is in preview. A bochka sandbox keeps its disk across stops and saves it every minute.
Does Replit or Koyeb have GPUs?
Koyeb does, from an RTX 4000 SFF Ada up to H100 and H200, billed per second. Replit and bochka have no GPUs.
Is bochka SOC 2 compliant?
SOC 2 is in progress. We're open about where we stand: live status at status.bochka.xyz and our data retention policy at docs.bochka.xyz/data-retention.
Try bochka
Install the CLI, then run bochka new.
Product preview