AI agent development cost in 2026: a line-by-line breakdown

In the voice booking budget below, the language model doing the thinking costs $5.89 a month and the voice minutes cost $500. That ratio is the point of this post. AI agent development cost is two bills: a one-off engineering bill to build the agent, and a running bill that is almost entirely metered. On OpenAI's published prices as of September 2026, our three worked budgets run from $361.80 to $1,530.60 a month, and the biggest line is rarely the one a team expects.

Every figure here is computed from a price list you can check, with the arithmetic shown and every assumption labelled as one. We use OpenAI's rates as the worked example because they are public and itemised; the structure of the bill carries over to any provider. We do not quote a range for the engineering side, because an honest range depends on your systems, and we explain what moves it instead.

The published prices every AI agent budget is built from

OpenAI bills models per million tokens, with separate rates for fresh input, cached input, cache writes and output. These are the standard short-context rates from the OpenAI pricing page on 21 September 2026 for the models we use below, plus the flagship for scale.

Model	Input	Cached input	Cache write	Output
gpt-6-astra	$10.00	$1.00	$12.50	$50.00
gpt-5.6-sol	$4.00	$0.40	$5.00	$20.00
gpt-5.6-terra	$2.00	$0.20	$2.50	$12.00
gpt-5.6-luna	$0.20	$0.02	$0.25	$1.20

The tools an agent calls are billed on top. The same page lists web search at $10.00 per 1,000 calls plus the retrieved search content billed as tokens at the model's rates; file search at $2.50 per 1,000 calls plus $0.10 per GB per day of storage after 1 GB free; and hosted containers (Hosted Shell and Code Interpreter) at $0.03 for 1 GB up to $1.92 for 64 GB per 20-minute session. GPT-Live 1 voice sessions cost $0.05 a minute, billed per second, with backend model and tool usage billed separately.

Four modifiers change those numbers after you have done the sum. The Batch tier halves the rates, so Terra drops to $1.00 input and $6.00 output for work that can wait. Fast mode, which OpenAI renamed from Priority processing on 30 July 2026, doubles them to $4.00 and $24.00. Regional data residency endpoints carry a 10% uplift for models released on or after 5 March 2026. And the GPT-5.6 Terra model page states that prompts over 272K input tokens are priced at 2x input and 1.5x output for the whole request. Sol's current rate is promotional, guaranteed only through 21 November 2026.

Prompt caching is the biggest lever on the input line

For GPT-5.6 and later, the prompt caching guide sets cache writes at 1.25x the uncached input rate and cache reads at 0.1x. A prefix must be at least 1,024 visible tokens to cache, and it stays eligible for at least 30 minutes after its last write or reuse. The guide's own example: one write and nine full reads cost 2.15x the ordinary input cost, against 10x without caching.

For an agent this matters because the system prompt and tool definitions are resent on every call. Keep them stable and at the front of the prompt, and most of your input tokens bill at a tenth of the list rate. All three budgets below assume that discipline.

Containers bill by the minute, with a five-minute floor

The pricing page quotes containers per 20-minute session, then adds that eligible container sessions are billed by the minute with a five-minute minimum per session. The page does not define "eligible". Our assumption, stated plainly: the per-minute rate is the 20-minute price divided by 20, so a 1 GB container is $0.0015 a minute and any session costs at least $0.0075. A 64 GB container on the same arithmetic costs at least $0.48 a session. If your agent opens a sandbox for a ten-second calculation, you pay for five minutes.

Budget 1: an internal assistant with search and a sandbox

An internal assistant answers staff questions from company documents, looks things up on the web and occasionally runs code on a spreadsheet. Our assumptions, all of them ours and none of them measured:

• gpt-5.6-terra, standard tier, 20,000 requests a month.
• Each request carries a 6,000-token stable prefix (instructions and tool definitions) plus 2,000 uncached tokens, and returns 600 output tokens.
• The prefix is read from cache on 95% of requests and written on the other 5%.
• 10,000 file search calls against 3 GB of stored documents; 3,000 web searches, each returning 4,000 content tokens; 2,000 container sessions at 1 GB, each under five minutes.

Line	Arithmetic	Monthly
Uncached input	20,000 x 2,000 = 40M tokens x $2.00	$80.00
Cached reads	19,000 x 6,000 = 114M x $0.20	$22.80
Cache writes	1,000 x 6,000 = 6M x $2.50	$15.00
Output	20,000 x 600 = 12M x $12.00	$144.00
File search calls	10,000 / 1,000 x $2.50	$25.00
File storage	(3 GB − 1 GB free) x $0.10 x 30 days	$6.00
Web search calls	3,000 / 1,000 x $10.00	$30.00
Web search content	3,000 x 4,000 = 12M x $2.00	$24.00
Containers	2,000 x 5-minute minimum x $0.0015	$15.00
Total		$361.80

Output is the largest single line at $144.00, even though it is the smallest token count. The container line is small here only because we assumed short sessions; if each session ran the full 20 minutes, the same 2,000 sessions would cost $60.00.

Budget 2: what a customer support AI agent costs per month

A customer support agent answers from a help-centre knowledge base, keeps conversation history and takes several model turns per chat. Assumptions, again ours:

• gpt-5.6-terra, standard tier, 30,000 conversations a month, four model calls each: 120,000 calls.
• Each call carries a 5,000-token cached prefix plus 3,000 uncached tokens of history and retrieved content, and returns 400 output tokens.
• 98% of calls read the prefix from cache; 2% write it.
• One file search call per conversation, against 5 GB of stored content.

