Agent 37 vs Modal VM Sandboxes
Agent 37 gives each user a lasting gVisor sandbox that can sleep when idle and wake with its memory, with a full VM type as an option. Modal VM Sandboxes are real VMs with Docker and systemd built for many short jobs, and each one ends within 24 hours.
The companies and products
Agent 37
Agent 37 hosts AI agents, one isolated, always-on sandbox per user, behind one API.
You create an instance from a template (Hermes, OpenClaw, Claude Code, Codex, OpenCode, Pi, Grok or your own Docker image) and talk to it through a chat API, files, exec, SSH and HTTPS URLs. The default instance is a container enforced by gVisor; a VM type gives a full Linux machine with its own kernel for Docker, Kubernetes and Android emulators. It is built for companies that give each of their customers an agent.
- Where it runs
- Dedicated servers in the United States
- Instance types
- Default (shared), Performance (dedicated cores), VM
- Compliance
- SOC 2 Type I, Type II in progress
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.
- Funding
- Over $466M raised
- 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. “2nd cheapest of 367” means 1 of the other 366 providers runs 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 | Agent 37: price rank | Modal VM Sandboxes: price rank | boat: price rank |
|---|---|---|---|
| Software factory 100 at once · 4 vCPU / 8 GB · 2,200 sessions of 8 h a month Modal VM Sandboxes run Docker in every VM but lose everything outside a Volume within 24 hours; Agent 37 needs its VM type for Docker, and boat gives Docker, systemd and a desktop in every sandbox. | 2nd cheapest of 367 $551 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 This is what Agent 37 is built for, one always-on assistant per user that sleeps and wakes; Modal VM Sandboxes stop at 24 hours, so they do not fit. | Cheapest of 366 $279 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 Agent 37's small default sandboxes suit short code runs, and boat's start limits make large bursts of one-minute jobs a poor fit. | Cheapest of 345 $22 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 Agent 37 holds up to 200 instances on its top self-serve tier, counting sleeping ones; Modal Team runs 5,000 containers at once, and boat plans go up to 2,000. | 30th of 361, with limits $79 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, while Agent 37 holds at most 200 instances on self-serve and boat's start limits queue large bursts. | 6th of 360, with limits $363 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 | 90th of 364, with limits $58 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 VM Sandboxes and boat run Docker builds in every VM; Agent 37 needs its VM type for Docker, which bills compute at 2.5 times its default rate. | 2nd cheapest of 377 $84 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 | 3rd cheapest of 368 $12 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 Agent 37 adds a noVNC desktop through a template build, on Modal you set up Xvfb and VNC yourself, and boat streams a 60fps desktop out of the box. | Cheapest of 369 $53 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 | 48th of 367, with limits $29 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 | Cheapest of 346 $32 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 | 36th of 338, with limits $648 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 Neither Agent 37 nor Modal can fork a machine that is still running; boat can, so one half-done attack can branch into many tries at once. | Cheapest of 360 $43 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 | Agent 37 | Modal VM Sandboxes | boat |
|---|---|---|---|
| Isolation | gVisor by default; full VM as an opt-in instance type | VM with its own Linux kernel on Cloud Hypervisor | Every sandbox is a full VM with its own kernel |
| Docker inside | Only on the VM type, at 2.5x the default compute rate | Yes; start dockerd yourself as the entrypoint | Yes, in every sandbox |
| systemd and init | Your entrypoint is PID 1 with no init system, even on the VM type | systemd works | systemd runs as in any Linux server |
| Nested virtualization | /dev/kvm on the VM type, with a ready Android template | Team and Enterprise plans only, on request | /dev/kvm in every sandbox on every plan |
| CPU benchmark (4 vCPU / 8 GB) | No published result | 15.54 runs/s | 26.69 runs/s |
| Longest session | No time limit; runs until you stop it or it sleeps | 24 hours (default 5 minutes) | No cap on paid plans; you set the time to live |
| Idle and resume | Opt-in auto-sleep after a quiet period, wakes on the next request with memory kept when the restore works | No paused state; a finished sandbox is gone, only Volumes and snapshots keep files | Stop for free, resume later with the whole disk; resume reboots the machine |
| Fork and snapshots | No fork; daily backups plus one on-demand backup, restored in place only | Filesystem snapshot into an image to boot new sandboxes; memory snapshots in alpha end the sandbox | Fork a running sandbox; disk saved every minute; named snapshots as templates |
| Custom images | Your own linux/amd64 Docker image as a template | Custom images built in code | Templates from named snapshots, no Dockerfile builds |
| Built-in agents | Hermes, OpenClaw, Claude Code, Codex, Grok, OpenCode, Pi, with a chat API per instance | Examples only; you install the agent harness | Claude Code, Codex, pi, OpenCode and others, driven from outside with a prompt, steer and events API |
| Keys kept out of the sandbox | Managed LLM, search and Composio through a per-instance token; your own keys go in as env vars | Secrets are environment variables, or you run your own proxy in a sidecar | Proxy for model providers and any HTTPS API you register |
| Desktop and computer use | noVNC desktop through a template build or the Ubuntu VM template | Not offered; set up Xvfb and VNC yourself | 60fps desktop, Chromium and computer-use API in every sandbox |
| Networking | HTTPS URL per port, custom domains; no public IP, SSH through a WebSocket tunnel | Encrypted and raw TCP tunnels, inbound IP allowlist, outbound allowlists | HTTPS URLs for up to 50 ports, raw TCP, dedicated IPv6 or IPv4 per machine |
| Regions | United States | US, EU and Asia-Pacific; pinning costs 1.15x to 1.75x | EU only (Germany, Finland, France), EU data residency |
Every feature Battleships tracks (43)
| Feature | Agent 37 | Modal VM Sandboxes | boat |
|---|---|---|---|
| Full VM (own kernel) | No | Yes | Yes |
| Docker inside | No | Yes | Yes |
| Nested virtualization | No | Yes | Yes |
| Root | Yes | Yes | Yes |
| Systemd | Not published | Yes | Yes |
| Desktop GUI | Yes | No | Yes |
| Browser | Yes | No | Yes |
| Computer-use API | Yes | No | Yes |
| SSH | Yes | Yes | Yes |
| Persistent disk | Yes | Yes | Yes |
| Pause/resume | Yes | No | Yes |
| Automatic snapshots | Yes | No | Yes |
| Fork/clone | Yes | Yes | Yes |
| Live fork (no pause) | Yes | 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 | No | No | No |
| GPU | No | No | No |
| Windows | No | No | No |
| Arm64 | No | 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 | Not published | Yes | No |
| SSO | No | Yes | No |
| SOC 2 | Yes | Yes | No |
| HIPAA | No | Yes | No |
| EU data residency | No | Yes | Yes |
| Zero data retention | Not published | Not published | Yes |
Performance
In the hpc-sandbox-benchmarks Node.js build-and-test loop at 4 vCPU / 8 GB, boat finished 26.69 runs per second and Modal's VM runtime 15.54, so boat did about 1.7 times the CPU work in the same time. Agent 37 has no published result on that benchmark, so there is no comparable measurement for it. Agent 37 says its default instances share host resources and sells a Performance type on dedicated cores.
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. Agent 37 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 | Agent 37, a month | Modal VM Sandboxes, 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 | $6 · Wallet (any top-up) | $15 · Starter · with limits | $20 · $20/mo |
| One agent that never stops 4 vCPU / 8 GB, 50 GB disk, running 24/7 all month | $12 · Wallet (any top-up) | $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 | $329 · Wallet ($100 lifetime top-ups) | $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 | $33 · Wallet ($250 lifetime top-ups) · 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 | $73 · Wallet ($250 lifetime top-ups) · with limits | $3,193 · Team · with limits | $2,000 · $2000/mo · with limits |
Agent 37: A prepaid wallet with no plan fee, metered per minute: $0.80 per vCPU and $0.70 per GB of RAM per month while running, and $0.09 per GB of disk per month even while asleep. Performance compute costs 4x and VM compute 2.5x the default rate.
Modal VM Sandboxes: Billed by the second for the higher of what 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: One hourly rate per machine size, by the second, only while the sandbox runs. Plans start at $20 a month and the whole fee becomes usage credit; a stopped sandbox costs nothing and keeps its disk.
Limits in those scenarios
Agent 37's instance cap is 10 after your first top-up, 50 at $100 of total top-ups and 200 at $250, and it counts sleeping and stopped instances, which is why it misses the 300 and 1,000 at once scenarios. The 50-agent fleet needs Docker, so Agent 37 is priced on its VM type there. A Modal VM Sandbox lives at most 24 hours and its root disk is gone when it ends, so the workday, always-on and fleet scenarios only keep files in a Volume or snapshot. On boat the limit that bites is start speed: even the $2,000 plan starts 90 sandboxes a minute, so 1,000 jobs at once queue.
| Scenario | Agent 37 | Modal VM Sandboxes | 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 Agent 37 when
you host one mostly idle assistant per customer in the US that should sleep with its memory kept and wake on the next message.
- Sleeps when idle and keeps its memory. For assistants that sit idle most of the day: an instance sleeps, keeps its memory and wakes on the next message.
- No session cap. An Agent 37 instance keeps running until you stop it, so one agent can live on its machine all month.
- Bring a Dockerfile, pick dedicated cores. Agent 37 builds templates from your own Docker image, and sells a Performance type on dedicated cores.
Use Modal VM Sandboxes when
you run huge bursts of short jobs that need Docker and finish within a day, need regions outside Europe or strict outbound rules, or already run your models on Modal.
- Docker and systemd in every VM. Every Modal VM Sandbox has its own Linux kernel, so Docker, FUSE and systemd work without picking a special type.
- Very large bursts. For huge bursts of short jobs: Modal runs 5,000 containers at once on Team, and more on Enterprise.
- Regions, outbound rules and one platform. Modal runs in the US, EU and Asia-Pacific, can limit outbound traffic to chosen domains, and hosts your models too.
Where boat fits
Agent 37 keeps a machine around but makes Docker an extra-cost type with no init system. Modal gives a real VM but ends it within 24 hours. If your agents need a full VM for hours or days that keeps its disk, look at boat.
A full VM that keeps its work
On Agent 37 Docker needs the VM type, at 2.5 times the compute rate and with no systemd. On Modal the VM ends within 24 hours and its root disk goes with it unless you snapshot or use a Volume.
Fork a machine while it runs
Agent 37 has no fork, and its backups restore only in place. Modal makes a filesystem image, but its memory snapshots end the original sandbox. boat copies a running sandbox so one half-done task can branch into many tries.
Keys outside and a desktop built in
On both, your own API keys sit inside a machine the agent controls, unless you build a sidecar proxy on Modal. boat's proxy covers any HTTPS API, and every sandbox has a 60fps desktop for computer use.
Use boat when your agents work for hours or days in a full VM they come back to, with Docker, systemd, a desktop, forks of running machines and keys kept outside for any API. Compare it one to one: boat vs Agent 37 and boat vs Modal VM Sandboxes.
Questions people ask
Is Agent 37 cheaper than Modal VM Sandboxes?
In our scenarios, yes. One always-on agent costs $12 a month on Agent 37 against $178 on Modal, and 50 parallel agents with Docker cost $329 against $2,229. Agent 37's self-serve tiers stop at 200 instances, so it cannot hold 300 or 1,000 at once.
Which is faster, Agent 37 or Modal VM Sandboxes?
Agent 37 has no published result on the hpc-sandbox-benchmarks CPU test, so there is no direct comparison. Modal's VM runtime did 15.54 runs per second at 4 vCPU / 8 GB, and boat did 26.69 in the same run.
Can Agent 37 and Modal VM Sandboxes run Docker?
Every Modal VM Sandbox can run Docker; you start dockerd yourself. Agent 37 runs Docker only on its VM type, which bills compute at 2.5 times the default rate; the default gVisor type cannot run a Docker daemon. boat runs Docker in every sandbox.
How long can a sandbox run on each?
An Agent 37 instance has no time limit and runs until you stop it or it sleeps. A Modal VM Sandbox defaults to 5 minutes and stops at 24 hours at most. boat has no session cap on paid plans.
Where do Agent 37 and Modal run?
Agent 37 runs on dedicated servers in the United States. Modal runs in the US, the EU and Asia-Pacific, and pinning a region costs 1.15x to 1.75x. boat runs only in the EU, in Germany, Finland and France.
Is boat SOC 2 compliant?
SOC 2 is in progress. We're open about where we stand: live status at status.ascii.dev and our data retention policy at docs.boat.dev/data-retention.
Try boat
Install the CLI, then run boat new.
7-day free trial