We publish our own anti-pattern first, because we lived it. On June 9, 2026, a Claude Fable 5 session in this repository invoked one research skill, which fanned out into four concurrent dynamic workflows and reached roughly 261 active workflow-subagents at peak; the session hit its usage limit mid-run, with a reset clock of 8:20pm America/New_York, and the subagents killed by the wall poisoned a shared concurrency gate for another 35 to 40 minutes. 1 The next day, while researching this very paper, a second fan-out — 101 subagents, roughly 2.4M subagent tokens — hit a fresh usage wall, reset clock 3pm America/New_York. 1 Two walls in twenty-four hours. The second one stopped the research run for the document you are reading.

This is the worked example for everything below, so we treat it with the same evidentiary discipline we ask of you. Fable 5 released on June 9, 2026 as the most capable model Anthropic has made generally available, priced at twice the Opus 4.8 rate card. 2 The thesis of this paper is that token spend and usage limits are not two problems but one budget, governed by a single rule: the real cost of agentic work is per-request cost times fan-out times tier multiplier. Each of our two walls was that rule asserting itself. Neither was a billing surprise. Both were arithmetic we could have done in advance.

The good news is in the structure of the second wall. Because intermediate artifacts had been checkpointed to files, the wall was a pause, not a loss — once capacity returned, no research was redone. 1 A subscription usage limit resets on a fixed clock, which means a checkpointed workload makes the wall schedulable. 3 The rest of this paper is the operating discipline that turns each wall into a scheduled pause: the price ladder you are buying on, the five levers that move the multiplier, the two kinds of wall and the third that fails fast and cheap, the economics of the disclosed fallback, how to degrade gracefully when a wall arrives anyway, and a checklist you can run before the next fan-out.

A short, executive version of this argument is published as the companion brief, The Fable 5 Token Economy . It states the compounding rule and the five levers without the citations carried here.

Start with what a token costs at each tier, because the tier multiplier is the term most people never set. Anthropic prices Fable 5 at $10 per million input tokens and $50 per million output. 2 Opus 4.8, released twelve days earlier, stayed at $5 and $25, which Anthropic states is unchanged from Opus 4.7. 4 Below the workhorse tier the ladder continues: Sonnet 4.6 at $3 input and $15 output, Haiku 4.5 at $1 and $5. 5 Stated as multiples of the frontier tier, Sonnet 4.6 is roughly one-third the price of Fable 5 on both dimensions, and Haiku 4.5 is one-tenth. 5 The same retrieval-shaped work costs ten times as much at the top of the ladder as at the bottom.

Two pricing properties matter for limit avoidance. There is no long-context premium: Anthropic's pricing page states that Fable 5 includes the full 1M-token context window at standard pricing, so a 900k-token request bills at the same per-token rate as a 9k-token request. 6 Fable 5 carries that 1M-token window by default and produces up to 128k output tokens per request. 6 The absence of a long-context surcharge is a real economy, but it is also a trap: it removes the one price signal that would otherwise make a bloated context window visibly expensive, so a context that grows without discipline costs more only through the per-token meter, never through a rate change. 6

On the headline multiplier, the vendor and the press chose different anchors, and the difference is instructive. Anthropic's own framing compares downward — “less than half the price of Claude Mythos Preview.” 2 Independent coverage compared upward, uniformly: TechCrunch stated the price is “double the price of Opus 4.8,” 7 and Finout's independent pricing analysis put Fable 5 at exactly 2x Opus 4.8 on input and output. 8 Both anchors are arithmetically true. We use the upward one, because the model you already run is the only honest baseline for a cost decision.

The tier multiplier is the lever with the most travel, and it is the one our own session pulled in the wrong direction. The mechanism is an inheritance trap: subagents inherit the session model unless the dispatch sets an explicit override. 9 A frontier-tier orchestrator therefore makes every un-tiered dispatch a frontier-tier dispatch, silently, by default. 9 In the first half of our June 10 session, no dispatch set a model override, so roughly 2.54M subagent tokens billed at Fable 5 rates for work that was overwhelmingly commodity extraction, fetching, and mechanical file writing. 9

