Frontier Frugality

All prices are nominal USD list prices per million tokens from Anthropic's pricing documentation, retrieved September 2026. Savings percentages from papers and vendor write-ups depend on workload mix: treat them as commonly cited ranges, not guarantees.

Executive Summary

An agentic coding session re-sends its whole history on every turn, so its input bill grows with the square of its length. In the calculator below, at its defaults (Claude Fable 5.1, 40 turns), the same session costs about $30 done naively and about $2.30 with the levers in this post: 13x cheaper.

The Price of Thinking at the Frontier

Every model family ships as a ladder of tiers, and the rungs are far apart. Here is Anthropic’s ladder as of September 2026:

Anthropic list prices, September 2026. Cache reads are no longer a flat 10% of input: 2.5% on Fable 5.1, 5% on Opus 5.5, and 10% on Sonnet 5.5 and Haiku 4.5. Sonnet 5's launch price of $2/$10, originally introductory, is now the standard rate; the scheduled rise to $3/$15 on September 1 was cancelled. Darker cells cost more; the cache-read column uses the same scale as the input column.

Think of the frontier model as a senior consultant billing $800 an hour and the cheap tiers as capable staff billing $80. Nobody asks the consultant to photocopy documents, yet most agentic setups have the most expensive model read every file and log. The goal is not to use the frontier model less; it is to spend every frontier token on a decision only it can make.

Per-token prices also understate the gap: Claude 4.7 and later models (Fable 5.1, Opus 5.5, Sonnet 5.5) use a newer tokenizer that produces roughly 30% more tokens for the same text than Haiku 4.5’s, so 10x per token is closer to 13x per page of text.

Where the Money Actually Goes

The API is stateless: every turn re-sends the full conversation history as input. An agentic session is a loop (read a file, run a test, read the output, edit) and each iteration appends to the context. For $T$ turns, a base context $C_0$ (system prompt, instructions, tool definitions), and $\Delta$ new tokens per turn:

The second term grows with the square of session length. A 5,700-token file read on turn 10 of a 60-turn session is paid for 50 more times. At Fable 5.1’s $10/MTok, 60 turns at 3,000 tokens per turn bills about 6.2 million input tokens, roughly $62 of input alone, for what feels like one coding task. Extended thinking adds to this: it is billed as output ($50/MTok on Fable 5.1), and practitioners budget 2-5x the visible output for thinking-heavy turns (an unverified rule of thumb).

Lever 1: Caching, the Discount You Must Not Fumble

Mechanism Prompt caching reads a repeated prefix back at a fraction of the input price: 0.1x on Sonnet 5.5 and Haiku 4.5, 0.05x on Opus 5.5, 0.025x on Fable 5.1. Writes cost 1.25x (2x for the 1-hour TTL). A 5-minute write pays for itself after one hit, so in a tight loop nearly all of the quadratic term gets the discount. On Fable 5.1 the $62 session drops to about $3.9 (about $8 under the old flat 0.1x).

The deeper discount has two consequences. The frontier premium shrinks once caching works: the same cached session on Sonnet 5.5 has an input bill of about $1.7, so Fable 5.1 costs about 2.3x that, not the 5x list ratio. And a broken cache hurts more: a full miss on Fable 5.1 costs 40x a hit (10x before).

Three rules keep the discount alive:

1. The cache is a prefix match. One changed byte early (a timestamp in the system prompt, a reordered tool definition) invalidates everything after it. Stable content first, volatile last.
2. The default TTL is 5 minutes. Pause longer and the next request re-writes the cache. Human-in-the-loop workflows may justify the 1-hour TTL at 2x write cost, which breaks even after two hits.
3. Defaults move. In March 2026 Anthropic changed the default TTL from 1 hour to 5 minutes, and community trackers attributed 20-60% cost increases to it (Anthropic disputed the attribution). Monitor caching defaults like a dependency.

Caching discounts the waste; it does not remove it. Models also reason worse when the window fills with stale tool output, so a bloated context is a quality problem even when it is a cheap one.

Lever 2: Don’t Let the Expensive Model Read

Architecture The quadratic term exists because bulk material enters the frontier model’s context. Keep it out: the frontier model orchestrates; cheap models read. It dispatches a subagent on a cheap model, in its own isolated context, to do the reading and return only conclusions. Anthropic’s multi-agent research system has this shape; in one circulating example, a subagent read 6,100 tokens and returned a 420-token summary. The 5,700-token difference was never re-billed and never diluted the orchestrator’s attention.

The arithmetic is lopsided twice: the bulk is paid once instead of on every remaining turn, and at the worker’s meter (Haiku’s $1/MTok, on a tokenizer that yields about 30% fewer tokens for the same file). Practitioners claim 5-10x savings for Haiku-class subagents (vendor figures, not audited).

Triage is the hard part. If you could hand the task to a junior developer with a clear spec, a cheap subagent can do it; if it needs judgment or taste, it stays with the orchestrator. Every dispatch needs a goal, acceptance criteria, and a report format (“conclusions and file:line only”), because a sloppy spec produces work the expensive model then repairs at expensive rates.

