AI Agent Cost Simulator – forecast multi-step agent spend

An autonomous agent rarely answers in one call. It reads a task, plans, calls a tool, reads the result, plans again, and loops until it decides the work is done. Every pass through that loop is a separate billed request, and the token count usually climbs each time because the growing history rides along. The AI Agent Cost Simulator takes the shape of your agent, the number of loop iterations, the tokens moving in each direction, and your model pricing, then returns what one task costs and what a month of tasks costs. It is built for solo developers and small teams shipping agentic features who need a real number before they turn the loop loose on production traffic.

The gap between a single chat completion and a six-step agent is not small. A chat call might cost a fraction of a cent. The same underlying model wrapped in an agent loop that runs six times, each time re-sending an expanding context, can cost six to twelve times as much per task. When you multiply that by thousands of monthly tasks and a retry rate for the times the agent stumbles, the figure stops being trivia and starts being a line item.

This simulator keeps the arithmetic transparent so you can see exactly which lever moves the total. Cut two steps off the loop, drop to a cheaper model for the planning turns, trim the system prompt that repeats on every iteration, and watch the monthly number respond. Nothing here is hidden behind a black box.

How to use the AI Agent Cost Simulator

Start with how many tasks your agent handles in a month. A task is one complete unit of work: resolving a support ticket, researching a question, refactoring a file, generating a report. Count the whole job, not the individual model calls inside it, because the steps input handles the calls.

Next, set steps per task. This is the number of times the agent goes through its reasoning loop for a single task, including the final answer turn. A tool-light agent that plans once and answers might run two or three steps. A research agent that searches, reads, searches again, and synthesizes commonly runs eight to ten. If you have logs, pull the real average rather than guessing, because this input multiplies everything downstream.

Then enter the average input and output tokens per step. Input tokens are everything the model reads on that turn: the system prompt, the task, the accumulated history, and any tool results pasted back in. Output tokens are what the model writes on that turn, which for planning steps is often short and for the final answer is longer. Use an average across the loop rather than a single step’s count.

If you only have per-task totals from a billing dashboard, divide the total input tokens by your step count to get the per-step average this field expects. That back-of-envelope split is close enough to plan with.

The tool call overhead field captures the extra tokens that function calling adds on each step: the tool schema, the arguments the model emits, and the JSON result fed back. This runs from around 50 tokens for a tiny single-function agent to several hundred for an agent carrying a dozen tool definitions in every request.

Set the input and output prices in dollars per million tokens, taken straight from your provider’s current rate card. Output almost always costs more than input, so keep the two fields distinct rather than averaging them. Finally, set the retry and failure overhead as a percentage. This accounts for the tasks that error out, hit a bad tool response, or need a re-run, all of which burn tokens without producing a clean result. Read the outputs from the top: cost per task first, then the monthly and annual figures, then the token volume and the input-versus-output split.

Calculator fields explained

Tasks per month – The number of complete jobs your agent processes in a month. Default is 1000, step 100. One task can span many model calls; those calls are counted by the steps field, not here.

Steps per task – How many times the agent runs its reasoning loop per task, counting the final response turn. Default is 6, step 1. This is the single strongest multiplier in the model, so measure it from logs when you can.

Average input tokens per step – The mean number of tokens the model reads on each loop iteration, covering system prompt, task text, and accumulated conversation history. Default is 2500, step 100. In agents this number tends to grow across steps as history accumulates, so use a loop-wide average.

Average output tokens per step – The mean number of tokens the model writes per step. Default is 400, step 50. Planning turns are usually short; the final synthesis turn is usually the longest, and the average blends them.

Tool call overhead tokens per step – Extra tokens per step from function schemas, emitted arguments, and returned tool results. Default is 150, step 10. Set this near zero for agents without tools and higher for agents carrying many function definitions.

Input price (USD per million tokens) – Your provider’s input rate. Default is 3.00, step 0.10. Copy it from the current rate card for the exact model you route the agent to.

Output price (USD per million tokens) – Your provider’s output rate. Default is 15.00, step 0.50. This is typically several times the input rate, which is why chatty agents get expensive fast.

Retry and failure overhead (%) – A percentage uplift for tasks that fail, retry, or re-run and consume tokens without a clean result. Default is 10, step 1. Agents with flaky tools or strict output validation often sit at 15 to 25 percent.

Understanding the results

The monthly cost is the figure most people came for, but the cost per task above it is where the diagnosis happens. At the default settings, one task costs about 9.2 cents and a thousand tasks land near 92 dollars a month. If your agent generates ten dollars of value per task, nine cents of cost is comfortable. If it deflects a support ticket worth two dollars, the margin is still healthy but the picture changes once you scale steps or move to a pricier model.

