Replit vs Modal VM Sandboxes

Replit is an app builder: you describe an app, Replit Agent writes it, and Replit hosts it. Modal VM Sandboxes are full Linux VMs that your own code starts by the thousand and that end within 24 hours.

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.

Kind of product: AI app builder with workspaces and app hosting, not a sandbox API
Hosting: Data is hosted mainly in Google Cloud data centers in the United States, with an optional India region
Regions for published apps: North America, Europe, Asia, South America and Australia on Core, Pro and Enterprise; the free plan publishes to North America
Isolation: Not documented: the security page promises strong logical separation between users but does not say containers or VMs
Plans: Starter (free), Core $20 a month, Pro from $100 a month, Enterprise custom; plan fees come back as usage credits
Compliance: Says it has a SOC 2 Type 2 attestation

Modal VM Sandboxes

Modal is a serverless cloud for AI work, and VM Sandboxes are the version of its sandboxes that run in a virtual machine with their own Linux kernel.

You create a VM Sandbox from Python, TypeScript or Go code with runtime="vm", run commands in it, and terminate it when the job is done. Modal built the runtime on the Rust-based Cloud Hypervisor, so Docker, FUSE, systemd and nested cgroups work, with the same API, images and prices as its gVisor sandboxes. It became generally available on 1 October 2026 and suits teams that want many short-lived agent machines next to Modal's inference and training.

Founders: Erik Bernhardsson and Akshat Bubna
Offices: New York, Stockholm and San Francisco
Funding: Over $466M raised
Isolation: Virtual machine per sandbox on Cloud Hypervisor, with its own Linux 7.2 kernel
Generally available: 1 October 2026; early customers launched over 20 million VMs before that
Session length: Default 5 minutes, maximum 24 hours
Compliance: SOC 2 on every plan; HIPAA on 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	Modal VM Sandboxes: price rank	bochka: price rank
Software factory 100 at once · 4 vCPU / 8 GB · 2,200 sessions of 8 h a month Modal starts real VMs with Docker from code but ends each one within 24 hours, Replit drives one app at a time through Replit Agent, and bochka keeps a full VM's disk with a desktop to check the app it built.	181st of 367, with limits $2,000 a month	84th of 367, with limits $759 a month	3rd cheapest of 367 $634 a month
Always-on AI employees 50 machines 24/7 · 2 vCPU / 4 GB An agent that lives on its machine all month hits Modal's 24-hour cap, and on Replit it means a Reserved VM that bills all month even when idle.	202nd of 366, with limits $2,033 a month	Can't run it	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 Short code runs suit Modal's fast starts and per-second billing, while Replit's Autoscale is a web host that sleeps when idle, not a code runner.	228th of 345, with limits $146 a month	Can't run it	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 Modal runs thousands of sandboxes at once on Team, Replit does not publish how many deployments can run at once, and bochka keeps a stopped user sandbox's disk for free.	233rd of 361, with limits $825 a month	Can't run it	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 Huge bursts of short rollouts are what Modal is built for; Replit has no API to start many machines, and bochka queues very large bursts.	258th of 360, with limits $4,226 a month	171st of 360, with limits $16,322 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	Can't run it	10th cheapest of 364 $200 a month
CI runners 40 at once · 8 vCPU / 16 GB · 6,000 sessions of 12 min a month Modal and bochka both run Docker builds in a VM, Replit's Nix-based environments do not document Docker, and only bochka gives /dev/kvm on every plan.	275th of 377, with limits $425 a month	188th of 377, with limits $1,064 a month	4th cheapest of 377 $86 a month
24/7 dev boxes 1 machine 24/7 · 4 vCPU / 8 GB A Replit workspace is a pleasant place to code by hand but has no Docker or systemd, and a Modal VM cannot stay on past 24 hours.	165th of 368, with limits $109 a month	Can't run it	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 bochka ships a 60fps desktop and a computer-use API; Replit's VNC pane shows a desktop to a person, and on Modal you install Xvfb and VNC yourself.	190th of 369, with limits $619 a month	Can't run it	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	Can't run it	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	Can't run it	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	Can't run it	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	294th of 360, with limits $642 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	Modal VM Sandboxes	bochka
Kind of product	AI app builder with browser workspaces and app hosting	Sandboxes inside a serverless AI cloud, created from Python, TypeScript or Go	Sandboxes you create, stop and fork by API, SDK or CLI
Isolation	Not documented; the security page says strong logical separation between users	VM with its own Linux kernel on Cloud Hypervisor	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	SDK call with runtime="vm"; up to 5,000 containers at once on Team	API, SDK and CLI to create, stop, resume and fork many sandboxes
Docker, systemd, root	System packages come from Nix; the docs do not describe Docker or systemd	Yes; you start dockerd yourself as the entrypoint	Yes, in every sandbox
Nested virtualization	Not documented	Team and Enterprise plans only, on request	/dev/kvm on every plan
CPU benchmark (4 vCPU / 8 GB)	Not measured	15.54 runs/s	26.69 runs/s
Running for days	A Reserved VM runs continuously and bills all month at a fixed price	24 hours at most (default 5 minutes)	No cap on paid plans, and stopping a sandbox ends the bill
Files over time	Workspace files and Agent checkpoints; published apps should not rely on their filesystem	No paused state; only Volumes and filesystem snapshots keep files	Disk saved every minute and on stop; a stopped sandbox costs nothing
Memory snapshots	No	Yes, in alpha: snapshotting ends the sandbox and snapshots expire after 7 days	No; resume boots the VM again
Desktop and computer use	VNC pane that streams a desktop to your browser; no computer-use API	Not offered; an example shows how to set up Xvfb and VNC yourself	60fps desktop, Chromium and a computer-use API built in
Coding agents and API keys	Replit Agent, drivable from an MCP client; managed keys for AI models only	Examples only; secrets are environment variables, or you run your own proxy in a sidecar	Claude Code, Codex and others with a prompt, steer and events API; a credentials proxy keeps keys out for any HTTPS API
Hosting that sleeps when idle	Autoscale starts on the first request and costs nothing while idle	No wake on request; encrypted and raw TCP tunnels while the sandbox runs	No wake on request; HTTPS URLs for up to 50 ports plus raw TCP
Outbound network rules	No egress allowlist	Block all, IP-range allowlist, domain allowlist (beta)	Open internet, no provider-side allowlist
Regions	North America, Europe, Asia, South America and Australia for published apps on Core and up	US, EU and Asia-Pacific; pinning a region costs 1.15x to 1.75x	EU only: Germany, Finland, France

