Replit vs AWS AgentCore
Replit is an app builder: you describe an app, Replit Agent writes it, and Replit hosts it. AWS AgentCore is the part of AWS that runs your own agent code in short microVM sessions, with a managed code interpreter and browser next to it.
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.
AWS AgentCore
Amazon Bedrock AgentCore is a set of AWS services to deploy and run AI agents: a Runtime that hosts your agent code, plus built-in Code Interpreter and Browser tools.
AgentCore is not a sandbox product first. It is a hyperscaler's agent platform: you push a container image or code, and each Runtime session gets its own Firecracker microVM that you reach through AgentCore APIs. Around it sit managed tools (Code Interpreter, Browser) and services for memory, identity, gateways and evaluations, and an Instances compute type runs longer sessions on EC2 in your own account. It is built for teams who already build on AWS and want agents to stay inside their account, IAM and VPC.
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 | AWS AgentCore: price rank | bochka: price rank |
|---|---|---|---|
| Software factory 100 at once · 4 vCPU / 8 GB · 2,200 sessions of 8 h a month AgentCore runs your own agents but gives each microVM session 2 vCPU and 8 hours, while Replit drives only Replit Agent, one app at a time; bochka gives each agent a full machine with Docker. | 181st of 367, with limits $2,000 a month | 100th of 367, with limits $888 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 is a Reserved VM on Replit, billed all month, or the Instances type on EC2 in your account on AgentCore; on bochka any sandbox just keeps running. | 202nd of 366, with limits $2,033 a month | 64th of 366, with limits $1,300 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 AgentCore Code Interpreter is built for short code runs and bills only for CPU actually used, which suits this job far better than Replit's app hosting. | 228th of 345, with limits $146 a month | 7th cheapest of 345 $114 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 Neither is built to give your users their own machines: Replit does not publish how many deployments can run at once, and AgentCore sessions have no open ports; bochka gives each sandbox HTTPS URLs. | 233rd of 361, with limits $825 a month | 210th of 361, with limits $506 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 | 125th of 360, with limits $8,075 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 | 33rd cheapest of 364 $650 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 or Android apps need Docker and /dev/kvm, which bochka has on every machine and neither Replit nor AgentCore documents. | 275th of 377, with limits $425 a month | 52nd cheapest of 377 $399 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 fine place to code by hand, while AgentCore has no SSH and resets files outside its storage mount after a stop. | 165th of 368, with limits $109 a month | 228th of 368, with limits $52 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, AgentCore Browser drives only a browser, and bochka streams a full Linux desktop at 60fps for agents. | 190th of 369, with limits $619 a month | 104th of 369, with limits $202 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 AgentCore Browser is a managed Chromium with live view and session replay, which Replit does not offer; bochka runs Chromium on a full machine you control. | 229th of 367, with limits $317 a month | 4th cheapest of 367 $144 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 | 27th cheapest of 346 $287 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 | 165th of 338, with limits $5,458 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 | 62nd of 360, with limits $294 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 | AWS AgentCore | bochka |
|---|---|---|---|
| What it is | AI app builder with browser workspaces and app hosting | AWS agent platform: hosted agent sessions plus managed Code Interpreter and Browser | Sandboxes you create, stop and fork by API, SDK or CLI |
| Isolation | Not documented; the security page says strong logical separation between users | Firecracker microVM per Runtime session; Code Interpreter and Browser in a containerized environment | Full VM with its own kernel on dedicated AMD Ryzen 9 9950X hosts |
| Starting machines from code | MCP server tools to create, update and publish apps; no API to start many machines | AgentCore APIs start sessions for your own agent code, with IAM or JWT | API, SDK and CLI to create, stop, resume and fork many sandboxes |
| Biggest machine | Reserved VM sizes such as 4 vCPU / 16 GB; workspace sizes no longer published | 2 vCPU / 8 GB per microVM session, not adjustable; bigger EC2 types only on Instances | Up to 16 vCPU / 32 GB on the $100 plan and above |
| Session length | Reserved VM runs continuously at a fixed monthly price | Up to 8 hours on microVMs, stopped after 15 idle minutes by default; up to 14 days on Instances | No cap on paid plans; you set the time to live |
| Files over time | Workspace files and Agent checkpoints; published apps should not rely on their filesystem | Only one storage mount under /mnt, up to 1 GB, in preview; EBS on Instances; the rest resets | The whole disk, saved every minute and on stop; a stopped sandbox costs nothing |
| Docker, systemd and /dev/kvm | System packages come from Nix; Docker, systemd and /dev/kvm not documented | Root inside the microVM; arm64 container images; Docker and /dev/kvm not documented | Root, Docker, systemd and /dev/kvm on every machine |
| Coding agents | Replit Agent, which an MCP client can also drive (create, update, ask, publish) | AWS's managed harness built on Strands Agents, or your own agent code | Claude Code, Codex, OpenCode and more preinstalled, with a prompt, steer and events API |
| Reaching the machine | Published apps on HTTPS domains and custom domains; SSH into the workspace on paid plans | No open ports or SSH; reached only through AgentCore APIs | HTTPS URLs on up to 50 ports, token-protected; raw TCP; SSH |
| Browser and desktop | VNC pane that streams a desktop to your browser; no computer-use API | Managed Chromium with live view, recording and replay; no full desktop | Full Linux desktop at 60fps with Chromium, computer use and browser control |
| Keeping keys out of the sandbox | Replit manages keys for some AI model providers; other keys are secrets in the app | AgentCore Identity stores OAuth tokens and API keys and hands them to your agent code | Credentials proxy for model providers and any HTTPS API; switch a credential to another account when credits run out |
| Hosted extras | Postgres and App Storage built into each app; Autoscale sleeps when idle | VPC mode, PrivateLink, memory, gateway and identity services inside AWS | No hosted databases or wake on request; run your own services inside a sandbox |
| GPUs | No | NVIDIA G-series and Inferentia2 on the Instances type | No |
| Regions | North America, Europe, Asia, South America and Australia for published apps on Core and up | 17 commercial AWS regions plus GovCloud | EU only: Germany, Finland, France |
Every feature Battleships tracks (43)
| Feature | Replit | AWS AgentCore | bochka |
|---|---|---|---|
| Full VM (own kernel) | Yes | Yes | Yes |
| Docker inside | No | Not published | Yes |
| Nested virtualization | No | No | Yes |
| Root | Not published | Yes | Yes |
| Systemd | No | No | Yes |
| Desktop GUI | Yes | No | Yes |
| Browser | No | Yes | Yes |
| Computer-use API | No | Yes | Yes |
| SSH | Yes | No | Yes |
| Persistent disk | Yes | Yes | Yes |
| Pause/resume | No | No | Yes |
| Automatic snapshots | Yes | No | Yes |
| Fork/clone | Yes | No | Yes |
| Live fork (no pause) | No | No | Yes |
| Memory fork | No | No | No |
| Custom image (Docker or snapshot) | Yes | Yes | Yes |
| ≥24 h sessions | Yes | No | Yes |
| Idle auto-stop | Yes | Yes | No |
| Wake on request | Yes | Yes | No |
| HTTPS preview URLs | Yes | No | Yes |
| Raw TCP inbound | Not published | No | 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 | Yes | No |
| GPU | No | Yes | No |
| Windows | No | No | No |
| Arm64 | Not published | Yes | No |
| Self-hosting | No | No | No |
| BYOC | No | Yes | No |
| Open source | No | No | No |
| Scoped API keys | Not published | Not published | Yes |
| Spend limits | Yes | Yes | Yes |
| Usage per sandbox (API) | Yes | No | 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
There is no comparable measurement for either one: neither Replit nor AWS AgentCore is in the hpc-sandbox-benchmarks run. bochka did 26.69 Node.js build-and-test runs per second at 4 vCPU / 8 GB. An AgentCore microVM session stops at 2 vCPU, so a like-for-like test would need its Instances type.
Node.js build-and-test loop at 4 vCPU / 8 GB, higher is better. Measured with the open hpc-sandbox-benchmarks suite. Replit and AWS AgentCore 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 | AWS AgentCore, 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 | $26 · Pay-as-you-go (Instances) · 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 | $107 · Pay-as-you-go (Instances) · 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 | $1,286 · Pay-as-you-go (Instances) · 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 | $423 · Pay-as-you-go · 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 | $825 · Pro $1,000 (annual) · with limits | $1,615 · Pay-as-you-go (Instances) | $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 has a fixed monthly price per size and bills whether busy or idle, so our scenarios price agents that way.
AWS AgentCore: Runtime microVMs, Code Interpreter and Browser bill per second for CPU actually used and peak memory. A 4 vCPU agent needs the Instances type: the EC2 on-demand price plus a 12% fee, with storage and data transfer on top.
AWS AgentCore: Plans start at $20 a month, and the whole fee is usage credit spent per second while a sandbox runs. A stopped sandbox costs nothing and keeps its disk.
Limits in those scenarios
Replit is not a fit in any scenario because it is an app platform: each always-on machine is a published Reserved VM that bills all month, and how many can run at once is not published. AgentCore's microVMs stop at 2 vCPU / 8 GB and 8 hours, so the 4 vCPU agents here use the Instances type, where only the storage mount or EBS survives a stop and a session ends after 14 days. AgentCore fits the 1,000-job burst; bochka does not, because it queues starts above 90 a minute and needs more starts per day than its $2,000 plan allows.
| Scenario | Replit | AWS AgentCore | bochka |
|---|---|---|---|
| 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 |
| 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 a database and regions outside Europe.
- An app built and hosted for you. Pick Replit if you want a working web app from a description, with Replit Agent writing, testing and publishing it.
- Databases and hosting in one place. Each Replit app comes with Postgres and storage, and Autoscale wakes on the first request and costs nothing while idle.
- Built for people, not just code. Replit gives you a browser workspace to code by hand, with collaborators, checkpoints and one-click publishing.
Use AWS AgentCore when
your agents must stay inside your AWS account and VPC, need a GPU, or are short code and browser tasks that fit its managed tools.
- It lives inside your AWS account. Teams built on AWS keep agents behind their own IAM, VPC, security groups and PrivateLink, in 17 commercial regions.
- Managed tools that bill only for use. For short code runs and browser tasks, Code Interpreter and Browser charge only for CPU actually used, with live view and replay.
- GPUs and two-week sessions. Agents that need a GPU or a session of up to 14 days can run on EC2 in your account with the Instances type.
Where bochka fits
If what you are really running is agents that do long work on a machine, both choices make you bend the job: Replit is built around one app per person, and AgentCore around short, small sessions. bochka gives each agent a full Linux VM by API, with Docker, a disk that keeps everything and a URL you can open.
A whole machine for as long as it takes
AgentCore microVM sessions stop at 2 vCPU and 8 hours unless you move to EC2 in your own account, and Replit's always-on machine is a Reserved VM app. bochka runs up to 16 vCPU with no session cap on paid plans.
Docker, systemd and /dev/kvm, with the disk kept
Neither Replit nor AgentCore documents Docker or /dev/kvm, and AgentCore resets files outside a 1 GB mount after a stop. bochka has root, Docker and KVM, saves the disk every minute, and forks a running sandbox.
Your coding agents, driven from outside
Replit's MCP server drives only Replit Agent, and AgentCore has no open ports to show what an agent built. bochka ships Claude Code and Codex with a prompt, steer and events API, plus HTTPS on 50 ports.
Use bochka when your own code starts machines for agents that work for hours: full VMs with Docker, a disk that keeps everything, coding agents you drive by API and a URL you can open. Compare it one to one: bochka vs Replit and bochka vs AWS AgentCore.
Questions people ask
Is Replit cheaper than AWS AgentCore?
Usually not for agent machines. One coding agent on workdays comes to $122 on Replit against $26 on AgentCore, and one that never stops is $122 against $107. Replit is lower for 1,000 short jobs at once ($825 against $1,615), but only AgentCore fits that one. bochka comes to $20 and $26 for the first two.
Which is faster, Replit or AWS AgentCore?
We cannot say: neither is in the public benchmark we use. bochka did 26.69 Node.js build-and-test runs per second at 4 vCPU / 8 GB there. AgentCore microVM sessions top out at 2 vCPU, and Replit no longer publishes workspace sizes.
Can Replit or AgentCore run Docker?
Neither documents it. Replit sets up environments with Nix packages, and AgentCore runs your arm64 container image as root in a microVM without saying Docker or /dev/kvm work inside. Every bochka sandbox has root, systemd, Docker and /dev/kvm.
Is Replit a sandbox for AI agents like AgentCore?
Not really. Replit is an app builder where Replit Agent writes and publishes apps, while AgentCore runs your own agent code in sessions you start through AWS APIs. bochka is a full Linux machine per agent that your code creates by API.
How long can a session run on each?
A Replit Reserved VM runs continuously as a published app. An AgentCore microVM session lasts up to 8 hours and stops after 15 idle minutes by default, or up to 14 days on Instances. bochka has no session cap on paid plans.
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