How Much Does an AI Agent Cost to Run? Cost Per Task in 2026

A tool-using agent run costs between one cent and about fifty cents per task on today's mainstream API models, and a long 30-step run costs between five cents and five dollars. Using a 4,000-token system prompt plus tool definitions, 1,500-token tool results and 300 output tokens per step, a 12-step run costs $0.0089 on DeepSeek V4 Flash ($0.05/$0.16 per 1M), $0.14 on Gemini 3.8 Flash ($0.75/$3.75), $0.37 on Claude Sonnet 5 ($2/$10) and $0.47 on GPT-5.4 ($2.50/$15). All prices are USD per 1M tokens from our catalogue, updated 2026-09-11.

Those numbers assume no prompt caching. With caching the same runs land at roughly $0.12 (Sonnet 5), $0.15 (GPT-5.4) and $0.06 (Gemini 3.8 Flash). The rest of this guide shows where every token comes from so you can rebuild the estimate for your own agent; the cheapest LLM for AI agents guide ranks 30 models on the same trace.

An agent is a loop. Each iteration sends the system prompt, the tool schemas, the user task, every previous assistant turn and every previous tool result, then reads back a short assistant turn that usually contains a tool call. The model never remembers the last step; you re-send it.

The reference trace used throughout this guide:

• System prompt plus tool definitions: 4,000 tokens, sent on every step
• Tool result appended after each step: 1,500 tokens
• Assistant output per step (reasoning plus the tool call): 300 tokens
• Context at step k = 4,000 + (k - 1) × 1,800 tokens

So step 1 sends 4,000 tokens, step 12 sends 23,800 and step 30 sends 56,200. Summed over a run:

• 5 steps: 38,000 input tokens, 1,500 output tokens
• 12 steps: 166,800 input tokens, 3,600 output tokens
• 30 steps: 903,000 input tokens, 9,000 output tokens

A 30-step run only ever produces 49,000 tokens of unique material (4,000 system plus 30 × 1,500 results) yet bills 903,000 input tokens. That 18× multiplier is the whole story of agent cost.

Cost = input tokens × input rate + output tokens × output rate. For Claude Sonnet 5 at 12 steps: 166,800 × $2/1M = $0.3336, plus 3,600 × $10/1M = $0.036, total $0.3696. The same arithmetic on each model:

Two things stand out. Going from 12 to 30 steps multiplies cost by about 5×, not 2.5×, because context growth is quadratic in step count. And output tokens are almost irrelevant: on Sonnet 5 the 30-step run spends $1.806 on input and $0.09 on output. "Keep responses short" barely moves an agent bill; keeping the context short does. Per step on Sonnet 5, step 1 costs $0.011 and step 12 costs $0.051, five times as much for the same amount of new work.

In the 12-step trace, 166,800 of the 170,400 billed tokens (98%) are input, and most of those are identical to what was sent one step earlier. Prompt caching exists for exactly this shape: the provider stores the processed prefix and charges a reduced rate when you send it again.

Cache reads cost roughly 10% of the list input rate on Anthropic and OpenAI, and roughly 25% on Gemini. Anthropic also charges roughly 125% of list for the initial cache write. These are approximate multipliers, not catalogue rows, so treat the figures below as estimates:

With caching, the 30-step Sonnet 5 run drops from $1.90 to about $0.40, a 79% cut, because only the newest 1,800 tokens per step bill at full rate. Caching works on a prefix, so anything that changes early in the prompt (a timestamp, a re-ordered tool list) silently disables it; check the cached token count in the usage object on every call. Our prompt caching cost comparison covers the per-provider rules.

Per-token prices tell you what a run costs, not what a finished task costs, and the finished task is what a buyer should optimise. Cost per successful task = cost per run ÷ success rate, plus whatever a failed run costs in retries or human review.

A worked example with assumed success rates (measure your own; these are illustrative):

• DeepSeek V4 Flash: $0.0089 per run at 50% success = $0.018 per success
• Gemini 3.8 Flash: $0.139 per run at 75% = $0.185 per success
• Claude Sonnet 5: $0.370 per run at 92% = $0.40 per success

The cheap model still wins on API spend alone. It stops winning the moment a failure costs anything: five minutes of a person's time per failed run outweighs the $0.35 saved. It also stops winning when the weaker model takes more steps. A Gemini 3.8 Flash run that wanders for 30 steps ($0.71) costs nearly twice a Sonnet 5 run that finishes in 12 ($0.37). Track steps-to-completion per model; it predicts cost better than the per-token rate. The practical pattern is to route to the cheap model first, validate, and escalate failures; the cheapest LLM for AI agents guide has the routing code.

For a well-specified agent with strict tool schemas and a validator on every tool call, Gemini 3.8 Flash ($0.75/$3.75) and GPT-5.4 mini ($0.75/$4.50) are the cheapest models we would run unattended: both cost about $0.14 for the 12-step trace, follow JSON schemas consistently, and rarely need more steps than a flagship for routine work. DeepSeek V4 Flash at $0.0089 per run is a genuine option for high-volume, low-stakes loops (classification, enrichment, scraping) where a retry is free.

Pay for Claude Sonnet 5 or GPT-5.4 when the task is open-ended, when a wrong tool call has side effects (sending email, editing code, moving money), or when the cheap model's step count blows out. Pay for Claude Opus 5 ($5/$25, $0.92 per 12-step run) or GPT-5.5 ($5/$30, $0.94) only for the planner role in a multi-agent setup or where a single failure costs more than a dollar. Most teams get the best per-task cost from a flagship planner delegating to cheap workers. The Claude, OpenAI and Gemini agent cost guides break down each family.

Agents fail expensively when they loop. Four controls, in order of how often they save money:

• Max steps: hard-stop the loop at N tool calls. For most task types 15 is generous; if a run needs 30 it is usually stuck.
• max_tokens per call: the largest plausible tool call plus a short explanation, typically 1,000 to 4,000 for agent turns. It stops runaway monologues, not context growth.
• Stop conditions: end on a final_answer tool call, a repeated identical tool call (a loop signature), or an empty tool result twice in a row.
• A per-run USD budget computed from usage: after each call, add input_tokens × rate_in + output_tokens × rate_out (cache reads at the reduced rate) to a running total and abort past your ceiling.

A $0.50 per-run budget on Sonnet 5 permits about 14 uncached steps of the reference trace, or roughly 35 cached steps. For work that is not latency-sensitive, batch endpoints cut list prices by roughly 50% on Anthropic and Google; useful for overnight backfills, useless for a loop that needs each step's result before the next. See LLM batch API pricing.

Plug your own figures into the formula. With S = system plus tools tokens, R = average tool result tokens, O = average output tokens per step and N = steps:

• Total input tokens = N × S + (R + O) × N × (N - 1) ÷ 2
• Total output tokens = N × O
• Run cost = input tokens × rate_in ÷ 1,000,000 + output tokens × rate_out ÷ 1,000,000

Then divide by your measured success rate and add the cost of the escalation path. Three reductions worth trying before you change model: summarise or drop tool results once they are a few steps stale (this attacks the quadratic term directly), trim tool schemas so S is nearer 2,000 than 6,000, and enable caching so re-sent context bills at the reduced rate. The AI cost calculator takes monthly token volumes; multiply run cost by runs per month for a budget line, and see the API vs subscription guide if a subscription tool is on the table.