Nobody Priced the Default Settings: the Product That Runs Your Coding Agents Is Choosing Your Model Bill

Your engineers chose their coding agents. Nobody chose the settings those agents run on — and those settings decide which model answers, how much of the conversation gets re-sent at full price, and how many subagents launch behind a single keystroke. An Accenture Responsible AI preprint repriced about 10,000 real agent sessions from public datasets and found that moving work to the cheapest capable model, without disturbing any conversation in progress, recovers 13 to 21% of agentic model spend (Kwartler, Aqrawi and Abbasi, 2026).

The transferable figure is not the percentage. It is the denominator underneath it: $41 per engineer per active day.

The Product Running Your Coding Agents Is a Procurement Decision Nobody Made

The paper's term for the product that runs an agent is the harness — Claude Code, Codex, and nineteen others the authors map across a coupling matrix built from licence files and configuration documents. Almost no enterprise builds one. They adopt whatever the model vendor bundles with the seats, at defaults.

That is where the money is decided. A harness picks which model answers a given turn, how much context that model reads, how the prompt cache is used, and which subagents run. In the authors' framing, it therefore picks the rate on the price sheet and sets the volume bought at it. Both halves of the bill, chosen by a configuration file nobody reviewed.

Compare that to how the same organisation treats a €30,000 software line item: a vendor review, a security questionnaire, a named owner. The agent harness arrived through a developer-tools budget and now moves a number an order of magnitude larger, with no owner at all.

What the Repricing Found

The authors built a router, placed it between the harness and the model endpoint, and emulated a 10,000-seat enterprise using behaviour measured in real sessions — corrections, pauses and subagent launches included.

Read the range carefully, because it is not a confidence interval. The $3.3M is what the authors' live classifier actually delivers; the $5.1M is what a perfect classifier would deliver. The gap between those two numbers is the quality of your routing decisions, not statistical noise.

One line in their results makes the mechanism concrete: a one-line change inside a long coding session falls from $0.90 to $0.36. Not because the model got cheaper. Because the request stopped dragging an entire conversation behind it.

A Third of the Bill Is Rework, Not Work

The finding most likely to survive repricing at your own company has nothing to do with routing.

In the emulation, corrections — the turns where someone tells the agent it got it wrong and it tries again — account for more than a third of the as-is bill. Strip them out and the monthly spend drops from $2.03M to $1.31M. Corrections are also the single most common reason people interrupt a coding agent at all, 32% of interruptions in the vendor sample the authors cite.

This is the same shape as the agent cost finding from McKinsey's QuantumBlack earlier in the year: for a banking customer-service agent, token costs are 20 to 25% of an agent's variable run cost, while human oversight is 70 to 75% (McKinsey QuantumBlack, 2026). Different workload, different method, same conclusion: the expensive part of an agent is the part where a human has to go back over its output.

There is a quality signal pointing the same way. GitClear's analysis of 623 million code changes between 2023 and 2026 found block duplication up 81%, within-commit copy-paste up 41%, error-masking constructs up 47%, and refactoring line moves down 70% (GitClear, 2026). Their coinage for the result is worth borrowing: perpetual V1 components — code that ships and is never consolidated, because nobody refactors what an agent can regenerate.

Rework you pay for twice: once on the invoice, once in the codebase.

Per-Token Price Is Not Per-Task Cost

The crossover result is the counterintuitive one, and it is the one that breaks the instinct every cost-conscious ops lead has.

On long, tool-heavy sessions, the highest-priced model costs less per session than the tier below it — in 51 to 80% of the real sessions costing $100 or more. The mechanism is caching: a top-tier model that reads cached context at half the rate of the tier below it wins on any session that re-reads its history enough times, and agentic work re-reads constantly. The paper is blunt about the dependency: strip out the top model and the whole saving collapses from 13% to 3.1%, because the crossover needs it.

So "we moved everyone to the cheap model" is not a cost programme. It is a bet that your sessions are short.

The Cache Is the Hidden Meter

Three configuration details in the paper are worth more to a 200-FTE company than the headline percentage.

