Why Do AI Agents Cost So Much on Repeat Tasks?
Repeat tasks stay expensive because the agent re-thinks the plan on every run. A Compiled Agent Model learns the task once and reuses it.
AI agents cost so much on repeat tasks because each run pays to think the task through again. The invoice, the schedule change, or the support ticket may share its shape with the last one, but the agent still reads the request, reasons about the plan, calls tools, reads what comes back, and reasons again. That spend lands in input tokens, reasoning tokens, tool-call loops, and the latency of the loop. A Compiled Agent Model learns a task once, reuses the plan when the same task returns with different values, and sends anything new to a frontier model.
Most of that cost is AI agent decision making: working out the same plan, step by step, on every run.
Where does the money go in AI agent decision making?
The money in that decision making goes to input tokens, reasoning tokens, tool-call loops, and latency.
Input tokens are what the agent reads before it can act: the standing instructions, the list of tools, the record in front of it, and whatever earlier steps in the same run wrote down. On a repeat, much of that reading is the same kind of material as last time. The values in today's record are new. The instructions around them often are not.
Reasoning tokens are the model working out the plan in its own words. Which field matters. Which tool comes next. What a mismatch means. When the result is done. On a task the agent has already completed, that walk is often the same walk as last time. It is still generated, and it is still billed, because the model is producing it again rather than picking up a plan it already has.
Tool-call loops multiply both. An agent rarely finishes in a single step. It chooses a tool, waits, reads the result, decides again, and calls another tool. Each lap adds input and adds reasoning. The cost is that chain, not the last sentence.
Latency is the part a person feels. Tokens are the money. Waiting is the time. The run is slow because the model is re-deciding the route, not because today's amount or today's date is hard to read.
A repeat run is expensive when the agent treats a familiar task as a fresh puzzle. The values change. The plan does not. The bill is mostly the plan.
Doesn't prompt caching fix this?
No. Prompt caching cuts the cost of re-reading. It does not cut the cost of re-thinking.
Caching helps when the same instructions, the same tool list, or the same standing context show up again. The provider can skip some of the work of reading that prefix, so the input side gets cheaper. Long instructions and a stable tool list should not be full price on every call.
What caching does not store is the decision the model reached. It does not store which tool to call on an invoice, how to line that invoice up with a ledger record, or when a mismatch should be flagged instead of posted. The next run still produces the reasoning, still makes the tool calls, and still waits on each result. You saved a re-read and paid for a re-think.
That is why a workload can have caching on and still look costly on tasks that repeat all day. Treat caching as a discount on reading. The plan is the part that repeats, and caching never learned the plan.
How do you tell if your workload repeats?
Your workload repeats when the task shape stays the same and the values change.
Look at the jobs an agent already does in a loop. An invoice comes in. The vendor, the amount, the date, and the line items differ from the last invoice. The job is still the same job: read the invoice, match it to a record, flag what does not match, and write the result. Scheduling has the same pattern. The person, the time, and the room change. The job is still: find a slot that works and confirm it. Support triage has the same pattern. The customer and the wording change. The job is still: tell what kind of request this is, pull the account, and route it.
If you can describe the task once and then list only the fields that vary, the work repeats. If a new run needs a new plan, because the goal changed or the tools changed, it does not. A new amount on a known kind of invoice is not new work.
Repeating is not the same as identical. The agent is recognizing a familiar job with new values, not a duplicate message. Invoices, scheduling, and support triage work that way. If yesterday's queue and today's queue fit the same sentence, you are paying again for a plan you already have.
What does reusing an agent's decisions look like?
Reusing an agent's decisions means a Compiled Agent Model learns a task once, uses that plan again when the task repeats, and sends anything new to a frontier model.
The run that teaches the task works like an agent works today. A frontier model reads the request, reasons, calls tools, and returns a result. That completed run is the lesson. You do not write the route by hand. The model did the job, and the Compiled Agent Model keeps the plan that worked.
When the same kind of task comes back, the values are new and the plan is not. A different vendor, amount, customer, or time slot belongs in the reused plan. The run does not pay for a fresh walk through decisions it already made. The frontier wait and the frontier bill are what you stop repeating.
Anything that does not fit goes back to a frontier model. A new kind of request, a tool the learned task does not use, a case that breaks the shape: those are not forced through the reused plan. The frontier model handles them. A Compiled Agent Model is for the repeat. It is not a claim that every task is a repeat, and it does not guess when the shape is unfamiliar.
Here is a single measured case, with the label we use for it. Invoice reconciliation, one run per model: 1.5s and $0.00023 per run vs Opus 5.5 at 24.8s and $0.105 per run, roughly 450x.
Read that label as one run of this task for each model. It is not a claim about every workflow, and it is not a promise that another task will land on the same figures. The repeat spends less time and less money because it is not re-deciding a plan it already learned.
FAQ
Why is AI agent decision making expensive on repeat tasks? The model works out the same plan again on every run: which field matters, which tool comes next, and when to stop. The values may be new, but those decisions are ones it already made, and the run still pays for them.
Why do AI agents cost so much on repeat tasks? Each run pays again for input tokens, reasoning tokens, and tool-call loops, even when the task shape is unchanged. The costly part is re-thinking the plan, and the wait is the latency of that loop.
Does prompt caching fix repeat agent cost? No. Prompt caching cuts re-reading of a shared prefix. It does not reuse the reasoning, the tool order, or the plan, so the re-think is still billed.
How can you tell that an agent workload repeats? The task shape stays the same and the values change. Invoices, scheduling, and support triage are common cases. A new goal or a new tool is new work, not a repeat.
What does a Compiled Agent Model do with a task it has not learned? It sends anything new to a frontier model. It reuses the plan only for a task it has already learned.
Where can I read the longer account?
The longer account is Don't forget what worked: what a Compiled Agent Model is, why the repeat is the part worth learning, and what changes when a frontier model is reserved for work that is actually new.