LLM Cache Pricing Cost Per Turn: The Math Every Agent Builder Gets Wrong

Every LLM pricing guide lists GPT-5.6 Luna at $0.20 input as the cheapest frontier model. Every guide is measuring the wrong variable. For agentic workflows—the highest-growth use case right now—LLM cache pricing cost per turn is the number that decides your bill, and Luna can cost 40x more per completed turn than mid-tier Claude. The math stays invisible until the second invoice arrives. This guide runs the numbers no competitor article has bothered to show: exact cost-per-turn formulas for transcript-accumulation loops, the two context-length cliffs that silently double bills mid-job, and why the cheapest sticker price produces the most expensive agentic workload.

Why Does LLM Cache Pricing Cost Per Turn Matter More Than Model Pricing in September 2026?

On September 1, 2026, Anthropic cut cache-read rates on the Fable line from $1.00 to $0.25 per million tokens—a 75% reduction. According to AlphaCorp AI's September 2026 analysis, Anthropic's own estimate puts typical workload savings at roughly 25% and heavily agentic coding savings at up to 45%. That single line item—not any benchmark improvement—is now the largest cost variable in LLM infrastructure for agent builders.

Here's the before-and-after math no pricing comparison page has published. Take a standard agentic coding loop: a 200K-token stable context (system prompt plus tool schemas plus growing transcript), re-read on every turn. Before September 1:

• Claude Fable 5.1, fresh input rate: 200K tokens × $10/1M = $2.00 per turn
• Claude Fable 5.1, old cache rate ($1.00/1M): $0.20 per turn
• Claude Fable 5.1, new cache rate ($0.25/1M): $0.05 per turn

Over 1,000 turns: $2,000 uncached, $200 at the old cache rate, $50 at the new rate. That's a 40x swing from uncached to current cached—and the difference between those two numbers is purely whether your team instructs the cache correctly. According to BenchLM's September 14 pricing registry, Claude Fable 5.1 sits at $10.00 input / $0.25 cached input / $50.00 output per million tokens.

The inversion nobody talks about: GPT-5.6 Luna at $0.20 input looks 50x cheaper than Fable 5.1. For single-turn classification calls, it is. For a 200K-token agent loop, Luna costs $0.04 per turn on cached input ($0.02/1M × 200K), but Luna has no stable-prefix caching guarantee on long transcripts the way Claude's prompt-caching architecture does. If the cache misses—because the transcript grew, because the prefix shifted, because you hit the 5-minute TTL—Luna bills at $0.04 per turn on cache-hit and $0.04 on cache-miss (200K × $0.20/1M). That sounds fine until you add output tokens at $1.20/1M and reasoning overhead, and the cost-per-completed-task comparison looks nothing like what the rate card suggests.

For AI automation tools built on agent loops, this isn't a footnote. It's the architecture decision.

What Are the Hidden Costs That Don't Appear in API Rate Cards?

Three bill multipliers never appear together on pricing comparison pages. They interact. When all three fire on the same request, your effective cost per turn can be 6x what the sticker implies.

Multiplier 1: Context-Length Cliffs

Two cliffs matter right now. According to AlphaCorp AI's September 2026 analysis of xAI's model documentation:

• Grok 4.6 at 200K tokens: input rate doubles from $2.00 to $4.00 per million, output from $6.00 to $12.00. The word that hurts: “entire.” The doubled rate applies to the whole request, not just the tokens above the line. An agent that crosses 200K on turn 30 pays $4/1M on all of turn 30 and every subsequent turn.
• GPT-6 Astra at 272K tokens: input and cache rates double, output rises 1.5x. A 300K-token Astra request at $10/1M standard costs $6.00 just on input—not $3.00. The 22K gap between the 200K and 272K cliffs is exactly where transcript-accumulation loops get caught.

Claude Fable 5.1 and Claude Opus 5 carry no long-context surcharge on their 1M-token window. That's not in the headline. According to CloudZero's August 2026 pricing analysis, “the same request on Claude Sonnet bills at standard rates” while GPT-5.6 Terra doubles above ~272K. For a retrieval-heavy agent running a 300K-token window at 500 turns, the surcharge adds $1,500 to a job that sticker math priced at $1,500—the cliff doubles the invoice, not the margin.

Multiplier 2: Reasoning Token Surcharges