Steps per task is the lever that surprises people. Because each step re-sends the growing context, adding a single loop iteration does not add one step’s worth of cost, it adds a step carrying more history than the step before it. Your monthly cost scales linearly with steps per task only when token counts stay flat; in real agents that grow their context, the scaling is steeper. Watch what happens when you push steps from 6 to 15 in the simulator.

The input versus output split tells you where to aim optimization effort. With the mid-tier defaults, input carries roughly 57 percent of the cost and output the rest, even though output tokens are far fewer, because the output rate is five times the input rate. An agent that writes long intermediate reasoning on every step will tip that balance toward output and reward you for asking it to think more tersely.

The total tokens per month figure is easy to skim past, but it decides whether you hit rate limits. An agent at 50,000 tasks and six steps moves close to a billion tokens a month, which can exceed standard-tier quotas and force you onto a higher plan or a request-pacing layer.

Effective cost per step is your microscope. If it looks high relative to the tokens involved, the culprit is usually a bloated system prompt or a heavy set of tool schemas repeating on every iteration. Trimming a 1,000-token system prompt down to 400 saves 600 tokens on every single step of every single task, and that compounds fast.

Very low inputs, such as a two-step agent on a budget model, can produce a monthly cost under a dollar. That is not a rounding error, it is the honest floor for a lightweight agent. Very high inputs, such as a 20-step deep-research agent on a frontier model with a 25 percent retry rate, can turn a modest task count into a four-figure monthly bill. Both extremes are realistic, which is why the simulator refuses to assume a typical shape and asks you for yours instead.

Calculation formulas

The simulator builds the total from the cost of a single step outward. For one step, the token cost is the input tokens plus tool overhead priced at the input rate, added to the output tokens priced at the output rate.

step cost = (input_tokens + tool_overhead) / 1,000,000 × input_price + output_tokens / 1,000,000 × output_price

A task runs that step some number of times, and the whole task carries a retry uplift for failures and re-runs.

cost per task = step cost × steps_per_task × (1 + retry_percent / 100)

monthly cost = cost per task × tasks_per_month

annual projection = monthly cost × 12

Walk the default numbers through it. Input side per step is 2500 plus 150 overhead, which is 2650 tokens at 3.00 dollars per million, giving 0.00795 dollars. Output side is 400 tokens at 15.00 per million, giving 0.006 dollars. Step cost is 0.01395 dollars. Six steps make 0.0837, and a 10 percent retry uplift lifts it to 0.09207 dollars per task. A thousand tasks produce 92.07 dollars a month and 1104.84 dollars a year.

Tool overhead is priced at the input rate in this model because schemas and returned results are read by the model, not generated by it. The arguments the model emits are technically output, but they are small enough that folding the whole overhead into the input side keeps the estimate within a rounding margin.

Token pricing varies widely by model class, so the simulator does not assume a tier. The table below shows representative rates you can drop into the price fields, region-neutral and expressed per million tokens.

Step count depends on what the agent is built to do, and the second reference table gives realistic ranges. Use it to sanity-check your steps input before trusting the total.

Practical examples

Each scenario below runs the exact formula above, so you can reproduce every number.

Example 1, solo support bot. A solo developer runs 200 tasks a month, 4 steps each, 1500 input and 250 output tokens per step, 100 overhead tokens, on a standard-tier model at 0.50 input and 1.50 output, with 5 percent retry. Step cost is (1600 / 1M × 0.50) + (250 / 1M × 1.50) = 0.0008 + 0.000375 = 0.001175. Task cost is 0.001175 × 4 × 1.05 = 0.004935. Monthly cost is about 0.99 dollars, roughly 11.84 dollars a year. An agent this light is essentially free to run.

Example 2, hobby research agent. 50 tasks a month, 8 steps, 3000 input and 500 output tokens, 200 overhead, mid-tier at 3.00 and 15.00, 10 percent retry. Step cost is (3200 / 1M × 3) + (500 / 1M × 15) = 0.0096 + 0.0075 = 0.0171. Task cost is 0.0171 × 8 × 1.10 = 0.15048. Monthly cost is 7.52 dollars, about 90.29 dollars a year. Low volume keeps the bill small even with a chatty eight-step loop.

Example 3, budget automation agent. 500 tasks, 3 steps, 1200 input and 200 output tokens, 100 overhead, budget tier at 0.15 and 0.60, 5 percent retry. Step cost is (1300 / 1M × 0.15) + (200 / 1M × 0.60) = 0.000195 + 0.00012 = 0.000315. Task cost is 0.000315 × 3 × 1.05 = 0.00099225. Monthly cost is about 0.50 dollars. A short loop on a budget model at moderate volume barely registers.

