How much does an AI agent cost to build and run in 2026?

AI agent cost starts at the build: about $75k to $150k for a well-scoped proof of concept, $40k to $250k for most mid-complexity builds and $500k plus for an enterprise platform, on the ranges we publish. Then the agent costs money every month in tokens, tools, infrastructure and upkeep. This guide prices both sides, with a complexity-tier table, the running cost formula and a worked customer support example.

By Kanika Mathur, Head of Service Delivery

Reviewed by Arjun SareenPublished Sep 15, 2026Updated Sep 15, 202613 min read

Cost

Key takeaways

The short version

Build cost follows complexity. On our published ranges a well-scoped proof of concept runs about $75k to $150k over 8 to 12 weeks, mid-complexity custom AI $40k to $250k and an enterprise platform $500k to $1M plus (Resourcifi AI pricing guide).
Running cost is a second budget. Our TCO calculator's worked default comes to about $115,400 in year one and $59,400 a year after the build drops off (Resourcifi AI TCO calculator).
Agents multiply tokens. On its own research system, Anthropic measured agents using about 4x the tokens of a chat interaction and multi-agent systems about 15x (Anthropic Engineering, 2025). On our arithmetic, design choices can move the token bill by several times, on top of model choice.
Tokens are often the smaller line. In our worked support example of 20,000 conversations a month, tokens are $1,280 of about $4,358 a month before trace overage; upkeep engineering is the largest line (our arithmetic on Anthropic and OpenAI list prices).
Caching and batching cut the token line fast. On Anthropic's mid and fastest tiers a cache hit costs 10 percent of the input price and batch jobs take 50 percent off at Anthropic and OpenAI; caching alone cut our example from $1,280 to $560 before cache-write charges a month.

How much does an AI agent cost? The quick answer

Using the ranges we publish in our AI development cost guide, a well-scoped proof of concept runs about $75k to $150k over 8 to 12 weeks, a mid-complexity custom build $40k to $250k, and an enterprise AI platform $500k to $1M plus. Running cost comes on top of that. In our worked TCO example, one AI feature costs about $115,400 in year one and $59,400 a year after that.¹²

The ranges are wide because AI agent cost depends less on the model than on four inputs our pricing guide names as the real drivers: data quality, integration complexity, accuracy requirements and inference volume.¹ A chatbot over a tidy help center sits at the bottom of the mid-complexity band. An agent that writes to your ERP and has to be right every time sits near the top, or moves into platform territory.

An agent keeps costing money after launch, because one user action can trigger several model calls once you add retries and agent turns.² So plan two numbers from day one: the build, and the monthly run.

$75k to $150k

Typical range for a well-scoped proof of concept, about 8 to 12 weeks, before recurring inference.

Resourcifi AI pricing guide, 2026

About 15x the tokens of a chat interaction on Anthropic's own research system. A single agent used about 4x.

Anthropic Engineering, 2025

$115,400

Year-one total cost of ownership for one AI feature in our worked default, falling to $59,400 a year once the build is paid.

Resourcifi AI TCO calculator, 2026

AI agent cost by complexity tier

Complexity sets the build price. On our published, directional ranges, an automation setup costs $2.5k to $15k, and a chatbot or narrow agent sits at the low end of the $40k to $250k mid-complexity band. A proof of concept for a harder agent runs $75k to $150k, production-grade builds climb into the mid six figures, and an enterprise platform starts at $500k.¹

AI agent cost by complexity tier (published build ranges, recurring inference extra; tier descriptions and notes are our mapping)
Tier	What it looks like	Published range	Timeline or note	What pushes it up
1. Automation setup	Our mapping: a fixed workflow (classify, draft, route) with one or two model calls	$2.5k to $15k setup	Plus $500 to $5k a month maintenance	Number of systems touched
2. Chatbot or narrow agent	Answers from your documents, a few read-only tools	Low end of $40k to $250k	Listed as "feature or chatbot at the low end"	Messy source content, accuracy bar
3. Proof of concept for a harder agent	Feasibility test on real data with go or no-go metrics	$75k to $150k	About 8 to 12 weeks	Data quality you have not yet inspected
4. Production agent	Writes to live systems, guardrails, evals, monitoring	Mid six figures for production-grade builds	Our reading: a narrow build may fit the $40k to $250k band	Integrations, permissions, audit needs
5. Enterprise AI platform	Several agents, shared tooling, governance, MLOps staff	$500k to $1M plus	Once compute and MLOps staffing are included	Scale, compliance, number of teams served