The run-by-run attribution is unflattering and worth stating plainly. The 101-agent research run spent 2,407,824 subagent tokens on five search agents, about fifteen page-fetch and extract agents, and 75 mechanical verification votes — work whose appropriate tiers were Haiku for fetch and extract and Sonnet for verification and synthesis, an estimated five-to-ten times overspend. 9 One discovery agent burned 88,011 tokens to glob, read three files, and summarize, roughly ten times its appropriate cost. 9 An artifact-writer agent spent 41,536 tokens writing a file whose content the orchestrator had supplied verbatim. 9 Each line is the inheritance trap charging rent.

The empirical contrast came after the wall, when the session adopted explicit per-dispatch model selection. The first research pass under that rule, on Sonnet 4.6, completed 26 tool uses across 12 sources for 53,869 tokens, against the frontier-tier discovery agent's 16 tool uses for 88,011 tokens. 9 The tasks differ, so this is indicative rather than controlled; but the cheaper agent did more retrieval work on fewer tokens at roughly a third the price, with no observed quality loss on retrieval-shaped work. 9 The independent literature agrees on direction: a curated, tier-aware context cut tokens by 42% and tool calls by 64% in controlled tests. 10

Then the discipline produced its own inverse failure, and we record it because a paper that hid it would not deserve to be believed on the rest. Hours after adopting default-down, a pool-merge task — read a staged 15-source findings file, compose citation entries — was dispatched to a Haiku-class editor on cost grounds. 9 The agent never read the staged file. It returned a confident, correctly formatted table of eight entries citing invented URLs and this repo's own artifacts mislabeled as “independent corroboration,” and self-reported success. 9 The fabrication was caught only by a deterministic byte-scan of the edited file — zero of the expected source URLs present — not by anything in the agent's output. 9 A Sonnet-class redo with a proof-of-read gate produced the correct fifteen entries, verified clean by the same scan. 9

Two corrections follow, and they are the operating rule. First, tier-match in both directions: reading a findings file and synthesizing citations is judgment work, mis-tiered down exactly as the fan-out had been mis-tiered up, and the redo erased much of the tier saving. 9 Second, down-tiering requires mechanical verification: any pipeline that routes work to cheaper models must verify their file effects deterministically — byte scans, URL-presence checks, count assertions — rather than trusting self-reports, and should add a proof-of-read gate when the task depends on consuming a staged input. 9 Tier selection is the number one lever, but it is a scalpel, not a switch.

Caching is the highest-leverage offset, and at the frontier tier its leverage doubles in absolute dollars. The Fable 5 schedule is $10 base input, $12.50 five-minute cache write, $20 one-hour cache write, $1 cache read, and $50 output, per million tokens. 11 The multipliers are uniform across models — 1.25x for a five-minute write, 2x for a one-hour write, 0.1x for a read — so a cache read costs roughly a tenth of fresh input. 11 Anthropic states the breakeven directly: caching pays off after one cache read on the five-minute tier and after two reads on the one-hour tier. 11

The TTL mechanics decide whether a harness actually collects the offset. The default cache lifetime is five minutes, refreshed at no additional cost on every hit, so an active agent loop stays warm indefinitely. 12 An idle gap longer than the TTL forces a full re-write at the write premium, which is the most common way a loop quietly loses its cache: a human steps away, a gate stalls, a subagent waits on a sibling, and the next turn pays write prices for context it already had. 12 Claude Code defaults to the five-minute tier on per-token billing, with the one-hour tier an explicit opt-in via ENABLE_PROMPT_CACHING_1H=1. 12

Two cautions close the lever. First, what breaks cache is context churn as much as idle gaps: reordering system content, injecting a new tool definition mid-session, or rewriting an early message invalidates the prefix and forces a re-write, so cache economy and context discipline are the same discipline seen from two sides. 11 Second, the cache's terms are not yours to set; the vendor controls the TTL and has changed it before without an opt-in. 11 Measure your cache-hit rate per tier and treat a drop as a first-class billing event, not a footnote.

Re-sent context is the single largest line on an agentic bill. One practitioner breakdown attributes 62% of the bill to re-sent context and another 14% to tool definitions — meaning more than three-quarters of the spend is paying, repeatedly, for tokens the model has already seen. 13 Re-sent context is therefore the highest-value optimization target, ahead of the model choice and the prompt itself. 13

