Your agent's hard drive: projecting a year of AI video on the Workspace

An autonomous agent that ships video every day has a problem no inference bill prepares you for: the files. Masters, dubbed audio tracks, localized shorts, thumbnails — they accumulate whether or not anyone is watching. We ran the projection for a full year of our own video factory on the Agent Workspace, at the published rates, and the number at the bottom of the spreadsheet is smaller than most people's coffee budget.

This post does three things. It explains why long-lived agents need a disk of their own and why the usual workaround is an anti-pattern. It opens up how the Workspace actually works — presigned uploads, proxied downloads, retention with automatic expiry. And it runs the numbers on a real, growing production workload: the autonomous documentary agent we described last week, projected forward twelve months. The projections are marked as projections. The rates are not — they are the published tariff.

Agents produce artifacts. Where do they go?

The agentic stack has spent two years solving inference, tools, payments, and memory. It has mostly ignored a duller question: where does an agent put a 95 MB file?

Short-lived agents never hit this. A research agent emits a report measured in kilobytes; it travels inside the response. But the moment an agent's output is media, models, or datasets, the payload stops fitting in a message. A video pipeline produces masters. A fine-tuning loop produces checkpoints. A scraping agent produces corpora. These artifacts have a lifecycle of months, not turns — the dubbed audio from March is exactly what you need when the localization strategy changes in August.

The default answer today is to hand the agent somebody's cloud account: an AWS key pair in an environment variable, or worse, in the prompt. That is an anti-pattern with a blast radius. A leaked inference key burns a balance with a hard ceiling; a leaked AWS_SECRET_ACCESS_KEY exposes whatever IAM sloppiness surrounds it — other buckets, other services, a bill with no ceiling at all. It also splits the agent's economics in two: tokens metered on one meter, storage billed to a card in someone else's name, and no single answer to "what did producing this video cost, all-in."

The Workspace's premise is that an agent's disk should live behind the same identity and the same balance as its inference. One credential, one meter, no cloud console. The agent uploads and downloads its own files through MCP tools, and every byte is priced in the same sub-cent units as everything else it does.

Inside the Workspace: presigned in, proxied out

The Workspace is backed by Cloudflare R2, but the agent never touches R2 directly — and the two asymmetries in how bytes move are the design.

Uploads take two paths. Files up to 10 MB go inline: workspace_upload takes base64 content in the tool call itself, one round trip, done. That covers thumbnails, SRT files, scripts, JSON manifests — most of what an agent writes daily. Anything larger goes through workspace_upload_init, which returns a presigned R2 PUT URL: single-use, expiring, and bound to the declared content length, so the credential the agent holds is worth exactly one upload of exactly one size. R2's S3-compatible API supports presigned URLs with expiries from one second to seven days; the Workspace hands out the narrowest one that does the job. The agent PUTs the master directly to R2 at R2's ingest speed — the platform never proxies a 95 MB body it does not need to see.

Downloads never take the direct path. Every read is proxied through the worker with a single-use signed URL, and R2 is never exposed to the client. This is not caution for its own sake; it is what makes the billing model enforceable. Download pricing is per GB, and a per-GB price on a bucket the client can hit directly is a price on the honor system. Because the only road out runs through the worker, the meter sees every byte, and the x402 walk-up caller with no account can be charged for a download as reliably as a registered agent drawing down a balance.

Retention is explicit. Every file carries a days_to_store set at upload. An hourly cron expires what has lapsed; workspace_extend renews retention on what should live longer. There is no "we kept your data forever and here is the surprise line item" — storage you did not decide to keep is storage you stop paying for.

The published tariff, all of it:

upload      $0.10 / GB
storage     ~$0.03 / GB-month
download    $0.04 / GB
floor       1¢ minimum per operation
x402        walk-up callers pay ~10% less than balance rates

The 1¢ floor matters for small files: a 40 KB thumbnail costs a cent to upload, not a millionth of a dollar, because an operation has a real cost regardless of size. The x402 discount is the same pattern documented across the platform — walk-up payment settles immediately and skips the accounting overhead a balance carries.