Tier 3 costing more than the bottom of tier 2 reflects uncertainty. Our guide treats a proof of concept as a feasibility test on your data, not yet a product.¹ A narrow chatbot over clean documentation carries little of that risk.

A useful rule: if the agent only reads and answers, budget from tier 2, which is also what it costs to develop an AI chatbot over clean documentation. If it takes actions in systems that matter (refunds, orders, patient or financial records), budget from tier 3 and plan for a tier 4 production build in the mid six figures. The step-by-step agent build guide covers where that line falls technically.

Where the build budget goes

Most of the build budget goes on engineering around the model, not on the model. Discovery and data work, tool integrations, evaluation suites, guardrails and production hardening make up most of the bill. Open-source frameworks such as LangGraph and the OpenAI Agents SDK cost nothing to license. The hours your team spends wiring them into your systems and proving the agent works are what you pay for.

For a sense of scale, the default in our TCO calculator prices a one-time build at 4 engineer-months for $56,000, which works out to $14,000 an engineer-month. That rate comes from the BLS median software developer wage with a loaded-cost gross-up.² A simple agent may fit in that envelope. Our pricing guide puts production-grade builds in the mid six figures, many times that default.¹

Build cost lines for an AI agent
Line	What the work is	What drives the cost
Discovery and data assessment	Inspect the data, set accuracy targets and go or no-go metrics	How scattered and dirty the source data is
Agent loop and orchestration	Prompts, state, memory, retries, handoffs	Single agent or several; how long tasks run
Tools and integrations	APIs the agent can call, with auth and permissions	Number of systems, and whether they are read or write
Evals	Test sets and scoring that prove the agent is right often enough	Accuracy bar and how many task types you cover
Guardrails and security	Input checks, action limits, human approval steps	Risk of the actions the agent can take
Production hardening	Monitoring, tracing, cost caps, rollout	Traffic, uptime needs, audit requirements

LangGraph is an MIT-licensed, low-level orchestration framework for long-running, stateful agents.¹⁰ The OpenAI Agents SDK is a lightweight package with built-in tracing.¹¹ Claude and other model APIs expose tool use directly. None of these removes the integration and eval work.

Two lines are underestimated more than any others:

Discovery. Our pricing guide treats discovery (data assessment, a hypothesis framework and go or no-go metrics set before any code) as a paid phase that earns its keep.¹ Skipping it can move the cost into rework.
Hardening. Our guide says not to bid the build before a paid discovery and POC have reduced the unknowns, because data pipelines, security and integration only show their cost then.¹ Quote the production build only after the pilot has measured what it needs to.

What an AI agent costs to run each month: the formula

Monthly run cost is tokens plus tools plus infrastructure plus upkeep, where tokens are conversations times model calls per conversation times the input and output price. Tools add fees such as web search at $10 per 1,000 searches. In a worked support example of 20,000 conversations a month, tokens are under a third of a $4,358 monthly bill before trace overage, because infrastructure and ongoing engineering cost more.²³⁴⁹

The formula, written out:

Tokens = conversations x calls per conversation x (input tokens x input rate + output tokens x output rate).
Tools = metered tool fees. Both Anthropic and OpenAI list web search at $10 per 1,000 searches, plus the tokens the results add.³⁴
Infrastructure = hosting, vector database, and observability. LangSmith's Plus plan, for example, is $39 a seat a month with 10k base traces included, then pay as you go.⁹
Upkeep = the engineering time to keep the agent accurate as your data, prompts and models change. Our TCO default is 20 percent of one engineer, $33,600 a year.²

Tool definitions count too. Anthropic bills the tools parameter as input and adds a tool-use system prompt of a few hundred tokens to every tool request.³ An agent that loops four times pays for its tool list four times.

A worked example: a customer support agent

Our assumptions, labelled so you can swap in your own: 20,000 conversations a month, 4 model calls per conversation, 6,000 input tokens (system prompt, tool definitions, retrieved help articles, history) and 400 output tokens per call. At a mid-tier rate of $2 per million input tokens and $10 per million output, which is the current list price for both Anthropic's and OpenAI's mid tiers, one call costs $0.016 and one conversation $0.064.³⁴

Illustrative monthly run cost, support agent, 20,000 conversations (our assumptions)
Line	Basis	Per month
Model tokens	20,000 x 4 calls x $0.016, mid tier	$1,280
Observability	Two LangSmith Plus seats at $39 (trace overage extra)	$78
Infrastructure	Hosting and vector database, TCO calculator default	$200
Ongoing engineering	20 percent of one engineer, $33,600 a year	$2,800
Total, before trace overage	Tokens are 29 percent of the bill	$4,358

