Modal vs Claude Managed Agents
Modal gives you sandboxes you create and drive from your own code, next to GPUs, in regions around the world. Claude Managed Agents gives you a finished agent: you send Claude a task and it works in a small container that Anthropic runs for you.
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.
Claude Managed Agents
Claude Managed Agents is Anthropic's ready-made agent harness: Claude runs as an autonomous agent in a cloud sandbox that Anthropic manages, and you talk to it through an events API.
This is an agent platform, not a sandbox you rent. You define an agent (model, prompt, tools, MCP servers, skills) and an environment, then start sessions, send messages as events and stream back what Claude does; the harness handles tool calls, prompt caching and compaction. Each session gets its own Ubuntu container, or runs its tools on a worker you host yourself. It is built for teams that want Claude doing long tasks without building their own agent loop or sandbox.
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 | Claude Managed Agents: price rank | bochka: price rank |
|---|---|---|---|
| Software factory 100 at once · 4 vCPU / 8 GB · 2,200 sessions of 8 h a month A software factory needs Docker and a disk that lasts: Modal's default sandbox has no Docker and resets its root disk, Managed Agents lists Docker as limited availability, and bochka has both in every sandbox. | Can't run it | 106th of 367, with limits $964 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 session limit, while Managed Agents sleeps idle sessions for free but keeps sandbox state only 30 days; a bochka sandbox has no session cap on paid plans. | 196th of 366, with limits $1,924 a month | 219th of 366, with limits $2,511 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 high concurrency fit best, and Managed Agents bills runtime only while the agent works. | 19th cheapest of 345 $181 a month | 163rd of 345, with limits $756 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 Your users can open what runs in a Modal or bochka sandbox through tunnels or HTTPS URLs, but a Managed Agents sandbox has no inbound ports. | 11th cheapest of 361 $811 a month | 231st of 361, with limits $823 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 what Modal is built for, with 5,000 containers on its Team plan. | 5th cheapest of 360 $19,038 a month | 252nd of 360, with limits $3,978 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 | 244th of 364, with limits $320 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 | 126th cheapest of 377 $1,793 a month | 227th of 377, with limits $96 a month | 4th cheapest of 377 $86 a month |
| 24/7 dev boxes 1 machine 24/7 · 4 vCPU / 8 GB A dev box needs SSH and a disk that lasts; Managed Agents has no SSH, Modal wipes the root disk within 24 hours, and bochka keeps the whole disk. | 138th of 368, with limits $23 a month | 224th of 368, with limits $48 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 Managed Agents ships a desktop or computer-use tool; bochka streams a full Linux desktop at 60fps with a computer-use API. | 98th of 369, with limits $183 a month | 127th of 369, with limits $288 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 | 126th of 367, with limits $288 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 | 127th of 346, with limits $390 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 | 155th of 338, with limits $4,798 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 | 179th of 360, with limits $160 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 Modal rents GPUs from T4 to B300 next to its sandboxes; Managed Agents and bochka have none. | 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 | Claude Managed Agents | bochka |
|---|---|---|---|
| What it is | A serverless cloud: you create sandboxes from Python, TypeScript or Go code and run commands in them | A hosted Claude agent: Anthropic's harness runs Claude in a sandbox and you send it events | A sandbox platform: each agent gets its own full Linux VM, with coding agents built in |
| Isolation | gVisor by default; a VM runtime with its own kernel is a separate option | Isolated Linux container per session | Full VM with its own kernel, every sandbox, on dedicated AMD Ryzen 9 9950X hosts |
| Machine size | You request CPU and memory per sandbox; max is enforced but not published | Up to 8 GB memory and 10 GB disk; vCPU not published; not configurable | Up to 16 vCPU / 32 GB on the $100 plan and above |
| Docker and /dev/kvm | Docker only with the VM runtime; nested virtualization on request on Team and Enterprise | Docker listed as limited availability; /dev/kvm not documented | Docker, systemd and /dev/kvm in every sandbox |
| What persists | Only files in Volumes; the root disk is gone when the sandbox ends | Sandbox checkpointed when idle; state kept only 30 days after the sandbox is created | The whole disk, saved every minute and on stop, for as long as you keep the sandbox |
| Longest session | 24 hours (default 5 minutes) | No session cap published; idle sessions sleep and wake on the next message | No cap on paid plans (default TTL 1 h, changeable) |
| Fork and snapshots | Filesystem snapshots into images; memory snapshots in alpha | No fork or clone of a session or sandbox | Fork a running sandbox without stopping it |
| Inbound access | Encrypted and raw TCP tunnels, connect tokens, inbound IP allowlist | No inbound ports or SSH; reached only through the sessions and events API | HTTPS URLs on up to 50 ports, token-protected by default, plus raw TCP and SSH |
| Browser and desktop | Not offered; an example shows how to set up VNC yourself | Headless Chromium with Playwright; no desktop or computer-use tool | 60fps Linux desktop, Chromium and a computer-use API built in |
| Agents | None built in; you bring and wire up your own agent | Anthropic's harness with Claude models only, with steering, memory stores and webhooks | Claude Code, Codex and five more preinstalled, driven from outside through one API |
| Keeping API keys out of the sandbox | Secrets are environment variables, or you run your own proxy in a sidecar | Vault secrets sit in the sandbox as placeholders and are swapped in at egress, per host | Credentials proxy for model providers and any HTTPS API; real keys never enter the sandbox |
| GPUs | T4 to B300; 10 at once on Starter, 50 on Team | None | None |
| Outbound rules | Block all, IP-range allowlist, domain allowlist (beta) | Unrestricted, or limited to listed hosts plus optional package registries and MCP servers | Open internet, no provider-side allowlist |
| Where it runs | US, EU and Asia-Pacific; pinning a region costs 1.15x to 1.75x | US workspace geo only; self-hosted workers can run tools on your own infrastructure | EU only: Germany, Finland, France |
Every feature Battleships tracks (43)
| Feature | Modal | Claude Managed Agents | bochka |
|---|---|---|---|
| Full VM (own kernel) | No | No | Yes |
| Docker inside | No | Not published | Yes |
| Nested virtualization | No | No | Yes |
| Root | Yes | Not published | Yes |
| Systemd | Yes | Not published | Yes |
| Desktop GUI | No | No | Yes |
| Browser | No | Yes | Yes |
| Computer-use API | No | No | Yes |
| SSH | Yes | No | Yes |
| Persistent disk | Yes | Yes | Yes |
| Pause/resume | No | Yes | Yes |
| Automatic snapshots | No | Yes | Yes |
| Fork/clone | Yes | No | 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 | No | Yes |
| Raw TCP inbound | Yes | No | Yes |
| Public IPv4 | No | No | No |
| Egress allowlist | Yes | Yes | No |
| Secret proxy | No | Yes | Yes |
| Secret proxy for any API | No | Yes | 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 | No | No |
| Self-hosting | No | Yes | No |
| BYOC | No | Yes | 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 | Not published | No |
| SSO | Yes | Yes | No |
| SOC 2 | Yes | Yes | No |
| HIPAA | Yes | No | No |
| EU data residency | Yes | No | Yes |
| Zero data retention | Not published | No | Yes |
Performance
In the hpc-sandbox-benchmarks Node.js build-and-test loop at 4 vCPU / 8 GB on 29 September 2026, bochka finished 26.69 runs per second and Modal's default gVisor sandbox 12.79, so bochka did about twice the work. Claude Managed Agents was not measured, and Anthropic does not publish how many vCPUs its sandbox gets, so there is no comparable score 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. Claude Managed Agents 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 | Claude Managed Agents, 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 | $15 · Starter · with limits | $13 · Claude API (pay-as-you-go, usage tiers) · 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 | $53 · Claude API (pay-as-you-go, usage tiers) · 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 | $634 · Claude API (pay-as-you-go, usage tiers) · 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 | $360 · Claude API (pay-as-you-go, usage tiers) · 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 | $796 · Claude API (pay-as-you-go, usage tiers) · with limits | $2,000 · $2000/mo · with limits |
Modal: Modal bills by the second for the higher of the CPU and memory you request or what you use, and an idle sandbox pays until it is terminated. Starter is free with $30 of monthly credit; Team is $250 a month with $100 of credit.
Claude Managed Agents: Managed Agents bills model tokens at API rates plus a flat session runtime fee, measured only while a session is running, including time spent waiting on the model. The table shows runtime only; tokens come on top and usually cost more.
Claude Managed Agents: bochka charges 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.
Limits in those scenarios
On Modal, a sandbox lives at most 24 hours and keeps only files in a Volume, and the 50-agent fleet needs Docker, which the default sandbox lacks. Managed Agents never counts as a clean fit here: its machine size is not published, Docker is not confirmed, and it publishes no limit for 300 or 1,000 sandboxes at once. On bochka, the limit that bites is start speed: 1,000 jobs at once queue above 90 starts a minute and pass the 2,400 starts a day allowed.
| Scenario | Modal | Claude Managed Agents | 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 |
| None that bite |
| 1,000 short jobs at once |
|
|
|
Which one should you use?
Use Modal when
you write your own agent or job code and need GPUs, regions outside Europe, or huge bursts of short sandboxes.
- GPUs next to your sandboxes. Useful if your agent trains or runs models: Modal rents GPUs from T4 to B300 on the same platform.
- Huge bursts of short jobs. Useful for RL rollouts and code runs: Modal runs up to 5,000 containers on Team and starts them fast.
- Any agent, any image, many regions. Modal runs whatever code and image you bring, in the US, EU or Asia-Pacific, not one vendor's agent.
Use Claude Managed Agents when
you want Claude itself doing long text and code tasks with no harness to build, and idle time that costs nothing.
- No agent loop to build. Teams that want Claude doing long tasks get the harness, caching, compaction, memory and webhooks ready to use.
- Idle sessions sleep for free. Agents that wait a long time between messages pay runtime only while working, and wake on the next message.
- Your own workers if you need them. Teams with strict rules can run every tool call on their own infrastructure while Anthropic keeps the orchestration.
Where bochka fits
If what you are running is coding agents that work for hours or days, look at bochka. Modal is a sandbox you build an agent around, and Managed Agents is an agent in a small box; bochka gives each agent a whole VM that keeps its disk, with Claude Code, Codex and others ready to drive from outside.
A full machine with Docker and /dev/kvm
Modal's default sandbox has no Docker, so you switch to its VM runtime, and nested virtualization is on request only. Managed Agents lists Docker as limited availability and caps memory at 8 GB. bochka has Docker, systemd and /dev/kvm in every VM.
A disk that outlives the session
On Modal the root disk is gone within 24 hours, so you write code to save work to a Volume. Managed Agents drops sandbox state 30 days after creation. bochka saves the whole disk every minute, and stopping is free.
Open what the agent built
Managed Agents has no inbound ports, SSH or desktop, and Modal leaves VNC and the agent harness for you to set up. bochka gives HTTPS URLs on 50 ports, raw TCP, SSH and a 60fps desktop with computer use.
Use bochka when your agents need a real machine for hours or days: Docker, emulators, a desktop, ports you can open, a disk that lasts, and your choice of Claude Code, Codex or other agents. Compare it one to one: bochka vs Modal and bochka vs Claude Managed Agents.
Questions people ask
Is Modal cheaper than Claude Managed Agents?
For sandbox runtime alone, Managed Agents costs less in every scenario on this page, for example $53 against $178 a month for one agent that never stops. But Managed Agents also bills model tokens on top, which usually cost more than the runtime, and Modal's price includes no model at all.
Which is faster, Modal or Claude Managed Agents?
Only Modal was measured: its default sandbox did 12.79 runs per second on a 4 vCPU / 8 GB build-and-test loop, against 26.69 for bochka. Anthropic does not publish the vCPU count of a Managed Agents sandbox, and much of a session's time is spent waiting on the model.
Can Modal or Claude Managed Agents run Docker?
Modal runs Docker only with its VM runtime, chosen with runtime="vm". Managed Agents lists Docker as limited availability. Every bochka sandbox runs Docker with no extra setting.
Can I run Claude Code on Modal or Claude Managed Agents?
Managed Agents runs Anthropic's own harness, not Claude Code. On Modal you can install any agent yourself, inside a sandbox that ends within 24 hours. bochka comes with Claude Code, Codex and five other agents preinstalled.
How long do the sandboxes keep their files?
A Modal sandbox lasts at most 24 hours and keeps only files saved in a Volume. A Managed Agents sandbox is checkpointed when idle but kept only 30 days after it is created. bochka keeps the whole disk until you delete the sandbox.
Do Modal or Claude Managed Agents have GPUs?
Modal rents GPUs from T4 to B300, on its gVisor runtime. Claude Managed Agents has none, and neither does bochka.
Try bochka
Install the CLI, then run bochka new.
Product preview