Notice the pattern across the first three examples: volume alone does not break the budget. Example 3 runs more than twice the tasks of Example 2 yet costs a fifteenth as much, because the budget model and the shorter loop matter more than raw task count.

Example 4, baseline SaaS agent. The default configuration: 1000 tasks, 6 steps, 2500 input and 400 output tokens, 150 overhead, mid-tier at 3.00 and 15.00, 10 percent retry. Task cost is 0.09207 as derived above. Monthly cost is 92.07 dollars, annual 1104.84 dollars. This is the reference point every other change is measured against.

Example 5, growing SaaS agent. Same per-task shape as Example 4 but 5000 tasks a month. Task cost stays 0.09207, so monthly cost is 460.35 dollars and annual is 5524.20 dollars. Volume scales the total cleanly when the loop shape holds steady.

Example 6, coding agent. 800 tasks, 10 steps, 4000 input and 800 output tokens, 200 overhead, mid-tier, 15 percent retry. Step cost is (4200 / 1M × 3) + (800 / 1M × 15) = 0.0126 + 0.012 = 0.0246. Task cost is 0.0246 × 10 × 1.15 = 0.2829. Monthly cost is 226.32 dollars, annual 2715.84 dollars. The long loop and heavy output push the per-task figure past a quarter dollar.

Example 7, production support at scale. 50,000 tasks, 6 steps, 3000 input and 500 output tokens, 200 overhead, frontier tier at 5.00 and 20.00, 12 percent retry. Step cost is (3200 / 1M × 5) + (500 / 1M × 20) = 0.016 + 0.01 = 0.026. Task cost is 0.026 × 6 × 1.12 = 0.17472. Monthly cost is 8736 dollars, or $104,832 per year at 50,000 tasks. At this scale the model tier choice alone is worth tens of thousands of dollars.

Example 8, deep multi-step agent. 2000 tasks, 15 steps, 8000 input and 600 output tokens, 300 overhead, mid-tier, 20 percent retry. Step cost is (8300 / 1M × 3) + (600 / 1M × 15) = 0.0249 + 0.009 = 0.0339. Task cost is 0.0339 × 15 × 1.20 = 0.6102. Monthly cost is 1220.40 dollars, annual 14,644.80 dollars. Deep context accumulation and a high retry rate stack up quickly.

Example 9, runaway loop edge case. 1000 tasks, 30 steps, 5000 input and 300 output tokens, 150 overhead, mid-tier, 25 percent retry. Step cost is (5150 / 1M × 3) + (300 / 1M × 15) = 0.01545 + 0.0045 = 0.01995. Task cost is 0.01995 × 30 × 1.25 = 0.748125. Monthly cost is 748.13 dollars, annual 8977.50 dollars. The same 1000 tasks as the baseline cost eight times as much once the loop runs unchecked at 30 steps.

Tips and best practices

Measure steps per task from real logs before you trust any projection. Teams routinely guess three or four and discover the agent averages eight because it re-plans after every tool call. That single correction can double your estimate, so instrument the loop and pull the actual median across a few hundred tasks.

Attack the system prompt first when the effective cost per step looks high. Anything sitting in the system prompt is paid for on every step of every task, so a prompt you trim from 900 tokens to 350 saves 550 tokens across your entire monthly volume. On the baseline agent that is roughly a 20 percent input reduction for one afternoon of editing.

Route different steps to different model tiers. Planning and tool-selection turns often work fine on a standard-tier model while only the final synthesis needs a mid or frontier model. Splitting a six-step loop into five cheap planning steps and one expensive answer step can cut the per-task cost by half without touching output quality.

Cap your loop length in code. An agent with no maximum step count can spiral on a hard task and burn a hundred steps chasing an answer it will not find. A hard cap of 12 or 15, with a graceful give-up, protects both your budget and your latency.

Set a per-task token budget alongside the step cap. When an agent crosses the budget, have it summarize its state and hand off rather than pressing on. This turns a rare thousand-token runaway into a predictable ceiling you can actually forecast.

Compress accumulated history between steps. Instead of pasting every prior turn verbatim into the next request, summarize older turns once the context passes a threshold. A running summary keeps the input tokens per step from climbing without limit on long tasks.

Track your real retry rate rather than accepting a default. If your tools are reliable and your output validation is loose, 5 percent may be honest. If you enforce strict JSON schemas and your tools time out, 20 percent is closer, and using 5 percent would understate your bill by 15 percent.

