<\/span>Key takeaways<\/span><\/h2>\n \n \n - Measure cost per successful task, not cost per token. It is the only number that can be compared with what the work costs today.<\/li>\n
- Agents resend their context on every step. Billed input tokens grow roughly with the square of the number of steps, so loop depth matters more than most teams expect. <\/li>\n
- Success rate is usually the biggest lever. In our support model, raising the agent's resolution rate from 78% to 88% cut cost per task by 37%. Halving the token price cut it by 5.5%.<\/li>\n
- Caching is decisive for long-running agents. Without it, our 24-step operations agent cost 73% more per successful task.<\/li>\n <\/ul>\n <\/div>\n \n\n\n
<\/span>Why price per token is the wrong starting number<\/span><\/h2>\n\n\n\nA provider price sheet answers a narrow question: what does it cost to send a given number of tokens to a model and receive a given number back?\u00a0An agent is not one call. A single customer request can trigger a planning call, several\u00a0tool\u00a0calls whose results are fed back into the model, a verification pass, and a final response, with the full conversation history attached to each request.<\/p>\n\n\n\n
Three properties of agent workloads make per-token thinking misleading.<\/p>\n\n\n\n
Calls multiply.<\/strong>\u00a0Every step in an agent loop is a separate billed request.\u00a0A six-step task is at least six calls, plus any guardrail or routing calls made by smaller models alongside it.<\/p>\n\n\n\nContext accumulates.<\/strong>\u00a0Language model APIs are stateless. To continue a task, the agent sends the system prompt, the tool definitions, the user request, and everything that has happened so far, again, on every step. Tool definitions alone can\u00a0run to\u00a0thousands of tokens, and they are billed as input on each call.<\/p>\n\n\n\nFailure has a price.<\/strong>\u00a0An agent that resolves 80% of tasks has not eliminated 80% of the cost of the work. The other 20% still needs a person, often a more expensive one, and the\u00a0agent’s\u00a0spend on those failed attempts is not refunded.<\/p>\n\n\n\nThere is also\u00a0a pricing\u00a0asymmetry worth knowing. Output tokens typically cost several times more than input tokens, and on models with extended\u00a0reasoning,\u00a0the reasoning tokens are billed as output even when the provider does not return the full reasoning text. An agent that “thinks” for 1,500 tokens before a 400-token action is paying output rates for 1,900 tokens.<\/p>\n\n\n\n
<\/span>The cost-per-successful-task formula<\/span><\/h2>\n\n\n\nThe metric we recommend is cost per successful task: the total spend attributable to a workflow divided by the number of tasks that reached a correct outcome.<\/p>\n\n\n\n
\nCost per successful task = (model spend on all attempts + human review and rescue +\u00a0allocated\u00a0platform cost) \u00f7 tasks completed correctly\u00a0<\/p>\n<\/blockquote>\n\n\n\n
Each term hides decisions that change the result. <\/p>\n\n\n\n
Model\u00a0spend on all attempts<\/strong>\u00a0includes failed attempts and automatic retries, not only the runs that succeeded. It also includes secondary models used for routing, moderation, or validation.<\/p>\n\n\n\nHuman review and rescue<\/strong>\u00a0is\u00a0the cost of people who check flagged outputs or take over tasks the agent could not finish. It is calculated as the share of tasks that need a person, multiplied by the loaded cost of that person’s time on one task.<\/p>\n\n\n\nAllocated platform cost<\/strong>\u00a0covers what does not scale per call: hosting, vector storage, observability tooling, and the evaluation runs you should be doing before every prompt or model change. Divide the monthly total by monthly task volume.<\/p>\n\n\n\nTasks completed correctly<\/strong>\u00a0is\u00a0the denominator, and it is where many cost reports quietly cheat. A task the agent completed incorrectly, without anyone noticing, is not a success. If you do not measure correctness, you cannot compute this number honestly, which is itself a useful signal about readiness for production.<\/p>\n\n\n\n<\/span>How agent token usage\u00a0actually grows<\/span><\/h2>\n\n\n\nConsider an agent with a 4,000-token starting context that adds 1,500 tokens of history per step (its own output plus the tool result it receives). On step\u00a0one\u00a0it sends 4,000 input tokens. On step\u00a0six\u00a0it sends 11,500. Across the whole task it is billed for 46,500 input tokens, not the 4,000 a naive estimate would use.<\/p>\n\n\n\n
The general shape is simple. If a task starts with a base context of B tokens and each step adds d tokens, the total billed input over n steps is:<\/p>\n\n\n\n
\nTotal input tokens = n \u00d7 B + d \u00d7 n \u00d7 (n \u2212 1) \u00f7 2<\/p>\n<\/blockquote>\n\n\n\n
The second term grows with the square of the step count. Doubling the number of steps\u00a0roughly quadruples\u00a0the history\u00a0portion\u00a0of the bill. This is why a long-horizon agent that\u00a0runs for\u00a024 steps can bill hundreds of thousands of input tokens for a task that produces a few pages of output.<\/p>\n\n\n\n![\"token](\"https:\/\/www.mindinventory.com\/blog\/wp-content\/uploads\/2026\/09\/token-context.webp\")
<\/figure>\n\n\n\nPrompt caching is the main countermeasure. Most major providers now bill cached input reads at a steep discount, commonly 50% to 90% below the standard input rate, and some charge a premium to write content into the cache. Because agent history is append-only, the unchanged prefix of each request can be served from\u00a0cache\u00a0and only the newest tokens are billed at full price. Whether your stack\u00a0actually achieves\u00a0this depends on keeping the prefix stable: reordering tool definitions, injecting timestamps near the top of the prompt, or rewriting earlier history breaks the cache match.<\/p>\n\n\n\n
<\/span>Three worked models<\/span><\/h2>\n\n\n\nWe modeled three archetypes that cover most agent deployments: a real-time support agent, a batch document processing pipeline with human review, and a long-running operations agent. The token prices below are illustrative assumptions for a mid-tier model and a larger reasoning-capable model. They are close to the range of current list prices but are not any\u00a0provider’s\u00a0quote, so replace them with your own rates before relying on the output.<\/p>\n\n\n\nAssumption<\/strong><\/td>Support resolution agent<\/strong><\/td>Document processing pipeline<\/strong><\/td>Operations agent<\/strong><\/td><\/tr>Model tier and price per million tokens (input \/ output) <\/td> Mid-tier, $3 \/ $15 <\/td> Mid-tier, $3 \/ $15, batch processed at 50% off <\/td> Larger reasoning model, $5 \/ $25 <\/td><\/tr> Cached input price per million tokens <\/td> $0.30 <\/td> Not used <\/td> $0.50 <\/td><\/tr> Steps per task <\/td> 6 <\/td> 1 extraction call plus 1 validation call <\/td> 24 <\/td><\/tr> Starting context and growth per step <\/td> 4,000 tokens, plus 1,500 per step <\/td> 3 page images at about 1,800 tokens each plus a 2,500-token schema <\/td> 6,000 tokens, plus 2,000 per step <\/td><\/tr> Output per step <\/td> 300 tokens <\/td> 900 tokens of structured data <\/td> 400 tokens plus 1,500 reasoning tokens <\/td><\/tr> Success without a person <\/td> 78% <\/td> 88% pass validation; 12% flagged for review <\/td> 70% on first attempt, one automatic retry <\/td><\/tr> Cost of a person per affected task <\/td> $4.00 to take over a conversation <\/td> $1.20 to review a flagged document <\/td> $25.00 for an analyst to finish the task <\/td><\/tr> Monthly platform, evaluation, and observability cost <\/td> $1,800 across 20,000 tasks <\/td> $800 across 40,000 documents <\/td> $2,000 across 3,000 tasks <\/td><\/tr> Human-only baseline per task <\/td> $5.00 <\/td> $1.50 <\/td> $25.00 <\/td><\/tr><\/tbody><\/table><\/figure>\n\n\n\nModel 1: support resolution agent<\/h3>\n\n\n\n
Each conversation runs six steps: understand the request, retrieve account data, check policy, act, confirm, and respond. The agent bills 46,500 input tokens and 1,800 output tokens per conversation. With the stable system prompt and tool definitions cached, model spend is about $0.12. A small guardrail model adds a tenth of a cent, and the\u00a0platform\u00a0allocation adds $0.09.<\/p>\n\n\n\n
That puts the agent side at $0.21 per conversation.\u00a0The 22% of conversations handed to a person add $0.88 on average. The cost per successful task is $1.09, and model tokens account for about 11% of it.<\/p>\n\n\n\n
The lesson is uncomfortable for teams focused on model pricing. Moving to a model at half the price saves about six cents per conversation. Resolving ten more conversations in every hundred saves forty.<\/p>\n\n\n\n
Model 2: document processing pipeline<\/h3>\n\n\n\n
Each document runs through one extraction\u00a0call\u00a0over\u00a0three page\u00a0images, followed by a validation pass on a small text model that checks totals, dates, and required fields. Because documents do not need an answer within seconds, both calls go through a batch interface, which major providers discount by around 50% in exchange for asynchronous processing.<\/p>\n\n\n\n
Model\u00a0spend is under two cents per document. Platform allocation adds two cents. The 12% of documents flagged for review add $0.14, so the cost per successful document is about $0.18, against a manual baseline of $1.50.<\/p>\n\n\n\n
Here the dominant cost is review, at 78% of the total. The validation pass is therefore the most valuable\u00a0component\u00a0of the\u00a0pipeline, because\u00a0a tighter validator that flags fewer false positives cuts review volume directly. Halving the flag rate from 12% to 6% reduces cost per document by 39%.<\/p>\n\n\n\n
Model 3: long-running operations agent<\/h3>\n\n\n\n
This agent handles multi-step internal work such as reconciling records across systems. It runs 24 steps on a larger model with extended reasoning. Each attempt bills 696,000 input tokens and 45,600 output tokens, of which 36,000 are reasoning tokens.<\/p>\n\n\n\n
The caching strategy decides\u00a0the economics. Without caching, one attempt costs $4.62 in model spend. Caching only the stable system\u00a0prompt\u00a0brings it to $4.10. Caching the full append-only history, so each step pays full price only for its new tokens, brings it to $1.72. Cache\u00a0write\u00a0premiums, where a provider charges them, add about six cents per attempt at these volumes and do not change the conclusion.<\/p>\n\n\n\n
With a 70% first-attempt success rate and one automatic retry, the agent averages 1.3 attempts per task. The 9% of tasks that fail twice go to an analyst at $25. Cost per successful task is $5.16 with full history caching and $8.92 without it, against a human baseline of $25.<\/p>\n\n\n\n
<\/span>Cost per call vs cost per successful task<\/span><\/h2>\n\n\n\nThis is the comparison that most budgets skip. The per-call figure is what a quick estimate from a price sheet would produce. The cost per successful task is what the business actually pays. <\/p>\n\n\n\nWorkload<\/strong><\/td>Average model cost per call<\/strong><\/td>Cost per successful task<\/strong><\/td>Ratio<\/strong><\/td>Human-only baseline<\/strong><\/td><\/tr>Support resolution agent<\/td> $0.020<\/td> $1.09<\/td> 55x<\/td> $5.00<\/td><\/tr> Document processing pipeline<\/td> $0.010<\/td> $0.18<\/td> 19x<\/td> $1.50<\/td><\/tr> Operations agent<\/td> $0.072<\/td> $5.16<\/td> 72x<\/td> $25.00<\/td><\/tr><\/tbody><\/table><\/figure>\n\n\n\nTwo conclusions follow. First, an agent can be far cheaper than the current process and still cost many times more than a per-call estimate suggests, so the estimate matters for budgeting even when the business case is strong. Second, the ratio grows with loop depth, which is why long-running agents are the ones most often under-budgeted.<\/p>\n\n\n\n![\"where](\"https:\/\/www.mindinventory.com\/blog\/wp-content\/uploads\/2026\/09\/where-the-money-goes.webp\")
<\/figure>\n\n\n\n<\/span>Which levers\u00a0actually move\u00a0the bill<\/span><\/h2>\n\n\n\nWe changed one assumption at a time and recorded the effect on cost per successful task.<\/p>\n\n\n\nChange<\/strong><\/td>Workload<\/strong><\/td>Effect on cost per successful task<\/strong><\/td><\/tr>Agent resolution rate rises from 78% to 88%<\/td> Support<\/td> \u221237%<\/td><\/tr> Cost of a human takeover rises from $4 to $6<\/td> Support<\/td> +40%<\/td><\/tr> Steps per conversation rise from 6 to 9<\/td> Support<\/td> +11%<\/td><\/tr> Token prices fall by 50%<\/td> Support<\/td> \u22125.5%<\/td><\/tr> Review flag rate falls from 12% to 6%<\/td> Documents<\/td> \u221239%<\/td><\/tr> Real-time calls instead of batch<\/td> Documents<\/td> +11%<\/td><\/tr> First-attempt success rises from 70% to 85%<\/td> Operations<\/td> \u221238%<\/td><\/tr> History caching turned off<\/td> Operations<\/td> +73%<\/td><\/tr> Steps fall from 24 to 12<\/td> Operations<\/td> \u221223%<\/td><\/tr> Token prices fall by 50%<\/td> Operations<\/td> \u221222%<\/td><\/tr> Reasoning tokens per step fall from 1,500 to 500<\/td> Operations<\/td> \u221215%<\/td><\/tr><\/tbody><\/table><\/figure>\n\n\n\nThe ranking is stable across the three workloads. Success rate and human cost dominate. Architecture choices such as caching, batching, and loop depth come next. Token price, the number most teams negotiate first, has the smallest effect in short workflows and only a moderate one in long workflows. <\/p>\n\n\n\n
<\/span>How to reduce cost per successful task<\/span><\/h2>\n\n\n\nThe order matters.\u00a0Optimizing\u00a0token spend before you can measure success rate usually saves little and sometimes lowers quality enough to raise the total.<\/p>\n\n\n\n
\n- Instrument every task\u00a0end\u00a0to end.<\/strong>\u00a0Log each model\u00a0call\u00a0with its token counts, cached tokens, reasoning tokens, and a shared task identifier, then record the task outcome: succeeded, escalated, retried, or failed.<\/li>\n<\/ol>\n\n\n\n
\n- Establish a\u00a0correctness\u00a0check.<\/strong>\u00a0Build an evaluation set from real tasks and score outcomes, not just whether the agent returned something. Without it, you cannot tell a cheaper configuration from a worse one.<\/li>\n<\/ol>\n\n\n\n
\n- Raise the success rate on the most common failures.<\/strong>\u00a0Review escalated tasks by cause. Missing tool access, ambiguous policies, and poor retrieval are usually cheaper to fix than model quality.<\/li>\n<\/ol>\n\n\n\n
\n- Cap loop depth and detect loops.<\/strong>\u00a0Set a maximum step count per task type and stop the agent when it repeats the same tool\u00a0call\u00a0with the same arguments.<\/li>\n<\/ol>\n\n\n\n
\n- Make caching work.<\/strong>\u00a0Keep system prompts, tool definitions, and history stable and at the start of the request, then confirm through billing data that cached token counts are what you expect.<\/li>\n<\/ol>\n\n\n\n
\n- Route by difficulty.<\/strong>\u00a0Send classification, extraction, and validation to smaller models, and reserve larger reasoning models for the steps that need them. Set reasoning effort per step rather than globally.<\/li>\n<\/ol>\n\n\n\n
\n- Batch anything that can wait.<\/strong>\u00a0Overnight reports, document backlogs, and evaluation runs rarely need real-time responses.<\/li>\n<\/ol>\n\n\n\n
\n- Prune context.<\/strong>\u00a0Summarize or drop tool results the agent no longer needs, and retrieve fewer, better documents rather than many marginal ones.<\/li>\n<\/ol>\n\n\n\n
<\/span>Budget controls that prevent runaway spend<\/span><\/h2>\n\n\n\nAn agent that loops on a confusing input can burn through a day’s budget in minutes. Controls belong in the orchestration layer, not in the prompt, because a model cannot be relied on to stop itself.<\/p>\n\n\n\n
Per-task limits.<\/strong>\u00a0Cap steps, total tokens, and elapsed time for each task type, and end the task with an escalation when any limit is reached.<\/p>\n\n\n\nPer-customer or per-tenant budgets.<\/strong>\u00a0In multi-tenant products, one heavy user should not be able to consume the margin on everyone else. Meter\u00a0spend\u00a0per tenant and throttle or alert at a threshold.<\/p>\n\n\n\nAnomaly alerts.<\/strong>\u00a0Alert on cost per task,\u00a0not only total\u00a0daily spend. A 3x jump in cost per task on stable volume usually means a prompt change broke\u00a0caching\u00a0or a tool started returning oversized results.<\/p>\n\n\n\nA kill switch.<\/strong>\u00a0Keep the ability to pause autonomous actions and route all traffic to people without\u00a0a deployment. It is cheap to build and expensive to lack.<\/p>\n\n\n\n<\/span>Comparing against the human baseline<\/span><\/h2>\n\n\n\nThe business case rests on the comparison between cost per successful task and what the same outcome costs today. Build the baseline with the same care as the agent model: loaded hourly cost, handling time per task, and the share of tasks that already need a second touch.<\/p>\n\n\n\n
Two adjustments keep the comparison honest. Include the cost of errors that neither the agent nor the reviewer catches, such as refunds, rework, or compliance exposure, on both sides. And account for the people who\u00a0remain\u00a0in the loop. In our support model, the human takeover rate is the single largest cost, which means the humans who stay are doing harder work. Their handling time per task may rise, and the baseline should reflect that.<\/p>\n\n\n\n
<\/span>What to measure from day one<\/span><\/h2>\n\n\n\nEvery production agent should report the following for each task type, weekly: task volume, success rate without human help, escalation rate by cause, average steps per task, input, cached, reasoning, and output tokens per task, model spend per task, human review cost per task, and cost per successful task. With those numbers in place, every change to prompts, models, or tools can be judged on the only metric that matters to the business.<\/p>\n\n\n \n \n
<\/span>Why price per token is the wrong starting number<\/span><\/h2>\n\n\n\nA provider price sheet answers a narrow question: what does it cost to send a given number of tokens to a model and receive a given number back?\u00a0An agent is not one call. A single customer request can trigger a planning call, several\u00a0tool\u00a0calls whose results are fed back into the model, a verification pass, and a final response, with the full conversation history attached to each request.<\/p>\n\n\n\n
Three properties of agent workloads make per-token thinking misleading.<\/p>\n\n\n\n
Calls multiply.<\/strong>\u00a0Every step in an agent loop is a separate billed request.\u00a0A six-step task is at least six calls, plus any guardrail or routing calls made by smaller models alongside it.<\/p>\n\n\n\nContext accumulates.<\/strong>\u00a0Language model APIs are stateless. To continue a task, the agent sends the system prompt, the tool definitions, the user request, and everything that has happened so far, again, on every step. Tool definitions alone can\u00a0run to\u00a0thousands of tokens, and they are billed as input on each call.<\/p>\n\n\n\nFailure has a price.<\/strong>\u00a0An agent that resolves 80% of tasks has not eliminated 80% of the cost of the work. The other 20% still needs a person, often a more expensive one, and the\u00a0agent’s\u00a0spend on those failed attempts is not refunded.<\/p>\n\n\n\nThere is also\u00a0a pricing\u00a0asymmetry worth knowing. Output tokens typically cost several times more than input tokens, and on models with extended\u00a0reasoning,\u00a0the reasoning tokens are billed as output even when the provider does not return the full reasoning text. An agent that “thinks” for 1,500 tokens before a 400-token action is paying output rates for 1,900 tokens.<\/p>\n\n\n\n
<\/span>The cost-per-successful-task formula<\/span><\/h2>\n\n\n\nThe metric we recommend is cost per successful task: the total spend attributable to a workflow divided by the number of tasks that reached a correct outcome.<\/p>\n\n\n\n
\nCost per successful task = (model spend on all attempts + human review and rescue +\u00a0allocated\u00a0platform cost) \u00f7 tasks completed correctly\u00a0<\/p>\n<\/blockquote>\n\n\n\n
Each term hides decisions that change the result. <\/p>\n\n\n\n
Model\u00a0spend on all attempts<\/strong>\u00a0includes failed attempts and automatic retries, not only the runs that succeeded. It also includes secondary models used for routing, moderation, or validation.<\/p>\n\n\n\nHuman review and rescue<\/strong>\u00a0is\u00a0the cost of people who check flagged outputs or take over tasks the agent could not finish. It is calculated as the share of tasks that need a person, multiplied by the loaded cost of that person’s time on one task.<\/p>\n\n\n\nAllocated platform cost<\/strong>\u00a0covers what does not scale per call: hosting, vector storage, observability tooling, and the evaluation runs you should be doing before every prompt or model change. Divide the monthly total by monthly task volume.<\/p>\n\n\n\nTasks completed correctly<\/strong>\u00a0is\u00a0the denominator, and it is where many cost reports quietly cheat. A task the agent completed incorrectly, without anyone noticing, is not a success. If you do not measure correctness, you cannot compute this number honestly, which is itself a useful signal about readiness for production.<\/p>\n\n\n\n<\/span>How agent token usage\u00a0actually grows<\/span><\/h2>\n\n\n\nConsider an agent with a 4,000-token starting context that adds 1,500 tokens of history per step (its own output plus the tool result it receives). On step\u00a0one\u00a0it sends 4,000 input tokens. On step\u00a0six\u00a0it sends 11,500. Across the whole task it is billed for 46,500 input tokens, not the 4,000 a naive estimate would use.<\/p>\n\n\n\n
The general shape is simple. If a task starts with a base context of B tokens and each step adds d tokens, the total billed input over n steps is:<\/p>\n\n\n\n
\nTotal input tokens = n \u00d7 B + d \u00d7 n \u00d7 (n \u2212 1) \u00f7 2<\/p>\n<\/blockquote>\n\n\n\n
The second term grows with the square of the step count. Doubling the number of steps\u00a0roughly quadruples\u00a0the history\u00a0portion\u00a0of the bill. This is why a long-horizon agent that\u00a0runs for\u00a024 steps can bill hundreds of thousands of input tokens for a task that produces a few pages of output.<\/p>\n\n\n\n<\/figure>\n\n\n\nPrompt caching is the main countermeasure. Most major providers now bill cached input reads at a steep discount, commonly 50% to 90% below the standard input rate, and some charge a premium to write content into the cache. Because agent history is append-only, the unchanged prefix of each request can be served from\u00a0cache\u00a0and only the newest tokens are billed at full price. Whether your stack\u00a0actually achieves\u00a0this depends on keeping the prefix stable: reordering tool definitions, injecting timestamps near the top of the prompt, or rewriting earlier history breaks the cache match.<\/p>\n\n\n\n
<\/span>Three worked models<\/span><\/h2>\n\n\n\nWe modeled three archetypes that cover most agent deployments: a real-time support agent, a batch document processing pipeline with human review, and a long-running operations agent. The token prices below are illustrative assumptions for a mid-tier model and a larger reasoning-capable model. They are close to the range of current list prices but are not any\u00a0provider’s\u00a0quote, so replace them with your own rates before relying on the output.<\/p>\n\n\n\nAssumption<\/strong><\/td>Support resolution agent<\/strong><\/td>Document processing pipeline<\/strong><\/td>Operations agent<\/strong><\/td><\/tr>Model tier and price per million tokens (input \/ output) <\/td> Mid-tier, $3 \/ $15 <\/td> Mid-tier, $3 \/ $15, batch processed at 50% off <\/td> Larger reasoning model, $5 \/ $25 <\/td><\/tr> Cached input price per million tokens <\/td> $0.30 <\/td> Not used <\/td> $0.50 <\/td><\/tr> Steps per task <\/td> 6 <\/td> 1 extraction call plus 1 validation call <\/td> 24 <\/td><\/tr> Starting context and growth per step <\/td> 4,000 tokens, plus 1,500 per step <\/td> 3 page images at about 1,800 tokens each plus a 2,500-token schema <\/td> 6,000 tokens, plus 2,000 per step <\/td><\/tr> Output per step <\/td> 300 tokens <\/td> 900 tokens of structured data <\/td> 400 tokens plus 1,500 reasoning tokens <\/td><\/tr> Success without a person <\/td> 78% <\/td> 88% pass validation; 12% flagged for review <\/td> 70% on first attempt, one automatic retry <\/td><\/tr> Cost of a person per affected task <\/td> $4.00 to take over a conversation <\/td> $1.20 to review a flagged document <\/td> $25.00 for an analyst to finish the task <\/td><\/tr> Monthly platform, evaluation, and observability cost <\/td> $1,800 across 20,000 tasks <\/td> $800 across 40,000 documents <\/td> $2,000 across 3,000 tasks <\/td><\/tr> Human-only baseline per task <\/td> $5.00 <\/td> $1.50 <\/td> $25.00 <\/td><\/tr><\/tbody><\/table><\/figure>\n\n\n\nModel 1: support resolution agent<\/h3>\n\n\n\n
Each conversation runs six steps: understand the request, retrieve account data, check policy, act, confirm, and respond. The agent bills 46,500 input tokens and 1,800 output tokens per conversation. With the stable system prompt and tool definitions cached, model spend is about $0.12. A small guardrail model adds a tenth of a cent, and the\u00a0platform\u00a0allocation adds $0.09.<\/p>\n\n\n\n
That puts the agent side at $0.21 per conversation.\u00a0The 22% of conversations handed to a person add $0.88 on average. The cost per successful task is $1.09, and model tokens account for about 11% of it.<\/p>\n\n\n\n
The lesson is uncomfortable for teams focused on model pricing. Moving to a model at half the price saves about six cents per conversation. Resolving ten more conversations in every hundred saves forty.<\/p>\n\n\n\n
Model 2: document processing pipeline<\/h3>\n\n\n\n
Each document runs through one extraction\u00a0call\u00a0over\u00a0three page\u00a0images, followed by a validation pass on a small text model that checks totals, dates, and required fields. Because documents do not need an answer within seconds, both calls go through a batch interface, which major providers discount by around 50% in exchange for asynchronous processing.<\/p>\n\n\n\n
Model\u00a0spend is under two cents per document. Platform allocation adds two cents. The 12% of documents flagged for review add $0.14, so the cost per successful document is about $0.18, against a manual baseline of $1.50.<\/p>\n\n\n\n
Here the dominant cost is review, at 78% of the total. The validation pass is therefore the most valuable\u00a0component\u00a0of the\u00a0pipeline, because\u00a0a tighter validator that flags fewer false positives cuts review volume directly. Halving the flag rate from 12% to 6% reduces cost per document by 39%.<\/p>\n\n\n\n
Model 3: long-running operations agent<\/h3>\n\n\n\n
This agent handles multi-step internal work such as reconciling records across systems. It runs 24 steps on a larger model with extended reasoning. Each attempt bills 696,000 input tokens and 45,600 output tokens, of which 36,000 are reasoning tokens.<\/p>\n\n\n\n
The caching strategy decides\u00a0the economics. Without caching, one attempt costs $4.62 in model spend. Caching only the stable system\u00a0prompt\u00a0brings it to $4.10. Caching the full append-only history, so each step pays full price only for its new tokens, brings it to $1.72. Cache\u00a0write\u00a0premiums, where a provider charges them, add about six cents per attempt at these volumes and do not change the conclusion.<\/p>\n\n\n\n
With a 70% first-attempt success rate and one automatic retry, the agent averages 1.3 attempts per task. The 9% of tasks that fail twice go to an analyst at $25. Cost per successful task is $5.16 with full history caching and $8.92 without it, against a human baseline of $25.<\/p>\n\n\n\n
<\/span>Cost per call vs cost per successful task<\/span><\/h2>\n\n\n\nThis is the comparison that most budgets skip. The per-call figure is what a quick estimate from a price sheet would produce. The cost per successful task is what the business actually pays. <\/p>\n\n\n\nWorkload<\/strong><\/td>Average model cost per call<\/strong><\/td>Cost per successful task<\/strong><\/td>Ratio<\/strong><\/td>Human-only baseline<\/strong><\/td><\/tr>Support resolution agent<\/td> $0.020<\/td> $1.09<\/td> 55x<\/td> $5.00<\/td><\/tr> Document processing pipeline<\/td> $0.010<\/td> $0.18<\/td> 19x<\/td> $1.50<\/td><\/tr> Operations agent<\/td> $0.072<\/td> $5.16<\/td> 72x<\/td> $25.00<\/td><\/tr><\/tbody><\/table><\/figure>\n\n\n\nTwo conclusions follow. First, an agent can be far cheaper than the current process and still cost many times more than a per-call estimate suggests, so the estimate matters for budgeting even when the business case is strong. Second, the ratio grows with loop depth, which is why long-running agents are the ones most often under-budgeted.<\/p>\n\n\n\n<\/figure>\n\n\n\n<\/span>Which levers\u00a0actually move\u00a0the bill<\/span><\/h2>\n\n\n\nWe changed one assumption at a time and recorded the effect on cost per successful task.<\/p>\n\n\n\nChange<\/strong><\/td>Workload<\/strong><\/td>Effect on cost per successful task<\/strong><\/td><\/tr>Agent resolution rate rises from 78% to 88%<\/td> Support<\/td> \u221237%<\/td><\/tr> Cost of a human takeover rises from $4 to $6<\/td> Support<\/td> +40%<\/td><\/tr> Steps per conversation rise from 6 to 9<\/td> Support<\/td> +11%<\/td><\/tr> Token prices fall by 50%<\/td> Support<\/td> \u22125.5%<\/td><\/tr> Review flag rate falls from 12% to 6%<\/td> Documents<\/td> \u221239%<\/td><\/tr> Real-time calls instead of batch<\/td> Documents<\/td> +11%<\/td><\/tr> First-attempt success rises from 70% to 85%<\/td> Operations<\/td> \u221238%<\/td><\/tr> History caching turned off<\/td> Operations<\/td> +73%<\/td><\/tr> Steps fall from 24 to 12<\/td> Operations<\/td> \u221223%<\/td><\/tr> Token prices fall by 50%<\/td> Operations<\/td> \u221222%<\/td><\/tr> Reasoning tokens per step fall from 1,500 to 500<\/td> Operations<\/td> \u221215%<\/td><\/tr><\/tbody><\/table><\/figure>\n\n\n\nThe ranking is stable across the three workloads. Success rate and human cost dominate. Architecture choices such as caching, batching, and loop depth come next. Token price, the number most teams negotiate first, has the smallest effect in short workflows and only a moderate one in long workflows. <\/p>\n\n\n\n
<\/span>How to reduce cost per successful task<\/span><\/h2>\n\n\n\nThe order matters.\u00a0Optimizing\u00a0token spend before you can measure success rate usually saves little and sometimes lowers quality enough to raise the total.<\/p>\n\n\n\n
\n- Instrument every task\u00a0end\u00a0to end.<\/strong>\u00a0Log each model\u00a0call\u00a0with its token counts, cached tokens, reasoning tokens, and a shared task identifier, then record the task outcome: succeeded, escalated, retried, or failed.<\/li>\n<\/ol>\n\n\n\n
\n- Establish a\u00a0correctness\u00a0check.<\/strong>\u00a0Build an evaluation set from real tasks and score outcomes, not just whether the agent returned something. Without it, you cannot tell a cheaper configuration from a worse one.<\/li>\n<\/ol>\n\n\n\n
\n- Raise the success rate on the most common failures.<\/strong>\u00a0Review escalated tasks by cause. Missing tool access, ambiguous policies, and poor retrieval are usually cheaper to fix than model quality.<\/li>\n<\/ol>\n\n\n\n
\n- Cap loop depth and detect loops.<\/strong>\u00a0Set a maximum step count per task type and stop the agent when it repeats the same tool\u00a0call\u00a0with the same arguments.<\/li>\n<\/ol>\n\n\n\n
\n- Make caching work.<\/strong>\u00a0Keep system prompts, tool definitions, and history stable and at the start of the request, then confirm through billing data that cached token counts are what you expect.<\/li>\n<\/ol>\n\n\n\n
\n- Route by difficulty.<\/strong>\u00a0Send classification, extraction, and validation to smaller models, and reserve larger reasoning models for the steps that need them. Set reasoning effort per step rather than globally.<\/li>\n<\/ol>\n\n\n\n
\n- Batch anything that can wait.<\/strong>\u00a0Overnight reports, document backlogs, and evaluation runs rarely need real-time responses.<\/li>\n<\/ol>\n\n\n\n
\n- Prune context.<\/strong>\u00a0Summarize or drop tool results the agent no longer needs, and retrieve fewer, better documents rather than many marginal ones.<\/li>\n<\/ol>\n\n\n\n
<\/span>Budget controls that prevent runaway spend<\/span><\/h2>\n\n\n\nAn agent that loops on a confusing input can burn through a day’s budget in minutes. Controls belong in the orchestration layer, not in the prompt, because a model cannot be relied on to stop itself.<\/p>\n\n\n\n
Per-task limits.<\/strong>\u00a0Cap steps, total tokens, and elapsed time for each task type, and end the task with an escalation when any limit is reached.<\/p>\n\n\n\nPer-customer or per-tenant budgets.<\/strong>\u00a0In multi-tenant products, one heavy user should not be able to consume the margin on everyone else. Meter\u00a0spend\u00a0per tenant and throttle or alert at a threshold.<\/p>\n\n\n\nAnomaly alerts.<\/strong>\u00a0Alert on cost per task,\u00a0not only total\u00a0daily spend. A 3x jump in cost per task on stable volume usually means a prompt change broke\u00a0caching\u00a0or a tool started returning oversized results.<\/p>\n\n\n\nA kill switch.<\/strong>\u00a0Keep the ability to pause autonomous actions and route all traffic to people without\u00a0a deployment. It is cheap to build and expensive to lack.<\/p>\n\n\n\n<\/span>Comparing against the human baseline<\/span><\/h2>\n\n\n\nThe business case rests on the comparison between cost per successful task and what the same outcome costs today. Build the baseline with the same care as the agent model: loaded hourly cost, handling time per task, and the share of tasks that already need a second touch.<\/p>\n\n\n\n
Two adjustments keep the comparison honest. Include the cost of errors that neither the agent nor the reviewer catches, such as refunds, rework, or compliance exposure, on both sides. And account for the people who\u00a0remain\u00a0in the loop. In our support model, the human takeover rate is the single largest cost, which means the humans who stay are doing harder work. Their handling time per task may rise, and the baseline should reflect that.<\/p>\n\n\n\n
<\/span>What to measure from day one<\/span><\/h2>\n\n\n\nEvery production agent should report the following for each task type, weekly: task volume, success rate without human help, escalation rate by cause, average steps per task, input, cached, reasoning, and output tokens per task, model spend per task, human review cost per task, and cost per successful task. With those numbers in place, every change to prompts, models, or tools can be judged on the only metric that matters to the business.<\/p>\n\n\n \n \n
Context accumulates.<\/strong>\u00a0Language model APIs are stateless. To continue a task, the agent sends the system prompt, the tool definitions, the user request, and everything that has happened so far, again, on every step. Tool definitions alone can\u00a0run to\u00a0thousands of tokens, and they are billed as input on each call.<\/p>\n\n\n\n Failure has a price.<\/strong>\u00a0An agent that resolves 80% of tasks has not eliminated 80% of the cost of the work. The other 20% still needs a person, often a more expensive one, and the\u00a0agent’s\u00a0spend on those failed attempts is not refunded.<\/p>\n\n\n\n There is also\u00a0a pricing\u00a0asymmetry worth knowing. Output tokens typically cost several times more than input tokens, and on models with extended\u00a0reasoning,\u00a0the reasoning tokens are billed as output even when the provider does not return the full reasoning text. An agent that “thinks” for 1,500 tokens before a 400-token action is paying output rates for 1,900 tokens.<\/p>\n\n\n\n The metric we recommend is cost per successful task: the total spend attributable to a workflow divided by the number of tasks that reached a correct outcome.<\/p>\n\n\n\n Cost per successful task = (model spend on all attempts + human review and rescue +\u00a0allocated\u00a0platform cost) \u00f7 tasks completed correctly\u00a0<\/p>\n<\/blockquote>\n\n\n\n Each term hides decisions that change the result. <\/p>\n\n\n\n Model\u00a0spend on all attempts<\/strong>\u00a0includes failed attempts and automatic retries, not only the runs that succeeded. It also includes secondary models used for routing, moderation, or validation.<\/p>\n\n\n\n Human review and rescue<\/strong>\u00a0is\u00a0the cost of people who check flagged outputs or take over tasks the agent could not finish. It is calculated as the share of tasks that need a person, multiplied by the loaded cost of that person’s time on one task.<\/p>\n\n\n\n Allocated platform cost<\/strong>\u00a0covers what does not scale per call: hosting, vector storage, observability tooling, and the evaluation runs you should be doing before every prompt or model change. Divide the monthly total by monthly task volume.<\/p>\n\n\n\n Tasks completed correctly<\/strong>\u00a0is\u00a0the denominator, and it is where many cost reports quietly cheat. A task the agent completed incorrectly, without anyone noticing, is not a success. If you do not measure correctness, you cannot compute this number honestly, which is itself a useful signal about readiness for production.<\/p>\n\n\n\n Consider an agent with a 4,000-token starting context that adds 1,500 tokens of history per step (its own output plus the tool result it receives). On step\u00a0one\u00a0it sends 4,000 input tokens. On step\u00a0six\u00a0it sends 11,500. Across the whole task it is billed for 46,500 input tokens, not the 4,000 a naive estimate would use.<\/p>\n\n\n\n The general shape is simple. If a task starts with a base context of B tokens and each step adds d tokens, the total billed input over n steps is:<\/p>\n\n\n\n Total input tokens = n \u00d7 B + d \u00d7 n \u00d7 (n \u2212 1) \u00f7 2<\/p>\n<\/blockquote>\n\n\n\n The second term grows with the square of the step count. Doubling the number of steps\u00a0roughly quadruples\u00a0the history\u00a0portion\u00a0of the bill. This is why a long-horizon agent that\u00a0runs for\u00a024 steps can bill hundreds of thousands of input tokens for a task that produces a few pages of output.<\/p>\n\n\n\n Prompt caching is the main countermeasure. Most major providers now bill cached input reads at a steep discount, commonly 50% to 90% below the standard input rate, and some charge a premium to write content into the cache. Because agent history is append-only, the unchanged prefix of each request can be served from\u00a0cache\u00a0and only the newest tokens are billed at full price. Whether your stack\u00a0actually achieves\u00a0this depends on keeping the prefix stable: reordering tool definitions, injecting timestamps near the top of the prompt, or rewriting earlier history breaks the cache match.<\/p>\n\n\n\n We modeled three archetypes that cover most agent deployments: a real-time support agent, a batch document processing pipeline with human review, and a long-running operations agent. The token prices below are illustrative assumptions for a mid-tier model and a larger reasoning-capable model. They are close to the range of current list prices but are not any\u00a0provider’s\u00a0quote, so replace them with your own rates before relying on the output.<\/p>\n\n\n\n Each conversation runs six steps: understand the request, retrieve account data, check policy, act, confirm, and respond. The agent bills 46,500 input tokens and 1,800 output tokens per conversation. With the stable system prompt and tool definitions cached, model spend is about $0.12. A small guardrail model adds a tenth of a cent, and the\u00a0platform\u00a0allocation adds $0.09.<\/p>\n\n\n\n That puts the agent side at $0.21 per conversation.\u00a0The 22% of conversations handed to a person add $0.88 on average. The cost per successful task is $1.09, and model tokens account for about 11% of it.<\/p>\n\n\n\n The lesson is uncomfortable for teams focused on model pricing. Moving to a model at half the price saves about six cents per conversation. Resolving ten more conversations in every hundred saves forty.<\/p>\n\n\n\n Each document runs through one extraction\u00a0call\u00a0over\u00a0three page\u00a0images, followed by a validation pass on a small text model that checks totals, dates, and required fields. Because documents do not need an answer within seconds, both calls go through a batch interface, which major providers discount by around 50% in exchange for asynchronous processing.<\/p>\n\n\n\n Model\u00a0spend is under two cents per document. Platform allocation adds two cents. The 12% of documents flagged for review add $0.14, so the cost per successful document is about $0.18, against a manual baseline of $1.50.<\/p>\n\n\n\n Here the dominant cost is review, at 78% of the total. The validation pass is therefore the most valuable\u00a0component\u00a0of the\u00a0pipeline, because\u00a0a tighter validator that flags fewer false positives cuts review volume directly. Halving the flag rate from 12% to 6% reduces cost per document by 39%.<\/p>\n\n\n\n This agent handles multi-step internal work such as reconciling records across systems. It runs 24 steps on a larger model with extended reasoning. Each attempt bills 696,000 input tokens and 45,600 output tokens, of which 36,000 are reasoning tokens.<\/p>\n\n\n\n The caching strategy decides\u00a0the economics. Without caching, one attempt costs $4.62 in model spend. Caching only the stable system\u00a0prompt\u00a0brings it to $4.10. Caching the full append-only history, so each step pays full price only for its new tokens, brings it to $1.72. Cache\u00a0write\u00a0premiums, where a provider charges them, add about six cents per attempt at these volumes and do not change the conclusion.<\/p>\n\n\n\n With a 70% first-attempt success rate and one automatic retry, the agent averages 1.3 attempts per task. The 9% of tasks that fail twice go to an analyst at $25. Cost per successful task is $5.16 with full history caching and $8.92 without it, against a human baseline of $25.<\/p>\n\n\n\n This is the comparison that most budgets skip. The per-call figure is what a quick estimate from a price sheet would produce. The cost per successful task is what the business actually pays. <\/p>\n\n\n\n Two conclusions follow. First, an agent can be far cheaper than the current process and still cost many times more than a per-call estimate suggests, so the estimate matters for budgeting even when the business case is strong. Second, the ratio grows with loop depth, which is why long-running agents are the ones most often under-budgeted.<\/p>\n\n\n\n We changed one assumption at a time and recorded the effect on cost per successful task.<\/p>\n\n\n\n The ranking is stable across the three workloads. Success rate and human cost dominate. Architecture choices such as caching, batching, and loop depth come next. Token price, the number most teams negotiate first, has the smallest effect in short workflows and only a moderate one in long workflows. <\/p>\n\n\n\n The order matters.\u00a0Optimizing\u00a0token spend before you can measure success rate usually saves little and sometimes lowers quality enough to raise the total.<\/p>\n\n\n\n An agent that loops on a confusing input can burn through a day’s budget in minutes. Controls belong in the orchestration layer, not in the prompt, because a model cannot be relied on to stop itself.<\/p>\n\n\n\n Per-task limits.<\/strong>\u00a0Cap steps, total tokens, and elapsed time for each task type, and end the task with an escalation when any limit is reached.<\/p>\n\n\n\n Per-customer or per-tenant budgets.<\/strong>\u00a0In multi-tenant products, one heavy user should not be able to consume the margin on everyone else. Meter\u00a0spend\u00a0per tenant and throttle or alert at a threshold.<\/p>\n\n\n\n Anomaly alerts.<\/strong>\u00a0Alert on cost per task,\u00a0not only total\u00a0daily spend. A 3x jump in cost per task on stable volume usually means a prompt change broke\u00a0caching\u00a0or a tool started returning oversized results.<\/p>\n\n\n\n A kill switch.<\/strong>\u00a0Keep the ability to pause autonomous actions and route all traffic to people without\u00a0a deployment. It is cheap to build and expensive to lack.<\/p>\n\n\n\n The business case rests on the comparison between cost per successful task and what the same outcome costs today. Build the baseline with the same care as the agent model: loaded hourly cost, handling time per task, and the share of tasks that already need a second touch.<\/p>\n\n\n\n Two adjustments keep the comparison honest. Include the cost of errors that neither the agent nor the reviewer catches, such as refunds, rework, or compliance exposure, on both sides. And account for the people who\u00a0remain\u00a0in the loop. In our support model, the human takeover rate is the single largest cost, which means the humans who stay are doing harder work. Their handling time per task may rise, and the baseline should reflect that.<\/p>\n\n\n\n Every production agent should report the following for each task type, weekly: task volume, success rate without human help, escalation rate by cause, average steps per task, input, cached, reasoning, and output tokens per task, model spend per task, human review cost per task, and cost per successful task. With those numbers in place, every change to prompts, models, or tools can be judged on the only metric that matters to the business.<\/p>\n\n\n <\/span>The cost-per-successful-task formula<\/span><\/h2>\n\n\n\n
\n
<\/span>How agent token usage\u00a0actually grows<\/span><\/h2>\n\n\n\n
\n
<\/figure>\n\n\n\n<\/span>Three worked models<\/span><\/h2>\n\n\n\n
Assumption<\/strong><\/td> Support resolution agent<\/strong><\/td> Document processing pipeline<\/strong><\/td> Operations agent<\/strong><\/td><\/tr> Model tier and price per million tokens (input \/ output) <\/td> Mid-tier, $3 \/ $15 <\/td> Mid-tier, $3 \/ $15, batch processed at 50% off <\/td> Larger reasoning model, $5 \/ $25 <\/td><\/tr> Cached input price per million tokens <\/td> $0.30 <\/td> Not used <\/td> $0.50 <\/td><\/tr> Steps per task <\/td> 6 <\/td> 1 extraction call plus 1 validation call <\/td> 24 <\/td><\/tr> Starting context and growth per step <\/td> 4,000 tokens, plus 1,500 per step <\/td> 3 page images at about 1,800 tokens each plus a 2,500-token schema <\/td> 6,000 tokens, plus 2,000 per step <\/td><\/tr> Output per step <\/td> 300 tokens <\/td> 900 tokens of structured data <\/td> 400 tokens plus 1,500 reasoning tokens <\/td><\/tr> Success without a person <\/td> 78% <\/td> 88% pass validation; 12% flagged for review <\/td> 70% on first attempt, one automatic retry <\/td><\/tr> Cost of a person per affected task <\/td> $4.00 to take over a conversation <\/td> $1.20 to review a flagged document <\/td> $25.00 for an analyst to finish the task <\/td><\/tr> Monthly platform, evaluation, and observability cost <\/td> $1,800 across 20,000 tasks <\/td> $800 across 40,000 documents <\/td> $2,000 across 3,000 tasks <\/td><\/tr> Human-only baseline per task <\/td> $5.00 <\/td> $1.50 <\/td> $25.00 <\/td><\/tr><\/tbody><\/table><\/figure>\n\n\n\n Model 1: support resolution agent<\/h3>\n\n\n\n
Model 2: document processing pipeline<\/h3>\n\n\n\n
Model 3: long-running operations agent<\/h3>\n\n\n\n
<\/span>Cost per call vs cost per successful task<\/span><\/h2>\n\n\n\n
Workload<\/strong><\/td> Average model cost per call<\/strong><\/td> Cost per successful task<\/strong><\/td> Ratio<\/strong><\/td> Human-only baseline<\/strong><\/td><\/tr> Support resolution agent<\/td> $0.020<\/td> $1.09<\/td> 55x<\/td> $5.00<\/td><\/tr> Document processing pipeline<\/td> $0.010<\/td> $0.18<\/td> 19x<\/td> $1.50<\/td><\/tr> Operations agent<\/td> $0.072<\/td> $5.16<\/td> 72x<\/td> $25.00<\/td><\/tr><\/tbody><\/table><\/figure>\n\n\n\n <\/figure>\n\n\n\n<\/span>Which levers\u00a0actually move\u00a0the bill<\/span><\/h2>\n\n\n\n
Change<\/strong><\/td> Workload<\/strong><\/td> Effect on cost per successful task<\/strong><\/td><\/tr> Agent resolution rate rises from 78% to 88%<\/td> Support<\/td> \u221237%<\/td><\/tr> Cost of a human takeover rises from $4 to $6<\/td> Support<\/td> +40%<\/td><\/tr> Steps per conversation rise from 6 to 9<\/td> Support<\/td> +11%<\/td><\/tr> Token prices fall by 50%<\/td> Support<\/td> \u22125.5%<\/td><\/tr> Review flag rate falls from 12% to 6%<\/td> Documents<\/td> \u221239%<\/td><\/tr> Real-time calls instead of batch<\/td> Documents<\/td> +11%<\/td><\/tr> First-attempt success rises from 70% to 85%<\/td> Operations<\/td> \u221238%<\/td><\/tr> History caching turned off<\/td> Operations<\/td> +73%<\/td><\/tr> Steps fall from 24 to 12<\/td> Operations<\/td> \u221223%<\/td><\/tr> Token prices fall by 50%<\/td> Operations<\/td> \u221222%<\/td><\/tr> Reasoning tokens per step fall from 1,500 to 500<\/td> Operations<\/td> \u221215%<\/td><\/tr><\/tbody><\/table><\/figure>\n\n\n\n <\/span>How to reduce cost per successful task<\/span><\/h2>\n\n\n\n
\n
\n
\n
\n
\n
\n
\n
\n
<\/span>Budget controls that prevent runaway spend<\/span><\/h2>\n\n\n\n
<\/span>Comparing against the human baseline<\/span><\/h2>\n\n\n\n
<\/span>What to measure from day one<\/span><\/h2>\n\n\n\n