The AI Bill Your Vendor Is Quietly Setting For You
Your enterprise bought a harness. It came pre-configured with model defaults, subagent settings, and caching rules the vendor chose. You negotiated the price sheet. You got a discount on input tokens. You signed the contract and moved on.
What you did not negotiate is the thing that actually sets your bill.
The harness decides which model handles each turn, whether subagents inherit the parent session's model, how long the prompt cache lives, and whether side tasks get routed cheaply or dragged through a 800,000-token conversation history. The price sheet lists what a token costs. The harness decides which rate applies and how many tokens you buy at it. For a 10,000-seat enterprise, those harness defaults are currently costing between $3.3M and $5.0M a year in recoverable spend. The money is not going to the model. It is going to the vendor's design choices.
Researchers at Accenture Responsible AI published a paper in September 2026 that traces exactly where that money goes and builds a router to recover it. The system they describe, tested against approximately 10,000 real Claude Code sessions from two public corpora, recovers 13.8% of model spend with a live classifier and 21.1% with perfect labels, pricing everything against Anthropic's list prices of 21 September 2026. At 10,000 seats, that is $3.3M to $5.0M a year. The surprising finding is not how much is recoverable. It is where the saving actually comes from: three quarters of it comes from the top-priced model being cheaper than the next tier on long sessions.
Why Ranking Models by List Price Gets Long Sessions Exactly Wrong
Every routing system built before this paper made the same assumption: cheaper list price means cheaper session. Route simple work to the cheaper model, expensive work to the premium model, optimize per request. This is wrong for agentic coding sessions, and the paper proves it with arithmetic and then validates it against real sessions.
The mechanism is cache-read pricing. On long, tool-heavy sessions, the dominant cost is not input tokens. It is re-reading a conversation that has grown to hundreds of thousands of tokens, request after request, as the model calls tools and processes results. Fable 5.1, Anthropic's highest-priced model at $10 per million input tokens, reads cached tokens at $0.25 per million, a 0.025x multiplier. Opus 5, the next tier at $5 per million input tokens, reads cached tokens at $0.50 per million, a 0.1x multiplier. Fable 5.1's cache-read price is half of Opus 5's.
The crossover, the context size above which Fable 5.1 costs less per session than Opus 5, depends on how many tool steps the session runs:
| Tool steps per turn | Context size where Fable 5.1 becomes cheaper |
|---|---|
| 6 tool steps | 211k tokens |
| 12 tool steps | 105k tokens |
| 18 tool steps | 65k tokens |
Among real TraceLab sessions costing more than $100 on Opus 5, 51% were cheaper on Fable 5.1. Among SWE-chat sessions in the same band, 80% were cheaper on Fable 5.1. The top 1% of sessions carry 31 to 53% of total spend. A router that ranks models by list price sends the sessions that matter most to the wrong model every time.
What Breaks When You Try to Route Inside a Harness the Normal Way
The standard response to this finding would be: build a router. Route long sessions to Fable 5.1, short ones elsewhere. The problem is that existing routers, from RouteLLM to FrugalGPT to most open-source implementations, were designed for single requests. Inside a harness, routing works differently and the penalty for getting it wrong is severe.
A harness does not send one request. One user turn is many requests over a prompt cache that belongs to one model. That cache holds the entire conversation history, compressed and cached at the model endpoint. Move a running session to a different model mid-conversation and the new model has no cache. The entire conversation history must be written fresh, billed at write rates, before the new model can answer anything. The authors derived the exact formula for when a mid-task switch pays back. For Fable 5.1 switching to Sonnet 5 with a return, the answer is 291 subsequent requests. For a session without a return, 46 requests. Naive mid-session switching almost never earns back its cost on Fable-pinned sessions.
This is why the router they build acts only at cache-safe moments: session start, side lanes that run in a separate conversation seeded with a compact project ledger rather than the full transcript, and subagent launch where a fresh conversation begins. The rule is precise: never rewrite a running conversation's model. Route before the cache exists or after it ends.
The implication for the 20 harnesses the paper audited is uncomfortable: seven of them, including Claude Code, pass the parent session's model to subagents by default, meaning every subagent inherits whatever the parent is running on, regardless of whether that model is appropriate for the subagent's task.
The Classifier That Makes 1.3 Million Routing Decisions for $179 a Month
Routing at session start and subagent launch requires a fast, accurate classifier that labels every prompt before the model sees it. The paper builds the router around Jev, a structured classifier from TypeSafe AI that evaluates prompts against a bring-your-own taxonomy without generating text. It answers typed questions about the prompt's action, domain, complexity, and context dependence in a single parallel pass, producing calibrated probabilities per option.
In the paper's emulation of 10,000 seats with 301,000 sessions per month, Jev handled 1.3 million routing decisions at a total cost of approximately $179 per month. Speed was measured independently at a median of 420ms. Accuracy across the authors' taxonomy was 74% on action labels, 80% on domain, 82% on history dependence, and 63% on complexity. That 63% complexity accuracy matters: it is the source of most holds, cases where the classifier lacks sufficient confidence to make a routing decision and keeps the turn on its current model.
Holds are not failures by design. The paper is explicit: a hold forgoes a saving but risks nothing. A false downgrade, a turn sent to a model below the tier its complexity requires, triggers a correction chain. Corrections make up more than a third of the total bill in the emulation. A misrouted turn is corrected on the home model plus further corrections cascade from there. The classifier's confidence threshold of 0.8 in the base case held 42% of routable turns in place rather than risk moving them incorrectly. At threshold 0.9, the saving barely changed (14.2% vs 13.8%) while the false-downgrade risk fell further. The paper's phrase captures the asymmetry precisely: a wrong move costs quality and rework; a hold costs only money.
The gap between live-classifier performance and perfect labels, 13.8% vs 21.1%, represents $144,000 per month at the emulated scale. Two thirds of that gap comes from holds and one third from misroute corrections. Improving classifier accuracy on complexity labels is where future gains are concentrated.
The Pause Problem Nobody Is Accounting For
The single most underappreciated sensitivity in the paper is not the classifier. It is pauses.
When a user walks away from a session, the prompt cache expires. The 5-minute cache is the default for API and enterprise gateway configurations. The 1-hour cache is available for Claude Code subscriptions. When a user returns after the cache has expired, the full conversation history is re-read at write prices. In the SWE-chat corpus, 17% of user turns came after a pause of more than 5 minutes. In TraceLab, 27% did.
The saving without any pauses is 24%. With TraceLab-level pauses, it falls to 7.4%. Pauses matter as much as the classifier. Switching the default cache lifetime from 5 minutes to 1 hour adds 3 percentage points to the saving, from 13.8% to 17.1%, at no other cost. The paper calls this the cheapest default to change. It requires a configuration change at the API or gateway level, not an engineering project.
For enterprises planning a deployment: negotiating 1-hour cache lifetime into the harness configuration before rolling out to 10,000 seats is worth roughly $720,000 a year at the emulated spend level. It requires no router, no classifier, and no new infrastructure.
Where the $270,000 Monthly Saving Actually Comes From
The paper decomposes the monthly saving at today's classifier labels into its components. The numbers are specific enough to be operationally useful:
- Crossover: choosing Fable 5.1 over Opus 5 on long sessions where Fable is actually cheaper adds $211,000 in monthly savings
- Side lanes: routing bounded side tasks through a compact project ledger (~6,000 tokens) instead of the full conversation transcript adds $64,000
- Subagent launch routing: choosing the right model when a fresh subagent conversation begins adds $32,000
- Session right-sizing at start: choosing the correct model tier before any cache exists adds $28,000
- Turns correctly held in place: $7,000
- Misroutes and correction chains: subtract $51,000
- Router overhead, cache warm-up, ledger building: subtract $18,000
- Classifier cost: subtract approximately $179
The math closes at approximately $270,000 net monthly saving against $1.97M in baseline spend. Three quarters of the gross saving comes from the crossover result alone. Side lanes and subagent routing together account for most of the rest. Session right-sizing, which is where most naive router designs focus all their attention, contributes only 10% of the total gross saving.
The one-line code change scenario makes this concrete. A developer with an 805,000-token session open asks for a one-line edit. Pinned on Fable 5.1, that turn costs $0.88. Routed through a ledger side lane on Sonnet 5, with the ledger containing 6,000 tokens of project context instead of the full transcript, the same turn costs $0.36. That is a 59% reduction on a single turn. At scale, those single turns accumulate.
What the Sovereignty Ladder Means for Decisions You Are Making This Quarter
The paper introduces a four-rung framework it calls the sovereignty ladder. The framing is useful because it separates the immediate cost question from the longer strategic question of harness ownership.
Rung 0 is vendor defaults. No work to do, highest bill, least visibility. Most 10,000-seat enterprise deployments are here now. Rung 1 is configured: model defaults, subagent defaults, domain floors, and user override set per harness. No telemetry, no measurement, but governance floors established. This is a configuration exercise, not an engineering project. Rung 2 is controlled: gateway, session-start routing, side lanes via harness hooks, telemetry, policy floors, and taxonomy in place. This is where the 14 to 21% saving lives, and where the paper's router operates. It requires a small platform team, classifier hosting, and works-council or legal review of the routing policy in regulated jurisdictions. Rung 3 is owned: an internal harness on vendor SDK or open-source base, pluggable models, access to other vendors at session start.
The paper's explicit recommendation is Rungs 1 and 2 this quarter, not because ownership is wrong but because the decision about Rung 3 is a 1 to 2 year horizon and the configuration work at Rungs 1 and 2 is prerequisite to making that decision with real data rather than guessing.
The lock-in pricing analysis gives that decision stakes. The paper repriced real sessions against every major competitor's list prices as of 23 September 2026. DeepSeek V4 Pro runs at 12 to 14 cents for every dollar spent on Opus 5 on the same sessions. Kimi K2.6 at 25 to 27 cents. GPT-5.6 Sol, OpenAI's counterpart to Opus 5, at 80 cents. GPT-6 Astra, OpenAI's counterpart to Fable 5.1, costs 1.70 to 2.12 times what Fable 5.1 costs on the same sessions, because its cache-read prices are four times as expensive. The paper is careful to note these comparisons assume equal quality and identical token use across models, neither of which is guaranteed. But the range illustrates what the crossover result looks like in a world with more vendor optionality.
The harness is not neutral infrastructure. It is the mechanism through which a vendor's pricing structure and model defaults govern the majority of your agentic AI spend. The enterprises accepting those defaults now will be governed by them for most of the agentic work still to come. Moving to Rung 1 costs an afternoon. Staying at Rung 0 costs millions.
The Agents Applied team covers the research shaping how enterprises actually deploy AI at scale.