Replit vs smol machines
Replit is an AI app builder: you describe an app, Replit Agent writes it, and Replit hosts it. smol machines is a sandbox service: your code creates Linux microVMs by API, branches them while they run, and can run the same VM on your own servers.
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.
smol machines
smol machines makes fast, isolated Linux microVMs that run the same way on your laptop, in their hosted cloud, or on your own servers.
The core is smolvm, an open-source microVM engine built on libkrun, where each machine has its own guest kernel. smol cloud is the paid hosted service that runs fleets of those machines behind a REST API and Node, Python and Rust SDKs. It is built for developers who want one VM model from local development to production, with live branching of running machines.
- Uptime SLA
- 99.95% on Pro, Startup and Enterprise
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 | smol machines: 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; smol machines has a REST API and SDKs for that, while Replit drives one app at a time through Replit Agent, and bochka adds coding agents you prompt and steer by API. | 181st of 367, with limits $2,000 a month | 73rd of 367, with limits $604 a month | 3rd cheapest of 367 $634 a month |
| Always-on AI employees 50 machines 24/7 · 2 vCPU / 4 GB An always-on assistant on Replit is a Reserved VM billed all month; on smol machines it is a machine you leave running, and neither ships a desktop or keeps keys outside the guest the way bochka does. | 202nd of 366, with limits $2,033 a month | 148th of 366, with limits $1,038 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 smol machines fits short code runs best of the three, with a one-minute minimum and branches of a warm machine that pay the minimum once. | 228th of 345, with limits $146 a month | 12th cheapest of 345 $140 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 smol machines fits sandboxes for your users and wakes a stopped machine on the next command; Replit does not publish how many deployments can run at once, and bochka adds a desktop and hosting on up to 50 ports. | 233rd of 361, with limits $825 a month | 7th cheapest of 361 $531 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 smol machines can branch a running machine with its memory and processes, so many rollouts start from one prepared state; Replit has no API to start many machines. | 258th of 360, with limits $4,226 a month | 111th of 360, with limits $6,978 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 | 265th of 364, with limits $685 a month | 36th cheapest of 364 $670 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 CI jobs that build containers need Docker, which smol machines and bochka run inside the VM and Replit does not document; only bochka adds /dev/kvm for emulators. | 275th of 377, with limits $425 a month | 66th cheapest of 377 $514 a month | 4th cheapest of 377 $86 a month |
| 24/7 dev boxes 1 machine 24/7 · 4 vCPU / 8 GB Replit's workspace is a good place to code by hand in a browser, smol machines gives you a command API with no SSH, and bochka gives a full VM with SSH. | 165th of 368, with limits $109 a month | 216th of 368, with limits $29 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 Replit's VNC pane shows a desktop to a person with no computer-use API, smol cloud has no hosted desktop, and bochka streams one at 60fps with computer use built in. | 190th of 369, with limits $619 a month | 90th of 369, with limits $156 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 | 176th of 367, with limits $136 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 | 241st of 346, with limits $242 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 | 148th of 338, with limits $4,344 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 | 252nd of 360, with limits $377 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 | Replit | smol machines | bochka |
|---|---|---|---|
| Kind of product | AI app builder with browser workspaces and app hosting | Hosted microVM sandboxes by REST API and SDKs, on an open-source engine | Sandboxes you create, stop and fork by API, SDK or CLI |
| Isolation | Not documented; the security page says strong logical separation between users | libkrun microVM with its own guest kernel | 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 | REST API with Node, Python and Rust SDKs | API, SDK and CLI to create, stop, resume and fork many sandboxes |
| Docker and nested virtualization | System packages come from Nix; the docs do not describe Docker, systemd or /dev/kvm | Docker runs inside the VM; nested virtualization is not exposed on hosted machines | Docker, root, systemd and /dev/kvm on every machine |
| Files over time | Workspace files and Agent checkpoints at milestones; published apps should not rely on their filesystem | Filesystem survives a stop; stopped disk keeps billing | Disk saved every minute and on stop; a stopped sandbox costs nothing |
| Fork a running machine | Not documented | Branch a running machine with its memory and processes; checkpoints capture RAM to a file | Fork a running sandbox with its disk |
| Wake on request | Autoscale apps start on the first request and go idle after 15 minutes | A command or terminal starts a stopped machine; idle apps wake on the next request | No; a stopped sandbox is started by API |
| Shell access | SSH into the workspace on paid plans | Command API, sessions and a WebSocket terminal capped at one hour per connection; no SSH | SSH, plus a command API and terminal |
| Inbound access | Published apps on HTTPS domains, custom domains and private deployments | Up to 16 published ports through a returned URL; no dedicated IP | HTTPS URLs for up to 50 ports, token-protected; raw TCP; dedicated IPv4 or IPv6 |
| Desktop and computer use | VNC pane that streams a desktop to your browser; no computer-use API | No hosted desktop; a guide shows running your own Chromium inside a machine | 60fps Linux desktop with Chromium, computer use and an embeddable stream |
| Coding agents | Replit Agent, which you can also drive from an MCP client | Registry images with the Codex CLI and the Harbor eval harness, run through the command API | 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 | Cloud secrets are environment variables the guest can read | Credentials proxy for model providers and any HTTPS API; switch a credential to another account when credits run out |
| Regions | North America, Europe, Asia, South America and Australia for published apps on Core and up | No region choice in the cloud API | EU only (Germany, Finland, France), with EU data residency |
| Self-hosting | No | Open-source smolvm runs on your laptop or your own servers | No |
Every feature Battleships tracks (43)
| Feature | Replit | smol machines | 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 | No | Yes |
| Fork/clone | Yes | Yes | Yes |
| Live fork (no pause) | No | Yes | 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 | Not published | 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 | No | No |
| Windows | No | No | No |
| Arm64 | Not published | Yes | No |
| Self-hosting | No | Yes | No |
| BYOC | No | Yes | No |
| Open source | No | Yes | No |
| Scoped API keys | Not published | Not published | Yes |
| Spend limits | Yes | Yes | Yes |
| Usage per sandbox (API) | Yes | Yes | Yes |
| Audit logs | Yes | Not published | No |
| SSO | Yes | Yes | No |
| SOC 2 | Yes | No | No |
| HIPAA | No | No | No |
| EU data residency | Yes | No | Yes |
| Zero data retention | Not published | Not published | Yes |
Performance
There is no comparable measurement for either: neither Replit nor smol cloud is in StarSling's hpc-sandbox-benchmarks CPU test, so 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 test. smol machines publishes a boot time under 200ms for smolvm, which is a start-time figure, not CPU speed.
Node.js build-and-test loop at 4 vCPU / 8 GB, higher is better. Measured with the open hpc-sandbox-benchmarks suite. Replit and smol machines 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 | smol machines, 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 | $25 · Standard | $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 | $93 · Standard | $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 | $1,139 · 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 | $465 · Startup | $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 | $1,389 · Startup | $2,000 · $2000/mo · with limits |
Replit: Replit plans (Core $20, Pro from $100) turn into monthly credits for Agent work and hosting, then usage goes on to pay-as-you-go. A Reserved VM, the only kind that stays on, has a fixed monthly price per size, such as $130 for 4 vCPU / 16 GB, and bills whether busy or idle.
smol machines: smol cloud charges a base fee for every hour a machine runs, plus the CPU and memory the guest actually uses, with a one-minute minimum and disk billed even while stopped. Pro ($20) and Startup ($150) are fees added on top of usage, not credit.
smol machines: Plans start at $20 a month, and the whole fee is usage credit spent per second on running sandboxes. 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, it does not document Docker, and it does not publish how many deployments can run at once. smol machines fits all five, but it caps the machines you hold by plan (20 on Standard, 100 on Pro, 1,000 on Startup), with stopped machines still taking a slot, so 50 agents needs Pro and 1,000 short jobs at once needs Startup. On bochka, the 1,000-job burst is queued above 90 starts a minute and needs more starts per day than the $2,000 plan allows.
| Scenario | Replit | smol machines | 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 |
| Sandboxes for your users |
| None that bite | None that bite |
| 1,000 short jobs at once |
| None that bite |
|
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 databases, sleeping when idle, or regions outside Europe.
- 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.
- Databases and storage next to the app. Useful for app builders: Postgres and App Storage come built into each Replit app.
- Regions on five continents. Useful if your users are spread out: Replit publishes apps in North America, Europe, Asia, South America and Australia.
Use smol machines when
your code needs microVMs by API, you fan out branches of a running machine with its memory, or you want one open-source engine from your laptop to your own servers.
- Open source, from laptop to your own servers. Teams that want the same VM locally, in a hosted cloud and on their own servers can do it with one open-source engine.
- Live branches with memory. Useful for RL and test fan-out: branch a running machine with its memory and processes into many children.
- Outbound allowlists and arm64. Teams that must limit which hosts a machine reaches, or need arm64 images, get both on smol cloud.
Where bochka fits
If what you are really running is agents, Replit is built for people making apps and smol machines gives you a bare VM boundary to build on. bochka gives each agent a whole machine with Docker, /dev/kvm, SSH and a desktop, plus coding agents you drive from outside and keys kept out of the sandbox.
Root, Docker and KVM
Replit does not document Docker or systemd, so docker compose jobs must be squeezed into Nix packages. smol cloud runs Docker but has no /dev/kvm, so an agent cannot boot an Android emulator or a VM inside.
Agents and keys handled for you
Replit's MCP server drives only Replit Agent, with no event stream. On smol cloud you write the agent harness on exec calls yourself, and secrets are environment variables a prompt injection can read.
A desktop agents can use
Replit's VNC pane shows a desktop to a person, with no API for an agent to click. smol cloud has no hosted desktop, so you build and maintain the desktop, browser and stream yourself.
Use bochka when your agents need a whole machine for real work: Docker, emulators, SSH, a desktop and a browser, with coding agents you drive from outside and keys that never enter the sandbox. Compare it one to one: bochka vs Replit and bochka vs smol machines.
Questions people ask
Is Replit cheaper than smol machines?
For agent machines, usually not. One coding agent on workdays comes to $122 on Replit against $25 on smol machines, and 50 agents in parallel to $1,330 on Replit against $1,139. Replit comes out lower for sandboxes for your users and for 1,000 short jobs at once, but it is not a fit for either, and on bochka those two come to $200 and $2,000.
Which is faster, Replit or smol machines?
We cannot say: neither has been run on the StarSling CPU benchmark we use. bochka did 26.69 runs per second on it at 4 vCPU / 8 GB. smol machines publishes a boot time under 200ms for smolvm, which measures start time, not CPU speed.
Can I run Docker on Replit or smol machines?
Replit's docs set up environments with Nix packages and do not describe running Docker. smol machines runs Docker inside the VM, with Docker data on the machine's ext4 disk, but does not expose nested virtualization on hosted machines. bochka has Docker, systemd and /dev/kvm on every machine.
Can I start many machines from my own code?
On smol machines, yes: a REST API and Node, Python and Rust SDKs create and control machines. Replit's MCP server can create, update and publish apps through Replit Agent, but it has no API to start many machines. bochka does it by API, SDK or CLI and can fork a running sandbox.
Is smol machines open source?
The engine, smolvm, and the smol SDK are open source and run on macOS, Linux and Windows hosts. smol cloud, the hosted service, is paid. Replit and bochka are hosted services only.
Try bochka
Install the CLI, then run bochka new.
Product preview