Every feature Battleships tracks (43)

Feature	Replit	Modal VM Sandboxes	bochka
Full VM (own kernel)	Yes	Yes	Yes
Docker inside	No	Yes	Yes
Nested virtualization	No	Yes	Yes
Root	Not published	Yes	Yes
Systemd	No	Yes	Yes
Desktop GUI	Yes	No	Yes
Browser	No	No	Yes
Computer-use API	No	No	Yes
SSH	Yes	Yes	Yes
Persistent disk	Yes	Yes	Yes
Pause/resume	No	No	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	No	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	No	Yes
Agent harness API	Yes	No	Yes
MCP server	Yes	No	No
GPU	No	No	No
Windows	No	No	No
Arm64	Not published	No	No
Self-hosting	No	No	No
BYOC	No	No	No
Open source	No	No	No
Scoped API keys	Not published	Not published	Yes
Spend limits	Yes	Not published	Yes
Usage per sandbox (API)	Yes	Not published	Yes
Audit logs	Yes	Yes	No
SSO	Yes	Yes	No
SOC 2	Yes	Yes	No
HIPAA	No	Yes	No
EU data residency	Yes	Yes	Yes
Zero data retention	Not published	Not published	Yes

Performance

ReplitNot measured

Modal VM Sandboxes15.54 runs/s

bochka26.69 runs/s

In the same hpc-sandbox-benchmarks run at 4 vCPU / 8 GB on 29 September 2026, bochka finished 26.69 Node.js build-and-test runs per second and Modal's VM runtime 15.54, so bochka did about 1.7 times the CPU work in the same time. Replit is not in that benchmark, so there is no comparable number for it.

Node.js build-and-test loop at 4 vCPU / 8 GB, higher is better. Measured with the open hpc-sandbox-benchmarks suite. Modal VM Sandboxes measured on: VM Sandbox, request = size. Replit 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	Replit, a month	Modal VM Sandboxes, 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	$15 · Starter · with limits	$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	$178 · Starter · 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,330 · Pro $1,000 (annual) · with limits	$2,229 · Starter · 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	$403 · Pro $250 (annual) · with limits	$792 · Team	$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	$3,193 · Team · 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, such as $130 for 4 vCPU / 16 GB, and bills whether busy or idle, while Autoscale charges only while it serves requests.

Modal VM Sandboxes: Modal bills VM Sandboxes by the second for the higher of the CPU and memory you request or use, until the sandbox ends. Starter is free with $30 of monthly credit, Team is $250 a month with $100 of credit, and pinning a region multiplies the price by 1.15x to 1.75x.

Modal VM Sandboxes: bochka plans start at $20 a month and the whole fee becomes usage credit, spent by the 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: each always-on machine is a published Reserved VM app, and it does not publish how many can run at once. A Modal VM Sandbox lives at most 24 hours and loses its root disk when it ends, so the workday, always-on and fleet scenarios only keep files put in a Volume or snapshot. Modal fits the sandboxes-for-your-users scenario on Team, and its 1,000-job burst relies on shared CPU above the small request. On bochka the limit that bites is start speed: the 1,000-job burst queues above 90 starts a minute.