Reasoning tokens bill as output at output rates, whether or not you see them. OpenAI's o-series and extended thinking on Claude both do this. CloudZero notes effective costs on reasoning-heavy tasks run 3x to 10x the base rate—but the range matters: tool-selection steps with constrained output average 3x-4x, while open-ended planning steps routinely hit 8x-10x because the model deliberates longer before committing. An agent loop using extended thinking on every tool-selection step isn't paying $10/1M input—it's paying $50/1M on hidden deliberation tokens, billed silently as output. Cap extended thinking to planning turns only; disable it on deterministic tool calls.

Multiplier 3: Cache-Write Costs

This one is genuinely invisible. According to Anthropic's pricing documentation cited by CloudZero: cache writes cost 1.25x input rate for a 5-minute TTL, or 2x input rate for a 1-hour TTL. On Claude Fable 5.1 at $10/1M input, a 1-hour cache write costs $20/1M. Break-even hits after one cache read at 5-minute duration, or two cache reads at 1-hour duration. An agent that writes a new cache block every turn and only reads it once pays more for caching than for fresh input. Most teams don't model this—they see the $0.25 cache-read rate and assume caching is pure savings.

Combine all three: an agent on GPT-6 Astra that crosses 272K, uses extended thinking, and writes a fresh cache block each turn is paying approximately: ($20 input doubled) + ($50 output × 3-10x reasoning multiplier) + ($20 write cost). That's a very different number than the $10/$50 sticker implies.

How Do You Calculate Cost-Per-Completed-Task Instead of Cost-Per-Token?

Stop optimizing for cost-per-token. Start optimizing for cost-per-completed-task. The formula:

Cost per task = 
  (uncached_input_tokens / 1M × input_rate)
  + (cached_input_tokens / 1M × cache_read_rate)
  + (cache_write_tokens / 1M × cache_write_rate)
  + (output_tokens / 1M × output_rate)
  + (reasoning_tokens / 1M × output_rate)
  × (1 / acceptance_rate)

The acceptance_rate term is the one everyone omits. A model that costs $0.05/turn but only produces an acceptable result 60% of the time actually costs $0.083/turn on accepted completions. A model at $0.15/turn with 95% acceptance costs $0.158/turn. That 2x sticker difference collapses to less than 2x on real work.

Three real workload patterns with worked examples, using BenchLM September 14 rates:

Pattern A: Simple Classification (1K input, 50 output, single-turn)

• GPT-5.6 Luna: (1K/1M × $0.20) + (50/1M × $1.20) = $0.0002 + $0.00006 = $0.00026/task
• Claude Sonnet 5: (1K/1M × $2.00) + (50/1M × $10.00) = $0.002 + $0.0005 = $0.0025/task
• Verdict: Luna wins by 10x. This is the only workload where the sticker price comparison is honest.

Pattern B: Document Analysis (50K input, 2K output, stable system prompt cached)

• GPT-5.6 Luna (30K cached, 20K fresh): (20K/1M × $0.20) + (30K/1M × $0.02) + (2K/1M × $1.20) = $0.004 + $0.0006 + $0.0024 = $0.0070/task
• Claude Sonnet 5 (30K cached, 20K fresh): (20K/1M × $2.00) + (30K/1M × $0.20) + (2K/1M × $10.00) = $0.04 + $0.006 + $0.02 = $0.066/task
• Verdict: Luna still wins, but the gap shrinks from 10x to ~9x. Output tokens matter here.

Pattern C: Agent Loop (200K context re-read every turn, 500 output tokens/turn, 1,000 turns)

• GPT-5.6 Luna (200K cached per turn): (200K/1M × $0.02) + (500/1M × $1.20) = $0.004 + $0.0006 = $0.0046/turn × 1,000 turns = $4.60 total
• Claude Fable 5.1 (200K cached per turn): (200K/1M × $0.25) + (500/1M × $50.00) = $0.05 + $0.025 = $0.075/turn × 1,000 turns = $75.00 total
• BUT—if Luna's cache misses 30% of turns (realistic for transcript-accumulation patterns where the prefix shifts): 700 cached turns at $0.0046 + 300 uncached turns at (200K/1M × $0.20 + 500/1M × $1.20) = 300 × $0.0406 = $3.22 + $12.18 = $15.40 total for Luna
• Claude Fable 5.1 with 30% cache misses: 700 × $0.075 + 300 × (200K/1M × $10.00 + 500/1M × $50.00) = $52.50 + 300 × $2.025 = $52.50 + $607.50 = $660 total
• Verdict: At 100% cache hit rate, Luna wins. At 30% miss rate, Luna still wins on cost—but Fable 5.1's cache is architecturally more stable for long transcripts. The right question is: can you guarantee Luna's cache hit rate on a growing 200K+ transcript over 1,000 turns?