Line	Arithmetic	Monthly
Uncached input	120,000 x 3,000 = 360M x $2.00	$720.00
Output	120,000 x 400 = 48M x $12.00	$576.00
Cached reads	117,600 x 5,000 = 588M x $0.20	$117.60
Cache writes	2,400 x 5,000 = 12M x $2.50	$30.00
File search calls	30,000 / 1,000 x $2.50	$75.00
File storage	(5 GB − 1 GB free) x $0.10 x 30 days	$12.00
Total		$1,530.60

That is about $0.051 per conversation. Output is under 5% of the tokens (48M of 1,008M) and 38% of the bill. The cheapest thing you can do to a support agent's running cost is make it answer in fewer words, which usually makes it a better support agent too.

The second-cheapest is the model. Luna's rates are exactly a tenth of Terra's, so the token lines fall from $1,443.60 to $144.36; with the unchanged $87.00 of file search, the month costs $231.36. Whether Luna resolves your tickets as well is an evaluation question, not a pricing one, and it is the question to answer before you pick.

Budget 3: an AI voice agent cost is mostly minutes

A voice booking line takes calls, checks availability and confirms appointments. GPT-Live handles the conversation and delegates the lookups to a backend model. Assumptions:

• 3,000 calls a month averaging 200 seconds each: 600,000 seconds, or 10,000 minutes.
• Three backend calls per phone call on gpt-5.6-luna: 9,000 calls, each with a 3,000-token cached prefix, 1,000 uncached tokens and 300 output tokens; 95% cache reads, 5% writes.
• Telephony carrier charges are excluded, because they are not on OpenAI's price list.

Line	Arithmetic	Monthly
GPT-Live voice	10,000 minutes x $0.05	$500.00
Backend output	9,000 x 300 = 2.7M x $1.20	$3.24
Backend uncached input	9,000 x 1,000 = 9M x $0.20	$1.80
Backend cached reads	8,550 x 3,000 = 25.65M x $0.02	$0.51
Backend cache writes	450 x 3,000 = 1.35M x $0.25	$0.34
Total		$505.89

The backend model is 1.2% of this bill, and each call costs about $0.17. Upgrading the backend to a stronger model barely moves the total; shaving 20 seconds off the average call moves it by $50. Because billing is per second without rounding up, call length is the variable to design for. This is the wrong budget to copy if your callers need long, open-ended conversations: the minutes scale linearly and nothing in the token lines offsets them.

What drives the AI agent development cost you pay once

The build is where published price lists stop helping, and where most ranking pages invent a number. We will not. In the builds we run, the engineering effort is decided by five things more than by the model you choose.

Integrations. An agent that reads one knowledge base is a different project from one that writes to a CRM, a booking system and a payment gateway. Every write action needs authentication, idempotency, error handling and a decision about who approves it. Integration work usually outweighs prompt work.

Evaluation. You need a test set of real tasks and a way to score whole runs, not single answers, before and after every prompt or model change. We have written about why you should score the trajectory, not the answer. Without it, the Terra-to-Luna saving in Budget 2 is a guess.

Observability and cost controls. The budgets above assume behaviour. Production agents loop, retry and call tools you did not expect. Session traces, per-user caps and alerts on spend are part of the build, not a later phase; our piece on traces, caps and cost controls covers what to instrument.

Guardrails and human approval. Refund limits, escalation to a person, and what the agent must never say take design time and testing time, and they scale with the risk of the actions you allow.

Data. Retrieval is only as good as the documents behind it. Cleaning, chunking and keeping a knowledge base current is recurring work that teams routinely leave out of the estimate.

For teams asking about AI agent development cost in India specifically: OpenAI's rates are published in US dollars and are the same wherever you build, so the running bill in the budgets above does not change by location. What changes is the engineering rate, and that is a conversation about scope rather than a number we can publish honestly here.

Is it cheaper to build or buy an AI agent?

The strongest case for buying is real. OpenAI's Agents API gives you a managed harness that handles sessions, orchestration, context compaction and recovery, and it charges no platform fee on top: model usage at API rates, tools at standard rates and OpenAI-hosted sandboxes at container rates. For a team without agent infrastructure, that removes a large slice of the build.

The limits are specific. The same page states the Agents API currently supports data residency only in the United States and does not support Zero Data Retention, and that choosing a self-hosted sandbox does not change that. For a bank in Mumbai or a health provider in Dubai, that can settle the question before cost does. We compared the two routes in detail in buy the harness, or keep yours.

Buying also does not remove the lines that matter most. Integrations, evaluation and guardrails are yours either way, and so is the metered bill. The managed harness saves orchestration code; it does not make output tokens or voice minutes cheaper. If the spend itself is the worry, our analysis of open-weight models against frontier spend is the next thing to read.

Before you sign off an estimate

Ask for the running bill in the form above: every line, its arithmetic, and its assumptions. Then challenge the assumptions rather than the rates, because the rates are public and the assumptions are where estimates go wrong. Measure output length, cache hit rate and call duration in a pilot, and rebuild the budget from those numbers before you commit to volume.

As an OpenAI Select Partner, we build agents on the OpenAI API as well as Claude and Gemini, and our AI engineering services start with exactly this exercise: a line-by-line budget for your workload before a line of agent code is written.