Modal vs Replit
Modal is a serverless cloud where your code creates sandboxes by the thousand, next to GPUs, and ends them within 24 hours. Replit is an AI app builder: you describe an app, Replit Agent writes it, and Replit hosts it.
The companies and products
Modal
Modal is a serverless cloud for AI work: inference, training, batch jobs and sandboxed code, all driven from Python, TypeScript or Go code.
Modal Sandboxes are containers you create from code, run commands in, and then terminate. By default they run under gVisor, a user-space kernel from Google; since October 2026 you can also pick a VM runtime with its own Linux kernel for Docker and FUSE (Battleships tracks that as a separate card, Modal VM Sandboxes). It suits teams that already run models on Modal and want short-lived, scalable code execution next to their GPUs.
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. “19th cheapest of 345” means 18 of the other 344 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 | Modal: price rank | Replit: price rank | boat: price rank |
|---|---|---|---|
| Software factory 100 at once · 4 vCPU / 8 GB · 2,200 sessions of 8 h a month | Can't run it | 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 An always-on agent hits Modal's 24-hour sandbox limit, and on Replit it becomes a Reserved VM app billed all month; a boat sandbox has no session cap on paid plans. | 196th of 366, with limits $1,924 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 For many short code runs, Modal's fast starts and large container limits fit well, while Replit's Autoscale is a web host that scales to zero, not a code runner. | 19th cheapest of 345 $181 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 Modal can start a sandbox per user from code, while on Replit each machine is a published app and the number that can run at once is not published; on boat a stopped sandbox keeps its disk and costs nothing. | 11th cheapest of 361 $811 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 RL rollouts launch many short sandboxes at once, which is the job Modal is built for and Replit is not. | 5th cheapest of 360 $19,038 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 | 59th cheapest of 364 $1,244 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 CI jobs that build Docker images need the VM runtime on Modal, are not documented on Replit, and run in every boat sandbox. | 126th cheapest of 377 $1,793 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 A Replit workspace is a good place to code by hand and a Modal sandbox ends within a day, while a boat sandbox keeps its disk and runs Docker and systemd. | 138th of 368, with limits $23 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 Neither Modal nor Replit has a computer-use API: Modal shows how to set up VNC yourself and Replit's VNC pane is for a person, while boat ships a 60fps desktop and a computer-use API. | 98th of 369, with limits $183 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 | 177th of 367, with limits $136 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 | 267th of 346, with limits $394 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 | 223rd of 338, with limits $8,795 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 | Can't run it | 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 Only Modal has GPUs here, from T4 to B300, so it is the pick for GPU eval jobs; neither Replit nor boat offers them. | 19th cheapest of 98 $1,187 a month | 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 | Modal | Replit | boat |
|---|---|---|---|
| Kind of product | Serverless cloud: sandboxes you create from Python, TypeScript or Go code | AI app builder with browser workspaces and app hosting | Sandboxes you create, stop and fork by API, SDK or CLI |
| Isolation | gVisor by default; VM runtime with its own kernel available | Not documented; the security page says strong logical separation between users | Full VM with its own kernel, every sandbox |
| Starting many machines from code | Yes: 100 containers at once on Starter, 5,000 on Team | No API to start many machines; an MCP server creates and publishes apps | API, SDK and CLI to create, stop, resume and fork many sandboxes |
| Docker inside | Only with the VM runtime | Not described; system packages come from Nix | Yes, with root and systemd, in every sandbox |
| Nested virtualization | VM runtime only, Team and Enterprise plans, on request | Not described | Yes (/dev/kvm, Android emulator) |
| Files over time | No paused state; a finished sandbox is gone, only Volumes keep files | Workspace files and Agent checkpoints; published apps should not rely on their filesystem | Disk saved every minute and on stop; a stopped sandbox costs nothing |
| Longest session | 24 hours (default 5 minutes) | A Reserved VM runs continuously at a fixed monthly price | No cap on paid plans, and stopping ends the bill |
| Desktop and computer use | Not offered; an example shows how to set up VNC yourself | VNC pane that streams a desktop to your browser; no computer-use API | 60fps desktop, Chromium and computer-use API built in |
| Coding agents | Examples only; you install and run the agent yourself | Replit Agent, which an MCP client can also drive | Claude Code, Codex, OpenCode and more preinstalled, with a prompt, steer and events API |
| Keeping keys out of the sandbox | Secrets are environment variables, or you run your own proxy in a sidecar | Managed keys for some AI model providers; other keys are secrets in the app | Credentials proxy for model providers and any HTTPS API you register |
| GPUs | T4 to B300; 10 at once on Starter, 50 on Team | None | None |
| Hosting a finished app | HTTPS and raw TCP tunnels into a running sandbox | One-click publishing with domains, Postgres, storage and Autoscale that sleeps when idle | HTTPS URLs for up to 50 ports, token-protected, plus raw TCP; no hosted databases |
| Outbound network rules | Block all, IP-range allowlist, domain allowlist (beta) | No allowlist documented | No provider-side allowlist |
| Regions | US, EU and Asia-Pacific; pinning a region costs 1.15x to 1.75x | North America, Europe, Asia, South America and Australia for published apps on Core and up | EU only: Germany, Finland, France |
Every feature Battleships tracks (43)
| Feature | Modal | Replit | boat |
|---|---|---|---|
| Full VM (own kernel) | No | Yes | Yes |
| Docker inside | No | No | Yes |
| Nested virtualization | No | No | Yes |
| Root | Yes | Not published | Yes |
| Systemd | Yes | No | Yes |
| Desktop GUI | No | Yes | 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 | No | Yes | Yes |
| Fork/clone | Yes | Yes | Yes |
| Live fork (no pause) | No | No | Yes |
| Memory fork | Yes | No | No |
| Custom image (Docker or snapshot) | Yes | Yes | Yes |
| ≥24 h sessions | Yes | Yes | Yes |
| Idle auto-stop | Yes | Yes | No |
| Wake on request | No | Yes | No |
| HTTPS preview URLs | Yes | Yes | Yes |
| Raw TCP inbound | Yes | Not published | Yes |
| Public IPv4 | No | No | No |
| Egress allowlist | Yes | No | No |
| Secret proxy | No | Yes | Yes |
| Secret proxy for any API | No | No | Yes |
| Preinstalled agents | No | Yes | Yes |
| Agent harness API | No | Yes | Yes |
| MCP server | No | Yes | No |
| GPU | Yes | No | No |
| Windows | No | No | No |
| Arm64 | No | Not published | 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 | Not published | Yes | Yes |
| Usage per sandbox (API) | Not published | Yes | Yes |
| Audit logs | Yes | Yes | No |
| SSO | Yes | Yes | No |
| SOC 2 | Yes | Yes | No |
| HIPAA | Yes | No | No |
| EU data residency | Yes | Yes | Yes |
| Zero data retention | Not published | Not published | Yes |
Performance
In StarSling's public benchmark at 4 vCPU / 8 GB, boat finished 26.69 Node.js build-and-test runs per second and Modal's default sandbox finished 12.79, so boat did about twice the work. Replit is not in that benchmark, so there is no comparable measurement 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 measured on: Sandbox (gVisor), request = size, any region. 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 | Modal, a month | Replit, a month | boat, 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 | $15 · Starter · with limits | $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 | $178 · Starter · with limits | $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 | $2,229 · Starter · with limits | $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 | $792 · Team | $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 | $3,193 · Team · with limits | $825 · Pro $1,000 (annual) · with limits | $2,000 · $2000/mo · with limits |
Modal: Modal bills by the second for the CPU and memory you request or use, whichever is higher, until the sandbox is terminated. Starter is free with $30 of monthly credit and Team is $250 a month with $100 of credit.
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 has a fixed monthly price per size and bills whether busy or idle, while Autoscale charges only while it serves requests.
Replit: boat plans start at $20 a month and the whole fee becomes usage credit, spent by the second while a sandbox runs. A stopped sandbox costs nothing and keeps its disk.
Limits in those scenarios
On Modal, a sandbox lives at most 24 hours on Starter and its root disk is wiped when it ends, so the workday, always-on and fleet scenarios keep only files in a Volume, and the 50-agent fleet needs the VM runtime for Docker. Replit is an app platform: each always-on machine is a published Reserved VM that bills all month, Docker is not documented, and how many can run at once is not published, so 300 sandboxes or 1,000 jobs at once are not confirmed. On boat, the 1,000-job burst queues above 90 starts a minute and needs more starts a day than the $2,000 plan allows.
| Scenario | Modal | Replit | boat |
|---|---|---|---|
| One coding agent, workdays |
|
| None that bite |
| One agent that never stops |
|
| None that bite |
| 50 agents in parallel |
|
| 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 Modal when
your code needs to start many short sandboxes at once, next to GPUs, with outbound rules and regions outside Europe.
- Sandboxes started by your code, at scale. Useful for platforms and RL: your program starts thousands of short sandboxes, up to 5,000 containers at once on Team.
- GPUs on the same platform. Useful if your agent trains or runs models: Modal rents GPUs from T4 to B300 next to its sandboxes.
- Outbound traffic rules. Useful for untrusted code: Modal can block a sandbox's outbound traffic or allow only chosen IP ranges or domains.
Use Replit when
you want Replit Agent to build a web app from a description and host it for you, with a database 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 writes, tests and publishes it with a domain.
- Hosting that sleeps 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 for small products: each Replit app gets Postgres and object storage without setting anything up.
Where boat fits
If what you are really running is coding agents that work for hours, neither fits cleanly: Modal ends sandboxes within a day and Replit is built to host apps, not to give your code machines. boat gives each agent a full VM that keeps its disk, runs Docker and a desktop, and is driven from outside by API.
A machine that keeps its work
A Modal sandbox lasts at most 24 hours and its root disk goes with it, unless you write code to save files to a Volume. On Replit an always-on machine is a Reserved VM app that bills all month.
Docker, systemd and KVM on its own kernel
An agent that runs docker compose or boots an emulator needs these. Modal has Docker only on its VM runtime and /dev/kvm on request on Team; Replit's Nix setup does not describe them at all.
Agents and a desktop driven from outside
On Modal you install VNC and the agent harness yourself, with keys in environment variables. Replit's MCP server drives only Replit Agent, and its VNC pane has no computer-use API.
Use boat when your agents work for hours or days: full VMs with Docker and a desktop that keep their disk, coding agents you drive by API, and keys kept outside. Compare it one to one: boat vs Modal and boat vs Replit.
Questions people ask
Is Modal cheaper than Replit?
It depends on the job, and neither fits most of our agent scenarios as is. One always-on agent comes to $178 on Modal against $122 on Replit, and 50 parallel agents to $2,229 against $1,330, while sandboxes for your users come to $792 on Modal, which fits, against $403 on Replit, which does not. boat comes to $26, $317 and $200 for the same three.
Which is faster, Modal or Replit?
We cannot say: Modal's default sandbox did 12.79 Node.js build-and-test runs per second in StarSling's benchmark, but Replit is not in it. boat did 26.69 in the same run, about twice Modal's default sandbox.
Can Modal or Replit run Docker?
Modal runs Docker only on its VM runtime, which you pick with runtime="vm"; the default gVisor sandbox does not document it. Replit sets up environments with Nix packages and does not describe running Docker. Every boat sandbox runs Docker, with root and systemd.
Is Replit a sandbox API like Modal?
No. Modal's sandboxes are created by your code; Replit is an app builder where Replit Agent writes and publishes apps, and its MCP server drives Replit Agent rather than starting machines. boat is a sandbox API like Modal, with full VMs.
How long can a session run?
A Modal sandbox runs for 5 minutes by default and 24 hours at most. A Replit Reserved VM runs continuously at a fixed monthly price. A boat sandbox has no session cap on paid plans, and stopping it ends the bill while keeping the disk.
Do Modal or Replit have GPUs?
Modal does, from T4 to B300, with 10 at once on Starter and 50 on Team. Replit does not, and neither does boat, so for GPU work Modal is the pick.
Try boat
Install the CLI, then run boat new.
7-day free trial