AI agent cost and what it takes to run one every month

AI agent cost is four lines added together: a one-time build, per-run token spend, orchestration infrastructure, and the human review step. Only the build is paid once. The other three bill every month, and at volume they decide whether the agent is worth running, so a build quote on its own tells you the smallest part of the number.

TL;DR: The cost of an AI agent is four lines: a one-time build, per-run tokens, recurring orchestration infrastructure, and a human review step that rarely appears in the quote. Market build bands run from roughly $5k for a narrow single-model agent to $500k and up for a production multi-agent system. Token spend is trivial at low volume and becomes a real line at volume, driven more by context re-reading and retries than by the model's headline price.

How much does an AI agent cost, line by line?

Running an AI agent costs money on four separate lines.

• Build is one-time engineering: scoping the task, wiring the tools and APIs, writing prompts, and building the evals and the review queue. Most quotes cover only this line.
• Tokens are recurring and billed per run. Every model call charges for input and output tokens, and the bill scales with context size, the number of steps and retries. This is usually the smallest line at launch and the one that surprises teams at volume.
• Orchestration infrastructure is the always-on machinery around the model: the queue or state machine that runs the agent, the vector store or memory layer, tracing and logging, and hosting. It is a mostly flat monthly cost that grows slowly with volume.
• The human review step is someone reading flagged outputs, fixing the wrong ones and feeding corrections back. For any agent that touches consequential work, this is recurring labor billed monthly, and most plans leave it out.

If your budget covers only the build, the agent will turn out cheaper to build than to run.

Token maths for a real agent at three volumes

Token cost is the easiest line to estimate and the one teams most often get wrong, because the model's list price is only one factor. The number you need is tokens per run, times runs per month, times a retry multiplier, times the price.

Take a lead-triage agent with three steps. It looks up the lead in the CRM and gathers context, drafts a first reply, then checks its own confidence. Assume 20,000 input tokens per run (system prompt, tool schemas and retrieved context, re-read across steps) and 1,000 output tokens.

Prices come from the Anthropic pricing page and the OpenAI pricing page as listed in September 2026, at standard rates per million tokens. Claude Sonnet 5 and gpt-6-sol both list $2 input and $10 output. Claude Haiku 4.5 lists $1 and $5. gpt-6-luna lists $0.10 and $0.50.

On Sonnet 5 or gpt-6-sol, 20,000 input tokens cost $0.04 and 1,000 output tokens cost $0.01, so one run costs about $0.05. The same run costs $0.025 on Haiku 4.5 and $0.0025 on gpt-6-luna.

These figures are arithmetic on list prices, with no benchmark behind them. List prices change, and your context size and retry rate will differ. The shape holds: input tokens dominate, and they scale with context and retries more than with the model's price. Double the context to 40,000 tokens and add a 1.5x retry multiplier, and the Sonnet 5 run goes from $0.05 to about $0.135, or roughly $1,350 a month at 10,000 runs instead of $500.

The top tier moves the numbers again. Claude Opus 5.5 lists $4 input and $20 output, about $0.10 for this run. gpt-6-astra lists $10 and $50, about $0.25 a run and $2,500 a month at 10,000 runs.

The costs of AI agents that teams forget

The build quote and the token estimate still undercount the bill. Four recurring costs sit outside both.

• Retries. A rate-limited CRM call or a tool that returns a 400 makes the agent re-run, and every failed attempt still bills tokens. A 1.3x to 2x retry multiplier is common, and a flaky integration pushes it higher.
• Evals per deploy. The regression suite you run before each change costs money. A 500-case eval at 5,000 input tokens per case is 2.5 million tokens, which is $5 at $2 per million before output tokens and any LLM-as-judge calls, which can double it. Run it on every commit and it becomes a monthly line. Our guide to building an LLM eval suite covers how to size it so you run the full set only when it matters.
• Tracing storage. Tools like LangSmith or Langfuse store every span, and storage grows with volume and retention. A month of traces at 10,000 runs is a small bill, while a year of retained traces is not. Set retention and sampling on purpose. AI agent observability goes through which spans to keep.
• On-call rotation. The agent will misbehave at 2am, through a provider outage, a broken tool or a prompt regression, and someone gets paged. That is engineering time, the most expensive line per hour, and no build quote includes it.