Lever 3: Route by Difficulty, Verify Independently

Architecture Delegation splits work within a task; routing splits it across tasks, because most queries never needed the frontier model. FrugalGPT (Stanford, 2023) cascaded models, cheapest first, escalating on a failed score, and matched GPT-4 accuracy at up to 98% lower cost on its benchmarks; production routers commonly cite 40-70% savings at under 2% quality loss (vendor figures). By hand, the discipline is:

1. Default down. Start at the cheapest tier that has handled this kind of subtask well.
2. Escalate on evidence. One Haiku-class failure goes to Sonnet-class; two Sonnet-class failures on the same subtask go to the frontier model with the full failure trail. Escalate judgment failures, not missing facts: a module-not-found error needs someone to read it, not a smarter model.
3. De-escalate after the breakthrough. Once the frontier model cracks the hard instance, batch-apply the pattern with a cheap model.

Also take the tier upgrade. Sonnet 5 launched in June 2026 scoring 63.2% on Anthropic’s agentic-coding benchmark against Opus 4.8’s 69.2% at less than half the price (Anthropic’s numbers). Its $2/$10 price has since become permanent and Opus 5.5 arrived at $4/$20, so a routing policy tuned six months ago probably over-escalates today.

Verify independently. Checking work is cheaper than producing it, which suggests plan-execute-review: the frontier model writes a short plan with acceptance criteria, a cheap model executes it (where most tokens burn), and a reviewer checks the diff and test log. Self-verification does not come free, though: use a fresh context, ideally a model at least as strong as the producer, given the criteria and artifacts but not the producer’s reasoning, which would anchor it.

Smaller Knobs That Stack

Configuration Pricing multipliers are multiplicative, so these compound with everything above:

• Batch API: flat -50% on input and output for asynchronous work such as evaluation sweeps and bulk classification. Stacked with cache reads, a cached-corpus pipeline drops to about 5% of the uncached input rate on Sonnet and Haiku (0.1 x 0.5), 2.5% on Opus 5.5, and 1.25% on Fable 5.1 (0.025 x 0.5).
• Effort control. The effort parameter (low through max) governs thinking-token spend, which bills at output rates. Defaulting subagents and mechanical tasks to low is one of the highest-leverage single lines of configuration.
• Output discipline. Output costs 5x input on every tier, so report formats like “conclusions only, long artifacts go to files” save money as well as context.

Multipliers stack: the last column is the cache-read share times the 50% batch discount. Darker cells cost more.

Interactive: The Agentic Session Bill

The calculator prices one agentic session ($T$ turns, each appending $\Delta$ tokens to a 15,000-token base context, 400 output tokens per turn) in four configurations, using September 2026 list prices and each tier’s own cache-read rate. Delegated reading is done by Haiku 4.5 subagents returning 10%-length summaries, with a 2x allowance for their own loops. At 60 turns and 3,000 tokens per turn on Fable 5.1 the naive figure reads about $63: the $62 of input plus output.

Three things to try. Drag session length upward: the naive bar pulls away faster than linearly, the quadratic term made visible. Compare caching alone with delegation alone on Fable 5.1: caching cuts $30 to $3.2, delegation alone only to $18, so caching is the bigger dollar lever. Delegation still trims another ~28% on top of a healthy cache (to $2.30), and its bar is roughly what you pay when the cache is not working. And naive at Fable prices versus both levers at Sonnet prices differs by more than 30x for the identical workload.

Into the Weeds: Distill the Playbook Before the Access Ends

Every lever so far assumes you still have frontier access. The most durable one assumes you are about to lose it, to a plan change, a rate limit, or a provider pulling the top tier from subagent use. The research name is Concept Distillation: collect the mistakes a weak model makes on your tasks, have the strong model induce general rules from them, validate the rules on held-out cases, and fold the survivors into the weak model’s standing instructions. No fine-tuning: judgment exported as text, carried to every cheaper or newer model.

I can report a first-person version. On the last day of my own Fable 5 access in July, I pointed the session at itself: audit how this machine’s sessions fail, and write the rules that prevent it. The result is a few plain-text files that cheaper models now execute mechanically, and its table of contents is essentially this post:

• A dispatch rulebook: the 2,000-token test, which tier handles which job, and an escalation ladder with hard retry caps.
• Judgment rubrics: what counts as “done” (verification output shown, not claimed), when the direction is wrong versus the execution, when to stop and ask, each as trigger, check, action.
• Delegation templates: fill-in-the-blank prompts that force a goal, acceptance criteria, and a report format on every subagent call.
• An honesty clause: rules recover execution discipline, not taste. On design calls and ambiguous product decisions, the weak model should say so, offer alternatives with tradeoffs, and let the human judge.

Whether this transfers fully is open: the research shows rules recovering a meaningful slice of the gap on tasks similar to those that generated them, not Haiku becoming Fable. The asymmetry is the point. The rules cost one session at frontier prices and run for free forever after, on every future model. The cheapest frontier token is the one you spent writing instructions for the model that replaced it.

References