Agent-Fleet Token Economics Is Cache Economics: Decomposing the 60x Dollar Spread

In a September 2026 interview, Freelancer.com CEO Matt Barrie described a fleet of about 44 agents, roughly 4 billion billed tokens in one day, and about $1,300 of spend, including about $900 on Anthropic Sonnet. He said 3 billion tokens were prompt-cache reads and estimated an uncached, Opus-class version of that day at about $80,000¹. These are his estimates and usage figures, not independently audited invoices.

Public price sheets let us test possible bills, but they do not reproduce his $1,300 bill or $80,000 counterfactual without per-model input, cache-write, cache-read and output counts. The 3-billion cached figure identifies a reported 75% cache-read share of total tokens, not a measured fraction of requests or useful work. This guide uses that distinction to build a budget checklist. It continues the math in our inference cost guide.

Mark everything from the anchor case as reported, not verified: one operator, one day, no audit. The decomposition below stands on its own regardless of whether the day happened exactly as told.

The anchor, dissected

For an illustrative calculation, use these named-model list prices per million tokens from Anthropic's September 2026 sheet². They are not proof of which SKU, route or negotiated rates Barrie used:

The reported aggregate gives only three constraints:

• Total: ~4.0B tokens, ~$1,300, ~$900 of it on Sonnet¹
• ~3.0B of those tokens were prompt-cache reads — 75% of the reported total, across unspecified models and routes
• ~1.0B tokens were not cache reads; this remainder includes ordinary input, possible cache writes and output, but the split is not published

Conditional check: If all 3.0B cache reads had been on Sonnet 5 at its listed $0.20/M, they alone would cost $600. The remaining $300 of the reported Sonnet subtotal could buy, for example, 100M ordinary input tokens plus 10M output tokens. That example accounts for only 110M of the other ~1B tokens; the remaining ~890M would have to be billed on other routes or under different prices. We do not have the route-level usage needed to establish that allocation. In particular, treating all 4B tokens as Sonnet 5 at these rates would not reproduce the reported $1,300 total.

The counterfactual, honestly

The $80,000 figure is a counterfactual with no specified model SKU or token mix. If we preserve the reported 4B total tokens, including at least 3B input tokens because cache reads are input, then removing the cache discount and pricing every token at the illustrative Opus 5 rates gives:

All 4B tokens input:        4.0B / 1M × $5                  = $20,000
3B input + 1B output:       3.0B / 1M × $5 + 1B / 1M × $25  = $40,000
General fixed-total case:   $20,000 + $20 × output tokens/M ≤ $40,000

Thus $20,000–$40,000 is the fixed-token-count range for this particular Opus 5 illustration, before any special billing terms. The old $80,000 derivation added 2.4B output tokens on top of the 4B total and double-counted the workload. Barrie's "Opus-class" estimate might refer to a different SKU, rates, workload or token mix; the transcript does not specify enough to verify it. Even the range above is a scenario, not a reconstructed invoice.

The spread, factorized

The quoted ratio 80,000 / 1,300 ≈ 61.5× compares an estimated counterfactual with a self-reported mixed-model bill. It cannot be factorized into a measured cache benefit and model benefit from the published aggregates. A narrower, reproducible input-only example is:

The 7.69× figure is a modelled input-only scenario, not a decomposition of the reported 61.5× spread: the reported 75% share uses all tokens as its denominator, while this example needs the input-token hit rate. Output and cache-write quantities are unknown.

What is known from the interview is narrower: of the roughly 4B reported tokens, about 3B were said to receive a cache-read classification. That does not tell us how many tasks completed or what share of non-cache tokens were generated output.

Why repeated prefixes matter

Many agent harnesses resend a growing conversation prefix with each model call: system instructions, tool definitions and previous messages may recur while the tail changes. If the prefix stays cacheable and requests reach a compatible route before expiry, later calls can use prompt-cache reads. Other harnesses compact, truncate or restructure context, so the reported 75% is one fleet's claimed aggregate, not a universal agent-loop rate³. The KV-cache guide explains how a serving engine can reuse matching prefix state.

Anthropic lists cache reads at 0.1× ordinary input price and writes at 1.25× or 2× depending on TTL; other providers' multipliers and eligibility rules vary²³. Cached input is cheaper, not free. A growing transcript with n steps adding a fixed L tokens each can resend about L·n(n−1)/2 prefix tokens if nothing is truncated. That quadratic input-volume model is conditional; actual bills also include cache creation, output, routing and compaction.

Cache TTLs, minimum prefix lengths and provider routing affect hit rates. OpenRouter documents Anthropic's five-minute and one-hour cache options and exposes cached_tokens in supported usage records³. Measure these quantities for your own harness rather than applying Barrie's 75% share to another workload.

The 85% self-optimization claim

Barrie also said that asking his agents to optimize token usage reduced consumption by another 85%¹. The host-published transcript gives no before/after task-completion or error-rate evaluation, so this remains an unaudited consumption claim. A shorter trace can reflect useful removal of repetition, reduced output, fewer attempts or abandoned work. Evaluate cost per completed, quality-checked task before concluding that an instruction saved money without hurting outcomes.

Scaling a fleet

Barrie discussed growing from about 40 to 400 agents¹. Multiplying his reported $1,300/day by ten gives $13,000/day only if work per agent, model mix, pricing and cache hit rates stay constant. Within one task, a repeatedly resent untruncated prefix can grow approximately quadratically with step count; compaction and window limits change that scaling. Step budgets and measured cache statistics are therefore useful inputs to a capacity plan.

For scale context, OpenRouter said in August 2026 that it processed more than 10 trillion tokens per day. At that stated volume, 4B tokens would be under 0.04% of a day's platform traffic. This ratio says nothing about Barrie's bill. A planetary power estimate would require a measured workload mix, model operations, hardware efficiency and facility overhead; the interview's token count alone cannot provide it.

Capacity-planning checklist

1. Count token classes by model and route. Record ordinary input, five-minute and one-hour cache writes, cache reads and output. An aggregate total_tokens figure cannot reconstruct a bill.
2. Use the input-token hit rate in the cache formula. With a 0.1× read price and no write premium, 1 − 0.9h is the input-only price multiplier when h is cached input divided by all input. For h=0.75, the multiplier is 0.325. Barrie's 75% uses all tokens as the denominator and cannot be substituted for h without the input/output split.
3. Measure compatibility and expiry. Stable prefixes, minimum cacheable length, TTL and sticky routing can change the realized rate³. Cache writes can temporarily cost more than plain input.
4. Bound task depth and test compaction. In a fixed-increment, untruncated loop, halving steps reduces prefix retransmission by approximately fourfold. Verify that compaction preserves task success.
5. Compare cost per completed task. Run the same evaluation set before and after model routing, prompt shortening or cache-policy changes.

Verdict

The interview establishes what Barrie reported, not a route-level accounting. Published rates support the conditional Opus 5 range of $20,000–$40,000 for four billion fixed tokens with at least three billion input tokens. They do not establish his $80,000 estimate or reproduce his mixed-route $1,300 bill. Prompt caching can materially reduce input spend, but its contribution requires the missing token-class breakdown.

Footnotes