TL;DR.
On November 10, Reuters reported that banks are trying to rein in the cost of AI agents, because spending on the tokens that run them could easily reach 20% of total labor costs, according to McKinsey's Global Banking Annual Review. Some banks have moved the bill to new teams they call AI FinOps. McKinsey senior partner Vik Sohoni said the first fix, routing employees to different models by the complexity of their query, stops working once agents are involved, because they "communicate with each other" and the tokens quickly add up.
Two days later, Reuters reported a Capgemini study of 500 executives at companies above $1 billion in revenue: 59% said AI spending over the past year came in significantly above budget, by 24% on average, and 59% plan to use more open-weight models to cap the bill.
Sohoni is right about the symptom. The diagnosis is narrower than "routing doesn't work for agents":
- They routed the wrong unit. Classifying the employee's question once decides the model for every agent call that follows. In an agent mesh, the question is one call. The case is eleven.
- The model isn't what grows. The payload is. When each agent hands the next one the full shared transcript, the last call of a case reads nearly 12x more input than the first, and every review round between two agents costs more than the one before.
- On one illustrative 11-call card-dispute case, routing once at the front door costs $1.248. Routing every call costs $0.676. Routing every call and handing off a 1,500-token state object instead of the transcript costs $0.194, 84% less. At 100,000 cases a month that's $124,800 against $19,406.
Below: the numbers, three charts, the four changes that make routing work inside an agent mesh, and meshbill.py, 45 lines that price your own agent trace three ways.
McKinsey, Capgemini and SAP figures are as reported by Reuters on November 10 and 12, 2026. Prices are Anthropic list prices as of November 12, 2026. The card-dispute case, its hop sizes and the tier each hop needs are illustrative assumptions, not bank data and not Nadir customer data.
What the two reports say.
| Report | Date | Number | What it measures |
|---|---|---|---|
| McKinsey, Global Banking Annual Review | Nov 10 | Token spend could reach 20% of labor costs | A projection for banks, not measured spend |
| McKinsey customer survey (46,000 people) | Nov 10 | 72% of AI users would let an agent do one banking task | Most would cap autonomous approvals at $500 |
| Capgemini, 500 executives, 10 countries | Nov 12 | 59% overshot AI budgets, by 24% on average | Self-reported, past 12 months |
| Capgemini, same study | Nov 12 | 53% worried about AI costs, up from 45% | Year-over-year sentiment |
| Capgemini, citing OpenRouter | Nov 12 | Open-weight models: 72% of traffic, 27% of spend | September 2026 |
Three things stand out.
The 20% is a ratio to payroll, not to IT. That's the comparison an AI FinOps team will actually be asked to defend. Token spend that used to be a line inside a cloud bill is now being measured against the people whose work the agents do.
The cost controls moved from engineering to finance. "AI FinOps" means someone outside the team that built the agents now owns the number. That team will ask for a cost per case, not a cost per token. If your traces can't produce one, the chargeback tutorial is the place to start.
The open-weight number is a routing number. 72% of traffic for 27% of spend means most requests already go to a cheaper model and the expensive ones stay expensive. Half of Capgemini's respondents said they'd keep closed models where the task needs them. SAP's finance chief said last month the company is replacing its costliest models with cheaper ones "where performance held up." That's per-task model choice, described by finance. We broke down the same split in The 71/23 Split and the bank version in Route Like a Bank.
Why front-door routing breaks.
The first wave of bank routing looked like this: an employee types a question, a classifier labels it simple or complex, and the question goes to a small model or a frontier one. For a chat assistant that's the whole job. One question, one call, one model.
An agent mesh doesn't work that way. Take a card dispute, the kind of case a retail bank handles thousands of times a day. An orchestrator plans it. An intake agent classifies it. A transaction agent searches the ledger. A policy agent retrieves the chargeback rules. A fraud agent scores the signals. A drafter writes the customer letter. A compliance agent reviews it, sends it back once, and reviews it again. The orchestrator closes the case.
That's eleven model calls. The employee's question was "is this dispute valid?", which reads as complex, so a front-door router sends it to the frontier model, and every one of the eleven calls inherits that decision. Classifying a dispute type doesn't need Opus 5.5. Neither does scanning 8,000 tokens of ledger rows. The compliance review might.
And each handoff passes along everything that came before:
This is what "tokens quickly add up" looks like on a trace. By the fourth call, every agent reads the ledger rows and the policy text whether it needs them or not. The drafter reads 12,000 tokens of chargeback rules to write a 1,200-token letter. The compliance agent reads 8,000 tokens of transactions to check the letter's tone. Under the full transcript, the case reads 273,000 input tokens to produce 7,800 output tokens.
Three bills for the same case.
We priced the same eleven calls three ways, with Anthropic's tiers as the example: Haiku 5.5 at $0.10/$0.50 per million tokens, Sonnet 5.5 at $2/$10, Opus 5.5 at $4/$20.
| Architecture | Input tokens | Cost per case | 100,000 cases/month |
|---|---|---|---|
| Route once at the front door (all Opus 5.5) | 273,000 | $1.248 | $124,800 |
| Route every call, forward the transcript | 273,000 | $0.676 | $67,592 |
| Route every call, hand off a state object | 69,100 | $0.194 | $19,406 |
Routing per call does what it should. Three calls drop to Haiku 5.5, six to Sonnet 5.5, and the bill falls 46%. But the two frontier compliance calls still read 34K and 36K tokens of transcript, and those two calls alone are 45% of the per-call bill. Per-call routing makes each token cheaper. It doesn't make there be fewer of them.
Cutting the payload is the other 38 points. With a structured state object (case ID, dispute type, the five transactions that matter, the policy clause that applies, the draft, the open questions) capped at 1,500 tokens, the compliance review reads 5,500 tokens instead of 33,800, and costs $0.036 instead of $0.149.
So McKinsey's observation holds for the routing banks built first. Routing by the employee's question can't see the eleven calls behind it, and routing by call can't shrink a payload that grows on every handoff. You need both.
Agents that talk back.
Sohoni's phrase was "communicate with each other." The expensive version of that is a loop: a drafter and a reviewer going back and forth until the reviewer approves.
With the transcript forwarded, every round adds a round's worth of text that every later call has to read, so the third round costs more than the second and the sixth costs more than the fifth. In our case each extra round adds $0.32 to $0.38 at the front door and $0.24 to $0.28 routed per call. With a state object, each round adds the same $0.055, and the line stays straight.
That's the property an AI FinOps team needs. A case that loops six times should cost about six rounds, not a curve, and a stopping rule is only cheap to enforce when the rounds are priced linearly.
Four changes that make routing work in a mesh.
1. Route each call, not each person. The unit is the model call, and the signal is the call's own job: the system prompt, the tool output it's reading, what it's asked to produce. An intake agent labeling a dispute is a small-model call no matter who asked. A compliance review isn't. With Nadir, every agent points at the same endpoint and sends model="auto":
from openai import OpenAI
nadir = OpenAI(base_url="https://api.getnadir.com/v1", api_key="ndr_...")
def call_agent(agent, state, tool_output=""):
# one routing decision per agent call, made on this call's prompt
return nadir.chat.completions.create(
model="auto",
messages=[
{"role": "system", "content": agent.system_prompt},
{"role": "user", "content": render_state(state) + tool_output},
],
extra_headers={
"X-Nadir-Use-Case": "card-dispute",
"X-Nadir-Tags": f"case:{state['case_id']},agent:{agent.name}",
},
)The tags are what the FinOps team asks for later. X-Nadir-Use-Case and X-Nadir-Tags ride along with every request, so cost per case and cost per agent come out of the request log instead of a spreadsheet. A tag per case ID is high-cardinality, so if you run millions of cases, tag the agent and the workflow and keep the case ID in your own trace.
2. Hand off state, not transcripts. Give each agent a typed state object with a token cap, and let each agent write its findings into named fields instead of appending prose. Raw tool output belongs to the agent that called the tool. The next agent gets the five rows that mattered, not 8,000 tokens of ledger. This is the same idea as masking old tool output inside one agent, applied across agents, and it's what the A2A post means by capping history.
3. Budget the case, not the month. A monthly cap trips on the 24th and stops everything, including the cases that make money. A per-case budget, checked before each call, degrades one runaway case: route its remaining calls one tier down, or hand it to a person. Budget Bankruptcy has the pacing math, and the $500M bill has the case against caps alone.
4. Keep a session on one model when the cache is warm. Per-call routing has a cost of its own. An agent that re-reads a long, cached prefix on every turn loses the cache when you switch it to a different model. Route at the start of an agent's work, not between turns of a cached loop. We priced the trade-off in the switch penalty.
Price your own mesh.
meshbill.py takes a list of agent calls and prices them three ways. Replace HOPS with one real case from your traces: the agent, its system and tool-schema tokens, the fresh tool output it read, its output tokens, and the cheapest tier you'd trust with it.
"""meshbill.py: price one agent-mesh case three ways.
entry - route once at the front door, every call on the top tier, full transcript
perhop - route each call to the tier its job needs, full transcript
handoff - route each call, pass a capped state object instead of the transcript
List prices, $ per million tokens, uncached.
"""
PRICE = {"small": (0.10, 0.50), "mid": (2.00, 10.00), "frontier": (4.00, 20.00)}
HOPS = [ # (agent, system+tools tokens, fresh tool tokens, output tokens, tier)
("orchestrator: plan", 3000, 0, 600, "mid"),
("intake: classify dispute", 2000, 1000, 300, "small"),
("transactions: search", 2500, 8000, 800, "small"),
("policy: retrieve rules", 2500, 12000, 1000, "mid"),
("fraud: score signals", 2000, 4000, 400, "small"),
("orchestrator: re-plan", 3000, 0, 500, "mid"),
("drafter: customer letter", 2000, 0, 1200, "mid"),
("compliance: review", 4000, 0, 700, "frontier"),
("drafter: revise letter", 2000, 0, 1200, "mid"),
("compliance: re-review", 4000, 0, 700, "frontier"),
("orchestrator: close case", 3000, 0, 400, "mid"),
]
STATE_CAP = 1500 # tokens in the handoff object
CASES = 100_000 # per month
def run(mode, hops=HOPS):
transcript, total, tokens_in = 0, 0.0, 0
for _, sys_t, tool_t, out_t, tier in hops:
tier = "frontier" if mode == "entry" else tier
carried = min(transcript, STATE_CAP) if mode == "handoff" else transcript
inp = sys_t + carried + tool_t
pi, po = PRICE[tier]
total += (inp * pi + out_t * po) / 1e6
tokens_in += inp
transcript += tool_t + out_t # what the next agent gets handed
return total, tokens_in
for mode in ("entry", "perhop", "handoff"):
cost, tin = run(mode)
print(f"{mode:8s} in {tin:8,d} ${cost:.3f}/case ${cost * CASES:>10,.0f}/month")Output on the illustrative case:
entry in 273,000 $1.248/case $ 124,800/month
perhop in 273,000 $0.676/case $ 67,592/month
handoff in 69,100 $0.194/case $ 19,406/monthWhat it leaves out, on purpose:
- Prompt caching. An agent that re-reads its own growing context can cache it, and that narrows the gap for the orchestrator. It doesn't help much at handoffs: each receiving agent has its own system prompt, so the forwarded transcript lands after a different prefix and bills as fresh input. Price your cache hit rate per agent, not per case.
- Quality. A state object that drops the one transaction compliance needed turns a cheap case into a rework. Test the handoff schema on real cases before you cap it, and log which fields each agent actually reads.
- Failures and escalations. A small-model call that fails and retries on a bigger one costs both. The retry tax has the math.
- Labor. We price tokens, not the analyst who reviews the case. The 20% figure compares those two, and only your own handling-time data can say which side moved.
What to do this quarter.
- Pick one high-volume agent workflow and pull 50 complete traces. Count calls per case, input tokens per call, and how many of those tokens were forwarded from an earlier agent.
- Run meshbill.py on the median and the p95 case. If forwarded tokens are under a third of input, routing per call is your main lever. If they're over half, fix the handoff first.
- Label each agent with the cheapest tier you'd trust. Then let a router check that label call by call, because the same agent gets easy and hard inputs.
- Tag every call with a case ID and an agent name before the AI FinOps team asks. Cost per resolved case is the number they'll put next to labor cost.
- Set a per-case budget and decide in advance what happens when a case hits it: one tier down, or a person.
Where Nadir fits.
Nadir routes per request, which in an agent mesh means per agent call. Point every agent at the same base URL with model="auto" and the classifier reads each call's own prompt and picks from the models you've configured, against the quality floor you set on the key. An intake call and a compliance call from the same case can go to different models, and each response reports which model served it and what it cost.
If you'd rather keep your agents calling providers directly, POST /v1/bucket returns simple, medium or complex for a prompt, and your orchestrator picks the model. Observe mode serves exactly the model you asked for and records what Nadir would have picked, so a week of it shows what per-call routing would do to your traces before it changes a single response.
Nadir doesn't redesign your handoffs. Changes 2 and 3 above are yours to make, and in our illustrative case they're the larger share of the saving.
On the hosted gateway with your own provider keys, the provider bills you directly and Nadir charges a flat $0.002 per request, with the first 50 requests a month free. In the case above that's $0.022 per case, eleven calls, which is worth checking against your own per-call costs. Savings depend on your workload, and nothing in this post forecasts yours.
Start with a free key or estimate your savings from your current model spend.
Conclusion.
McKinsey's 20% is a projection, and Capgemini's 24% overrun is self-reported. The direction is consistent, though, and the reason Sohoni gave is the right one: agents talk to each other, and every exchange gets billed. What failed was routing the employee's question once, then forwarding every token to every agent. Route the call. Hand off state, not the transcript. Budget the case. On one illustrative dispute, that's the difference between $1.25 and $0.19, and between a cost curve that bends upward with every review round and one that stays a straight line.
Sources: [Reuters via Zawya, "Banks seek to rein in soaring AI agent costs, McKinsey says"](https://www.zawya.com/en/world/banks-seek-to-rein-in-soaring-ai-agent-costs-mckinsey-says-2169978), Tatiana Bautzer, November 10, 2026: the 20% of labor costs projection, AI FinOps teams, Vik Sohoni's quote, the 46,000-customer survey, 72% and the $500 approval cap. [Euronext republication](https://live.euronext.com/en/financial-news/banks-seek-rein-soaring-ai-agent-costs-mckinsey-says) and [Finimize, "Banks Are Putting AI Agents On A Token Budget"](https://finimize.com/content/banks-are-putting-ai-agents-on-a-token-budget). [Reuters via Global Banking & Finance Review, "Most large firms plan higher open-weight AI use to cap bills, study shows"](https://www.globalbankingandfinance.com/large-firms-plan-higher-open-weight-ai-use-cap-bills-study/), Leo Marchandon, November 12, 2026: the Capgemini survey figures, OpenRouter traffic and spend shares, and SAP's comment. Anthropic list prices for Haiku 5.5, Sonnet 5.5 and Opus 5.5 as of November 12, 2026. The card-dispute case, hop sizes, tier labels and the 1,500-token state cap are our illustrative assumptions.