exe.dev vs Replit
exe.dev rents real Linux VMs with root, systemd and Docker that you reach over SSH and HTTPS. Replit is an AI app builder: you describe an app, Replit Agent writes it, and Replit hosts it.
The companies and products
exe.dev
exe.dev, made by Bold Software, Inc., rents Linux VMs for developers and AI agents that you reach over SSH and HTTPS.
You reserve a pool of vCPUs and memory, and your VMs share it; you can also start standalone VMs billed by the second. Each VM is KVM-isolated (they use Cloud Hypervisor), boots from a container image in about two seconds, and has root, systemd and Docker. It comes with Claude Code, Codex, Pi and exe.dev's own Shelley agent, and is aimed at developers who want a persistent dev box or a sandbox for their agents.
- Company
- Bold Software, Inc.
- Preinstalled agents
- claude, codex, pi and the Shelley web agent
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.
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. “15th cheapest of 366” means 14 of the other 365 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 | exe.dev: price rank | Replit: price rank | bochka: price rank |
|---|---|---|---|
| Software factory 100 at once · 4 vCPU / 8 GB · 2,200 sessions of 8 h a month Neither fits a software factory fully: exe.dev VMs are headless with no snapshots, and Replit drives only Replit Agent, one app at a time. | 253rd of 367, with limits $3,701 a month | 181st of 367, with limits $2,000 a month | 3rd cheapest of 367 $634 a month |
| Always-on AI employees 50 machines 24/7 · 2 vCPU / 4 GB exe.dev ranks 15th for always-on assistants because each one gets its own VM; on Replit each one is a Reserved VM app billed all month, and bochka ranks 5th. | 15th cheapest of 366 $3,833 a month | 202nd of 366, with limits $2,033 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 Neither is built as a code interpreter; Replit's Autoscale scales to zero between requests, but it is a web host, not a code runner. | 235th of 345, with limits $175 a month | 228th of 345, with limits $146 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 exe.dev Personal stops at 50 VMs at once and Replit does not publish a limit, so 300 sandboxes for your users fits neither; bochka ranks 1st here. | 257th of 361, with limits $1,226 a month | 233rd of 361, with limits $825 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 | 265th of 360, with limits $5,250 a month | 258th of 360, with limits $4,226 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 | 283rd of 364, with limits $1,050 a month | 265th of 364, with limits $685 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 | 288th of 377, with limits $504 a month | 275th of 377, with limits $425 a month | 4th cheapest of 377 $86 a month |
| 24/7 dev boxes 1 machine 24/7 · 4 vCPU / 8 GB exe.dev ranks 25th as a 24/7 dev box with root, SSH and a disk that lasts, against 165th for Replit, whose workspaces have no Docker or systemd; bochka ranks 18th. | 25th cheapest of 368 $35 a month | 165th of 368, with limits $109 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 screen: exe.dev VMs are headless, Replit's VNC pane is for a person, and bochka streams a 60fps desktop with a computer-use API. | 240th of 369, with limits $1,055 a month | 190th of 369, with limits $619 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 On exe.dev you install and run a headless browser yourself, Replit has no browser-control API, and bochka gives agents a visible Chromium. | 130th of 367, with limits $530 a month | 229th of 367, with limits $317 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 | 124th of 346, with limits $278 a month | 234th of 346, with limits $217 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 | 166th of 338, with limits $5,490 a month | 150th of 338, with limits $4,378 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 exe.dev ranks 60th for parallel red teaming, well ahead of Replit at 208th, since it gives each run a real VM; bochka ranks 2nd. | 60th of 360, with limits $263 a month | 208th of 360, with limits $215 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 | Can't run it | Can't run it | 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 | exe.dev | Replit | bochka |
|---|---|---|---|
| Kind of product | Linux VMs for developers and agents, reached over SSH and HTTPS | AI app builder with browser workspaces and app hosting | Sandboxes you create, stop and fork by API, SDK or CLI |
| Isolation | KVM VM with Cloud Hypervisor; you can't choose the kernel | Not documented; the security page says strong logical separation between users | Full VM with its own kernel on dedicated AMD Ryzen 9 9950X hosts |
| Root, Docker and systemd | Root, systemd and Docker in every VM | System packages come from Nix; the docs do not describe Docker or systemd | Root, systemd and Docker on every machine |
| Nested virtualization | Enterprise only | Not documented | Yes, /dev/kvm on every plan |
| Custom images | Boot each VM from your own Docker image | Environments set up with Nix packages | Templates from named snapshots; no Dockerfile or OCI images |
| Saved state | Disk persists and is streamed to a second server; no snapshots | Workspace files and Agent checkpoints at milestones; published apps should not rely on their filesystem | Snapshots every minute while running and on stop; a stopped sandbox resumes with its disk |
| Coding agents | Claude Code, Codex, Pi and Shelley preinstalled; only Shelley takes prompts through the API | Replit Agent, which you can also drive from an MCP client | Seven agents preinstalled, with a prompt, steer and events API and TypeScript and Python SDKs |
| MCP server | Yes, at exe.dev/mcp, for controlling VMs | Yes, to create, update, ask and publish apps through Replit Agent | No |
| Desktop and computer use | Headless; no desktop or screen streaming | VNC pane that streams a native desktop to your browser; no computer-use API | 60fps desktop and Chromium, computer use, browser control, embeddable stream |
| Inbound traffic | HTTPS proxy for ports 3000 to 9999, one of them public; SSH; no public IP or raw TCP | Published apps on HTTPS and custom domains; SSH into the workspace on paid plans | HTTPS URLs for up to 50 ports, token-protected by default; raw TCP; dedicated IPv6 or IPv4; SSH |
| Keeping keys out of the machine | Integrations inject secrets at the network edge for any HTTP host, S3 and GitHub | Replit manages keys for OpenAI, Anthropic, Google and OpenRouter models; other keys are secrets in the app | Credentials proxy for model providers and any HTTPS API; switch to another account when credits run out |
| Hosting that sleeps when idle | No wake on request; VMs run until you stop them | Autoscale starts on the first request and goes idle after 15 minutes, costing nothing while idle | No wake on request; you stop and resume sandboxes yourself |
| Paying for an always-on machine | Personal pool at a flat monthly fee that your VMs share, billed whether busy or idle | Reserved VM at a fixed monthly price per size, billed whether busy or idle | Billed per second while running; a stopped sandbox costs nothing |
| Regions | 9 regions in the US, Europe, Asia and Australia | Published apps in North America, Europe, Asia, South America and Australia on Core and up; data mainly in the US | EU only: Germany, Finland, France |
Every feature Battleships tracks (43)
| Feature | exe.dev | Replit | bochka |
|---|---|---|---|
| Full VM (own kernel) | Yes | Yes | Yes |
| Docker inside | Yes | No | Yes |
| Nested virtualization | Yes | No | Yes |
| Root | Yes | Not published | Yes |
| Systemd | Yes | No | Yes |
| Desktop GUI | No | Yes | Yes |
| Browser | Yes | No | Yes |
| Computer-use API | No | No | Yes |
| SSH | Yes | Yes | Yes |
| Persistent disk | Yes | Yes | Yes |
| Pause/resume | Yes | No | Yes |
| Automatic snapshots | No | Yes | Yes |
| Fork/clone | Yes | Yes | Yes |
| Live fork (no pause) | Yes | No | Yes |
| Memory fork | No | No | No |
| Custom image (Docker or snapshot) | Yes | Yes | Yes |
| ≥24 h sessions | Yes | Yes | Yes |
| Idle auto-stop | No | Yes | No |
| Wake on request | No | Yes | No |
| HTTPS preview URLs | Yes | Yes | Yes |
| Raw TCP inbound | No | Not published | Yes |
| Public IPv4 | No | No | No |
| Egress allowlist | No | No | No |
| Secret proxy | Yes | Yes | Yes |
| Secret proxy for any API | Yes | No | Yes |
| Preinstalled agents | Yes | Yes | Yes |
| Agent harness API | Yes | Yes | Yes |
| MCP server | Yes | Yes | No |
| GPU | No | No | No |
| Windows | No | No | No |
| Arm64 | No | Not published | No |
| Self-hosting | No | No | No |
| BYOC | Yes | No | No |
| Open source | No | No | No |
| Scoped API keys | Yes | Not published | Yes |
| Spend limits | Not published | Yes | Yes |
| Usage per sandbox (API) | Yes | Yes | Yes |
| Audit logs | Not published | Yes | No |
| SSO | Yes | Yes | No |
| SOC 2 | No | Yes | No |
| HIPAA | No | No | No |
| EU data residency | Yes | Yes | Yes |
| Zero data retention | Not published | Not published | Yes |
Performance
Neither exe.dev nor Replit is in StarSling's hpc-sandbox-benchmarks run, so there is no comparable CPU measurement for either, and we cannot say which is faster. bochka did 26.69 Node.js build-and-test runs per second at 4 vCPU / 8 GB in that benchmark.
Node.js build-and-test loop at 4 vCPU / 8 GB, higher is better. Measured with the open hpc-sandbox-benchmarks suite. exe.dev and Replit 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 | exe.dev, a month | Replit, 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 | $35 · Personal | $122 · Pro $100 (annual) · with limits | $20 · $20/mo |
| One agent that never stops 4 vCPU / 8 GB, 50 GB disk, running 24/7 all month | $35 · Personal | $122 · Pro $100 (annual) · with limits | $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,848 · Personal | $1,330 · Pro $1,000 (annual) · with limits | $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 | $530 · Personal · with limits | $403 · Pro $250 (annual) · with limits | $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,050 · Personal · with limits | $825 · Pro $1,000 (annual) · with limits | $2,000 · $2000/mo · with limits |
exe.dev: Personal pools are a flat monthly fee, from $15 for 2 vCPU to $155 for 16 vCPU, that bill the same whether VMs are busy or idle. Standalone VMs bill per second at $0.105 per 2 vCPU / 4 GiB per hour.
Replit: Replit plans (Core $20, Pro from $100) turn into monthly credits 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; Autoscale bills only while it serves requests.
Replit: Your monthly plan fee, from $20, is all usage credit, spent per second only while sandboxes run. A stopped sandbox costs nothing and keeps its disk.
Limits in those scenarios
exe.dev Personal allows one pool of up to 16 vCPU and 50 VMs, plus up to 50 standalone VMs, so 300 sandboxes for your users or 1,000 jobs at once do not fit. Replit is marked as not a fit in every scenario: each always-on machine is a published Reserved VM app that bills all month, it does not publish how many can run at once, and it does not document Docker or a disk you can rely on. On bochka, the 1,000-job burst is queued above 90 starts a minute.
| Scenario | exe.dev | Replit | 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 |
| 1,000 short jobs at once |
|
|
|
Which one should you use?
Use exe.dev when
you want a persistent Linux VM with root, Docker and SSH, booted from your own Docker image, in regions outside Europe.
- A real Linux VM. Useful if your agents run Docker or system services: every exe.dev VM has root, systemd and Docker, which Replit does not document.
- Your own Docker image. Useful if your setup lives in a Dockerfile: exe.dev boots each VM straight from your own image.
- A dev box at a flat fee. Useful for one machine that stays on: a 4 vCPU exe.dev pool comes to $35 a month in our table, against $122 for Replit.
Use Replit when
you want Replit Agent to build a web app from a description and host it for you, with databases and hosting that sleeps when idle.
- An app built and hosted for you. Useful if you want a working app from a description: Replit Agent builds, tests and publishes it for you.
- Hosting that costs nothing when idle. Useful for web apps with uneven traffic: Autoscale wakes on the first request and costs nothing while idle.
- Databases next to the app. Useful if your app needs data storage: Replit builds Postgres and App Storage into each app.
Where bochka fits
If what you are really running is coding agents, not a dev box or a hosted app, look at bochka. Every sandbox is a full VM with Docker and /dev/kvm, a 60fps desktop, a snapshot every minute, and one API to drive agents inside from outside.
A screen your agents can use
exe.dev VMs are headless, and Replit's VNC pane shows a desktop to a person with no computer-use API. On either, an agent that checks a UI needs you to set up and stream a desktop yourself.
State saved every minute
exe.dev has no snapshots to roll back to, and Replit checkpoints only at Agent milestones. When an agent deletes files or wrecks an install, a whole session's work can be lost; bochka loses at most a minute.
Drive agents inside from outside
On exe.dev only Shelley takes prompts through the API, so Claude Code or Codex means scripting shell sessions. Replit's MCP server drives Replit Agent only, with no event stream to watch.
Use bochka when your own code needs to start machines for agents: full VMs with Docker and a desktop, state saved every minute, and coding agents you drive by API. Compare it one to one: bochka vs exe.dev and bochka vs Replit.
Questions people ask
Is exe.dev cheaper than Replit?
For one machine, yes: one coding agent on workdays or running 24/7 comes to $35 on exe.dev against $122 on Replit. For larger loads Replit's bill is lower, such as $1,330 against $1,848 for 50 agents in parallel, but Replit is marked as not a fit in every scenario we priced. bochka comes to $20, $26 and $317 for those same three.
Which is faster, exe.dev or Replit?
We cannot say. Neither is in the hpc-sandbox-benchmarks run, so there is no comparable CPU measurement for either. bochka scored 26.69 runs per second there at 4 vCPU / 8 GB.
Can exe.dev or Replit run Docker?
exe.dev VMs have root, systemd and Docker, and can boot from your own Docker image. Replit sets up environments with Nix packages and does not describe running Docker inside. Every bochka sandbox has Docker, systemd and /dev/kvm.
Do exe.dev or Replit have a desktop for computer use?
exe.dev VMs are headless. Replit has a VNC pane that streams a desktop to you in the workspace, but no API for an agent to take screenshots and click. bochka gives every sandbox a 60fps desktop with Chromium and computer-use and browser-control APIs.
Can I drive coding agents from my own code?
On exe.dev the Shelley agent takes prompts through the CLI or HTTPS API, and Claude Code, Codex and Pi run through shell commands. Replit's MCP server lets an MCP client create, update and publish apps through Replit Agent only. On bochka you prompt, steer and stream events from seven built-in agents.
Where do exe.dev and Replit run?
exe.dev has nine regions in the US, Europe, Asia and Australia. Replit hosts data mainly on Google Cloud in the United States and publishes apps on five continents on Core and up. bochka runs only in the EU, in Germany, Finland and France.
Try bochka
Install the CLI, then run bochka new.
Product preview