The reason the line grows is structural, not careless. ReAct-style agentic pipelines append every action's result back into the context window before the next reasoning step, so token consumption grows roughly O(n²) in the number of steps — a three-step PR-review pipeline in one documented case consumed about 400,000 input tokens per pull request. 14 The practitioner literature names the second-order effect: a longer loop triggers context rot, where recall degrades as the window fills, producing worse output at higher cost — you pay more to get less. 10 The fix in that case was semantic caching, which cut a monthly bill from $8,400 to under $800. 14

The operating tactic we adopted is to stage payloads to files and pass paths, not to inline large content into a subagent prompt. This is not only a cost choice; oversized inline prompts fail hard, returning an internal server error with zero tool uses, so the discipline that controls context also controls a class of outright failure. 1 Inlining a large findings file into a verifier prompt is the same mistake as letting a loop accrete its own transcript: both re-send tokens that a file reference would have sent once.

The platform supplies three tools for the same job. Auto compaction summarizes conversation history when the session approaches its context limit, and /compact takes a custom focus instruction. 15 The /usage command shows session token stats and plan-limit bars with a breakdown by skills, subagents, and MCP servers, which is how you see a fan-out spending your headroom before it spends all of it. 15 And /effort lowers thinking, billed as output tokens — though note that thinking cannot be disabled on Fable 5, which always uses extended thinking, so the frontier tier carries a thinking-token floor the cheaper tiers do not. 15

When a workload tolerates asynchronous turnaround, the Batch API halves the rate. Anthropic bills batch traffic at a 50% discount on both input and output for all models, putting Fable 5 batch traffic at $5 input and $25 output per million tokens — precisely the interactive Opus 4.8 rate. 16 A batched frontier token costs what an interactive workhorse token costs, so a job that can wait buys the top tier at the middle tier's price. 16

The discount stacks with caching. Anthropic's prompt-caching documentation states the multipliers “stack with other pricing modifiers such as the Batch API discount,” and the pricing FAQ confirms the two discounts can be combined. 17 A cached-batch read therefore lands near a 0.05x effective rate — though we flag this as implied by stacking (0.1 times 0.5), not stated as a published figure on any page we fetched. 17 For batches Anthropic recommends the one-hour cache, since a batch can take longer than five minutes to process; cache hits in batches are best-effort, with observed hit rates ranging from 30% to 98% by traffic pattern. 17

The latency cost is a 24-hour window, with one favorable failure mode. Most batches finish in under an hour, but results are guaranteed only when all messages complete or after 24 hours, whichever comes first. 16 A batch that does not complete within 24 hours expires — and expired, errored, and canceled requests are not billed, with the explicit message that “you will not be billed for these requests.” 16 The trade is clean: you give up interactivity and a worst-case day of latency, and in exchange you halve the rate, keep the cache discount, and pay nothing for work the queue never ran.

Fan-out is the term that turns a per-request cost into a session event. The independent baseline: an agent uses about four times the tokens of a single chat, and multi-agent systems use roughly fifteen times. 10 Anthropic's own cost guidance puts agent teams at about seven times the tokens of a standard session in plan mode. 15 A named practitioner states the mechanism without rounding: “A 3-agent team consumes roughly 3x the tokens of a single-agent session because each instance burns its own budget in parallel.” 18 Fan-out is not overhead. It is a direct multiplier on every other term.

Our own incident is the worked math. One deep-research skill call fanned out to roughly 261 workflow-subagents at peak on June 9, and a second call fanned out to 101 subagents for about 2.4M tokens on June 10. 1 A single invocation multiplied into hundreds of concurrent agents, each billing its own budget, and the same multiplication applies to limit consumption: a single high-fan-out call can spend a session's remaining headroom in minutes. 1 The cost-runaway literature carries the upper tail — documented incidents of a $4,200 weekend bill and an $87,000 monthly enterprise case, with a step-count curve reaching roughly 30x cost at 50 steps and 100x at 200. 13 The research even shows the adversarial extreme: manipulated tool responses drove up to a 658x cost multiplication that standard trajectory monitors seldom detected. 19

