DEV Community

Ishank Choudhary
Ishank Choudhary

Posted on Originally published at Medium

Agent37 Hands-On: Coding Agent Sandboxes Priced Against Vercel Sandbox and E2B

On 3 November someone posted a price list for one always-on agent sandbox with 2 vCPUs and 4 GB of RAM: Vercel $249 a month, Agent37 $4.76. Guillermo Rauch, Vercel's CEO, replied that it was "a total miscalculation of active cpu time" behind "fake cost comparisons". Vercel Sandbox bills CPU only while your code is actually using it, so a sandbox that sits idle doesn't cost $249.

Fair point. On 16 November Agent37 answered with new math: 100 coding agents for an hour at "just 5% active CPU". The video in the post puts that at $0.68 on Agent37 against $9.75 on Vercel. That post had 1,669 likes when I checked.

Both sides lean on one number that nobody measured in public: how much CPU does a coding agent actually burn inside its sandbox? Every price in that thread depends on it. So I measured it.

What Agent37 is

Agent37 sells persistent cloud computers for agents. You call POST /v1/instances with a template such as agent37-claude-code, agent37-codex or agent37-opencode, and you get an always-on Linux box with a chat gateway on port 3737, a browser terminal and a file browser. It's priced like a small VPS, not like a function: $0.80 per vCPU per month, $0.70 per GB of RAM per month and $0.09 per GB of disk per month, metered by the minute. The default 2 vCPU / 4 GB / 4 GB disk shape is $4.76 a month, which comes to $0.0065 an hour.

There's one detail on their billing page that matters a lot here. Default instances "share hardware, so sustained heavy CPU use may be limited when the hardware is busy." If you need guaranteed cores, a vm instance costs 2.5 times the default rate and a performance instance 4 times.

Why I didn't use their cloud, and what I ran instead

Agent37's API needs an account, an API key and a funded wallet. The $5 starter credit needs a card on file, and a free workspace can run only 32 GB of memory at once, which is eight of the small instances. For this piece I stayed off their cloud, so this isn't a test of Agent37's platform. I haven't measured their create times, their wake-from-sleep, or how their shared hosts behave under load.

What I could test is the part both sides argue about: the workload. Agent37 publishes the images behind its templates. The opencode-base image is the OpenCode agent plus Agent37's open-source gateway, built from a public Dockerfile in agent37-platform/templates. It's the same image their custom OpenCode templates build on. I pulled it, ran it under Docker with the same 2 vCPU / 4 GB limits as their default shape, and read CPU and memory straight from each container's cgroup.

Here's the lab: a Debian 13 box with 8 vCPUs, 15 GiB of RAM and Docker 27.3.1. The agent ran on OpenCode Zen's free deepseek-v4.1-flash-free model, so I didn't use a paid key anywhere.

docker pull ghcr.io/agent37-platform/opencode-base:2026.11.11a   # 2.29 GB, 24.6 s

docker run -d --name a37-1 --network host --cpus 2 --memory 4g \
  -e AGENT37_GATEWAY_PORT=24000 \
  -e AGENT37_TERMINAL_PORT=25000 -e AGENT37_FILEBROWSER_PORT=26000 \
  ghcr.io/agent37-platform/opencode-base:2026.11.11a

curl -s localhost:24000/v1/health?agent=opencode
# {"ok":true,"agent":"opencode","healthy":true}
Enter fullscreen mode Exit fullscreen mode

From docker run to a healthy gateway took 2.55 to 2.91 seconds for a single container. When I started ten at once, all ten were healthy in 5.28 seconds. That's local Docker with the image already pulled, so don't read it as Agent37's create time.

The gateway API is pleasantly boring. A turn is one POST, and the response includes usage and a cost field (zero on a free model):

curl -s localhost:24000/v1/responses -H 'content-type: application/json' \
  -d '{"input":"Reply with the single word pong.","model":"opencode/deepseek-v4.1-flash-free"}'
# "status": "completed", "output_text": "pong",
# "usage": {..., "cost_usd": 0}
Enter fullscreen mode Exit fullscreen mode

The gateway has no auth of its own. Its README says it's "a localhost service behind the host", and on Agent37 the edge checks your key. If you run the image yourself, don't publish port 3737 to the internet.

The workload: a real coding task, not a sleep loop

I wanted something close to the "vibe code an app" demo, but checkable. Every turn got this prompt:

Create a small Node.js project in /home/node/app: an Express todo API with an
in-memory store (GET /todos, POST /todos with a JSON {title}, DELETE /todos/:id,
400 on a missing title) exported from app.js, a server.js that listens on PORT,
and tests in test/todos.test.js using node:test and supertest that cover all four
behaviours. Install the dependencies with npm, set "test" in package.json to
"node --test", and run npm test until it passes. Reply with DONE and the test
summary line.
Enter fullscreen mode Exit fullscreen mode

