How Much Does an AI Agent or LLM Feature Cost in 2026?

Agency estimates published in 2026 put a simple AI agent at $20,000–$35,000 and an enterprise multi-agent system at $100,000–$200,000 or more, and the average AI project on Clutch costs about $120,600. Running one is usually far cheaper than building it: our worked example handles 30,000 agent tasks a month for about $1,100 at list prices, or under $150 on a small model. The real cost driver is scope, because bounded agents ship and open-ended ones get cancelled.

Key takeaways

Build cost scales with autonomy, not with “AI”. A single LLM call behind a well-defined feature is a small project. Planning, multi-step tool use and integrations with legacy systems are what push budgets into six figures.
Model choice changes run cost by 10–100x. Today’s list prices range from $0.10 to $10 per million input tokens and from $0.50 to $50 per million output tokens.
Prompt caching and batch APIs are free money. Anthropic and OpenAI both list a 50% batch discount, and cached input costs 5–10% of the normal input price on many models.
Embeddings and vector search are rarely the problem. For a typical internal-knowledge agent they cost a few dollars a month.
Evals, guardrails, observability and maintenance are the costs teams forget. Budget engineering time for them, not just tooling fees.
Gartner expects over 40% of agentic AI projects to be cancelled by the end of 2027. The cheapest defence is a small, bounded first version with a measurable success metric.

What “AI agent” means for the budget

The term covers very different systems, and the price follows the design. For budgeting purposes we split them into four tiers.

Tier	What it does	Typical shape
1. LLM feature	One model call with a fixed prompt: summarise, classify, extract, draft	A single API call, structured output, no tools
2. RAG assistant	Answers questions over your documents or data	Retrieval, embeddings, a vector index and citations
3. Tool-using agent	Takes actions through your APIs in a loop: look up, decide, call, verify	Tool schemas, a state machine, retries, human approval steps
4. Multi-agent or enterprise system	Several agents, long-running workflows, legacy integration, compliance	Orchestration, audit logs, permissions, SSO, data residency

Each tier roughly doubles the surface area that has to be tested. Tier 3 is where most of the risk lives, because the system now changes state in the real world.

Build cost by complexity tier

Very little rigorous public data exists on AI build costs. Most published numbers are agency marketing, so treat them as directional. These are the most concrete sources we could find.

Source	Tier	Published range
Cleveroad, agency estimate, Feb 2026	Reactive agent (chatbot-style)	$20,000–$35,000+
Cleveroad	Intermediate (memory, multi-step workflows, API integrations)	$40,000–$70,000+
Cleveroad	Advanced (planning logic, tool orchestration)	$80,000–$120,000
Cleveroad	Enterprise (domain-specific, compliance, legacy integration)	$100,000–$200,000+
Clutch, review-based data, Sep 2026	Average AI development project	$120,594.55
Clutch	Most common project budget	$10,000–$49,999

Clutch’s numbers come from verified client reviews, so they are the closest thing to market data here. The same page says most AI providers listed charge under $50 an hour, a figure driven by offshore firms. It also puts a typical AI project at 10 months. That long timeline tells you most of these projects are scoped far beyond a first version.

For a US in-house comparison, the BLS reports a median wage of $135,980 for software developers in May 2025. That figure is before benefits, equipment and management overhead. A two-engineer team building a tier 3 agent for three months costs well into five figures in salary alone.

How we read these ranges

From our experience shipping LLM features, these are the factors that actually move a budget:

Integration count. Every system the agent reads from or writes to needs auth, error handling, test fixtures and a failure mode. Five integrations cost far more than one.
Write actions. Read-only agents are cheap to make safe. Agents that refund money, send email or change records need approval flows, idempotency and audit trails.
Accuracy bar. “Useful draft that a human edits” and “correct without review” are different projects. The second needs a serious evaluation set and often a fallback path.
Data readiness. If the source documents are scattered PDFs with no owner, the retrieval pipeline becomes the project.
Compliance. PII redaction, data residency and audit logging are real engineering work, not a checkbox.

A tier 1 or narrow tier 2 feature can be built, evaluated and shipped in about two weeks by a senior team. This is the scope of our AI Feature Sprint. The ranges above are for teams that go straight to tier 3 or 4.

Run cost: what tokens actually cost in 2026

All prices below are list prices per 1 million tokens, taken from each provider’s official pricing page on 7 October 2026. Prices change often, so check before you commit.

OpenAI

From OpenAI’s API pricing page:

Model	Input	Cached input	Output
gpt-6-astra (most capable)	$10.00	$1.00	$50.00
gpt-6.1-sol	$2.00	$0.10	$10.00
gpt-6-luna (most efficient)	$0.10	$0.01	$0.50
gpt-5.4-mini	$0.75	$0.075	$4.50

