# 6. What does it cost when nothing is running?

Source: https://archil.com/guides/evaluating-storage/what-does-it-cost-when-nothing-is-running · Part of Evaluating storage for agents · Facts checked 2026-11-04

**The short answer:** An agent’s workspace sits idle most of the time it exists, so the bill depends on what storage charges for while nothing runs. A provisioned volume bills its full size every hour, and a sandbox’s own disk costs whatever the machine costs to keep up. Archil bills its active rate only for data used in about the last hour, plus a low rate on the whole disk.

Give each of 1,000 agents a 100 GiB EBS gp3 volume, and you pay $8,000 a month before any agent runs a command. Keep a sandbox up for each one so its local disk survives, and the compute adds about $121,000 a month. Most of those hours, the agents are waiting.

This chapter measures how much of an agent’s life is waiting, using our own team’s agents, and then prices what each kind of storage charges for it. (Every price here is a list price in us-east-1 (N. Virginia), before discounts, free tiers, and taxes. AWS bills a GB as 2³⁰ bytes, the same as a GiB, so this chapter applies AWS’s per-GB rates per GiB. For how providers meter storage and why their prices take the shape they do, see [How storage is metered](https://archil.com/guides/how-file-systems-work/how-storage-is-metered).)

## Where an agent’s time goes

We read the timestamps on 30 days of our engineering team’s coding-agent sessions: 384 agent loops and about 37,000 tool calls. We read only when each model turn and tool call started and ended, not what they contained.

The median tool call finished in 0.5 s, and 89% finished in under 10 s. About 1% ran longer than 5 minutes, such as builds and test suites, and that 1% accounted for about half of all tool time. Between calls, the agent waits for the model to write its next step, and often for a person to read the result.

Suppose each loop had started a sandbox at its first tool call and stopped it after 15 minutes without one. That sandbox would have been idle for 65% of the time it ran, and for 88% in the median loop. A 5-minute auto-stop still leaves it idle 48% of the time, and it starts more often. (The method and results are in [Do AI agents need a sandbox running for the whole session?](https://archil.com/article/do-ai-agents-need-a-sandbox-running-for-the-whole-session))

**One agent loop and its sandbox**

An example agent loop over two hours: three bursts of short tool calls and one 6-minute build, about 7 minutes of tool work in all, separated by waits on the model and a 45-minute wait on a person. A sandbox that stops after 15 minutes without a tool call is up for 73 minutes, almost all of it idle. One that stops after 5 minutes is up for 51 minutes but starts three times. These numbers belong to the example. The measured idle shares are in the text.

## What each kind of storage bills for the waiting

A workspace has to outlive every tool call and usually every session, so its storage bills through all of that waiting. What it bills for depends on the model:

- **A provisioned volume** bills its size. EBS gp3 costs $0.08 per GB-month, charged, in AWS’s words, “by the amount of GB you provision”. A full volume and an empty one cost the same, and EBS can grow a volume but can’t shrink it, so each volume carries headroom for the largest workspace you expect. (From [Amazon EBS pricing](https://aws.amazon.com/ebs/pricing/) and [Modify an Amazon EBS volume](https://docs.aws.amazon.com/ebs/latest/userguide/ebs-modify-volume.html): “You can’t decrease the volume size.”)
- **A sandbox’s own disk** bills as the machine. To keep the files, you keep the sandbox running, or pay the vendor to keep a stopped copy. An idle sandbox with 2 vCPUs and 4 GiB costs about $0.17 an hour at E2B’s list price, $121 over a 730-hour month. (E2B bills $0.000014 per vCPU-second and $0.0000045 per GiB-second ([E2B pricing](https://e2b.dev/pricing)). Other providers’ idle hours are in [What does an idle agent sandbox cost per hour?](https://archil.com/article/what-does-an-idle-agent-sandbox-cost-per-hour))
- **Storage billed by what it holds** charges for bytes stored, so an empty workspace costs nothing. EFS Standard costs $0.30 per GB-month and S3 Standard $0.023. EFS moves files to cheaper classes after 30 days without access, but a workspace the agent opens every day restarts that clock. (From [Amazon EFS pricing](https://aws.amazon.com/efs/pricing/), [EFS lifecycle management](https://docs.aws.amazon.com/efs/latest/ug/lifecycle-management-efs.html), and [Amazon S3 pricing](https://aws.amazon.com/s3/pricing/).)
- **Archil** bills $0.20 per GiB-month of active data: data read in about the last hour, or written and flushed in about the last hour. We measure it every minute and bill the time-weighted average. Reading metadata with `ls`, `stat`, or `find` doesn’t make file data active. The whole disk also bills at $0.025 per GB-month on a disk we manage, or at your bucket’s own rate on a disk synced to your bucket. (From [Metering](https://docs.archil.com/concepts/metering) and [Pricing & Billing](https://docs.archil.com/administration/billing). Branches and checkpoints are copy-on-write, so data they share bills once.)

**Four meters, one day**

The figure follows one agent workspace through a day with three working sessions, about 4 hours of tool calls in all. A sandbox kept running bills all 24 hours, and a provisioned volume bills its full size for all 24. Archil’s active meter counts the data the agent touched, during each session and for up to an hour after, about 7 hours in all. All day, the whole disk also bills at the archive rate, or at your bucket’s rate on a disk synced to your own bucket.

## Pricing a fleet

Here’s the arithmetic for one workspace that holds 5 GiB, whose agent works 2 hours a day in one session and touches half its data. The active meter runs about 3 hours a day: the session, plus the hour after it. That’s 5 GiB × 50% × 3/24 × $0.20, about $0.06 a month. The archive rate on the whole disk, about 5.37 GB × $0.025, adds $0.13. The workspace costs about $0.20 a month, against $1.60 for a 20 GiB gp3 volume or $1.50 on EFS Standard.

The calculator does the same arithmetic for a fleet and splits each bill into the hours the agent works and the hours it waits.

**Price a fleet of workspaces**

The calculator starts with 1,000 workspaces of 5 GiB each on 20 GiB volumes. Each agent works 2 hours a day in one session and touches half its data. At those settings, EBS gp3 costs $1,600 a month, EFS Standard $1,500, and S3 Standard alone $115, and about 92% of each falls in the hours the agent waits. Archil costs about $197 a month on managed disks and $178 synced to your own S3 bucket. A sandbox kept running for each workspace so its disk survives adds about $120,900 a month in compute. One that stops after 15 idle minutes adds about $11,300, before whatever the vendor charges to keep its stopped copy. It leaves EFS in Standard, before throughput charges.

The calculator makes one conservative assumption about Archil: it bills the archive rate on every byte, all month, on top of the active rate. That reading gives the highest bill. If archive applies only to inactive data, a managed disk costs slightly less than shown.

## Where a volume costs less

Our active rate is 2.5 times gp3’s, so a workspace that’s busy all day costs more on Archil than on a volume sized to fit it. If an agent touches all 5 GiB of its workspace around the clock, that’s $1.00 a month active plus $0.13 archive, against $0.40 for a 5 GiB gp3 volume. With one session a day, a tightly sized gp3 volume costs less once the agent touches all its data for more than about 5 hours a day. Data that nobody touches costs less still in plain object storage, which is why a disk synced to your bucket leaves cold data at your bucket’s rate.

## Compute that stops between calls

The same reasoning applies to the machine. A serverless tool call runs one command in a short-lived microVM with the disk mounted, returns the output, and shuts down. Between calls, nothing runs and no compute bills.

**A serverless tool call**

The agent’s harness sends `npm test` to the disk. A microVM starts with the disk mounted, runs the command, returns its output, and shuts down. The call bills $0.00005. Until the next call, nothing runs and no compute bills, and the files stay on the disk.

We charge $0.05 per 1,000 calls, with execution included. Our agents made about 160 tool calls per hour of activity, so 2 hours a day for a month is about 9,700 calls, or $0.49. Per-call pricing has limits. At about 3,300 calls an hour, close to one a second sustained, it costs the same as an idle E2B sandbox of the same size. Each call can run for up to 5 minutes, and a dev server or a Python kernel has to stay up between calls. For those, use a persistent sandbox with the same disk mounted. (From [Serverless execution](https://docs.archil.com/compute/serverless-execution), [Sandboxes](https://docs.archil.com/compute/sandboxes/introduction), and our [pricing page](https://archil.com/pricing). Each call gets 2 vCPUs and 4 GiB. Our persistent sandboxes bill $0.055 per vCPU-hour and $0.020 per GiB-hour while they run.)

## Measuring your own idle time

Before comparing prices, measure how much of your agent’s time is waiting. Log when each tool call starts and ends, as one JSON object per line, for one agent loop. The following script replays those calls against a sandbox that stops after 5 or 15 minutes without a call, and prints how much of its running time it would sit idle:

```python
# idle_share.py < calls.jsonl, one {"start": ..., "end": ...} per line, in Unix seconds
import json, sys

calls = sorted((c["start"], c["end"]) for c in map(json.loads, sys.stdin))

def idle_share(stop_after):
    running = busy = 0.0
    up = done = calls[0][0]            # the sandbox starts with the first call
    for start, end in calls:
        if start > done + stop_after:  # idle too long: it stopped, and starts again
            running += done + stop_after - up
            up = start
        busy += max(0.0, end - max(start, done))
        done = max(done, end)
    running += done + stop_after - up
    return 1 - busy / running

for minutes in (5, 15):
    print(f"{minutes}-minute auto-stop: idle {idle_share(minutes * 60):.0%} of running time")
```

Then put your own numbers in the calculator. To check a vendor’s bill, create one workspace, leave it untouched for 48 hours, and read every line item that kept accruing.