AI agent pricing bands for the build, by scope

Build cost is a range, and scope sets the range more than the vendor's brand does. These are market bands we see across agency quotes and freelance marketplaces, not a Robust Devs price list. They vary by region and by how much integration and compliance work the job carries.

• A narrow point agent, with one model, a handful of tool calls, internal use and limited human review, runs roughly $5k to $25k.
• A mid-scope orchestrated agent, with a multi-step state machine, retrieval, a human-in-the-loop review queue and basic evals, runs roughly $25k to $100k.
• A production systems agent, with multiple agents, observability, regression evals, auth, and security or compliance review, runs roughly $100k to $500k and up.

Several variables move you within a band: how clean the data sources are, how many third-party systems the agent touches, whether compliance requirements such as SOC 2 or HIPAA shape the data flow, and how much of the review step you automate. A narrow agent plugged into one clean CRM lands at the bottom. A multi-agent system touching legacy systems and regulated data lands at the top. The build line follows the same logic as any custom software build, and the custom software development cost guide breaks down what moves a quote.

For an agent that runs for years, the build is the smallest share of lifetime cost. Tokens, infrastructure and review compound monthly. The best lever on build cost is scoping the real inputs, consequences and integration points before anyone writes code, which is what a Discovery Sprint is for.

Where you can cut AI agent cost

Four levers cut the recurring lines, and together they are worth more than negotiating a better model price.

• Caching. On Sonnet 5, Haiku 4.5 and the gpt-6 models, both providers bill a cache hit at a tenth of the base input price. Anthropic's prompt caching docs charge 1.25x base input to write a 5-minute cache entry, and OpenAI's prompt caching guide applies caching automatically to repeated prompt prefixes of 1,024 tokens or more on GPT-5.6 and later models. Both work on the prefix, so put the static system prompt and tool schemas first and the per-run data last. If 15,000 of the 20,000 input tokens in the example above are a stable prefix, the Sonnet 5 run drops from $0.05 to about $0.023.
• Model routing. Send easy steps to a small model and escalate to a larger one only when a step needs it. The saving depends on the pair: gpt-6-luna costs 95% less per token than gpt-6-sol, while Haiku 4.5 costs half as much as Sonnet 5.
• Shorter contexts. This is the biggest lever, because token spend scales with what each step re-reads. Pass each step only the slice it needs, and summarize history instead of appending all of it. A three-step agent that reads a 4k slice per step spends a third of the input tokens of one that re-reads 12k each step.
• Fewer agents. Multi-agent orchestration multiplies tokens, because each agent re-reads context and adds its own scaffolding. Collapse to one agent with explicit steps unless you need parallel work or isolated failure domains. Most "agents" in a design turn out to be steps. Our piece on multi-agent systems covers when the split earns its token bill.

A one-page model for the monthly cost of an AI agent

Bring the four lines into one monthly number. Estimate each line, then add them.

Monthly cost = (build divided by the months you amortize it over) + (tokens per run times runs per month times retry multiplier times price per token) + infrastructure + (flagged runs times minutes reviewed per run times loaded hourly rate divided by 60)

To see how the review line behaves, say 10,000 runs a month flag 5% for review, at 3 minutes each and a $60 loaded hourly rate. That is 500 reviews, 25 hours and $1,500 a month, three times the $500 token bill in the Sonnet 5 example. Cutting the flag rate is often worth more than switching models.

What to do before you commit to a budget

Instrument a prototype before you sign off on an AI agent cost estimate. Log input and output tokens per step, count retries, and record how many runs a person had to touch. A week of that data replaces every assumption in the model above with your own figures, and it shows which of the four levers to pull first.

If you want to run your own figures, estimate your agent's monthly cost with the cost estimator.