The batch tier halves these prices. For example, gpt-6.1-sol drops to $1.00 input and $5.00 output.

Anthropic

From Anthropic’s pricing docs:

Model	Input	Cache hit	Output
Claude Opus 5.5	$4	$0.20	$20
Claude Sonnet 5.5	$2	$0.20	$10
Claude Haiku 4.5	$1	$0.10	$5

Writing to the 5-minute cache costs 1.25x the base input price, and the Batch API gives “a 50% discount on both input and output tokens”. The same page notes that Claude 4.7 and later use a tokenizer that “produces approximately 30% more tokens for the same text”. Per-token prices are therefore not directly comparable across vendors. Measure tokens on your own prompts.

Google Gemini

From the Gemini API pricing page:

Model	Input	Output
Gemini 3.1 Pro Preview (prompts up to 200k tokens)	$2.00	$12.00
Gemini 3.8 Flash (through 31 Dec 2026)	$0.75	$3.75
Gemini 3.8 Flash (from 1 Jan 2027)	$1.50	$7.50
Gemini 3.5 Flash-Lite	$0.30	$2.50

Note the Flash price doubles on 1 January 2027. If you model costs on today’s Flash price, model next year’s too.

Embeddings and vector storage

Item	Price	Source
OpenAI text-embedding-3-small	$0.02 per 1M tokens	OpenAI
OpenAI text-embedding-3-large	$0.13 per 1M tokens	OpenAI
Gemini Embedding 2 (text)	$0.20 per 1M tokens	Google
Cloudflare Vectorize queries	50M queried dimensions/month included, then $0.01 per million	Cloudflare
Cloudflare Vectorize storage	10M stored dimensions included, then $0.05 per 100 million	Cloudflare
Pinecone Standard	$50/month minimum, storage $0.33/GB/month, reads $16–$18 per million units	Pinecone

A worked monthly cost example

Here is a realistic tier 3 workload: an internal support agent that looks up an account, searches a knowledge base and drafts a reply for a human to approve.

Assumptions:

30,000 tasks a month (about 1,000 a day).
3 model calls per task (plan, tool call, final answer), so 90,000 calls.
Each call sends 6,000 input tokens. 3,000 are a stable prefix (system prompt and tool definitions) that can be cached, and 3,000 are task-specific (retrieved passages and conversation state).
Each call returns 500 output tokens.
A knowledge base of 40 million tokens, chunked at 500 tokens, which gives 80,000 chunks.

Monthly token volume:

Input:   90,000 calls x 6,000 tokens = 540M tokens
         of which cacheable prefix   = 270M tokens
         of which uncached           = 270M tokens
Output:  90,000 calls x   500 tokens =  45M tokens

Model cost on Claude Sonnet 5.5 with prompt caching:

Uncached input: 270M x $2.00 / 1M  = $540.00
Cache hits:     270M x $0.20 / 1M  =  $54.00
Output:          45M x $10.00 / 1M = $450.00
                                     --------
Total                                $1,044.00  (about $0.035 per task)

This ignores cache writes. With steady traffic the 3,000-token prefix is written rarely, at 1.25x input price, so writes add only a few dollars. Without caching, the same workload costs 540M x $2 + 45M x $10 = $1,530.

The same workload on other models:

Model	No caching	With prefix caching
gpt-6-astra	$7,650	$5,220
Claude Opus 5.5	$3,060	$2,034
Gemini 3.1 Pro Preview	$1,620	not modelled
Claude Sonnet 5.5	$1,530	$1,044
gpt-6.1-sol	$1,530	$1,017
Claude Haiku 4.5	$765	$522
Gemini 3.5 Flash-Lite	$274.50	not modelled
gpt-6-luna	$76.50	$52.20

The arithmetic is the same throughout. For example, gpt-6-luna with caching is 270M x $0.10 + 270M x $0.01 + 45M x $0.50 = $52.20. Gemini context caching also bills for storage time, so we left it out instead of guessing.

Retrieval cost:

Embed corpus once (text-embedding-3-small): 40M x $0.02 / 1M = $0.80
Vectorize stored dims: 80,000 x 1,536 = 122.9M, minus 10M free
                       = 112.9M x $0.05 / 100M              ~= $0.06
Vectorize queried dims: (30,000 + 80,000) x 1,536 = 169.0M,
                       minus 50M free = 119.0M x $0.01 / 1M ~= $1.19

We used the 1,536-dimension default of text-embedding-3-small from OpenAI’s embeddings guide. The query formula follows Cloudflare’s own worked example. Retrieval comes to about $2 a month. On Pinecone the $50 Standard minimum would be the floor.

