Route the Cache, Not the Price Sheet

TL;DR for operators

A higher-priced model can be the cheaper model to run. Under the September 2026 pricing assumptions examined by Abbasi, Aqrawi, and Kwartler, Fable 5.1 becomes cheaper than Opus 5 once a warm agentic turn reaches roughly 71,000 tokens of context at 18 tool steps, despite Fable’s higher ordinary input and output prices.¹

The reason is not model intelligence. It is cache economics. A coding agent may turn one user request into many model calls, each rereading much of the same conversation. Changing models can force that accumulated context to be written into a new model’s cache and, if the system later switches back, written again. The enterprise routing problem is therefore not “Which capable model has the lowest token price?” It is “At this point in this session, which route minimizes total expected cost without violating capability or governance constraints?”

The paper’s 10,000-seat emulation estimates monthly model spend falling from about $2.03 million to $1.76 million with its live classifier, a 13.4% reduction. Perfect routing labels produce a 20.8% ceiling. Those are simulation estimates, not observed production savings, and they move sharply when cache pricing, pauses, agentic intensity, or classifier behavior changes.

One user request is not one model request

Traditional model routing is often framed as a per-request choice: estimate the task’s difficulty, identify a sufficiently capable model, and send the request to the cheapest suitable option.

Coding agents change the unit of economics. A single user turn can trigger reasoning, tool calls, observations, more reasoning, and further tools. If there are $k$ tool steps, the turn contains $k+1$ model requests. Each request may reread a large conversation prefix.

A prompt cache stores that prefix so later requests can reread it at a discounted rate. Once that cache is warm, its economics become path dependent. Staying on the current model preserves cheap reads. Switching can require an expensive cold write of the accumulated context.

The paper formalizes the minimum cheaper stretch needed to justify such a switch:

Here, $R_{\mathrm{h}}$ and $R_{\mathrm{t}}$ are the home and target models’ cache-read prices, while $W_{\mathrm{t}}$ is the target-model cache write and $W_{\mathrm{h}}$ is the rewrite required if the conversation later returns home.

The arithmetic changes the routing question. A cheaper target model is not economical merely because its next request costs less. The cheaper run must last long enough to recover the cache migration cost.

Cache reads can reverse the price ranking

The paper’s most useful result is a price crossover that makes this mechanism concrete.

Using Anthropic’s 21 September 2026 prices and the paper’s warm-turn assumptions, Fable 5.1 becomes cheaper than Opus 5 at progressively smaller context sizes as tool activity increases:

More tool steps mean more repeated cache reads. Fable’s lower cache-read price can therefore outweigh its higher ordinary input and output prices.

The authors also reprice real Claude Code sessions token for token. Among sessions costing at least $100 on Opus 5, Fable is cheaper in 51% of TraceLab cases and 80% of SWE-chat cases.

That evidence supports the crossover mechanism, but not a general claim that Fable is cheaper. The result depends on session shape and September 2026 pricing. The paper’s own sensitivity test makes the boundary unusually clear: when cache-read prices are normalized to $0.1\times$ input price, the crossover disappears and modeled routing savings fall to roughly 6%.

For procurement teams, that means nominal input and output rates are incomplete contract-comparison variables. Cache reads, cache writes, cache lifetime, and typical tool-loop depth can materially change the effective cost ranking.

The router avoids rewriting conversations it already paid to build

Once switching has a migration cost, aggressive per-request routing becomes unattractive. The proposed architecture instead concentrates model changes where existing cache state is least valuable.

At session start, there is no warm conversation to destroy, so the router can right-size the model before context accumulates. At subagent launch, a new agent begins with fresh cache state, creating another comparatively clean routing point. Side lanes isolate bounded tasks without moving the main conversation wholesale.

Uncertain cases are held rather than automatically downgraded. On the authored catalogue, the classifier’s reported accuracies are 74% for action, 80% for domain, 63% for complexity, and 82% for history dependence. The policy holds 42% of routable turns in place; among turns that are moved, 12.5% are false downgrades.

That restraint matters because a bad downgrade can generate corrections, rework, and additional cache activity. In the sensitivity analysis, lowering the confidence threshold from 0.8 to 0.7 reduces estimated savings from 13.4% to 9.6%. More routing is not necessarily more economical routing.

The 13.4% result is a consequence of a particular workload

The headline enterprise experiment models 10,000 seats and about 301,000 sessions per month. The synthetic catalogue contains 46 conversations and 109 authored turns across 11 job types, expanded through Monte Carlo variants using behavior calibrated from about 10,000 public Claude Code sessions.

Under the base assumptions, monthly model spend falls from approximately $2.03 million to $1.76 million. Perfect labels reduce it to $1.61 million.

The sensitivity tests explain more than the headline percentage. With almost no pauses longer than five minutes, savings rise to 22.8%. With TraceLab-like pauses, they fall to 8.2%. A one-hour cache lifetime raises savings to 15.5%. Halving agentic intensity nearly eliminates the benefit at 0.3%, while doubling it raises estimated savings to 23.8%.

These are not secondary findings competing with the main result. They identify the conditions under which the main result is economically plausible.

Control of the harness becomes part of model procurement

Cognaptus’ business inference is that enterprises should treat the coding-agent harness as part of the cost and governance surface, rather than as a neutral interface over interchangeable models.

The paper’s audit of 21 harnesses shows substantial differences in model coupling, endpoint control, subagent configuration, skills and MCP support, and telemetry. A harness that cannot reach alternative endpoints can prevent an enterprise from exploiting a cheaper route even when its own session traces suggest one exists.

The proposed intermediate architecture is therefore a controlled layer behind existing harnesses: a gateway, routing policy, classifier, session state, governance floors, and aggregate telemetry. This preserves the employee-facing tool while moving decisions about model choice and policy into an enterprise control plane.

That is a narrower commitment than building an internal harness. It also keeps model choice contestable as prices, cache rules, and model capabilities change.

The estimate should be used as a diagnostic, not a budget promise

The evidence is substantial enough to justify measuring cache-aware session economics, but not to treat 13.4% as a transferable savings rate.

The enterprise deployment is emulated, not live. The task catalogue and ground-truth labels were authored by the researchers. Behavioral calibration comes from developer-focused Claude Code datasets. The engineering scenarios skew toward long, cache-heavy work, which favors the reported crossover. Public list prices may differ materially from enterprise contracts. Cross-vendor repricing assumes equal quality and token use. The full enforcement gateway and user-facing routing system were not deployed, and the simulator and scenario catalogue are not released.

The more defensible enterprise action is therefore to reproduce the accounting on internal traces: measure context size, tool steps, cache expiry, correction chains, subagent launches, and actual contracted cache prices. Only then does a routing policy have a credible cost surface to optimize.

Price the session before choosing the model

Agentic AI makes model cost path dependent. Every accumulated token of conversation state can become an asset when repeatedly read from cache or a liability when a model switch forces it to be rewritten.

That changes both FinOps and architecture. The relevant economic object is no longer a model’s advertised token rate but the cost of executing a session path under a particular harness, cache policy, and routing rule.

Enterprises do not need to own the entire harness to act on that insight. They do need enough control to observe session economics, preserve warm state when appropriate, choose models at cleaner boundaries, and keep vendor choice open.

Cognaptus: Automate the Present, Incubate the Future.