What it looks like from the agent's side

The video factory's nightly archive step is three tool calls and one raw PUT. No SDK for a cloud provider, no bucket policy, no IAM role — the same MCP endpoint the agent already uses for everything else:

// after the render completes: init, then PUT straight to R2
const { upload_url } = await call('workspace_upload_init', {
  filename: 'ep-2026-07-26-master.mp4',
  content_length: master.byteLength,   // bound into the signature
  days_to_store: 365,
});
await fetch(upload_url, { method: 'PUT', body: master });

// small artifacts go inline
await call('workspace_upload', {
  filename: 'ep-2026-07-26-thumb-a.jpg',
  content_base64: thumbA,
  days_to_store: 90,
});

// August: the localization strategy changes, March's dub matters again
await call('workspace_extend', {
  filename: 'ep-2026-03-12-dub-fr.m4a',
  days_to_store: 365,
});

Notice that days_to_store is doing more than housekeeping. It is the cost policy, expressed per file. In the factory's plan, masters get 365 days because they are the asset; thumbnails and shorts get 90 because they are cheap to regenerate from the master; render intermediates get whatever the QA window is and then expire on their own. The storage bill is not something that happens to the agent — it is the sum of retention decisions the agent made, one file at a time, and workspace_extend is how a decision gets revised when the world changes.

The proxied download path has a second-order consequence worth naming. Because every read is metered and every reader can be charged — including an x402 walk-up caller with a wallet and no account — the archive is not just storage; it is a product surface. Another operator's agent can pay per download for a dataset, a dub track, or a b-roll library sitting in your Workspace, settled in stablecoins, with no distribution agreement and no shared cloud account. Nothing in this post's projection depends on that. But the rails permit it, and an archive that can invoice its own readers is a different asset class than a bucket.

The projection: a year of video in numbers

Now the workload. We are building — in production, and in an explicit growth phase — an autonomous documentary factory on top of the platform: a multi-model script council, expressive TTS narration, generated art and animation, French, German, and Spanish dubbing, and localized vertical shorts cut from each long-form video. The build log covers the pipeline and the Memory OS loop that makes it improve week over week. This is not a finished business being retold as a case study; it is a pipeline that is growing, and the honest way to write about its storage is to project it.

Each finished video leaves behind a set of masters worth archiving. Budgeted per video, with headroom for render intermediates worth keeping:

long-form master (~8 min)                  ~95 MB
dubbed audio tracks, FR/DE/ES              ~21 MB
localized shorts (up to 16, 4 languages)   ~90 MB
thumbnails + SRT caption files              ~6 MB
------------------------------------------------
per-video archive budget                  ~250 MB

At one video per day, doing the math, that is roughly 91 GB archived over a year. Applying the tariff, with storage accumulating linearly (the catalog averages about 46 GB on disk across year one):

upload       91 GB x $0.10                    $9.13
storage      ~46 GB avg x $0.03 x 12 months  $16.40
1¢ floors    thousands of small files         low single digits
--------------------------------------------------------
year one, all-in                             ~$25-29

Twenty-five to twenty-nine dollars to archive an entire year of daily video production. For scale: generating those 365 videos — script council tokens, TTS, image and animation generation, dubbing — projects to roughly $3,500 a year. The archive of everything the factory makes is about 0.8% of the budget for making it. Storage is not a cost center in this business; it is a rounding error that buys you the ability to re-cut, re-dub, and re-publish anything you have ever made.

Two more numbers complete the picture. Year two, in steady state — the catalog carrying the full back catalog plus new dailies, averaging around 180 GB on disk — projects to roughly $70 a year. And pulling the entire year-one catalog back out, all 91 GB, costs about $3.65 at the download rate. That last number is worth remembering for the next section, because it is where the comparison with the incumbents stops being subtle.

The egress trap: an honest comparison with S3

The honest comparison starts by conceding a point: raw S3 storage is cheaper per gigabyte than the Workspace. S3 Standard runs $0.023/GB-month in us-east-1 against the Workspace's ~$0.03. If storage-at-rest were the whole bill, S3 would win by about 25%.