Change the design and the token line moves far more than any other. On Anthropic's own research system, agents used about 4x the tokens of chat and multi-agent systems about 15x, so the same traffic on a multi-agent design could cost nearly 4x as much.⁶ The chart shows what one support workload costs in tokens under five setups.

The same 20,000 conversations cost $560 to $6,400 a month in tokens

Monthly token bill for one support agent under five setups. Traffic is held constant; only model tier and design change.

Data behind this chart
Setup	Rate per million tokens (in / out)	Per month
Mid tier, 5,000 input tokens cached at 0.1x	$2 / $10, cache hits $0.20	$560
Fastest Anthropic tier	$1 / $5	$640
Mid tier, no caching	$2 / $10	$1,280
Multi-agent design, mid tier (illustrative, 15x divided by 4x)	$2 / $10	About $4,800
Flagship tier	$10 / $50	$6,400

Sources: Anthropic, Pricing (2026); OpenAI, API Pricing (2026); Anthropic Engineering, multi-agent research system (2025) for the 4x and 15x ratios, which make the multi-agent bar illustrative. Workload assumptions are ours: 20,000 conversations, 4 calls each, 6,000 input and 400 output tokens per call. Cache writes ignored.

On this workload the model tier moves the token bill 10x, from $640 on the fastest tier to $6,400 on the flagship, while the $2,800 a month of upkeep stays whichever model you choose. The AI TCO calculator lets you run the full year with your own inputs, and in its worked default the steady state comes to $59,400 a year, about $4,950 a month.²

Cost by use case, including customer support

Use case decides the tier and the shape of the running bill. A customer support agent is usually a tier 2 build, with a bill driven by conversation volume, that grows into tier 4 once it takes actions such as refunds. A research agent costs more per task because it loops and searches. A document-processing agent can run its token line at half price through batch APIs, because the work can wait.

AI agent cost by use case (tiers from the complexity table)
Use case	Typical tier	Main run-cost driver	Cheapest lever	Watch for
Customer support agent	2, then 4 when it acts	Conversation volume	Cache the system prompt and tools	Per-outcome vendor fees at scale
Internal knowledge assistant	2	Retrieved context size	Retrieve fewer, better passages	Stale or conflicting source documents
Research or sales prospecting agent	3 to 4	Loops and web searches	Cap turns and searches per task	Runaway loops on vague tasks
Document processing agent	2 to 3	Pages per month	Batch processing at 50 percent off	Accuracy on unusual layouts
Operations agent that writes to live systems	4 to 5	Approval and audit steps	Route routine steps to a smaller model	Permissions and rollback

What a custom customer support agent costs

For a support agent that answers from your help center and hands off to people, budget from tier 2 in the table above.¹ If it also looks up orders, issues refunds or changes accounts, plan a proof of concept first and a production build after it. The run side is the worked example above. Our customer service agent guide covers the build and the difference between deflecting a conversation and resolving it.

The buy option is a useful reference point. Intercom prices its Fin agent at $0.99 per outcome, with a minimum monthly commitment and no setup or platform fees on an existing helpdesk. It charges once per conversation, when the customer confirms a resolution, asks for no more help, or Fin completes a workflow.⁸ On our arithmetic, 10,000 outcomes a month is $9,900, and 20,000 is $19,800. At low volume, buying usually wins. At high volume, or when the agent must act inside systems the vendor cannot reach, building starts to pay back.

Research and multi-step agents

Research agents are where token counts climb: Anthropic reports that its early multi-agent versions spawned 50 subagents for simple queries.⁶ Budget these per task, and cap searches and turns before launch.

How AI agent pricing works: builders and platforms

You pay twice, and each side prices differently. Builders charge for the work through one of six models: fixed-bid, time and materials, phased, retainer, outcome-based, or hybrid. Platforms charge for the running through tokens, per-outcome fees, session runtime or seats. For most agent projects, phased pricing caps your exposure before the data is proven, and pass-through inference shows the real model bill as usage grows.¹

How builders price the work
Model	Fits	Tradeoff
Fixed-bid	Well-defined scope, only after a proof of concept	High overrun risk; the builder absorbs scope creep
Time and materials	R&D, custom models, multi-phase work	No cost ceiling; inefficiency can hide in hours
Milestone or phased	Discovery, proof of concept, build, hardening	Needs disciplined gating to work
Retainer or managed	Monitoring, retraining, ongoing ops	Can drift without clear deliverables
Outcome-based	Measurable results such as a resolution	Cost variability; needs trustworthy measurement
Hybrid (base plus usage)	Most AI engagements	Harder to communicate to the buyer

