Cost of Building an AI Agent in 2026: Pilot to Production

The cost of building an AI agent has two halves that behave differently. The build is a one-off spend dominated by people and integration work — connecting the systems the agent must touch, handling their auth, and designing the approval step that stops a wrong action reaching a customer. The run is a monthly spend of model tokens, observability and vector tooling, and the engineering time to keep it reliable. At pilot volume the monthly bill is mostly salary, not tokens: in the worked example below — 10,000 tasks a month on a mid-tier model — engineering time is about 86% of it and the model API about 8%. The number worth tracking is cost per completed task.

Key takeaways

• People dominate at pilot volume — and the biggest line is the one most estimates leave out. At 10,000 tasks a month, maintenance engineering is ~86% of the included monthly run cost and the model API is ~8%. Add the human review that figure excludes — at 20 seconds a task and a software-developer loaded rate — and review alone outweighs model, tooling and maintenance combined.
• The same workload costs about 108× more on a flagship model than on the cheapest tier: $18 versus $1,950 a month for the same task volume, on prices re-checked 13 October 2026.
• Token prices are not comparable across models. Anthropic’s newer tokenizer “produces approximately 30% more tokens for the same text” — so $2 per million is not $2 of the same work.
• Agents spend more tokens than chat — “about 4× more,” in Anthropic’s data on its own systems. A chat-era token estimate under-budgets an agent.
• Prices move inside weeks and models retire on someone else’s schedule. Our table is dated and has a hard trigger on it: Google’s Gemini 3.6–3.8 Flash prices double on 1 January 2027 (the cheaper Flash-Lite rows in our table are unchanged).

Budget owner: jump to the worked example, then to the costs estimates usually miss. Engineer: the run-cost formula and the volume crossover are where the arithmetic lives.

What are you actually pricing when you ask what an AI agent costs?

Three different things get called “an AI agent,” and they differ by what is included, not by a dollar range.

Pilot — one bounded workflow, one success metric, one or two systems to read from and write to, a human confirming anything irreversible. Production single agent — the same workflow hardened: several integrations, an eval suite, an audit trail, an approval queue, and someone on call when a vendor changes an API. Multi-workflow program — several agents sharing retrieval, tooling and routing, run by a standing team.

The tiers map onto how we scope and build AI agents: a bounded pilot is quoted fixed-price when the question and the data are already known, and Time & Materials when the real effort only becomes clear as you go — which our engagement-models page notes is common in AI work, while a multi-workflow program runs as a dedicated team or Time & Materials. If you need the definition layer first, what an AI agent is and what it automates covers it. The routing and provider-abstraction layer a multi-workflow program needs has its own cost drivers, treated separately in our piece on the orchestration layer.

Every number below rests on this block. These are our assumptions, not measurements, and they are the inputs to change first:

That is 12,000 input plus 1,500 output, or 13,500 tokens per task. A sanity check on it: a chat-shaped support exchange runs in the low thousands of tokens, so our figure is several times a chat workload — the direction of the multiplier in Anthropic’s write-up of its own multi-agent research system, which reports that “agents typically use about 4× more tokens than chat interactions.” Read that for what it is: Anthropic’s own data, on a research agent rather than a back-office one, from a company that sells tokens. Ours is a deliberately agentic estimate, not a measurement — and replacing it with a measured number is the highest-value output of a pilot.

How much does it cost to build an AI agent, stage by stage?

We don’t publish a rate card. The reason is on our own engagement models page: cost “is driven by target scale, architecture, compliance requirements, integrations and how much of the stack already exists, and it is quoted after scoping, never published as a rate card.” So this section gives you what we do publish — shapes and durations — plus an independent reference line you can check yourself.

Read those two rows separately, because they are different engagements. The month-ish MVP figure is a guide for a fixed-scope build and carries no published headcount; the 2–4 engineers plus a Tech Lead belongs to an ongoing dedicated team. Multiplying one by the other would invent a number neither of them states — which is exactly the kind of figure this guide exists to help you interrogate.

