AI Development Cost in 2026: Real Numbers, Not Ranges

Those bands come from vendor guides across the US, UK, and India. Treat them as a rough market view, not as data. No neutral body checks AI project prices.

Why does the range span 100x? Because "AI project" can mean a prompt wrapper or a fine-tuned model on owned hardware. Those are not the same species of work.

Build cost is not the number you need

A quote covers design, engineering, and launch. It does not cover the next 36 months.

Annual maintenance runs 15% to 25% of the build cost, a figure that shows up across many vendor guides. Add running costs on top. We go through the full three-year total further down, and it lands close to double the build price.

Data work eats time, not budget.

Here is where almost every published guide goes wrong. Data preparation takes 50% to 70% of project time but only 25% to 35% of direct cost, according to Uvik's 2026 cost analysis.

Most articles quote one figure and call it the other. That gap is exactly why AI projects slip. Cheap work that takes forever still wrecks a delivery date.

Cost per project tells you nothing.

A $180,000 build at $0.004 per query is a business. The same build at $0.40 per query is a liability.

Unit cost decides whether an AI feature survives contact with real usage. Ask for cost per query, per ticket, or per document before you approve a budget.

Most guides assert totals. Almost none show the arithmetic. Here it is.

Example one: a clinical copilot for 400 users

Take a retrieval system for 400 clinicians. Each runs 15 queries per working day. Over 21 working days, that is 126,000 queries a month.

Each query sends about 8,000 input tokens. That covers the system prompt, retrieved document chunks, and the question. Each answer runs about 600 output tokens.

Monthly volume comes to 1,008 million input tokens and 75.6 million output tokens.

Run it naively on a flagship model. Claude Opus 5 bills $5 per million input tokens and $25 per million output tokens, per Anthropic's pricing page. That is $5,040 for input and $1,890 for output.

Monthly cost: $6,930.

Now switch to a mid-tier model. Claude Sonnet 5 bills $2 per input token and $10 per output token. Same volume, same workload, and the cost drops to $2,772.

Now add prompt caching. Roughly 6,000 of those 8,000 input tokens are stable. The system prompt and policy docs do not change between queries.

Cache hits are billed at 10% of the input rate. Those tokens now cost $0.20 per million instead of $2.

Cached input: $151. Fresh input: $504. Output: $756.

Monthly cost: $1,411.

Now route by difficulty. Send 70% of simple lookup queries to Claude Haiku 4.5 at $1 and $5. Keep the harder 30% on Sonnet 5, and cache both.

Monthly cost: $917.

Same system. Same volume. Same answers, assuming your routing logic is sound.

The spread between the first setup and the last is 87%.

That is the entire argument for design work on cost, done in numbers rather than adjectives.

Example two: why a support agent costs triple the estimate

Anthropic publishes a worked figure for support automation. Processing 10,000 tickets at roughly 3,700 tokens each on Haiku 4.5 costs about $37, per its own docs.

Clean number. It also assumes the model answers in one pass.

Real support agents call tools. They look up the order, check the refund policy, and query the account status. Each tool call sends the conversation back through the model with everything that came before.

Add three tool calls per ticket, and the token count per conversation climbs past 6,000. Tool definitions carry their own overhead, around 500 tokens on Haiku 4.5 before you count a single result.

The same 10,000 tickets now cost about $108.

Nothing went wrong. The estimate was just built on a single-pass assumption. Agentic systems multiply token consumption in ways linear estimates never catch, and this is the most common reason a pilot budget fails to survive production.

Six mechanics that move real money. All of them are documented on vendor pricing pages. Almost none appear in published cost guides.

Current token prices

Sources: Anthropic pricing, OpenAI developer pricing, and Google Gemini API pricing. All checked 31 August 2026.

Two dates worth writing into your plan. GPT-5.6 Sol's $4 rate is introductory, and OpenAI has committed to it only through 21 November 2026. Gemini 3.7 Flash's pricing doubles on 1 January 2027.

Output costs five times what input costs.

Every major provider charges more for generation than for reading. Anthropic runs a 5x multiple. OpenAI runs 5x to 6x.

So verbose answers cost you, not long prompts. A system that returns three paragraphs where one would do is quietly running at triple the cost.

Reasoning tokens bill as output

Models that think before answering generate hidden tokens. You never see them. You pay for them at output rates.

A 500-token visible answer can consume more than 2,000 billable tokens. Budget from measured usage, never from the length of the response your users read.

A model upgrade can add 30% at the same price.

This one catches finance teams completely off guard.

Anthropic's pricing docs note that Claude 4.7 and later models use a newer tokenizer. It produces roughly 30% more tokens for the same text.

