AI agent cost guide: why agents are expensive

The cost that catches teams off guard with AI agents comes from the loop, not a single answer. An agent thinks, uses a tool, reads the result and decides what to do next - over and over. That loop is what makes agents useful, and also why a simple-looking task can run up a surprisingly big bill.

One task, many calls

A chatbot answers a message with one call to the AI. An agent rarely gets off that lightly. To finish one job it plans, picks a tool, reads what comes back, decides the next move, sometimes tries again, and writes a summary at the end. Anywhere from five to fifty calls for a single task is normal - and every call re-sends the standing instructions and everything gathered so far. That repeated text is where the money goes, because it piles up faster than the answers the agent actually writes. Caching the part that stays the same is the single best fix; the caching guide explains when it's worth it.

A few things decide how big the bill gets: how many steps the task takes, how many tools it uses (each one is an extra round-trip), how often steps fail and retry, and how much context rides along on every call. If one in seven steps retries, that's 15% on top of everything - which is why agents catch out people who only budgeted for things going smoothly.

Two things do most of the work

The two biggest levers point the same way. The first is using the right model for each job: a capable one for the planning and final answer, a cheap one for the routine steps. Sending everything to the cheapest model feels thrifty but usually costs more, because weak planning leads to wrong turns and extra retries. The second is reliability. If tasks only succeed 80% of the time, you're paying for the 20% that fail - so think in terms of cost per finished task, not cost per call. Make the agent more reliable and you win twice: fewer retries, and fewer runs thrown away. The agent cost calculator lets you try different model setups before you commit.

Follow one task through

Take a research agent asked to compare three suppliers. It might draw up a plan, run a few searches, open some pages, pull out facts, notice something missing, search again, and finally write the comparison. What looked like one request has quietly become a dozen AI calls and just as many tool uses.

The expensive part usually isn't the final write-up. It's everything the agent drags along the way: the original instructions, the tool list, search results, notes and earlier decisions. By the last step it's reading far more than it writes.

Give the agent a spending limit it understands

Agents need stopping rules - a cap on steps, retries, spend and time. And decide what happens when it hits the limit: hand back what it has, or pass it to a person. An agent silently looping forever is both expensive and a pain to debug.

Limits work best with a quick progress check. Every few steps, ask whether the agent has actually learned anything new or is just repeating itself. If it's going in circles, stop it - don't hand it another retry.

Make tools easy to use correctly

Clear tool names and helpful error messages save a surprising amount. If a tool is fussy and gives a vague error, the agent burns several calls guessing. If it accepts one clear format and says exactly what was wrong, the agent fixes it in one. Keep what tools hand back small, too - a database lookup should return the few rows that matter, not a giant dump the agent has to wade through. Often the best way to cut tokens is just tidier software.

Different jobs, different models

Planning, pulling out facts, calling tools and writing the final answer don't all need the same model. A stronger model for planning can be worth it if it stops dead ends. Routine steps can go to a cheap one. The final answer can use whichever model meets your quality bar. Test these setups on whole tasks, not single prompts - a model that's cheaper per call can still cost more per finished task if it needs extra steps.

Measure results, not activity

The numbers worth watching: cost per finished task, steps per task, how often each tool fails, how often a person has to take over, and how often a task hits its limit. Token totals are fine to know, but they don't tell you whether the work was any good.

During launch, look at the failed and unusually pricey runs each week. They almost always point to a few fixable things: one flaky tool, an oversized result, a missing stop rule, or a prompt that invites the agent to wander.