A reference line, so the durations convert to money. The US Bureau of Labor Statistics puts the median annual wage for software developers at $135,980 in May 2025, and its June 2026 compensation release puts wages at 70.0 percent of total employer cost for private-industry workers. Dividing one by the other is our arithmetic, not a published figure — and it uses the all-private-industry benefit ratio, not a software-specific one: $135,980 ÷ 0.70 ≈ $194,257 a year ≈ $16,200 per loaded engineer-month— a single loaded engineer-month, in the US, on public data.

That is a unit, not a quote: multiply it by whatever team size and duration your own scope actually implies. It is a floor (it excludes recruiting, equipment, management, QA, PM and design), it is a US in-house figure, and it is not a Trembit price, not an agency quote, and not a claim about anyone’s relative cost. Use it the way you would any sanity check — to ask a vendor which of these lines their number does and doesn’t cover.

Where does the build effort actually go if it isn’t the model?

This is where estimates go wrong, because the model call is the cheap, fast part. We built Chambiar, an agent that acts across Gmail, Slack and Google Drive from plain-language prompts. The model work was real — LangChain orchestration, intent classification, tool calling — but look at what sat around it:

• Three integrations, three sets of everything. Each platform has its own authentication flow, permission scopes, rate limits and token refresh cycles — and the agent must hold valid credentials for all three at once and survive one expiring mid-task.
• Unified OAuth with encrypted per-user token storage and automatic refresh, behind a single onboarding flow.
• Action preview and confirmation before anything high-impact, such as emailing a client or sharing a file externally.
• Task history and an activity feed, so a user can see what was automated and when.
• Audit logging of the triggering prompt, the interpreted intent, the API calls made and the outcome.
• Modular integrations, so adding Calendar or Jira later is one module rather than a rewrite.

The pattern holds outside agents too. On Eska, an AI leasing-risk platform — an ML/NLP scoring pipeline, not an LLM agent — the engineering read: “We spent more time on reliable contract parsing than on the scoring model itself — because garbage in from messy documents means garbage out from any algorithm.”

So before anyone talks about a model, an agent estimate needs lines for: per-system auth and token lifecycle; the confirmation step and its interface; task history and audit logging; the extraction path that turns messy inputs into something a model can use; and an eval suite. A quote with a line for “LLM integration” and nothing for most of that is not an estimate for this.

What does it cost to run an AI agent each month?

Three lines: model, tooling, people.

1. Model API. The formula:

monthly cost = (tasks × calls per task × tokens per call ÷ 1,000,000) × price per million

Run input and output separately — output costs several times input, commonly 4–6× across the rows below. Prices below are per million tokens, read from each vendor’s own pricing page on 13 October 2026; the right-hand columns apply them to our 120M input / 15M output month.

The same task volume, $18 to $1,950 — a 108× spread (same tasks, not identical token counts; see the tokenizer caveat below). Four published details change that arithmetic:

• Cache reads. A cached prompt prefix reads at 0.1× the base input on most Claude models — and at 0.05× on Opus 5.5 and Sonnet 5.5, the tier our worked example uses, or 0.025× on Fable 5.1. An agent re-sends a near-identical system prompt and tool block every call, so this is the cheapest lever to pull.
• The batch discount probably does not apply. The Batch API is 50% off input and output, but it is asynchronous. Anthropic excludes it from its own Managed Agents product because “Sessions are stateful and interactive. There is no batch mode.” The same holds for any interactive agent path.
• Tool definitions cost tokens before the model does anything. Enabling tools on Claude Sonnet 5.5 adds a 286-token system prompt, plus your own tool names, descriptions and schemas, on every call.
• Tokenizers differ. Claude 4.7 and later use a newer tokenizer that “produces approximately 30% more tokens for the same text.” A per-token price is not a per-unit-of-work price across vendors, or even across generations.