Scenario	Replit	Modal VM Sandboxes	bochka
One coding agent, workdays	different kind of product: app platform monthly / always-on product: priced as 1 machines kept on and reused	files survive a stop only in Volumes: packages installed elsewhere reset	None that bite
One agent that never stops	different kind of product: app platform	Starter: sessions capped at 24 h files survive a stop only in Volumes: packages installed elsewhere reset	None that bite
50 agents in parallel	adjacent product, not a like-for-like sandbox missing persistent disk, Docker inside different kind of product: app platform how many machines can run at once: limit not published, probably fine at 50 (the typical published limit is 50)	files survive a stop only in Volumes: packages installed elsewhere reset	None that bite
Sandboxes for your users	adjacent product, not a like-for-like sandbox different kind of product: app platform not confirmed: how many machines can run at once (you need 300; the typical published limit is 50)	None that bite	None that bite
1,000 short jobs at once	adjacent product, not a like-for-like sandbox different kind of product: app platform not confirmed: how many machines can run at once (you need 1,000; the typical published limit is 50)	shared vCPUs on this tier (Modal (VM Sandboxes) sells dedicated cores separately as “VM Sandbox, request = size”): heavy, sustained CPU use can be slowed by other tenants	max 2,400 starts/day (needs ~6,667) max 600 starts/hour (needs ~1,000) bursts above 90 starts/min are queued (a burst of 333 takes ~4 min to start)

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 and 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 with Postgres and storage.
Hosting that costs nothing when idle. Useful for web apps with uneven traffic: Autoscale wakes on the first request and costs nothing while idle.
Regions on five continents. Useful if your users are spread out: published apps can run in North America, Europe, Asia, South America or Australia.

Use Modal VM Sandboxes when

your code runs huge bursts of short jobs that finish within a day, needs strict outbound rules, or sits next to models you already run on Modal.

Real VMs started from code. Useful for agent platforms: your code starts a VM with its own kernel, Docker and root, which Replit does not offer.
Very large bursts. Useful for huge bursts of short jobs: Modal runs 5,000 containers at once on Team and bills by the second.
Outbound rules and models on one bill. Useful if you need strict egress or already serve models on Modal: block or allowlist traffic, next to inference and training.

Where bochka fits

If what you are really running is agents that work for hours or days, neither choice is a clean fit: Replit is built around one person building one app, and Modal's VMs end within a day. bochka gives each agent a full VM that your code starts, that keeps its disk, and that comes with Docker, a desktop and coding agents ready to go.

A machine that keeps its work

A Modal VM ends within 24 hours and its root disk goes with it unless you write snapshot or Volume code. Replit's published apps should not rely on their filesystem. bochka saves the disk every minute and stops for free.

Docker, KVM and a desktop on every machine

Replit's docs do not describe Docker, systemd or /dev/kvm. Modal runs Docker, but nested virtualization needs Team and a support request, and you install Xvfb, VNC and a browser yourself. bochka ships all of it, on a CPU about 1.7 times as fast as Modal's VM.

Agents driven from outside, keys kept out

Replit's MCP server drives only Replit Agent, with no event stream. Modal gives examples, and keys sit in environment variables unless you run your own sidecar proxy. bochka lets you prompt, steer and watch Claude Code or Codex while a proxy holds the keys.

Use bochka when your agents work for hours or days in a machine they come back to, with Docker, /dev/kvm, a desktop and coding agents you drive by API, on a faster VM that keeps its disk. Compare it one to one: bochka vs Replit and bochka vs Modal VM Sandboxes.

Questions people ask

Is Replit cheaper than Modal VM Sandboxes?

It depends on the job. For 50 agents in parallel we priced $1,330 a month on Replit against $2,229 on Modal, and for sandboxes for your users $403 on Replit against $792 on Modal, but only Modal fits that scenario. For one always-on agent bochka comes to $26 a month, against $122 on Replit and $178 on Modal.

Which is faster, Replit or Modal VM Sandboxes?

Replit is not in the public hpc-sandbox-benchmarks test, so we cannot say. Modal's VM runtime did 15.54 runs per second at 4 vCPU / 8 GB, and bochka did 26.69 in the same run.

Can Replit run Docker?

Replit sets up environments with Nix packages, and its docs do not describe running Docker, systemd or virtual machines inside. Modal VM Sandboxes run Docker if you start dockerd as the entrypoint, and every bochka sandbox has Docker, systemd and /dev/kvm.

How long can a Modal VM Sandbox run?

The default timeout is 5 minutes and the maximum is 24 hours; for longer work Modal suggests a filesystem snapshot and a new sandbox. A Replit Reserved VM runs continuously, and bochka has no session cap on paid plans.

Can I start many machines from code on Replit?

Not really. Replit's MCP server lets a client create, update and publish apps through Replit Agent, but there is no API to start many machines. Modal and bochka are both built for that.

Try bochka

Install the CLI, then run bochka new.

Product preview