What Does an AI Agent Actually Cost to Run?

By now, running AI agents isn't a differentiator. A stats roundup published in mid-September 2026 puts the figure at roughly 79% of companies running AI agents in some form. Nearly everyone has something in production or close to it.

What almost nobody has is a number. Ask a VP of Operations what one resolved support ticket costs when an agent handles it end to end, and you usually get a model price per million tokens, a shrug, and a promise to "pull the usage dashboard." That gap is exactly what Forrester captured in its 2026 assessment of agentic AI, headlined "Companies Are Chasing, Few Are Catching."

Chasing is an adoption problem. Catching is a margin problem. And it's budget season — the pilots greenlit in 2026 are being asked two questions right now: what did this return, and what does it cost at ten times the volume?

Your agent's problem probably isn't intelligence. It's gross margin.

Most agent programs stall not because the model can't do the work, but because nobody modeled what the work costs when it runs thousands of times a day with retries, escalations, and humans checking the output.

Here's the uncomfortable framing: if you can't state your cost per successful outcome, you don't have an AI program. You have an unbounded variable cost line with a dashboard attached.

Traditional software budgeting doesn't prepare you for this. Seat-based SaaS costs the same whether your team uses it once or a hundred times. Agentic workloads are the opposite — every unit of work consumes compute, and the volume is exactly what you're trying to grow.

The formula that belongs in your board deck

One line of arithmetic reframes the entire conversation:

Cost per successful outcome = (model cost + tool/API cost + retry cost + human review cost + observability cost) ÷ tasks completed autonomously

Note the denominator. It isn't tasks attempted. It's tasks the agent finished without a human rescuing it. Every failed trajectory still consumed tokens — it just produced no value, so its cost gets absorbed by the tasks that worked.

A worked example

The numbers below are illustrative — your workload will differ — but the structure is what matters. Say you're triaging inbound support tickets at 10,000 tickets per month:

• Model inference: multi-step reasoning, tool calls, and a verification pass across 10,000 attempts
• Tool and API calls: CRM lookups, knowledge-base retrieval, ticketing system writes — each metered, each billed
• Retries: the share of attempts that fail mid-trajectory and re-run, consuming full token cost for zero output
• Human review: the escalation rate multiplied by a loaded agent-hour cost
• Observability: logging, tracing, and evaluation runs — small per task, real at volume

Now divide by the tickets actually closed autonomously. If your agent handles 10,000 attempts but only completes 6,000 without human intervention, your true denominator dropped by 40% while your numerator stayed flat. The cost per resolved ticket is not what the usage dashboard says. It's substantially higher.

Run that math honestly and you get one of three answers: the agent is cheaper than the human process, roughly even, or more expensive. All three are useful. Only the first one justifies scaling. The second says fix the architecture before you add volume. The third says you found an expensive way to do something you were already doing.

The four places money leaks

1. Retry loops and failed trajectories

An agent that gets stuck, loops, and eventually gives up may burn more tokens than one that succeeds. Unbounded retries are the single most common cause of a cost curve that outruns a usage forecast. Step budgets, loop detection, and early-exit conditions are cost controls, not just reliability features.

2. Over-specified models on trivial steps

Agentic workflows are chains of steps, and most steps are boring: classify this, extract that, format the output. Routing every step to a frontier model is the equivalent of flying a cargo plane to deliver an envelope. Model tiering — cheap models for cheap steps, expensive models only where reasoning actually matters — is usually the largest single lever available.

3. Context bloat

Paying to re-read the same policy document on every invocation is a recurring charge for information you already have. Caching, retrieval that returns the relevant passage instead of the whole file, and disciplined context assembly all reduce token spend per task without touching output quality.

4. Escalation rates nobody instruments

If you don't measure your autonomy rate — the percentage of tasks completed without a human — you cannot calculate cost per outcome at all. Many teams track model spend precisely and human intervention not at all, which is measuring the cheap half of the equation.

Cost is a design decision, not a bill you receive

Model pricing is not a fixed input you plan around. OpenAI launched its Astra model in early September 2026, and release timelines are now tracked on live, rolling trackers that update within hours — alongside cheaper open-weight options like Apertus and Kimi. The price-performance frontier for any given task moves on a weekly cadence.

That has one practical implication for budgeting: "we standardized on one provider's pricing" is a fragile assumption. If your architecture hard-codes a single model into your agent logic, you can't capture savings when a cheaper option ships — you can only rebuild. We've written before about why your stack shouldn't change every time your model does; the economic version of that argument is that re-routability is a cost-control feature.

Designing for cost means model tiering, caching, routing layers, step budgets, and instrumentation on autonomy and escalation from day one. Retrofitting those into a system built for a demo is expensive. Building agentic AI systems with unit economics as a first-class requirement is not.

Five questions to ask any AI vendor this quarter

• What is our projected cost per successful outcome at ten times current volume? If the answer is a token price, they haven't modeled it.
• Who owns the observability data? If you can't see per-task traces and costs, you can't manage them.
• What happens to our cost when a cheaper model ships? The answer should be "we re-route," not "we re-platform."
• What autonomy rate are you targeting, and by when? That number is your denominator.
• What's the escalation SLA when the agent hands off to a human? Escalation is a cost, a latency hit, and a customer experience event.

What to do before you sign the 2027 line item

Pick one workflow — the one with the highest volume and the clearest success definition. Instrument it: token cost per attempt, retry rate, tool call cost, escalation rate, review minutes. Then divide. You'll have a defensible number in a week or two, and that number will tell you whether to scale, redesign, or stop.

Do this for one workflow and you'll have a template for every other one. Skip it, and you'll defend a 2027 budget with adoption metrics in a year when adoption stopped being the point.

Talk to Levels AI

We build agentic systems with cost per outcome as a design constraint, not a line on an invoice you discover in month three. If you're preparing a 2027 AI budget and need a defensible number, we'll model the unit economics of one workflow with you — inference, tools, retries, review, and observability — before any build commitment.

Start with an AI consulting conversation. Bring the workflow you're least sure about. We'll do the arithmetic.