2. Tooling. Order of magnitude, not a recommendation: trace-level observability plus a managed vector store lands around $50–$250 a month at pilot scale. Langfuse Core is $29/month (100k units, $8 per extra 100k), rising to Pro at $199/month; Pinecone Builder is “$20/month flat” and Standard “$50/month min. usage” (both checked 3 October 2026). We don’t itemise hosting — we have no re-fetched vendor figure for it, and for a single agent it is a rounding error against the people line.

3. People. Somebody watches the dashboards, triages eval regressions, edits prompts and tool schemas when a vendor API shifts, and does the migration when a model retires. Assume 0.25 of one engineer for one production agent — our assumption, not a measurement — which at the $16,200 reference is about $4,047 a month.

What does a realistic agent cost per month at 10,000 tasks?

Scenario: a back-office document-triage agent — read an inbound document, pull the fields, check them against a system of record, then route or queue it. 10,000 tasks a month on the assumptions above. An illustration with labelled assumptions, not a client result.

Take the mid-tier line from the table — 120 × $2 input plus 15 × $10 output = $390 — and add the other two:

What that total does not include, and you should add before quoting it to anyone: the human review time for whatever share of tasks gets checked (at 10,000 tasks and 20 seconds each, that alone is ~55 hours a month — on its own larger than the 0.25 FTE maintenance line above); retried and failed runs, which consume tokens without completing a task; evaluation runs; hosting and egress; security review; and the build itself. Those are excluded because they are scope-dependent, not because they are small — the review line in particular tends to be the biggest number nobody budgets.

$4,690 ÷ 10,000 = about $0.47 per completed task, over tasks the agent completed rather than tasks it attempted — and that figure excludes review, so it is a floor, not an all-in number.

Put review back in and the ranking changes. At the same reference rate, $16,200 a month over a ~160-hour month is about $101 an engineer-hour (on a 173-hour month it is ~$94, and the all-in lands near $0.99 rather than $1.03), so 55.6 hours of review is roughly $5,600 a month — more than the model, tooling and maintenance lines put together. Reviewing every task at 20 seconds takes the illustration to about $10,300 a month, or $1.03 per task. That is the single most useful number in this guide: on these assumptions the cheapest way to change your agent’s cost is not the model tier, it is deciding which tasks a human still has to read. Review a confident 70% automatically and the review line falls with it. Swap Sonnet for Haiku 5.5 and the excluding-review figure becomes $0.43 — a four-cent move, and all-in it barely shifts, from $1.03 to about $0.99. Cut the maintenance assumption from 0.25 to 0.1 FTE and the excluding-review figure becomes $0.23 — all-in, about $0.79, because review is untouched by either lever. That is the point: at this volume you are not managing a token bill, you are managing an engineering commitment, and the model-tier choice is close to noise.

One effect to budget for: if your 12,000-token figure was measured on an older model, moving to a Claude 4.7-or-later generation takes the model line from $390 to roughly $507 for the same documents, on that ~30% tokenizer increase.

A pilot’s real deliverable is replacing the assumed 13,500 tokens per task with a measured one on your own data — which is why a cost profile is part of what a proof of concept hands back, and part of how we scope and build AI agents.

How does the cost change as volume grows, and where can you control it?

The people line is roughly fixed; the model line is linear in tasks. So the crossover is arithmetic: $4,047 of maintenance ÷ $0.039 per task on a Sonnet 5.5-class model ≈ 104,000 tasks a month. Below that, cost per task falls fast as the fixed line spreads — at 100,000 tasks the same agent costs about $0.08 per task instead of $0.47, both still excluding review. Above it you are buying tokens, and the tier decision you could ignore at pilot scale starts to dominate the model line. Review, if you still review every task, stays larger than both — about $0.56 a task at any volume on the assumptions above, which is why the automation rate matters more than the tier.

The levers, in the order they pay:

1. Cache the stable prefix — 0.1× input on most Claude models, 0.05× on the Sonnet 5.5 tier used above, against a system prompt and tool block that barely change between calls.
2. Use the cheap tier for the cheap steps. Most agent steps are classification and extraction, not reasoning, and that 108× spread is what you are choosing between. Which step gets which model is a routing decision; its cost drivers sit in the orchestration piece linked above.
3. Spend fewer tokens, not cheaper ones. Fewer calls per task and tighter retrieved context beat a tier downgrade and don’t cost accuracy.

Which costs do agent estimates usually miss?

• Evals and regression testing. A prompt change that fixes one case breaks another, and you cannot tell without a graded set. It is both build cost and recurring cost; a pilot without it has no way to prove it still works next month.
• Forced model migrations. Not hypothetical: Anthropic’s pricing table currently marks Claude Opus 4.1, Opus 4, Sonnet 4 and Haiku 3.5 as “retired, except on Bedrock and Google Cloud.” Each retirement is unplanned re-prompting, re-evaluation and re-measurement on a schedule set by someone else (Opus 4 is Google Cloud only). Budget it as recurring, not exceptional.
• Human review time in the loop. The confirmation step you built is somebody’s minutes, every task. At 10,000 tasks a month, twenty seconds of review each is about 55 hours — larger than the entire model line. Whether approval is per-task or per-exception is the most expensive design decision in the project, which is why approval checkpoints and audit trails deserve design time rather than a feature flag.
• Security review. An agent that acts on your systems needs a threat model, and prompt injection is the specific one: a schema validates the form of a tool call, not the attacker’s choice of values inside it. Budget the review, the privilege scoping and the retest. No architecture removes the problem.
• Data preparation. The Eska pattern — whatever sits between messy inputs and a model-readable payload is substantial engineering in its own right, and it never appears in a model-centric estimate.

How do you cap the cost before you commit to a full build?

Buy the measurement before you buy the build. One workflow, one metric, your data, a fixed window, and a deliverable that includes a cost profile and a go/no-go rather than a demo. That turns every assumption in this article into a number specific to you: tokens per task measured, the real integration surface discovered, the approval rate observed. A pilot that comes back “no” is the cheapest outcome on this page.

Be willing not to build. Anthropic’s engineering guidance on building effective agents, from December 2024, recommends “finding the simplest solution possible, and only increasing complexity when needed,” and notes that “agentic systems often trade latency and cost for better task performance.” If your workflow is deterministic and exceptions are rare, a scripted integration does it for a fraction of both halves — no token bill, no eval suite.

Frequently asked questions

How much does it cost to build an AI agent?

It depends on which of three things you are pricing: a pilot (one bounded workflow, one metric), a production single agent (hardened, with evals, audit trail and an approval queue) or a multi-agent system. Most of the build effort goes into integrations, data preparation and evaluation, not the model call, so ask any estimate which of those lines it covers.

What does an AI agent cost to run each month?

In our worked example of 10,000 tasks a month, the model, tooling and maintenance lines come to about $4,690, or roughly $0.47 per completed task. Maintenance engineering is about 86% of that and the model API about 8%. Human review is excluded from that figure; reviewing every task at 20 seconds takes the total to about $1.03 per task.

Does choosing a cheaper model cut agent costs?

Less than most people expect. The same workload costs about $18 a month on the cheapest tier and $1,950 on a flagship model, but at pilot volume the people around the agent dominate. In the worked example, swapping Sonnet 5.5 for Haiku 5.5 moves the all-in cost from $1.03 to about $0.99 per task. Deciding which tasks still need human review moves it far more.

How can we cap the cost before committing to a full build?

Buy the measurement first: one workflow, one metric, your own data and a fixed window, with a cost profile and a go/no-go as the deliverable rather than a demo. If the workflow is deterministic and exceptions are rare, a scripted integration may do the job without an agent at all.

Talk it through. A free 30-minute call: bring the workflow, your monthly volume, and the systems the agent would have to touch. You’ll get a feasibility read, the cost lines we would expect at that scope, and a candid answer on whether an agent is the right tool at all. No deck, no pitch — get in touch.