Re-run the simulator whenever your provider changes prices. Model rate cards shift, and a mid-tier output price moving from 15 to 10 dollars per million reshapes your input-versus-output balance and your optimization priorities overnight.

Keep tool schemas lean. Every function definition you attach rides in the request on every step. An agent carrying twelve tools it rarely uses pays for all twelve on every iteration, so prune the toolset to what each agent actually needs.

Common mistakes to avoid

Counting model calls as tasks

People often enter their monthly API call count into the tasks field, then set steps to one, which double-counts nothing but hides the loop entirely. A task is one complete job; the calls inside it belong in the steps field.

If your billing shows 30,000 calls and your agent averages six steps, your task count is 5000, not 30,000. Getting this split right is the difference between a sensible estimate and one that is off by the step multiplier.

Ignoring context accumulation

The most expensive habit is entering a flat, low input-token figure for every step when the real agent re-sends its whole growing history on each pass. Step one might read 1500 tokens while step eight reads 9000, and using the step-one number for all eight badly understates the bill.

A 15-step agent that starts at 2000 input tokens and grows 800 tokens per step reads over 10,000 tokens on its final step. Averaged across the loop that is roughly 7600 tokens per step, not 2000. Enter the average, or your monthly figure will be a fraction of reality.

The fix is to use a loop-wide average that reflects the growth, or to summarize history so the growth never happens. Either way, do not plan against the opening step’s token count.

Leaving the loop uncapped

An agent with no maximum step count is a budget hole waiting to open. On a hard or ambiguous task the loop can run far past its usual length, and a handful of such tasks can dominate a month’s cost.

Set a hard cap and a token budget. A runaway loop can multiply cost tenfold compared to a well-behaved one, as Example 9 shows against the baseline. The cap costs you nothing on normal tasks and saves you from the rare catastrophic one.

Averaging input and output prices together

Some estimates use a single blended price for both directions, which erases the fact that output usually costs three to five times input. That blend hides where your money actually goes and points optimization at the wrong target.

Blending a 3-dollar input rate and a 15-dollar output rate into one 9-dollar figure makes short, output-light planning steps look as expensive as long synthesis steps. Keep the two prices separate so the input-versus-output split stays honest.

Always fill both price fields from the rate card. The split output the simulator produces is only useful when the two rates are entered distinctly.

Forgetting retry and failure overhead

Setting retry to zero assumes every task completes cleanly on the first attempt, which no production agent does. Failed tool calls, malformed outputs, and re-runs all consume tokens, and pretending they do not understates the bill.

Even a well-built agent sits around 8 to 12 percent. If yours enforces strict schemas or leans on flaky external tools, measure it, because the true figure could be double the default.

Optimizing output when input dominates

Developers sometimes spend days shortening the agent’s responses when the input-versus-output split clearly shows input carrying most of the cost. Effort spent on the smaller side of the split moves the total very little.

Read the split first, then optimize the larger side. On an input-dominated agent, trimming the system prompt and compressing history pays back far more than clipping output length.

When to use this calculator

Reach for the simulator before you ship an agentic feature to production traffic. The moment you move from a single chat completion to a loop, your cost model changes shape, and a number you were comfortable with per call can become uncomfortable per task. Running the projection first tells you whether the unit economics hold at your expected volume.

It also earns its place during model selection. When you are weighing a mid-tier model against a frontier one for the synthesis step, the simulator turns an abstract quality preference into a concrete dollar difference. Example 7 shows a frontier-tier production agent costing six figures a year, and seeing that number can justify routing all but the final step to something cheaper.

Use it again whenever you change the loop. Adding a verification step, attaching a new tool, or raising the step cap all shift the total, and re-running the projection catches a cost increase before it lands on next month’s invoice.

The teams that get surprised by an agent bill are almost always the ones who priced a single call and assumed the loop was a small multiplier. It is not a small multiplier. Price the loop.

You can skip it for one-shot, single-call features where there is no loop to model. If your feature makes exactly one request per task, a plain token cost calculator answers the question faster, and the steps field here would just sit at one. The simulator earns its keep specifically when the agent iterates.

Related calculators

• Multi-Model API Cost Comparator
• LLM Token Cost Calculator with Caching
• Monthly AI API Budget Calculator
• Tool Use / Function Calling Cost Adder
• Retry Rate Impact Calculator
• Context Window Cost Optimizer
• RAG Cost Calculator
• System Prompt Overhead Calculator

Glossary

Agent – A system that wraps a language model in a loop, letting it plan, call tools, read results, and iterate until a task is complete rather than answering in one pass.

Step – One iteration of the agent loop, corresponding to one billed model request that reads context and produces output.