That's a typical agent turn. The agent writes files, runs npm install (real network and disk I/O), runs the tests and fixes things until they pass. After each turn, my harness ran npm test again inside the container itself. I didn't trust the agent's "DONE".

While the turn ran, a sampler read the container's cgroup once a second. usage_usec is total CPU time used across all cores, which is the same thing Vercel calls Active CPU. anon is real process memory, without page cache:

def read_cg(cid):
    p = f"/sys/fs/cgroup/docker/{cid}"
    st = dict(l.split() for l in open(p + "/cpu.stat"))
    ms = dict(l.split() for l in open(p + "/memory.stat"))
    return dict(usage_usec=int(st["usage_usec"]),
                throttled_usec=int(st["throttled_usec"]),
                anon=int(ms["anon"]))

# active CPU % of the 2-vCPU shape over one turn
cpu_s = (after["usage_usec"] - before["usage_usec"]) / 1e6
pct = 100 * cpu_s / (2 * wall_s)
Enter fullscreen mode Exit fullscreen mode

I ran three single turns one after another, then ten containers with ten turns at the same time. That's 13 turns in all.

Results: 13 for 13, and nowhere near 5%

Every turn finished, and my own npm test re-run passed in all 13 containers, with 4 tests and 0 failures each time. The agent did the job.

Here's what the sandbox used to do it:

  • Turn time: median 31.0 s, from 19.6 s to 45.8 s. All ten parallel turns finished within 45.8 s.
  • CPU time: median 15.2 CPU-seconds per turn, from 11.4 to 18.2.
  • Active CPU: a median of 24.6% of the 2-vCPU shape, from 19.2% to 29.6%.
  • Peak in one second: up to 1.59 vCPU, during npm install and the test runs.
  • Memory: peak process memory from 755 to 873 MB (median 821 MB), well inside 4 GB.
  • Throttling: at most 0.29 s per turn against the 2-vCPU cap.

The part that surprised me most: the container was rarely idle even while it was waiting on the model. Only 37 of the 384 one-second samples taken during turns were under 0.05 vCPU. The agent process streams the model's output, parses tool calls and writes files the whole time. When people say "it's mostly waiting on the LLM," they're right about the wall clock, but not about the CPU.

Between turns, the picture flips. I left all ten containers idle for 13 minutes after the run. Each one used about 2.8 CPU-seconds in that window, which is 0.18% of 2 vCPUs. Memory sat at around 490 MB until roughly ten minutes after the last turn. Then the gateway shut down the idle OpenCode server and each container dropped to about 70 MB. That matches the gateway's documented OPENCODE_IDLE_MS default of 10 minutes.

So a coding agent has two very different states: about 25% while it's working, and under 0.2% while it waits for you. The real question for pricing is what share of the hour your agent spends working.

What "5% active CPU" actually means

At 5% of 2 vCPUs for an hour, a sandbox uses 360 CPU-seconds. At my median of 15.2 CPU-seconds per turn, that's about 24 turns an hour, or one every 2.5 minutes. That's a fair description of an agent pairing with a person who reads each answer before replying.

It's not a fair description of "100 coding agents vibe code an app." Agents running on their own, back to back, sit near the 24.6% I measured. Agent37's own 5% figure is generous to Vercel, not to Agent37.

The pricing, with my numbers plugged in

I priced one 2 vCPU / 4 GB sandbox per hour from the public rate cards on 17 November: Agent37's billing docs, Vercel Sandbox Pro in iad1 ($0.128 per active vCPU-hour plus $0.0212 per GB-hour of provisioned memory), and E2B ($0.000014 per vCPU-second plus $0.0000045 per GiB-second, billed on provisioned size):

def agent37(util, mult=1.0):          # flat; util doesn't matter
    return ((2 * 0.80 + 4 * 0.70) * mult + 4 * 0.09) / 730

def vercel(util):                     # active CPU + provisioned memory
    return 2 * util * 0.128 + 4 * 0.0212

def e2b(util):                        # provisioned, per second
    return (2 * 0.000014 + 4 * 0.0000045) * 3600
Enter fullscreen mode Exit fullscreen mode

Here's what that gives for 100 sandboxes for one hour:

  • Idle (0.18%, measured): Agent37 $0.65, Vercel $8.53, E2B $16.56
  • 5% (the number in the X thread): Agent37 $0.65, Vercel $9.76, E2B $16.56
  • Busy (24.6%, measured): Agent37 $0.65, Vercel $14.77, E2B $16.56