Guardrails and observability:

Amazon Bedrock Guardrails content filters cost $0.15 per 1,000 text units, where a text unit is up to 1,000 characters. Filtering one input and one output per task is roughly 60,000 text units, or about $9.
Langfuse Core costs $29 a month for 100k units, plus $8 per additional 100k. Expect $30–$50 at this volume, depending on how many spans each task emits.

Total: about $1,100 a month on Sonnet 5.5, or under $150 a month on gpt-6-luna. Both figures assume the cheaper model passes your evals, and that assumption is the whole question.

The hidden costs

Token bills are visible. These costs aren’t, and they are where budgets break.

Evals

An agent without an evaluation set is a demo. You need a few hundred representative inputs with expected outcomes, a scoring method (exact match, rubric, or LLM-as-judge with spot checks), and a way to run it on every prompt or model change. Building the first set takes days of domain-expert time, not engineering time, and teams routinely skip it. When a model is deprecated or a cheaper one appears, the eval set is what lets you switch in an afternoon instead of a month.

Tooling is cheap by comparison. Braintrust Pro lists $249/month and LangSmith Plus $39 per seat per month. The labelled data is the expensive part.

Guardrails

You need input filtering (prompt injection, off-topic requests, PII), output validation (schema checks, policy checks, grounding against retrieved sources), and hard limits on what tools can do. The most effective guardrail is architectural. Give the agent narrowly scoped tools with server-side permission checks, not a general-purpose API key and a polite system prompt.

Observability

Every task needs a trace: which documents were retrieved, which tools were called with which arguments, token counts, latency and the final output. Without this you can’t debug a bad answer, and you can’t attribute cost per customer. Wire it in on day one. Retrofitting it later is painful.

Maintenance

Models get deprecated, prices change (see the Gemini Flash change above), and provider behaviour drifts between versions. Your documents change too. Plan for ongoing engineering time to re-run evals, update prompts, migrate models and handle new edge cases from production traces. A few hours a week is typical for a single production agent. This is the work a retainer is designed for.

Why 40% of agentic AI projects will be cancelled

In June 2025, Gartner predicted that more than 40% of agentic AI projects will be cancelled by the end of 2027 “due to rising costs, unclear business value, or insufficient risk controls”, as reported by The Register. Gartner also warned about “agent washing”, the rebranding of existing chatbots and RPA tools as agents. It estimated that only about 130 of the thousands of agentic AI vendors are real.

The same article covers Carnegie Mellon’s TheAgentCompany benchmark of simulated office tasks. The best model tested at the time, Gemini 2.5 Pro, fully completed 30.3% of tasks. Models have improved since, but the lesson holds: open-ended autonomy on messy real-world tasks is still unreliable.

MIT’s NANDA initiative reported something similar for generative AI in general. In The GenAI Divide: State of AI in Business 2025, only about 5% of pilots achieved rapid revenue acceleration, according to Fortune’s coverage.

None of these sources says agents don’t work. They say unbounded agents with fuzzy goals don’t survive contact with a budget review.

How to scope a small, bounded first version

This is the scoping checklist we use before writing any code:

One workflow, one user group. For example, “draft replies to billing tickets for the support team”, not “automate support”.
One success metric you can measure in week one. Draft acceptance rate, minutes saved per ticket, or error rate against a labelled set.
Read-only first. Let the agent propose actions and have a human approve them. Add write access per tool only once the evals justify it.
Two or three tools, maximum. Each tool is an integration, a permission boundary and a set of failure modes.
An eval set of 100–300 real examples before launch. Pull them from production data, not from what the team imagines users will ask.
A cost ceiling per task. Cap the number of iterations and the tokens per task in code. Runaway loops are the most common source of surprise bills.
A cheaper model as the default, the expensive one as fallback. Route to the bigger model only when the smaller one fails a confidence or validation check.
A kill date. If the metric hasn’t moved by a fixed date, stop and reassess. A cancelled two-week experiment is cheap. A cancelled ten-month programme is not.

A first version scoped like this fits in weeks, not quarters. It also produces the data you need to decide whether tier 3 or 4 is worth funding.

Where to start

If you have a specific LLM feature or agent in mind and want it built, evaluated and in production quickly, our AI Feature Sprint is a fixed $8,500 over 10 business days. If the day-5 demo doesn’t convince you, you can stop and get the deposit back.

If you already have an AI feature that is slow, expensive or unreliable, the AI-App Rescue Audit ($1,490, 72 hours) will tell you where the cost and quality problems are. For anything else, get in touch.