Task – One complete unit of work the agent performs end to end, made up of one or more steps.

Context accumulation – The growth in input tokens across steps as prior turns and tool results pile into each new request.

Tool call – A step where the model invokes an external function, adding schema, arguments, and returned results to the token count.

Tool overhead – The extra tokens per step from function schemas and their returned results, priced at the input rate here.

Retry rate – The percentage uplift applied for failed, re-run, or invalid tasks that consume tokens without a clean result.

Is a step the same as a tool call? Not always. A step is any loop iteration, including pure reasoning turns with no tool involved. Every tool call is a step, but not every step is a tool call.

Input tokens – Everything the model reads on a step: system prompt, task, history, and tool results, billed at the input rate.

Output tokens – Everything the model writes on a step, billed at the output rate, which is usually higher than the input rate.

Cost per task – The fully loaded cost of one complete task, including tool overhead and retry uplift.

Effective cost per step – Task cost divided by step count, retry included, useful for spotting an expensive single iteration.

Blended cost – A single averaged price across input and output, which hides the real split and is best avoided in agent estimates.

Annual projection – Monthly cost multiplied by twelve at flat volume, a planning figure rather than a guarantee.

Frequently asked questions

How is an agent task different from a single API call?

A single API call is one request and one response. An agent task is a whole job that may require many calls, because the agent loops through planning, tool use, and revision until it decides the work is done.

At the default six steps, one task equals six billed requests, so a task costing 9.2 cents is six separate calls stacked together, each carrying more context than the last.

Why does adding one step cost more than a fixed amount?

Because each step re-sends the accumulated history, a later step reads more tokens than an earlier one. Adding a step appends an iteration that carries the fullest context so far.

In an agent growing 800 tokens of history per step, the tenth step might read three or four times what the first step read, so the marginal step is more expensive than the average.

Does output really cost more than input?

Yes, on nearly every provider output is priced higher than input, commonly three to five times higher. That gap is why a wordy agent gets expensive even when it reads little.

Output tokens cost five times input tokens here at the mid-tier defaults, so 400 output tokens can rival 2000 input tokens in cost. Keeping intermediate reasoning terse pays off directly.

What retry rate should I use if I have no data?

Start at 10 percent for a reasonably reliable agent. Drop to 5 percent only if your tools are stable and your output validation is loose.

Agents with strict JSON schemas or external tools that time out often measure 15 to 25 percent, and using 10 there would understate the monthly figure by a meaningful margin.

How do I estimate tokens per step without measuring?

Add up your system prompt, a typical task description, and the tool schemas, then add a growth allowance for accumulated history. That gives a rough input figure per step.

For a quick first pass, take your per-task total input tokens from a billing dashboard and divide by your step count. It is an approximation, but it lands close enough to plan a budget.

Once the agent runs in production, replace the estimate with the logged average, which is almost always higher than the initial guess because context growth is easy to underestimate.

Can I model an agent that uses two different models?

The simulator uses one input and one output price, so for a two-model agent run it twice: once for the cheap planning steps and once for the expensive synthesis step, then add the results.

Split the step count accordingly, for example five steps at the standard tier and one at the frontier tier, and the sum is a fair estimate of the mixed-routing cost.

Why is the annual number just monthly times twelve?

The projection holds volume flat to give a clean planning baseline. It does not assume growth, seasonality, or price changes, because those are specific to your situation.

If you expect task volume to climb, scale the monthly figure up before multiplying, since the annual line will otherwise understate a growing agent by a wide margin.

Does the simulator include the cost of the tools themselves?

No. It prices the tokens that tool calls add to model requests, but not any separate fees for the external services the tools reach, such as a search API or a database query charge.

If your tools carry their own per-call pricing, calculate that separately and add it to the monthly total the simulator produces for a complete picture.

Disclaimer

This calculator produces educational estimates for planning. The numbers depend on the specific model, the provider, your prompt structure, your tool design, and the current rate card, all of which change over time and between vendors. Treat the output as a starting point for a budget conversation, not a fixed quote.

Real agent behavior varies more than any formula captures. Context growth, retry patterns, and step counts shift with the difficulty of incoming tasks, so your measured cost will differ from any single projection. Cost outputs here are not financial or business advice.

Before you commit real spend, verify every price against your provider’s current published rates and check your token and step assumptions against your own logs. The live calculator on this page is the source of truth for its exact fields and current behavior, so use it directly rather than relying on the figures reproduced in this article.

Run a small real test at low volume before scaling the agent to production traffic. A few hundred live tasks will tell you your true steps per task, token growth, and retry rate more accurately than any estimate, and those measured inputs are what make the projection trustworthy.