← Writing

AI economics · November 2026

The Agent Cost Curve

Why a 15-step AI agent costs more than 15 single prompts, and what to do about it.

In brief

Why agent costs surprise people

A common way to cost a multi-step AI agent is to take the price of one call to the model, multiply it by the number of steps, then by volume. In our worked example, a 15-step agent costs $1.51 per case. That's nearly three times the $0.56 you'd get by pricing each of its 15 AI calls on its own.

The same thing shows up in live deployments. ICONIQ's State of AI 2026 report describes one builder who budgeted an agentic workflow at $0.10 per run and saw it pass $1.50 as the agents retried and corrected themselves. It isn't a one-off: in a McKinsey survey, 93% of respondents report going over their AI budgets.

The gap comes from how a loosely built agent works, where the AI does every step. Anyone building or signing off a business case for an agent needs a working grasp of four concepts: three that push the cost up and one that brings it down. Here's a short summary of each, and the rest of the article covers them in detail.

  1. Token accumulation. Every time the agent goes back to the AI, it resends the case so far, so input costs grow much faster than the number of calls. In our example, doubling the calls more than triples them.
  2. Context window inflation. What fills the context, mostly tool results, drives both the bill and the quality of the model's reasoning.
  3. Cost multipliers in multi-call architectures. Sub-agents such as planners, critics and judges each add AI calls, and each call carries its own context.
  4. Designing for cost. Keep routine work in code, then use caching, lean tool results and model routing for the AI calls that remain. The Concept 4 section explains how each of these levers works.

The worked example: a reconciliation agent

To put numbers on the four concepts, we use one worked example throughout the article: an AI agent that clears reconciliation exceptions in a payments business.

The agent works one exception case at a time: a settlement line that didn't auto-match to the ledger. It queries the ledger and the PSP settlement file, tests candidate matches, and either proposes a match or flags the case for an analyst. In this first version the AI does everything, including the matching and the sums, over 15 AI calls. We come back to a better design in Concept 4. The numbers work the same way whether you build the agent yourself or buy it from a vendor. With a vendor, the token bill and the error rate sit inside the price per case.

The table below sets out what the model assumes. AI providers charge by the token, a chunk of text of roughly three-quarters of a word, and they price the tokens the AI reads (input) separately from the tokens it writes (output). The first five rows say how many tokens each part of a case takes: the fixed instructions and tool descriptions sent with every call, the case details, what the AI writes at each step, what each tool sends back, and the final answer. The next three rows give prices for a frontier model, a cheaper small model, and cached input. In the latter, each AI call in a run starts with the same text as the call before, so the provider can store that text and charge about a tenth of the normal input price to read it again. Storing it costs 25% more than the normal price, but only the first time. The last row is the monthly volume.

AssumptionValue
System prompt and tool definitions4,000 tokens
Case details at the start2,000 tokens
Model output per step (reasoning and tool call)300 tokens
Tool result per step (raw)1,500 tokens
Final answer500 tokens
Frontier tier price, per million tokens$5 input, $25 output
Small tier price, per million tokens$1 input, $5 output
Cached input10% of input price to read, 125% to write
Volume50,000 cases a month

The prices are illustrative, set roughly where frontier and small models from the main labs list today. Every figure in this article comes from this illustrative model unless a source is named.

Concept 1: Token accumulation

An AI model keeps nothing between calls. Every time the agent goes back to the AI, it sends the run so far: the system prompt, the tool definitions, the case, and every earlier step and tool result. In our loosely built agent, call 10 pays for calls 1 to 9 again. Hence the input bill grows much faster than the number of calls. Double the calls and the input bill more than triples, from 279,000 to about 963,000 tokens.

Every call to the AI resends the run: 15 calls cost $1.51 against $0.56 priced one by one

Cumulative cost of one case in a loosely built agent, frontier tier, no caching (US dollars). ScalePoint worked example, illustrative assumptions in the table above.