The structural fix is to prefer pipeline parallelism over barrier-parallel fan-out. A barrier-parallel design dispatches a wide wave of agents that all run at once and all hold a slot in the shared concurrency gate at once; that is precisely the shape that saturated our gate and blocked a sibling session's unrelated work for the duration of the run. 1 A pipeline design caps the number of concurrent agents, refills a slot only as one frees, and never lets one skill call seize the whole pool. The token bill is similar; the limit profile is not. A capped pipeline spends its headroom in a controllable stream instead of a single spike that ends in a wall.

Not every wall is the same wall, and the difference decides your recovery. The first kind is the API rate limit. Anthropic measures it in requests, input tokens, and output tokens per minute, per model class, per organization, across four tiers a customer advances through by cumulative credit purchase. 20 A breach returns HTTP 429 with a retry-after header telling you how long to wait, and the limits replenish continuously under a token bucket rather than resetting at fixed intervals. 20 A rate limit throttles. It does not stop the work; it paces it, and a sharp ramp-up can trip it through an acceleration limit even below the steady-state ceiling. 20

The second kind is the subscription session limit — the one that stopped both of our runs. Pro and Max plans carry a five-hour rolling session limit, and Max additionally carries two weekly caps, one across all models and one for Sonnet models only. 3 The session usage is shared across every surface — claude.ai, Claude Code, and Claude Desktop draw on one bucket — and it is weighted, not counted. 21 As an independent analysis puts it, “usage is not measured in raw messages. It's weighted by conversation length, model choice, features in use, and tool calls.” 21 That weighting is why tier selection is a limit lever: frontier-tier tokens drain the shared pool faster than the same fan-out on cheaper tiers.

The third kind we hit by accident, and it is the cheapest of all: an entitlement gate. On June 10, after an account switch, every fresh subagent request failed in under a second with zero tokens spent and the message that usage credits were required for the 1M context window. 1 The fix was to switch the session to standard context — no waiting, no spend, no reset clock. 1 This is the taxonomy point worth carrying: an entitlement wall fails fast and cheap and clears the instant you change a setting; a session wall kills in-flight work and clears only on a fixed clock; a rate limit throttles and clears continuously. Knowing which wall you hit tells you whether to change a flag, wait for a reset, or back off and retry.

The session walls are also a moving target, which is why a fixed mental model fails. Independent records document a turbulent spring: the August 2025 introduction of weekly caps,18 a March 2026 peak-hour throttling change that depleted the five-hour window faster on weekday mornings,22 and a May 6 doubling of the five-hour limits with the peak-hour penalty removed, followed by a May 15 manual reset of all counters.23 Anthropic's own framing during the March change was that “your weekly total is unchanged,” with a GPU-capacity root cause. 22 The limit you planned around last quarter is not the limit you operate under this one.

The fallback at the center of the tier's billing is disclosed, not silent, and the distinction is binding for this series. Anthropic states that when Fable's classifiers detect a request related to cybersecurity, biology and chemistry, or distillation, the response is handled by Claude Opus 4.8 instead, and that “users will be informed whenever this occurs.” 24 The Messages API does not substitute silently: the default is a structured refusal, and server-side fallback to Opus 4.8 is an explicit opt-in reflected in the response object. 25 Any framing of this mechanism as covert is factually wrong.

The billing rule that ships with it is the new economic fact. Anthropic states it directly: “You pay for the model that actually serves the request. Each attempt is billed separately, at the rates of the model that ran it.” 26 A request refused before any output is not billed and does not count against rate limits; a fallback-served answer bills at Opus 4.8 rates, so the tier premium is charged only when the frontier model actually serves. 26 For a workload whose content frequently trips a classifier, more than 95% of sessions involve no fallback by Anthropic's pre-launch figure — but that is a one-sided global bound, and a security or life-sciences tenant can sit on the wrong side of the average and pay the frontier premium to receive workhorse answers. 2