Our guide rates fixed-bid as high overrun risk, with the agency absorbing scope creep, and reserves it for well-defined scope after discovery and a POC have shrunk the unknowns.¹ If a vendor fixes a price before seeing your data, ask what it assumes about that data.

On the platform side, the common units are:

Tokens. Priced per million, input and output separately. Standard short-context list rates run from $0.10 in and $0.50 out on OpenAI's small tier to $10 in and $50 out on the flagship tiers at both OpenAI and Anthropic.³⁴
Per outcome. Intercom's Fin at $0.99 per outcome is the reference example.⁸
Session runtime. Anthropic's Claude Managed Agents bills tokens plus $0.08 per session-hour, counted only while the session is running.³
Seats and traces. Observability and eval tooling such as LangSmith charge per seat plus trace volume.⁹

When a builder runs the agent for you, ask for inference as a pass-through line, optionally with a stated markup.¹ You then see the real model bill as usage grows.

How to cut agent compute cost without losing quality

Agent compute cost optimization starts with design, then pricing features. Use a workflow where one will do and one agent before several. Route easy requests to a smaller model, cache the stable part of every prompt, and batch any work that can wait. Then prove with evals that the cheaper setup still meets your accuracy bar, because a cheap wrong answer costs more than an expensive right one.

Do not build an agent you do not need. Anthropic recommends finding the simplest solution possible, which might mean not building an agentic system at all, because agentic systems trade latency and cost for better task performance.⁷
Stay single-agent until evals say otherwise. As the running-cost section shows, splitting one agent into several can push the token line to nearly 4x on Anthropic's own measurements.⁶
Route by difficulty. Send common questions to a smaller, cheaper model and hard ones to a more capable model, a pattern Anthropic describes directly.⁷ Anthropic's fastest tier costs half its mid tier. OpenAI's small tier is one twentieth of its mid tier.³⁴
Cache the prefix. On Anthropic's mid and fastest tiers a cache hit costs 10 percent of the standard input price, and a 5-minute cache pays for itself after one read.³ OpenAI's mid tier lists cached input at $0.10 against $2.00.⁴ In our support example, caching 5,000 of 6,000 input tokens cut the token bill from $1,280 to $560 before cache-write charges, about 56 percent.
Batch what can wait. Both providers take 50 percent off input and output for batch jobs. OpenAI's batch jobs run in a 24-hour completion window, often finishing sooner.³⁵ Overnight document runs belong here; live chat does not.
Trim tools and context. Tool definitions are billed as input on every call,³ so load only the tools a step needs.
Cap turns and spend. Set a maximum number of loops, searches and tokens per task, and alert on outliers. The autonomous nature of agents means higher costs and compounding errors, so Anthropic recommends extensive testing in sandboxed environments with guardrails.⁷

Prices also fall under you. Looking back over November 2022 to October 2024, Stanford's 2025 AI Index, the most recent edition to report this measure, found the inference cost of a system at a fixed older capability level dropped more than 280-fold, with hardware costs falling 30 percent a year.¹² Re-run your cost model each quarter and keep the model swappable behind evals. Our AI cost optimization guide ranks these levers by payoff.

When we take over an AI system someone else built, we typically cut serving cost by 40 to 70 percent. If you want a build and run budget for your own agent, our AI agent development team will price both against your volumes, or you can book a discovery call and bring your traffic numbers.

Frequently asked

AI agent cost questions

How much does it cost to build an AI agent?

On the ranges we publish, a well-scoped proof of concept runs about $75k to $150k over 8 to 12 weeks, a mid-complexity custom build $40k to $250k, and an enterprise AI platform $500k to $1M plus. A chatbot or narrow agent sits at the low end of the mid band. Recurring inference is extra. The drivers are data quality, integration complexity, accuracy requirements and inference volume, rarely the model itself.

What does an AI agent cost per month to run?

Add four lines: tokens, tool fees, infrastructure and upkeep engineering. In our worked support example, 20,000 conversations a month at mid-tier list prices of $2 per million input tokens and $10 per million output cost $1,280 in tokens. With observability, hosting and 20 percent of one engineer, the total is about $4,358 a month before trace overage. Our TCO calculator's worked default comes to $59,400 a year at steady state.

How much does an AI chatbot cost?

A custom chatbot that answers from your own documents usually sits at the low end of the $40k to $250k mid-complexity range we publish, because it reads and answers rather than acting in your systems. Our published range for a simpler automation setup is $2.5k to $15k, plus $500 to $5k a month to maintain. Running cost is usually lower than an agent's, because a chat exchange uses far fewer tokens than an agent loop.

How much would a custom AI agent for customer support cost?