The rate card does not change. Your bill does.

On the clinical copilot above, that is about $830 a month appearing from nowhere. Nobody raised a price. The text counts differently now.

Long context has a cliff, not a slope.

OpenAI bills requests above 272,000 input tokens at double the input rate and 1.5x the output rate, applied to the whole request. Gemini 3.1 Pro steps from $2 and $12 up to $4 and $18 above 200,000 tokens.

These are step functions. A retrieval system that gradually widens its context window will cross one and double its bill overnight, with no code change and no traffic spike.

Anthropic prices the full 1 million token window at standard rates on Claude 4.6 and later, with no surcharge. If your workload is context-heavy, that difference is worth checking before you pick a provider.

Data residency carries a premium.

Running inference in a specific region costs more. Anthropic applies a 1.1x multiplier across every token category for US-only inference. Bedrock and Google Cloud regional endpoints add 10% over global routing.

For healthcare and financial workloads with residency rules, that 10% is not optional. Put it in the model at scoping, not in the invoice.

GPU compute

The median on-demand H100 price sits at $3.39 per GPU-hour across 38 providers, per GetDeploying's multi-provider tracker on 27 August 2026. That median rose about 13% over the previous 90 days.

The full spread runs from roughly $1.49 an hour on marketplaces to $12.29 on Azure list pricing. One H100 running continuously costs $2,400 to $2,900 a month. An eight-GPU node running flat out runs $36,000 to $40,000.

Add about 25% for storage, egress, and operations in year one.

Vector databases

At 10 million vectors, monthly hosting looks roughly like this. pgvector on managed Postgres runs around $45 and Qdrant Cloud around $65. Pinecone Serverless is around $70 with a $50 plan minimum, and Weaviate Cloud around $135.

We will flag an honest gap here. Other sources put Pinecone at $200 to $500 for the same vector count, and we couldn't reconcile that with Pinecone's published pricing. The difference is serverless versus pod-based, but we wouldn't budget on it without testing your workload.

Three costs never appear in the sticker price. Egress runs $0.08 to $0.09 per GB on AWS, and index rebuilds cost $12 to $40 per 10 million vectors. The index structure itself adds roughly 1.5x storage overhead.

The three-year picture

Take the clinical copilot from earlier.

• Build cost: $140,000
• Inference: $917 a month
• Vector hosting: $65 a month
• Upkeep: 20% of build, per year

Over 36 months, that comes to roughly $259,000. The build was $140,000.

Three-year total cost of ownership runs about 1.85x the build price. If your board approved the build number alone, you are about to be short by most of it.

Route by difficulty

The spread between a capable budget model and a frontier flagship is roughly 50x on input tokens. Most production traffic does not need the flagship.

Classify the request first, then send it to the cheapest model that clears your quality bar. The copilot example above shows what this is worth when combined with caching.

Cache aggressively

Cache hits bill at 10% of the standard input rate on both Anthropic and OpenAI. That is a 90% discount on every stable token you send.

System prompts, policy documents, tool definitions, and few-shot examples rarely change between requests. If you are sending them fresh every time, you are paying ten times what you need to.

Batch anything that can wait

The Batch API halves both input and output rates across every major provider. Sorting, tagging, summaries, and overnight reports don't need sub-second latency.

Sorting your workload into real-time and deferred buckets usually takes a week. It pays for itself right away.

Self-hosting: know where the line actually is

Published breakeven points for self-hosting an open-weight model range from 5 million tokens a month to over a billion. That is not sloppy research. It is a real open question, and the honest answer is that it depends on two things.

Which API are you comparing against? Against a frontier model at $5 to $10 per million, breakeven arrives within a few million tokens a day. Against a budget open-weight API at $0.14 to $0.50 per million, self-hosting rarely wins on price.

Your GPU use. A dedicated GPU costs the same whether you use it or not. Below 60%, the economics fall apart fast, and use is the factor that almost every published guide leaves out.

Compliance can override all of it. Data residency rules and contractual confidentiality sometimes make self-hosting the only route, regardless of what the spreadsheet says.

Model deprecation

Providers retire models. When the one you built on goes away, you pay for regression tests and prompt retuning across your test set.

This is where eval work earns its keep. Teams that built evals during the project handle a deprecation in days. Teams that skipped them rebuild trust in the system from scratch, and that costs several times more than the evals would have.

Budget evals at build time. They look like overhead right up until the moment they are the only thing standing between you and a rewrite.

Re-indexing

Change your embedding model and every stored vector becomes worthless. You re-embed the entire corpus and rebuild the index.

At 10 million vectors, that is a $12 to $40 compute charge plus the embedding API cost, which is usually the larger number.