$0.00$0.50$1.00$1.50151015AI call in the run$0.56 if each callwere priced on its ownCall 1: $0.04 so farCall 2: $0.08 so farCall 3: $0.14 so farCall 4: $0.20 so farCall 5: $0.28 so farCall 6: $0.36 so farCall 7: $0.45 so farCall 8: $0.55 so farCall 9: $0.66 so farCall 10: $0.78 so farCall 11: $0.91 so farCall 12: $1.04 so farCall 13: $1.19 so farCall 14: $1.34 so farCall 15: $1.51 so far$1.51 agent run

The first call sends 6,000 tokens. By call 15 the AI is reading 31,200. Over the run it reads 279,000 input tokens, against 90,000 if each call started from scratch. Mastercard's September 2026 white paper, The New Economics of AI, describes the same mechanism and cites Gartner's estimate that agentic systems use 5 to 30 times more tokens per task than a standard chatbot.

Concept 2: Context window inflation

By call 15 the AI reads 31,200 tokens, and 21,000 of them are old tool results the agent looked at once and never needed again. That old data costs money, and it also makes the AI less accurate. Models reason less reliably over long, noisy contexts, and the one settlement reference that matters gets buried. The reliability section shows why the lost accuracy costs more than the extra tokens.

Concept 3: Cost multipliers in multi-call architectures

Many designs add AI calls around the main loop to improve quality, and each new call carries a context of its own.

Architecture (frontier tier, no caching)Cost per caseVersus single agent
Single agent, 15 calls$1.511.0x
Add an LLM judge to check the final answer$1.681.1x
Orchestrator plus three sub-agents$2.491.6x
Self-critique after every step$3.142.1x

A judge at the end adds one call. Self-critique doubles the calls and leaves its comments in the context for every later step. Each of these has to earn its multiple through better accuracy, and only testing shows whether it does.

Concept 4: Designing for cost

The biggest design choice is what goes to the AI at all. A sounder design splits the work three ways: code establishes the facts, the AI makes the judgement calls, and a person signs off. AWS describes this pattern in its write-up of a multi-agent KYC and KYB system, where code does the registry lookups and sanctions list checks and the AI only judges questions like whether a sanctions match is real.

In our reconciliation case, code would do the exact amount and reference matching, the sums and the lookups, and only the cases code can't settle would go to the AI. Teams choose this design for reliability, checkability and accountability. Lower cost is a side effect: fewer AI calls per case means less for the AI to re-read on each one.

This is also why the token bill can be close to nothing in a well-built system. In ScalePoint's onboarding and KYC review demo, code runs the checks and makes the decision, the AI is called twice per case, once to read the documents and once to draft the email, and the default volumes are those of an FX firm with around $130m of revenue, roughly 630 cases a month. Over three years the model costs about $2,300, at around 11 cents a case, against $1.65m of staff time on today's process, so the cost that matters is staff time and errors, which is where the reliability section below ends up. Even at ten times that, for example from reading scanned documents as images or retrying failed calls, the model would be under 3% of the cost.

For the AI calls that remain, three standard techniques cut the token bill of our loosely built agent by almost 90%, from $1.51 to $0.17 a case. Each one adds to the one before.

Set-upToken cost per caseInput tokens per caseMonthly token bill (50,000 cases)
A. Baseline: frontier model, no caching$1.51279,000$75,600
B. Add prompt caching$0.44279,000$21,800
C. Add trimmed tool results (1,500 down to 400 tokens)$0.29163,500$14,500
D. Add model routing (small model for 13 of 15 calls)$0.17163,500$8,600

Prompt caching does the most work. The start of every AI call repeats the previous call word for word, so the provider can store it and charge about a tenth of the normal input price to read it again. Caching only works if the start of the prompt stays identical, so a timestamp in the system prompt breaks it.

Trimming tool results shrinks the context itself. A raw ledger query might return 40 rows with every field, when the agent needs five candidate matches and four fields. Cutting each result to 400 tokens removes 40% of the input tokens.