First, cache lifetime. A coding agent's cache survives an hour on a consumer subscription but five minutes on API keys and cloud providers — which is exactly how an enterprise gateway connects. Anthropic documents both options, and prices the one-hour cache at 2× base input tokens on writes (Anthropic, 2026). In two public corpora of real sessions, 17 to 27% of user turns arrived after a pause longer than five minutes. Every one of those turns rebuilds the cache from cold at full price. The longer TTL is not free, but it is almost certainly cheaper than what the default is doing to you.

Second, the gateway itself. If the proxy between the harness and the model strips cache markers or beta headers, the provider bills the entire conversation as uncached input on every single turn. That is a silent, total loss of caching, caused by a correctly-functioning piece of network infrastructure.

Third, context defaults by role. Ten thousand cold returns to a 300,000-token history cost $18,750 just to re-send it; pruning that history to 30,000 tokens first costs $1,875. An engineer mid-task may genuinely need the full history. A marketer revising a draft does not need the reasoning behind the previous version. One threshold for everyone is a pricing decision disguised as a default.

The Honest Counter

Four limits, stated plainly.

This is a preprint, and the version matters. arXiv 2609.28919 was posted on 24 September 2026 and revised on 26 September. The revision moved the headline from 14-21% to 13-21%, the saving from $5.0M to $5.1M, and retitled the paper. It has not completed peer review. If you have seen the earlier figures quoted elsewhere, they are the v1 numbers.

It is an emulation, not an audited invoice. The authors model a 10,000-seat enterprise using behaviour drawn from public session corpora, not one company's bill. They are candid that their scenarios under-represent the shortest turns — a quarter of real requests sit in sessions of fewer than seven requests, against 3.8% of theirs — and that sessions shaped like one of their reference corpora would bring the 13% down to about 9%.

The arithmetic is pinned to one price sheet. Everything rests on Anthropic's list prices of 21 September 2026. Under a flat cache-read regime, the crossover disappears and the saving falls to 6%. Providers reprice at short notice. What transfers is the method, not the number.

The routing itself is imperfect. The classifier gets complexity right only 63% of the time, and 12.5% of the turns it moved were false downgrades sent below the tier the work required. Loosening its threshold from 0.8 to 0.5 moves 46% more turns and drops the saving to 10%, because the correction chains cost more than the moves save. Aggressive routing is how you buy rework.

And the broadest caution: if token cost really is a quarter of an agent's variable run cost, then recovering 13 to 21% of the token line is recovering something like 3 to 5% of what the agent actually costs you. Worth having. Not a strategy.

What to Change This Quarter

Four moves. None of them is a purchase, and only one of them is technical.

1. Pull the per-engineer-per-active-day number off your own invoice. That is the whole exercise. At the emulation's $41, thirty engineers across roughly 220 active days is near $271,000 a year; at the vendor's reported average of about $13, it is near $86,000 — my arithmetic on their unit, not their finding, and the spread is exactly why you measure instead of assuming.
2. Give harness configuration a named owner, at the same level as any other spend of that size. Right now the defaults are owned by whoever shipped them.
3. Check three settings before you consider routing: cache TTL, whether your gateway forwards cache markers unchanged, and whether context limits differ by role. The paper's own recommendation order puts these before any router, because a router behind a cache-stripping gateway saves nothing.
4. Change the metric from cost per token or cost per seat to cost per verified task — the unit that includes the correction chain. It is the authors' closing recommendation and it is the only number that moves when the work actually gets better rather than cheaper.

That last one is harder than it sounds, because it requires the cost of a piece of agent work and the record of whether a human accepted it to live in the same place. Worth looking at how Scovai structures that on its Digital Employees surface: three sources of cost kept deliberately separate — what you pay on the invoice, what the platform's own counters measure, and what the provider declares — with monthly and per-transaction ceilings attached to the seat rather than to the tool, and a stated rule that where a number does not exist the surface says so instead of printing a zero.

The uncomfortable conclusion of this paper is that the largest variable technology cost most companies will add this decade is currently being set by a configuration file that arrived with a developer tool. Not by a vendor negotiation, not by a budget, not by anyone's decision.

So find out, before the quarter closes, what your coding agents actually cost per engineer per active day — and who, by name, is allowed to change the settings that decide it. If the answer to the second question is nobody, you have located the problem, and it was never the price per token.