Price volatility is now a real planning input.

Four material price changes hit between June and August 2026. OpenAI cut GPT-5.6 Luna by 80% and Terra by 20% on 30 July, then cut Sol again on 22 August. Anthropic canceled a scheduled increase to Claude Sonnet 5 that was due to take effect on 1 September.

Your token cost basis will move during any build longer than a quarter. It can move either way.

Three things that help:

• Model on today's rates, but sign on volume rather than unit prices.
• Build a provider-swap layer, so switching is a config change, not a rewrite.
• Treat any rate labeled "promotional" as temporary, because it is

Off-the-shelf works when your use case is genuinely standard. Generic customer service, document question and answer, and internal search over public content. If a SaaS product does 80% of what you need, custom engineering is usually a poor trade.

Custom earns its cost in four cases:

• The workflow is proprietary, and no vendor models it.
• Data cannot leave your environment.
• The AI is the product, not a feature.
• At your volume, unit cost makes per-seat pricing too costly.

That last one is quieter than the others. It also decides more cases than people expect.

Per-seat AI pricing tracks headcount. Your own system tracks usage. For a fintech with 200 users and heavy volume, those two curves split apart inside a year.

What the Failure Statistics Actually Say

Three numbers dominate every discussion of AI project risk. All three get cited badly.

Gartner forecasts worldwide AI spending at $2.59 trillion in 2026, up 47% year over year, per its 19 May 2026 release. Most published articles still quote the $2.52 trillion figure from January. That one was superseded.

Gartner also predicts over 40% of agentic AI projects will be canceled by the end of 2027, citing escalating costs, unclear business value, and inadequate risk controls. Worth knowing: this prediction dates from 25 June 2025, not 2026. It resurfaced in coverage this July and is now widely presented as new.

MIT's NANDA project reported that 95% of generative AI pilots showed no measurable impact on profit and loss. We cite it, then add the caveat it deserves.

The six-month window for measuring return is short. Coverage describes the sample in different ways. And the report came from a group that builds agentic systems and concludes they're the answer.

The better-built number gets far less attention. RAND Corporation researchers found AI project failure rates above 80%, roughly double the rate of normal IT projects. That study looked at causes rather than at a single financial window.

None of these say AI does not work. They say scoping and wiring fail more often than models do.

We build AI systems, so we price them accordingly. A few things we have settled on.

We do not quote from a one-page brief. A number built without seeing your data, your systems, and your compliance setup is a guess in a suit. It holds until the first change request.

We price the run, not just the build. Every scope we write includes a three-year model alongside the build figure. That covers token volume, hosting, upkeep, and the model risk on whichever provider the design leans on.

If a client only wants the build number, we give them both anyway.

We build eval work into the first phase. Not because it is good practice in the abstract. Because it is the gap between a model swap costing a week and costing a quarter, and providers retire models faster than they did a year ago.

We tell clients when custom is the wrong answer. Sometimes a SaaS product does the job at a tenth of the price. Saying so costs us a project and keeps a relationship, and that trade has worked out well enough that we keep making it.

Most of our work sits in SaaS, fintech and healthtech, where sensitive data and deep wiring make off-the-shelf tools run out of road fast. If you want a second read on a quote you have already received, we will look at it. That is a chat, not a pitch.

Ten questions to answer first. If you cannot answer them, no vendor can give you a real number.

1. What is the unit of work? A query, a ticket, a document, a transaction.
2. What volume of that unit, per month, at launch and at 12 months?
3. Where does the data live now, and what state is it in?
4. Which systems must this touch to be useful?
5. What accuracy bar makes it worth deploying?
6. Who reviews the output, and how often?
7. What are the data residency and retention rules?
8. What happens when the model provider deprecates your model?
9. Who owns the code, the prompts, the fine-tuned weights, and the eval set?
10. What does the three-year total look like, not the build?

Question 10 separates a real vendor conversation from a sales call.

The honest answer to "what does AI development cost" is that the build price is the easy half. Most published guides stop there because it is the half that fits in a table.

The harder half is what the system costs to run, and that number moves. It moves with your token volume, your design, provider price changes you don't control, and a tokenizer change that can add 30% while the rate card stays still.

Three things are worth taking away:

• Model your costs per unit of work, not per project.
• Assume the three-year total lands near double the build.
• Treat routing, caching, and batching as design decisions, not work to do later.

On the system we costed above, the gap between doing all three and skipping them was 87%.

One thing we have not resolved. The self-hosting breakeven is still an open question, and we suspect it will stay that way while token prices keep falling. We would rather say that than pretend the number is known.