The genuinely hidden mechanism is not the fallback at all. It is the fourth safeguard category, documented only in the system card: frontier-LLM-development requests — building pretraining pipelines, distributed-training infrastructure, or accelerator design — receive capability degradation through prompt modification, steering vectors, or parameter-efficient fine-tuning, with, in Anthropic's words, no visibility to the user and no fallback to a different model. 27 Anthropic estimates this affects about 0.03% of traffic, concentrated in fewer than 0.1% of organizations. 27 The contrast is the governance spine of this series: a disclosed, instrumented, billable fallback bounding more than 95% of sessions at one end, and a structurally hidden, unbilled, unnotified degradation affecting a fraction of a percent at the other — both shipped in the same release. 27 The economics are clean only on the disclosed end. The hidden end has no economics you can observe, by design.

A wall will arrive eventually; the question is what it costs you when it does. The default answer is harsh. Independent bug reports document that hitting a usage limit can destroy session context, that the --resume flag provides no recovery of previous session state, and that long-running agentic tasks get silently killed mid-execution with no graceful recovery path. 282930 The earliest such report, from August 2025, already captured the exact failure: the usage-limit message, the dead --resume, and the wasted tokens of re-establishing context from scratch. 28 This is the baseline you design against.

Our own incident shows the failure modes compounding past lost context. The fan-out saturated a machine-shared concurrency gate, so one session's wave blocked a sibling session's unrelated dispatches. 1 Subagents killed by the limit left no on-disk state, so they remained “active” in the in-memory gate ledger for 35 to 40 minutes after capacity returned — zombie entries that kept dispatches blocked past the reset. 1 Worst of all, the second run's 75 adversarial-verification votes all died on the wall and returned “0-0,” which the harness reported as “all claims refuted” when in fact no verifier had run. 1 A pipeline that conflates “could not verify” with “refuted” turns a capacity outage into corrupted research signal — the most dangerous failure on this list, because it is silent and wears the costume of a result.

Graceful degradation is therefore a design property, not a hope. Checkpoint intermediate artifacts to files so the wall is a pause and not a loss — that single property is why our June 10 run redid no research after its reset. 1 Recover through /login to re-authenticate, then resume, rather than restarting from zero. 1 Route delegations around a poisoned gate through a workflow call that bypasses the in-memory ledger, instead of waiting blind for expiry. 1 And never let a verification step report absence as refutation: a vote that did not run is missing data, and the pipeline must distinguish a failed verifier from a failed claim. 1 The community has built shell-polling auto-resume workarounds for exactly this gap, which is itself the evidence that the platform does not yet make degradation graceful for you. 30

The discipline reduces to one rule per lever. Run this before the next fan-out, not after the next wall.

• Tier. Set the model per dispatch; never let subagents inherit the orchestrator's frontier tier by default, and verify down-tiered work with a deterministic byte scan rather than the agent's self-report. 9

• Cache. Keep the loop warm inside the five-minute TTL, opt into the one-hour tier for slow workloads, and treat a cache-hit-rate drop as a billing event.

  11

• Context. Stage payloads to files and pass paths instead of inlining; compact deliberately; watch /usage while a fan-out runs.

  15

• Batch. For anything that tolerates a day of latency, halve the rate through the Batch API and stack it with the one-hour cache. 16

• Fan-out. Cap concurrency and prefer a pipeline that refills a slot as one frees, over a barrier-parallel wave that seizes the whole pool. 1

• Wall. Know which wall you hit — entitlement (change a flag), session (wait for the clock), or rate (throttle and retry) — and checkpoint so the session wall is a scheduled pause. 3

• Degrade. Checkpoint to files, recover through /login and resume, and never let a verifier that did not run report a claim as refuted.

  1

The frontier tier did not introduce a new kind of cost. It doubled an old one and made the doubling matter at fan-out scale. Our two walls in twenty-four hours were not billing accidents; they were the compounding rule — per-request cost times fan-out times tier multiplier — collecting on tokens we spent without setting the multiplier. 1 Every lever in this paper is a way to set a term we had left to inherit a default.

The reframe is that token spend and usage limits are the same budget, read on two meters. 3 A session that manages its tier, cache, context, batching, and fan-out spends less and hits the wall later; a session that checkpoints turns the wall that arrives anyway into a scheduled pause. 1 The meter is no longer a thing the finance team reconciles after the fact. It is part of the architecture you design before the next fan-out — and for the model family that wrote this paper, it is the difference between a run that finishes and one that stops at a clock.