# 5. What you pay for

Source: https://archil.com/guides/storage-for-agents/what-you-pay-for · Part of The buyer’s guide to storage for AI agents · Facts checked 2026-11-04

**The short answer:** Storage bills for one of three things: capacity you reserve, the machine the files live on, or what you use. An agent’s workspace waits far more than it works, so which of those you pay for matters more than any rate. Billing by use needs storage that stands apart from both a reserved size and the machine.

Take one agent workspace that holds 5 GiB, whose agent works about 2 hours a day in one session and touches half its data. The following table prices a month of it three ways:

| What the bill counts          | Example                                             | Per month   |
| ----------------------------- | --------------------------------------------------- | ----------- |
| Capacity you reserve          | A 20 GiB EBS gp3 volume                             | $1.60       |
| The machine the files live on | An E2B sandbox with 2 vCPUs and 4 GiB, kept running | about $121  |
| What you use                  | An Archil-managed disk                              | about $0.20 |

The rates don’t explain the spread. Per GiB, our active rate is higher than gp3’s. What differs is what each meter counts during the 22 hours a day the agent isn’t working. Those hours are most of an agent’s life, as [our measurement of 384 agent loops](https://archil.com/guides/storage-for-agents/the-work-outlives-the-machine#where-an-agents-hours-go) showed.

This chapter traces each meter back to the design that produces it, shows where the cheapest-looking option stops being cheapest, and prices a fleet. For how metering works in general, including GB-months, pooling, and storage classes, see [How storage is metered](https://archil.com/guides/how-file-systems-work/how-storage-is-metered). (Every price here is a list price in us-east-1 (N. Virginia), before discounts, free tiers, taxes, and plan minimums. Our Developer plan bills at least $10 a month, and usage counts toward that minimum. AWS bills a GB as 2³⁰ bytes, the same as a GiB, so this chapter applies AWS’s per-GB rates per GiB.)

## The meter follows the architecture

Each design bills for the thing it has to keep for you while you’re away.

A provisioned volume is a block device of a size you choose. The provider promises you that space and its performance, so it bills them as promised. EBS gp3 costs $0.08 per GB-month, charged, in AWS’s words, “by the amount of GB you provision”. The volume couldn’t bill you for less if it tried. A block device stores blocks, and it doesn’t know which of them hold files.

A sandbox’s own disk is part of the machine. The files exist for as long as the machine runs, or for as long as the vendor keeps a stopped copy of it. The price of keeping the files is the price of keeping the machine, which bills CPU and memory by the second.

To bill by use, the storage has to stand apart from both. It can’t be a size that someone reserved, and it can’t live on the machine that runs the agent. A service that pools many customers’ data, the way S3 and EFS do, can bill the bytes you store. The provider carries the empty space across all its customers, whose peaks rarely line up. A service that also tracks which data is in use can bill hot data differently from cold.

That separation is the design [the chapter on where the truth lives](https://archil.com/guides/storage-for-agents/where-the-truth-lives) reached for other reasons. The authoritative copy lives off the machine, and the machine borrows the right to answer through a checkout. The same split is what lets a meter count use.

**Where the meter sits**

Three designs hold the same 5 GiB workspace, drawn as 1 GiB cells. The agent writes its files and then waits. A provisioned volume reserved 20 GiB and holds 5 GiB of data, and its meter bills all 20 GiB, full or empty, every hour: the provider set the space aside, and the volume can’t tell which blocks hold files. A sandbox with 2 vCPUs and 4 GiB keeps the files on its own disk, and its meter bills the whole machine for every hour it stays up, so keeping the files means keeping it running. With decoupled storage, the machine stops once the agent is done. The meter bills the 2 GiB the agent touched in the last hour at the active rate, and the whole disk at a low rate. The quantities are an example.

## Reserved capacity

A volume bills from the moment you create it “until you release the storage”, attached to a machine or not, full or empty. For agents, that has two consequences.

First, you size each volume for the largest workspace you expect, not the typical one. EBS can grow a volume but can’t shrink it. Suppose most workspaces hold 5 GiB and a few reach 20 GiB. The fleet either provisions 20 GiB everywhere or runs its own machinery to grow volumes as they fill. (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.”)

Second, the empty part of a volume costs as much as the full part. Divide the bill by the data stored, and a volume that’s a quarter full costs four times its list rate per stored GiB. That’s more than EFS Standard charges. A fork made by copying is another volume, billed at its full size. [The chapter on copies and references](https://archil.com/guides/storage-for-agents/copies-and-references) covers what a copy costs in time.

**What a stored gigabyte costs on a rented volume**

A 100 GiB gp3 volume costs $8.00 a month however full it is. Divide that by the GiB actually stored to get the price per stored GiB: at 100% full it is the list price, $0.08; at 25% full it is $0.32; at 10% full it is $0.80. EFS Standard costs $0.30 per stored GiB and S3 Standard $0.023, at any fill. The volume costs more per stored GiB than EFS Standard below about 27% full, and never gets as low as S3 Standard.

## The machine

E2B bills $0.000014 per vCPU-second and $0.0000045 per GiB-second for as long as a sandbox runs, used or not. A 2 vCPU, 4 GiB sandbox kept up for a 730-hour month gives the table’s second row. Almost none of that pays for the files. Priced in storage, an idle machine hour is expensive. (From [E2B pricing](https://e2b.dev/pricing). Other providers’ idle hours, with links to each price list, are in [What does an idle agent sandbox cost per hour?](https://archil.com/article/what-does-an-idle-agent-sandbox-cost-per-hour))

**One idle hour, priced in storage**

One idle hour of a 2 vCPU, 4 GiB sandbox at E2B’s list price, about $0.17, buys 7.2 GiB-months of S3 Standard at $0.023 each, or 2.1 GiB-months of EBS gp3. A 5 GiB workspace kept in S3 Standard for a month costs $0.115, less than that one hour.

Sandbox vendors have started to bill the machine closer to use, and they deserve credit for it. Vercel Sandbox bills memory for as long as a sandbox is provisioned, but CPU only while it’s actively used. Fly.io Sprites bill the CPU and memory actually used, and an idle Sprite moves to a non-billed state within seconds. Daytona bills a stopped sandbox for its disk only. (From [What does an idle agent sandbox cost per hour?](https://archil.com/article/what-does-an-idle-agent-sandbox-cost-per-hour), which links each provider’s pricing page.)

Each of these shrinks the machine’s share of the idle bill. The files still belong to the sandbox, though, kept in that vendor’s storage and reached through it. Whether they survive losing the machine is the question [the chapter on the obvious designs](https://archil.com/guides/storage-for-agents/the-obvious-ways-to-build-it) asked of each one.

## Use

Storage billed by use comes in two grades.

The first grade bills the bytes you store. EFS Standard costs $0.30 per GB-month and S3 Standard $0.023, so an empty workspace costs nothing. A full one bills every hour, though, used or not. EFS moves files to cheaper classes after 30 days without access, but a workspace the agent opens every day keeps restarting 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/).)

The second grade bills the data in use. Archil charges $0.20 per GiB-month of active data. Data is active if it was read in about the last hour, or written and flushed to the disk’s data source in about the last hour. Active data is the data in our high-speed layer, in front of the object storage that holds the rest. The meter counts nothing else. We measure it every minute and bill the time-weighted average. Reading metadata with `ls`, `stat`, or `find` doesn’t make file data active.

Under the active meter, the whole disk bills at $0.025 per GB-month on an Archil-managed disk. On a disk synced to your own bucket, there’s no archive charge, and your cloud provider bills the bucket at its own rate. (From [Metering](https://docs.archil.com/concepts/metering) and [Pricing & Billing](https://docs.archil.com/administration/billing) in our docs. 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.

For the example workspace, the active meter runs about 3 hours a day: the 2-hour session, plus the hour after it. Half of 5 GiB, active for 3 hours in 24 at the active rate, comes to about $0.06 a month. Archive on the whole disk, 5 GiB or about 5.37 GB at the archive rate, adds about $0.13. Together they make the table’s third row.

Our price list doesn’t say whether archive also bills data that’s active. This chapter takes the reading that costs the most: archive on every byte, all month, on top of the active rate. Every number and figure in this chapter uses that assumption, including both calculators. If archive applies only to inactive data, a managed disk costs slightly less than shown.

## Where a volume costs less

Billing by use wins when the agent waits. When it doesn’t wait, the higher rate shows. 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.

Suppose the agent touches all 5 GiB of its workspace around the clock. That meters $1.00 a month active, plus archive, against $0.40 for a 5 GiB gp3 volume. With one session a day, a tightly sized volume costs less once the agent touches all its data for more than about 5 hours. If your agents work most of the day on data that fits a size you know in advance, price a volume first.

Data that nobody touches costs less still in plain object storage. For that reason, a disk synced to your own bucket leaves cold data at your bucket’s rate instead of ours.

**One workspace, two meters**

The figure prices one 5 GiB workspace with one working session a day, by the hours the agent works. A gp3 volume costs the same at any hour: $0.40 a month at 5 GiB, $0.80 at 10 GiB, and $1.60 at 20 GiB. Archil’s cost rises with the hours its active meter runs, the session plus an hour, on the share of data touched, and archive adds about $0.13 on every byte all month. When the agent touches all its data, a 5 GiB volume costs less above about 5.4 hours of work a day, a 10 GiB volume above about 15 hours, and a 20 GiB volume never. When it touches half its data, a 5 GiB volume costs less above about 11.8 hours a day.

## Compute billed by use

The machine can follow the storage. Once the files live apart from the sandbox, nothing has to stay up between tool calls. A serverless tool call runs one command in a short-lived microVM with the disk mounted, returns the output, and shuts down.

**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 own 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. A dev server or a Python kernel has to stay up between calls, so for those, use a persistent sandbox with the same disk mounted. (From [Serverless execution](https://docs.archil.com/compute/serverless-execution), [Limits](https://docs.archil.com/reference/limits), and [Pricing & Billing](https://docs.archil.com/administration/billing). Each call gets 2 vCPUs and 4 GiB. Serverless tool calls and sandboxes run in AWS regions only.)

## Pricing your own fleet

The calculator does the same arithmetic for a fleet and splits each bill into the hours the agent works and the hours it waits. Start from your own agents’ idle share. [What does it cost when nothing is running?](https://archil.com/guides/evaluating-storage/what-does-it-cost-when-nothing-is-running) has a short script that replays your tool-call timestamps against an auto-stop and prints it.

**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.

Then check a real bill. Create one workspace with each vendor you’re considering, us included, leave it untouched for 48 hours, and read every line item that kept accruing.