Agent37's vm and performance types would cost $1.56 and $2.46 for the same 100 sandbox-hours.

The 5% row reproduces the math in their video: $9.76 against their $9.75 for Vercel, and E2B matches their $16.56 to the cent. My Agent37 figure, from their published rates, is $0.65 rather than the $0.68 in the video.

Three things stood out once the numbers were in front of me.

Memory, not CPU, is most of Vercel's bill. At 5% active CPU, 87% of the Vercel price is the 4 GB of provisioned memory. Even a fully idle Vercel sandbox costs $0.085 an hour, which is 13 times Agent37's flat rate. The active-CPU argument is real, but it can't close a gap that's mostly RAM.

A busier agent makes Vercel more expensive, not cheaper. At my measured 24.6%, Vercel's price goes up about 51% compared with the 5% case. E2B doesn't care how busy you are, because it bills the provisioned size.

Right-sizing helps everyone except the flat plan. My agents peaked under 900 MB, so a 1 vCPU / 2 GB sandbox would fit the work. On Vercel that's about $0.105 an hour at the same CPU-seconds, and on E2B $0.083 (custom sizes are a Pro-plan feature there). Agent37's smallest shape is 2 vCPU / 4 GB, so it can't get any cheaper. It's already the cheapest of the three.

What the price doesn't tell you

Before I'd move a production agent fleet over, this is what I'd check:

Shared hardware. Agent37's $4.76 is for a default instance on shared hosts, and the docs say sustained heavy CPU "may be limited when the hardware is busy." My agents averaged a quarter of a core but peaked at 1.6 vCPU during installs. Whether those bursts get throttled on a busy host is the one thing a local test can't tell you. If they do, vm at 2.5 times the price is still $1.56 for 100 agent-hours.

Concurrency is gated by spend. Running 100 agents at 4 GB each means 400 GB awake at once. Agent37 allows 32 GB before your first top-up, 200 GB once your top-ups total $50, and 800 GB at $250. Vercel Pro allows 10,000 concurrent sandboxes. E2B Hobby allows 10 and Pro allows 100, for $150 a month. The hourly price is only half the bill.

Persistent vs ephemeral. Agent37 instances live until you delete them, and they bill disk alone while asleep. Vercel and E2B cap a single session (24 hours on Vercel Pro, 1 hour on E2B Hobby, 24 hours on E2B Pro). Vercel's persistent sandboxes can stop and resume, but the model is still sessions you start and stop. Which model is "cheaper" depends on whether your agent is a long-lived per-user computer or a throwaway job.

Image hygiene. The image's boot log prints a notice that the bundled File Browser "is being wound down" and that the project was archived on 1 September with "no further releases and no security fixes." On Agent37 it sits behind the authenticated edge, but I'd still want it out of my own template.

What I'd tell my team

For agents that run around the clock or sit idle a lot, Agent37's flat per-month pricing is very hard to beat, and the active-CPU argument doesn't change that. If anything, it works in Agent37's favour, because coding agents use more CPU while they work than the 5% in the thread. The pricing question is settled for me. What's still open is the operational one: how shared hosts handle bursts, and how quickly you can unlock enough concurrency.

What I couldn't test: Agent37's cloud itself (create latency, sleep and wake, persistence across restarts, host contention), the Claude Code and Codex templates (no accounts on this box), any paid model, and Vercel and E2B sandboxes themselves. Their numbers here come from their rate cards, not from my runs.

If you want to reproduce the workload numbers, here's the minimal version. My box has no Docker bridge, so I ran with --network host and the port variables shown earlier. The -p form below is the standard equivalent, which I didn't run myself. The sampler is just the read_cg function above in a loop:

docker pull ghcr.io/agent37-platform/opencode-base:2026.11.11a
docker run -d --name a37 --cpus 2 --memory 4g -p 127.0.0.1:3737:3737 \
  ghcr.io/agent37-platform/opencode-base:2026.11.11a
curl -s localhost:3737/v1/responses -H 'content-type: application/json' \
  -d '{"input":"<your coding task>","model":"opencode/deepseek-v4.1-flash-free"}'
# cgroupfs driver path; with the systemd driver it's system.slice/docker-<id>.scope
cat /sys/fs/cgroup/docker/$(docker inspect -f '{{.Id}}' a37)/cpu.stat
Enter fullscreen mode Exit fullscreen mode

All numbers come from my own runs on 17 November 2026 (IST), with opencode-base 2026.11.11a (OpenCode 1.19.5, gateway v0.18.1) and prices read the same day. Your model's speed changes the percentages: a faster model packs the same CPU work into less time, so it pushes active CPU up.

Originally published on Medium.

Top comments (0)