exe.dev vs AWS AgentCore
exe.dev gives each agent a Linux VM with root, Docker and SSH that runs until you stop it and keeps its whole disk. AWS AgentCore hosts agent sessions inside your AWS account, with managed Code Interpreter and Browser tools, but its microVM sessions stop at 2 vCPU and 8 hours.
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
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. “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 | AWS AgentCore: price rank | bochka: price rank |
|---|---|---|---|
| Software factory 100 at once · 4 vCPU / 8 GB · 2,200 sessions of 8 h a month A coding agent needs Docker and hours of work: exe.dev gives it a full VM, AgentCore microVMs stop at 2 vCPU and 8 hours, and bochka adds a desktop and minute snapshots. | 253rd of 367, with limits $3,701 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 assistant that lives on one machine all month fits exe.dev, whose VMs have no time limit; AgentCore needs its Instances type on EC2 to get past 8 hours, and bochka ranks 5th here. | 15th cheapest of 366 $3,833 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 many short code runs and bills only for CPU used; exe.dev and bochka are full VMs and rank much lower here. | 235th of 345, with limits $175 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 exe.dev Personal stops at 50 VMs at once and AgentCore sessions have no open ports, so your users cannot open the app their sandbox runs; bochka gives each one HTTPS URLs. | 257th of 361, with limits $1,226 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 | 265th of 360, with limits $5,250 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 | 283rd of 364, with limits $1,050 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 AgentCore bills only for CPU used, which suits short CI jobs, while exe.dev pools bill whether jobs run or not; bochka exposes /dev/kvm for jobs that need emulators. | 288th of 377, with limits $504 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 exe.dev makes a good 24/7 dev box with SSH and a disk that lasts; AgentCore has no SSH and resets files outside its storage mount, and bochka adds a desktop in the browser. | 25th cheapest of 368 $35 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 Neither exe.dev nor AgentCore streams a whole desktop; AgentCore Browser covers web pages only, while bochka streams a full Linux desktop at 60fps. | 240th of 369, with limits $1,055 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 replay, bochka runs Chromium on a full machine with a desktop, and on exe.dev you set up a headless browser yourself. | 130th of 367, with limits $530 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 | 124th of 346, with limits $278 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 | 166th of 338, with limits $5,490 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 | 60th of 360, with limits $263 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 | exe.dev | AWS AgentCore | bochka |
|---|---|---|---|
| What it is | Linux VMs for developers and agents, reached over SSH and HTTPS | An AWS agent platform: hosted agent sessions plus managed Code Interpreter and Browser tools | A sandbox platform: each agent gets its own full Linux machine |
| Isolation | KVM VM with Cloud Hypervisor; you can't choose the kernel | 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 |
| Biggest machine | Pools up to 16 vCPU on Personal, larger on Work with approval | 2 vCPU / 8 GB per microVM session; bigger EC2 types only on Instances | Up to 16 vCPU / 32 GB on the $100 plan and above |
| Session length | No cap; VMs run until you stop them | 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 |
| What survives a stop | The whole disk, streamed to a second server | Only one storage mount under /mnt, up to 1 GB, in preview; EBS volumes on Instances | The whole disk, saved every minute and on stop |
| Snapshots and fork | No snapshots; cp copies a VM's disk into a new VM | No user snapshots or fork of a session | Automatic snapshots every minute; fork a running sandbox with its disk |
| Docker, systemd and /dev/kvm | Root, Docker and systemd; nested virtualization on Enterprise only | Root inside the microVM; Docker and /dev/kvm not documented | Root, Docker, systemd and /dev/kvm on every plan |
| Custom images | Boot from your own Docker image | Your own arm64 container image on Runtime | Templates from named snapshots; no Dockerfile or OCI images |
| Inbound access | HTTPS proxy for ports 3000 to 9999 and SSH; no public IP or raw TCP | No open ports or SSH; reached only through AgentCore APIs with IAM or JWT | HTTPS URLs for up to 50 ports, token-protected by default; raw TCP; SSH |
| Browser and desktop | Headless; no desktop or screen streaming | Managed Chromium with live view, recording and replay; no full desktop | Full Linux desktop streamed at 60fps, with Chromium and computer use |
| Coding agents | Claude Code, Codex, Pi and Shelley preinstalled; only Shelley takes prompts through the API | AWS's managed harness built on Strands Agents, or your own agent code | Claude Code, Codex and five more preinstalled, with a prompt, steer and events API |
| Keeping API keys out | Integrations inject secrets at the network edge for any HTTP host | AgentCore Identity stores tokens and keys and hands them to your agent code | Credentials proxy for model providers and any HTTPS API; switch accounts when credits run out |
| Network controls and GPUs | No GPUs; no provider-side allowlist | VPC mode, security groups and PrivateLink; GPUs on Instances | Open internet; no GPUs |
| Regions | 9 regions in the US, Europe, Asia and Australia | 17 commercial AWS regions plus GovCloud | EU only (Germany, Finland, France), with EU data residency |
Every feature Battleships tracks (43)
| Feature | exe.dev | AWS AgentCore | bochka |
|---|---|---|---|
| Full VM (own kernel) | Yes | Yes | Yes |
| Docker inside | Yes | Not published | Yes |
| Nested virtualization | Yes | No | Yes |
| Root | Yes | Yes | Yes |
| Systemd | Yes | No | Yes |
| Desktop GUI | No | No | Yes |
| Browser | Yes | Yes | Yes |
| Computer-use API | No | Yes | Yes |
| SSH | Yes | No | Yes |
| Persistent disk | Yes | Yes | Yes |
| Pause/resume | Yes | No | Yes |
| Automatic snapshots | No | No | Yes |
| Fork/clone | Yes | No | 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 | No | Yes |
| Idle auto-stop | No | Yes | No |
| Wake on request | No | Yes | No |
| HTTPS preview URLs | Yes | No | Yes |
| Raw TCP inbound | No | No | Yes |
| Public IPv4 | No | No | No |
| Egress allowlist | No | Yes | No |
| Secret proxy | Yes | No | Yes |
| Secret proxy for any API | Yes | 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 | No | Yes | No |
| Self-hosting | No | No | No |
| BYOC | Yes | Yes | No |
| Open source | No | No | No |
| Scoped API keys | Yes | Not published | Yes |
| Spend limits | Not published | Yes | Yes |
| Usage per sandbox (API) | Yes | No | Yes |
| Audit logs | Not published | Yes | No |
| SSO | Yes | Yes | No |
| SOC 2 | No | 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 CPU measurement for exe.dev or AWS AgentCore: neither was part of the hpc-sandbox-benchmarks run. bochka did 26.69 runs per second on its Node.js build-and-test loop at 4 vCPU / 8 GB. We don't guess how the other two would score.
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 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 | exe.dev, 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 | $35 · Personal | $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 | $35 · Personal | $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,848 · Personal | $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 | $530 · Personal · 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 | $1,050 · Personal · with limits | $1,615 · Pay-as-you-go (Instances) | $2,000 · $2000/mo · with limits |
exe.dev: Personal pools are a flat monthly fee for reserved capacity your VMs share, billed whether they are busy or idle. Standalone VMs bill per second at $0.105 per 2 vCPU / 4 GiB per hour.
AWS AgentCore: Runtime microVMs, Code Interpreter and Browser bill per second for CPU actually used and for peak memory. The 4 vCPU shape in these scenarios is the Instances type: the EC2 on-demand price plus a 12% management fee, with storage and data transfer on top.
AWS AgentCore: Plans start at $20 a month, and the whole fee is usage credit. You pay per second while a sandbox runs, and a stopped sandbox costs nothing and keeps its disk.
Limits in those scenarios
AgentCore microVM sessions stop at 2 vCPU / 8 GB and 8 hours, so the 4 vCPU scenarios use Instances, where only the session storage mount keeps files and packages installed elsewhere reset. That is why AgentCore does not fit the coding-agent, always-on and 50-agent scenarios. exe.dev Personal caps you at 50 VMs at once, so it does not fit 300 user sandboxes or 1,000 short jobs at once, which is the one scenario AgentCore fits. bochka fits every scenario except 1,000 short jobs, where its start limits queue the burst.
| Scenario | exe.dev | 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 |
| 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 lasting Linux VM per agent or developer, reached over SSH, booted from your own Docker image, in regions outside Europe.
- A VM that stays. For agents and dev boxes that live for weeks, exe.dev VMs run until you stop them and keep their whole disk.
- SSH and Docker like a normal server. You SSH in, get root, systemd and Docker, and can boot the VM from your own Docker image.
- Simple flat pools. Its Personal plan is one flat monthly fee for a pool your VMs share, with no AWS account to set up.
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 the 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 billed by use. For short code runs and browser tasks, Code Interpreter and Browser charge only for CPU actually used.
- GPUs and two-week sessions. On the Instances type, agents can use NVIDIA or Inferentia2 GPUs and run sessions for up to 14 days.
Where bochka fits
If your agents do real work on a machine for hours, like installs, builds, tests and a browser, look at bochka too. It keeps exe.dev's lasting full VM, and adds a desktop, minute snapshots, open ports and one API to drive agents inside from outside, none of which AgentCore microVMs offer.
Roll back a bad agent step
Neither exe.dev nor AgentCore has snapshots, and AgentCore keeps only a 1 GB mount after a stop. One bad step can cost a session's work. bochka saves the disk every minute and can fork a running sandbox.
A screen your agents can use
exe.dev VMs are headless, and AgentCore Browser shows only a browser. An agent checking a desktop app has nothing to look at unless you build a stream yourself. bochka streams a full 60fps desktop.
Drive Claude Code from your app
On exe.dev only Shelley takes prompts through the API, and AgentCore runs its own harness or your code. You end up scripting shell sessions. bochka lets you prompt, steer and stream seven agents through one API.
Use bochka when your agents do real work on a machine for hours, with Docker, a desktop and a browser, a disk saved every minute and one API to drive agents inside from outside. Compare it one to one: bochka vs exe.dev and bochka vs AWS AgentCore.
Questions people ask
Is exe.dev cheaper than AWS AgentCore?
It depends on the work. For one agent all month, exe.dev's Personal pool is $35 a month against $107 on AgentCore Instances. For 50 agents in parallel AgentCore is lower, at $1,286 against $1,848, but it does not fit that scenario because installed packages reset after a stop. bochka is $26 and $317 for those two.
Which is faster, exe.dev or AWS AgentCore?
We can't say: neither was part of the hpc-sandbox-benchmarks run, so there is no comparable CPU score. bochka scored 26.69 runs per second at 4 vCPU / 8 GB on that test.
Can I run Docker on exe.dev and AgentCore?
exe.dev VMs come with root, systemd and Docker. AgentCore runs your arm64 container image as root in a microVM, but its docs do not say Docker or /dev/kvm work inside a session. bochka runs Docker and exposes /dev/kvm on every plan.
How long can a session run on each?
exe.dev VMs have no time limit and run until you stop them. An AgentCore microVM session lasts up to 8 hours and stops after 15 idle minutes by default; the Instances type runs up to 14 days. bochka has no session cap on paid plans.
Do files survive a stop?
On exe.dev the whole disk stays. On AgentCore only a storage mount under /mnt, up to 1 GB and in preview, or EBS volumes on Instances survive. bochka keeps the whole disk and saves it every minute.
Can I open an app my agent starts?
exe.dev serves ports 3000 to 9999 through its HTTPS proxy. AgentCore sessions have no open ports or SSH, so you would proxy traffic through your own code. bochka gives HTTPS URLs on up to 50 ports plus raw TCP.
Try bochka
Install the CLI, then run bochka new.
Product preview