Model routing hands the routine AI steps to a small model and keeps the frontier model for planning the case and checking the answer. On price alone, routing is the biggest saving left after caching.

Compaction, which summarises older steps once a run gets long, and step caps, which hand a looping run to a person, also belong in any design review.

Mastercard's paper reaches a similar conclusion. Its illustrative "AI Virtual CFO" example costs about $105,000 a month with a cost-unaware design and about $23,000 with routing, context control and selective orchestration, so the careless version costs roughly 4.5 times as much.

What failures do to the cost per case

So far we've only looked at the token bill, which leaves out what happens when the agent gets a case wrong. Set-up D is the cheapest on tokens because it hands most steps to a small model, and small models make more mistakes. Once each failed case goes to an analyst, set-up D costs $5.28 per case, more than twice set-up C at $2.39. Hence the number that matters is cost per correctly handled case. DoiT's Cost Per Task framework takes the same view, folding success rate, retries and undetected failures into one number per completed task. McKinsey finds that about 60% of an agentic task's cost goes on checking, repairing and re-verifying answers.

Reliability compounds over a run. If each step is right 99% of the time, a 15-step run gets the whole case right 86% of the time (0.99 to the power of 15). Drop the routine steps to 97% and the run succeeds only 66% of the time. 97% is a guess for a small model on structured finance data, so the second table below shows a range. In this example every failed case goes to an analyst, at $15 a case (20 minutes at $45 an hour).

Set-upCases handled correctlyToken cost per caseAll-in cost per caseMonthly all-in (50,000 cases)
A. Baseline86%$1.51$3.61$180,600
B. Add prompt caching86%$0.44$2.54$126,800
C. Add trimmed tool results86%$0.29$2.39$119,500
D. Add model routing66%$0.17$5.28$263,900

Set-up D's result depends heavily on that guess. Here it is from 95% to 99% per routine step, against $2.39 for set-up C.

Small model accuracy per stepCases handled correctlyAll-in cost per case, set-up D
95%50%$7.62
96%58%$6.52
97%66%$5.28
98%75%$3.86
99%86%$2.27

Routing only pays when the small model is almost as good as the frontier model on the steps it takes over. Here it breaks even at about 98.9% accuracy per step, which you can only find out by testing on your own cases. Our research tests how accurate models are on payments finance tasks, so this figure can come from a test.

A wrong match posted to the ledger without a flag would make this worse, since it costs far more than $15 to find and fix later.

What to ask before you sign off

Most vendors quote a price per case or per outcome, so you won't see the token bill. These five questions get at what sits behind that price, and they work just as well for an internal team.

  1. How many cases come back to your team to fix? Add the checking time on the ones that pass, and you have a cost per correctly handled case. In McKinsey's banking customer service example, human oversight is 70 to 75% of variable run costs and tokens are 20 to 25%.
  2. What does the agent do in code, and what does it leave to the AI? Matching, sums and lookups belong in code. If the AI does them, expect higher cost and more errors.
  3. How many AI calls does a typical case take? Every call re-reads what came before.
  4. Is it using prompt caching? Caching cut the bill by 71% here with no change to what the agent does.
  5. If it routes steps to a smaller model, where's the test? Ask for results on cases like yours.

Closing

Agents are worth building for many payments and finance tasks. The economics hold up when they're modelled the way agents actually run: call by call, with routine work in code, with measured accuracy, and with the cost of failures in the same number. A business case built on a single call price will be wrong on cost and on payback.

ScalePoint's AI Economics engagement applies this method to live and planned AI systems: what they cost per correctly handled case, what they've returned, and what to tell the board. More under Services.

Sources

Further reading: El-Ramly, ACEM: a cost estimation model for agentic software engineering, which splits agent cost into tokens, human review and infrastructure.

Last reviewed 17 November 2026.

Related pieces:

martin@scalepointpartners.com