The Grok 4.6 case deserves its own row. At under 200K tokens, Grok costs $0.40 per turn (200K/1M × $2.00). The moment the transcript crosses 200K, that doubles to $0.80 per turn. Over a 1,000-turn job where crossing happens at turn 500: 500 × $0.40 + 500 × $0.80 = $600 total. Start that same job expecting $400 based on sticker math and you find the $200 overrun at invoice time.

When LLM Cache Pricing Breaks: Edge Cases You Should Know

• Transcript accumulation past the cache TTL: Both Anthropic and OpenAI use 5-minute cache TTLs for standard writes. An agent loop that takes longer than 5 minutes between turns—common in human-in-the-loop workflows or slow tool calls—silently invalidates the cache on every turn. Your $0.05/turn Fable loop becomes a $2.00/turn loop without any error message. The fix: use the 1-hour TTL cache write (2x write cost, break-even after 2 reads), or keep tool call latency under 5 minutes by parallelizing where possible.
• Prompt prefix reordering kills the cache hit: Cache reads require the stable prefix to be byte-identical up to the cache breakpoint. Injecting the current date, a session ID, or a dynamic user name into the system prompt before the stable content means zero cache hits on every turn. According to CloudZero's analysis, this fails silently—nobody sends a notification. The instrumentation fix: log cache hit/miss rates via the API response headers. If your cache hit rate drops below 80% on a workload you expect to be stable, a prefix is shifting.
• The Grok 200K cliff mid-transcript: Grok 4.6's 500K context window invites exactly the pattern that triggers the cliff. You design for long-context use, the transcript grows naturally across turns, and turn 31 crosses 200K. Every turn from that point pays double. What most teams discover only after the first invoice: the cliff isn't a per-excess-token surcharge—it reprices the entire request. Trim or summarize the transcript before 190K tokens to stay safely under the cliff. Grok 4.5 had no such step; Grok 4.6 introduced it as of August 12, 2026.
• Even when everything looks fine, cache billing can double if the provider silently updates the tokenizer: According to Anthropic's pricing documentation, Claude 4.7 and later models use a newer tokenizer producing roughly 30% more tokens for the same text. A prompt that cost $X at the old tokenizer now costs $1.30X before any rate change. If you benchmarked your cache economics against an older model version and migrated to Fable 5.1 without recounting tokens on real prompts, every cost assumption is wrong by ~30%.
• Cache-write thrashing on dynamic tool schemas: If your agent updates tool definitions between turns—adding new tools as sub-agents spawn—each update invalidates the cache block covering the tool schema section. You pay a cache write fee on every turn instead of every session. The cost: 1.25x input rate per million, per turn, on the schema size. For a 50K-token tool schema block, that's $0.625 per turn in write fees alone on Fable 5.1. Architecture fix: freeze tool schemas for the session lifetime and dynamically inject tool availability as a lightweight message rather than a schema update.

What LLM Cache Pricing Cost Per Turn Means for Your Stack

The pricing comparison page you bookmarked is measuring the wrong thing. Token rates are an input to the calculation, not the calculation itself. The number that actually governs your LLM infrastructure costs is LLM cache pricing cost per turn—and it depends on four variables that shift independently: the sticker rate, the cache hit rate, the context-length cliff position, and the acceptance rate on completions.

Concretely, here are the routing rules that fall out of this analysis:

1. Single-turn, short context: Use GPT-5.6 Luna or Gemini 3.8 Flash. Sticker price dominates. Cache economics are irrelevant at 1K-token inputs.
2. Document analysis with stable system prompt: Cache the system prompt on any provider. Even Claude Sonnet 5 at $2/1M cached becomes $0.20/1M—competitive with Luna on the prompt portion.
3. Agentic loops under 200K: Grok 4.6 at $2/1M input with $0.50/1M cache reads is competitive. Stay under 190K to avoid the cliff. Consider Kimi K3's $0.30/1M cache-hit rate as an alternative.
4. Agentic loops over 200K, high turn count: Claude Fable 5.1's $0.25/1M cache read and absence of a context surcharge makes it the defensible choice—if you instrument the cache correctly and keep your prefix stable.
5. Any workload with reasoning tokens: Budget output-token rates for every internal reasoning step. A loop that looks like $5/1M input is secretly paying $50/1M on the deliberation.

The sharpest take I'm willing to commit to: teams running Claude Fable 5.1 with a broken prefix—one dynamic field injected before the stable content—are paying $2.00/turn instead of $0.05/turn and blaming the model for the overrun. You didn't pick the wrong model. You didn't instrument the right one.

---