Storage-at-rest is never the whole bill. S3 charges $0.09/GB for data transfer out to the internet — after an account-wide free allowance of 100 GB per month. A year-one catalog pull of 91 GB might squeeze under that allowance if the account does nothing else that month. By year two the catalog is past 180 GB, and a full pull costs real money every time: at $0.09/GB, each catalog-sized egress event runs about $8 — and it runs again the next time you do it. A localization pass that re-reads every master, a migration, a backup verification, an analytics job on another provider's compute: each one is an egress event. The Workspace's $0.04/GB download is not just cheaper per gigabyte; it is the same price every month, with no allowance to track and no tiering table to model. Pulling our whole first-year catalog costs $3.65, and we know that number before we do it.

Underneath, the asymmetry has a clean explanation: R2 charges zero egress fees — storage at $0.015/GB-month and free data transfer to the internet, by design. The Workspace's rates sit above R2's raw rates, and that spread is not hidden: it is the margin that pays for the proxied, metered download path, the presigned upload flow, retention enforcement, and the fact that the agent needs no cloud account at all. You are paying the platform to stand between your agent and the bucket. Given what a bucket credential in a prompt can cost, that is the cheapest line item in this post.

The deeper difference is not price but shape. S3's egress fee is a moat: data is cheap to bring in and expensive to take out, which is precisely the wrong gradient for an agent whose artifacts are meant to be re-read, re-cut, and re-served. An agent's archive is not cold storage; it is working memory at media scale. Pricing that punishes reads punishes exactly the behavior that makes a long-lived agent valuable.

What it means for LLM4Agents

The Workspace closes the last gap between "an agent that calls models" and "an agent that runs a business." The video factory's entire operational surface — inference, tool calls, payments, memory, and now the archive — sits behind one identity and one meter. When the operator asks what a video cost, the answer includes its storage, priced in the same cents as its tokens. No other line item on the stack requires a second vendor, a second credential, or a second invoice, and storage was the last one that did.

It also completes the platform's security story for artifacts. The RAG tutorial already showed the Workspace as an ingest buffer measured in megabytes; the video projection shows it holding the crown jewels of an agent business — a year of masters — without the agent ever holding a credential that outlives one upload. Single-use, size-bound presigned PUTs in; single-use signed URLs, proxied and metered, out. The blast radius of a compromised agent is one file, one direction, once.

And the economics compound with the memory thesis. We have argued since the memory architectures update that an agent's edge is what it accumulates. Memory OS accumulates rules and episodes; the Workspace accumulates the artifacts those episodes produced. At roughly $25-29 for year one, the factory never has a reason to delete anything — and an agent that keeps everything it has ever made, indexed and re-readable for cents, has a different ceiling than one that ships and forgets.

Staying on the frontier

What this projection exposes about where the Workspace should go next, in order:

1. Ship lifecycle tiering. R2 offers an Infrequent Access class at $0.01/GB-month underneath the standard $0.015. A workspace_archive flag — or automatic demotion of files unread for 90 days — would cut the steady-state storage line for exactly the catalog-shaped workloads this post describes, and the saving could be passed through the tariff.
2. Expose multipart for very large masters. The presigned single-PUT flow is clean up to a few gigabytes. Long-form 4K masters will pass that. Presigned multipart — same single-use, size-bound discipline per part — keeps the security model intact while removing the ceiling.
3. Add integrity receipts. Return a content hash on upload completion and verify it on download. An agent archiving a year of masters should be able to prove, for a cent, that what it stored is what it gets back — the same receipts-first discipline the payment rails already follow.
4. Publish a storage manifest tool. A workspace_list with sizes, retention deadlines, and projected month-end cost turns the spreadsheet in this post into a tool call. Agents that account for their own spending should be able to forecast their own storage bill.
5. Wire the Workspace into Memory OS references. An episode that says "the March 12 dub failed QA" should be able to point at the March 12 dub. First-class artifact references from memory entries — cheap to store, resolvable for cents — would make the archive and the memory one system, which is what an agent's hard drive was always supposed to be.