If it answers from your help center and hands off to people, budget from the low end of our published $40k to $250k mid-complexity band. If it also looks up orders or issues refunds, plan a $75k to $150k proof of concept before the production build. To run, our example of 20,000 conversations a month comes to about $4,358 before trace overage. For comparison, Intercom prices its Fin agent at $0.99 per outcome, so 10,000 outcomes a month would cost $9,900.

Is it cheaper to buy an AI agent or build one?

At low volume, buying usually wins. In our TCO calculator's worked default, a per-seat buy path (50 seats at $30) costs about $28,000 in year one and $18,000 a year after, against $115,400 and $59,400 to build. A per-outcome vendor fee is different: it scales straight up with usage, so at Intercom's $0.99 per outcome, 20,000 outcomes a month is $19,800. Build when volume is high or the agent must act in systems a vendor cannot reach.

How do you reduce AI agent compute cost?

Start with design: use a workflow where one will do and a single agent before several, since multi-agent systems use about 15x the tokens of chat against about 4x for one agent. Then route easy requests to a smaller model, cache the stable prompt prefix (on Anthropic's mid and fastest tiers a cache hit costs 10 percent of the input price), and batch work that can wait for 50 percent off. Check each change against your evals.

Kanika Mathur

Head of Service Delivery, Resourcifi

Kanika Mathur is Head of Service Delivery at Resourcifi. She leads the engineering pods that scope, build and run client software, from mobile apps to AI systems, and she reviews the process and figures in our engineering guides for accuracy.

Resourcifi on LinkedIn →

Arjun Sareen

Reviewer. Head of Business Development, Resourcifi

Arjun Sareen is Head of Business Development at Resourcifi. He scopes builds with founders and product leaders, matches each project with the right team model, and hears the same buying questions every week, which is what he writes about.

Resourcifi on LinkedIn →

Sources

Resourcifi, AI development cost: how to scope, quote, and price an AI build (published cost ranges: proof of concept about $75k to $150k over 8 to 12 weeks, mid-complexity custom AI $40k to $250k, enterprise AI platform $500k to $1M plus, automation setup $2.5k to $15k plus $500 to $5k a month; the six pricing models; cost drivers; qualitative guidance on discovery, pilot hardening and fixed-bid risk (no percentages); mid six figures for production-grade builds; pass-through billing).
Resourcifi, How much does AI cost? An AI TCO calculator for the real price of owning a feature (worked default: $56,000 build over 4 engineer-months, $33,600 a year ongoing engineering at 20 percent of one engineer, $2,400 a year infrastructure, $115,400 year-one TCO and $59,400 steady state).
Anthropic, Pricing (Claude Platform Docs) (list rates per million tokens by tier ($1 and $5 fastest, $2 and $10 mid, $10 and $50 top), cache hit at 0.1x input on the mid and fastest tiers (0.025x on the top tier), 50 percent batch discount, tools billed as input tokens plus a tool-use system prompt, web search at $10 per 1,000, Managed Agents session runtime at $0.08 per session-hour).
OpenAI, Pricing (OpenAI API docs) (list rates per million tokens: flagship $10 input and $50 output, mid tier $2 and $10 with cached input at $0.10, small tier $0.10 and $0.50; batch at half price; web search at $10 per 1k calls).
OpenAI, Batch API (50 percent cost discount against synchronous APIs, each batch completes within 24 hours).
Anthropic Engineering, How we built our multi-agent research system (agents use about 4x more tokens than chat and multi-agent systems about 15x (June 2025); early versions spawned 50 subagents for simple queries).
Anthropic Engineering, Building effective agents (find the simplest solution, agentic systems trade latency and cost for task performance, route easy questions to smaller cost-efficient models, higher costs and compounding errors of autonomous agents (December 2024)).
Intercom, Intercom Pricing (Fin AI Agent at $0.99 per outcome, outcome definition, charged once per conversation, minimum monthly commitment, no setup, integration or platform fees on an existing helpdesk).
LangChain, LangSmith Plans and Pricing (Plus plan at $39 a seat a month with 10k base traces included, then pay as you go).
LangChain (GitHub), langchain-ai/langgraph (LangGraph is a low-level orchestration framework for long-running, stateful agents, MIT license).
OpenAI, OpenAI Agents SDK (lightweight package with very few abstractions and built-in tracing; MIT license (openai/openai-agents-python repository)).
Stanford HAI, The 2025 AI Index Report (inference cost at a fixed capability level dropped over 280-fold between November 2022 and October 2024; hardware costs down 30 percent a year (2025 edition, 2022 to 2024 trend; the 2026 edition's headline findings do not update it)).