AI agent development cost in 2026: real price ranges
What an AI agent costs to discover, build and run, using our published fixed prices, a worked token budget and the drivers that move a quote.
A production AI agent typically costs $25k–$120k to build at a fixed price, after a $5,000 two-week discovery sprint. Running it adds model tokens, hosting and monitoring, often a few hundred to a few thousand dollars a month. Integrations, compliance, evaluation and human approval steps move the price far more than the model does.
Listen to the summary ·
Read the transcript
A workflow agent that handles 20,000 tasks a month costs about $36 a month in Claude Haiku 5.5 tokens at list price. The build is where most of the money goes: the model is cheap, and everything around it is not.
An agent has three costs. Discovery takes two weeks and ends with a prototype on your real data and a fixed quote. The build pays for integrations, approvals, an evaluation set and a security review. Running it adds tokens, hosting and monitoring every month.
Five things move a quote, and the choice of model is not one of them. Integrations are usually the biggest line item, because each system the agent touches needs authentication, error handling and tests.
On list prices checked October 29, 2026, the same 20,000 tasks cost about $676 a month on Claude Sonnet 5.5 with prompt caching. At 100,000 tasks, caching and routing decide whether it is $178 or $6,800.
A custom agent is not worth its build price when a product already does the job at your volume. Intercom lists its Fin AI Agent from $0.99 per outcome, so 1,000 outcomes a month is about $12,000 a year. At that volume, buying wins.
The guide below works through the token math and the payback formula, and lists six checks to run on any quote.
AI-generated voice summary of this guide.
A production AI agent costs $25k–$120k to build at a fixed price, after a $5,000 two-week discovery sprint, and then tokens, hosting and monitoring every month. The tokens are the small part: a workflow agent that handles 20,000 tasks a month costs about $36 a month on Claude Haiku 5.5 and about $676 on Claude Sonnet 5.5 at list prices. That gap is the whole story of AI agent cost: the model is cheap, and the system that lets it act safely inside your CRM or ERP, with approvals and an audit log, is not.
The figures below are the ones on our pricing page, the same ones we quote against.
How much does an AI agent cost to build?
A production AI agent costs $25k–$120k as a Fixed-Price Build, after a two-week, $5,000 Discovery Sprint whose fee is credited to the build. Where a project lands in that band depends on three things: how many systems the agent touches, how much it may do without a person, and which compliance rules apply. The same math holds for agentic AI development in general: the cost follows the number of tools an agent can call and the actions it may take on its own, not the model you pick.
The total cost of an agent has three parts, and most budgets only plan for the middle one:
| Cost | What it covers | Our published price | When you pay it |
|---|---|---|---|
| Discover | Workshops, a working prototype on your real data, architecture and integration plan, fixed quote | $5,000 fixed fee, credited to the build | Weeks 1–2 |
| Build | Production agent, integrations, guardrails, evaluation set, security review, launch, 30 days of support | $25k–$120k per project | 6–16 weeks, billed in milestones |
| Run | Model tokens, hosting, logging, monitoring, evaluation runs, prompt and model updates | Usage-based (see the worked example below); optional dedicated team from $12k per month | Every month after launch |
The three costs of an AI agent
- What it covers
- Workshops, a working prototype on your real data, architecture and integration plan, fixed quote
- Our published price
- $5,000 fixed fee, credited to the build
- When you pay it
- Weeks 1–2
- What it covers
- Production agent, integrations, guardrails, evaluation set, security review, launch, 30 days of support
- Our published price
- $25k–$120k per project
- When you pay it
- 6–16 weeks, billed in milestones
- What it covers
- Model tokens, hosting, logging, monitoring, evaluation runs, prompt and model updates
- Our published price
- Usage-based (see the worked example below); optional dedicated team from $12k per month
- When you pay it
- Every month after launch
What you pay for in discovery, build and run
Each phase removes a different risk.
Discovery: proving the agent can work on your data
Discovery is two weeks with a senior architect. It ends with a prototype running on your real data (not a slide deck), the architecture, a plan for each integration, and a fixed quote. Its job is to surface the problems that make AI projects overrun: data that is messier than the demo set, APIs that need approval to access, and approval rules nobody wrote down.
Build: turning a prototype into a system you can trust
The build is where most of the money goes, and little of it is spent on the model. It pays for connecting the agent to your systems of record, adding approval steps for high-impact actions, writing an evaluation set that proves the agent behaves, a security review, and launch. Work happens in two-week sprints with live demos, and the code sits in your repository from day one.


Run: the monthly bill after launch
Running costs are model tokens, hosting, logs and monitoring, plus the time to update prompts and models as vendors release new versions. For most business agents tokens are the smallest of these at modest volume, and the largest at high volume. The worked example below shows how to estimate them.
AI agent cost by type
The type of agent decides most of the build price, because it decides how many systems the agent touches and how much it is trusted to do alone. The ranges below are how we place work inside our published band; the fixed quote comes from discovery.
| Agent type | What it does | Typical scope | Where it usually lands |
|---|---|---|---|
| Single-task assistant | Answers questions or drafts replies from one knowledge source; a person sends | One system, read-only, citations, basic evaluation | Low end, from $25k |
| Workflow agent | Reads and writes two to four systems and takes actions inside rules, with approvals | CRM or ERP writes, approval queue, audit log, evaluation per action | Middle of the range |
| Multi-agent system | Specialist agents work in parallel, process documents and cite every finding to its source | Document intelligence, several data feeds, tenant isolation | Top of the range, up to $120k; larger scopes are phased |
Where common agent types land in a $25k–$120k build
- What it does
- Answers questions or drafts replies from one knowledge source; a person sends
- Typical scope
- One system, read-only, citations, basic evaluation
- Where it usually lands
- Low end, from $25k
- What it does
- Reads and writes two to four systems and takes actions inside rules, with approvals
- Typical scope
- CRM or ERP writes, approval queue, audit log, evaluation per action
- Where it usually lands
- Middle of the range
- What it does
- Specialist agents work in parallel, process documents and cite every finding to its source
- Typical scope
- Document intelligence, several data feeds, tenant isolation
- Where it usually lands
- Top of the range, up to $120k; larger scopes are phased
Two of our own builds sit at different points on that table. Superdeal is a workflow agent inside a campaign CRM: its scope is creator discovery on three social platforms, drafted offers, and an approval step on everything it sends. A multi-agent research system we built sits at the top: specialist agents run in parallel over 20+ data feeds and uploaded documents, and every finding cites its source. Its scope is much larger than Superdeal’s, and the reasons are integrations and documents, not the model.
Two agent types carry extra line items the table does not show. A single-task assistant that answers from documents is a RAG system, and the RAG assistants we build are priced by how messy and permissioned those documents are; RAG development cost breaks that down. Voice agents add telephony, speech-to-text and text-to-speech to every minute of every call, which our guide to AI voice agent pricing per minute prices line by line.
Where the build budget goes
On our own agent builds, roughly 30% of the build price goes to integrations, about 20% to approvals, the audit log, security review and launch, 15–20% to the evaluation set, and only about 15% to the agent itself: its prompts, tools and orchestration. The rest, roughly 15–20%, covers data preparation, the admin screens for approvals and reports, project management with sprint demos, and the 30 days of support after launch.
The agent is the smallest line. When a quote is mostly “AI development” and says little about integrations or evaluation, it is pricing the part that is cheapest to get right.
What drives the cost of an AI agent?
Five things move a quote, and the choice of model is not one of them. Model choice changes the running cost, but it rarely changes the build price by much.
| Driver | Why it costs money | How to keep it down |
|---|---|---|
| Integrations | Each system needs auth, rate-limit handling, error paths and tests, and writes need rollback | Start read-only; add writes once the agent’s decisions are trusted |
| Data readiness | Scans, inconsistent fields and missing history must be cleaned or worked around | Prototype on real data in discovery, not a curated sample |
| Compliance | HIPAA, PCI or SOC 2 controls add hosting constraints, logging and review | Keep regulated data out of scope for version one where you can |
| Evaluation | Every action needs test cases that prove correct behavior, rerun on each change | Build the evaluation set from real past cases you already have |
| Autonomy | The more the agent does without a person, the more guardrails and approval logic it needs | Launch with human approval on high-impact steps, then relax it with data |
Cost drivers and how to keep each one down
- Why it costs money
- Each system needs auth, rate-limit handling, error paths and tests, and writes need rollback
- How to keep it down
- Start read-only; add writes once the agent’s decisions are trusted
- Why it costs money
- Scans, inconsistent fields and missing history must be cleaned or worked around
- How to keep it down
- Prototype on real data in discovery, not a curated sample
- Why it costs money
- HIPAA, PCI or SOC 2 controls add hosting constraints, logging and review
- How to keep it down
- Keep regulated data out of scope for version one where you can
- Why it costs money
- Every action needs test cases that prove correct behavior, rerun on each change
- How to keep it down
- Build the evaluation set from real past cases you already have
- Why it costs money
- The more the agent does without a person, the more guardrails and approval logic it needs
- How to keep it down
- Launch with human approval on high-impact steps, then relax it with data
Integrations are usually the biggest line item
An agent that cannot read from and write to your systems of record is a demo. Each integration means authentication, handling the API’s limits and failures, mapping fields, and testing what happens when a write half-succeeds. With three or more integrations, this work can outweigh the agent logic itself.
Evaluation is what makes an agent shippable
Pilots skip evaluation and pay for it later. An evaluation set is a library of real cases with the correct outcome, run against every prompt or model change. It is the difference between “it worked in the demo” and “we know it works”. Budget for it as its own line: someone has to collect the cases, agree the correct outcomes with the people who do the work today, and rerun the set whenever a prompt or model changes. We cover why skipping it stalls projects in why AI pilots stall before production.
Human approval is cheaper than full autonomy
Every step an agent takes on its own needs guardrails: confidence thresholds, limits, rollback and logging. Putting a person on the high-impact steps for the first months is faster to build and easier to get past risk and compliance review. You remove approvals one by one as the logs show the agent is reliable. Our checklist of AI agent guardrails lists the controls an agent needs before any approval comes off.
Worked example: what an AI agent costs to run each month
An agent’s running cost is mostly tokens: the text sent to the model and the text it writes back. Here is the arithmetic for a realistic workflow agent, using list prices from Anthropic’s pricing page.
Assumptions: the agent handles 20,000 tasks a month. Each task makes four model calls. Each call sends 6,000 input tokens, of which 4,500 are a stable system prompt and tool definitions that prompt caching can reuse, and gets back 500 output tokens. List prices per million tokens, checked October 29, 2026, are $2 input, $0.10 cache read and $10 output for Claude Sonnet 5.5, and $0.10, $0.01 and $0.50 for Claude Haiku 5.5 (its price for prompts up to 100,000 tokens, which covers this example). Anthropic bills cache reads at 0.1 times the input price on most models and at 0.05 times on Sonnet 5.5.
| Model | Cost per call, cached | Monthly, with caching | Monthly, no caching |
|---|---|---|---|
| Claude Haiku 5.5 | $0.00045 | about $36 | about $68 |
| Claude Sonnet 5.5 | $0.0085 | about $676 | about $1,360 |
Monthly token cost for 20,000 tasks (list prices)
- Cost per call, cached
- $0.00045
- Monthly, with caching
- about $36
- Monthly, no caching
- about $68
- Cost per call, cached
- $0.0085
- Monthly, with caching
- about $676
- Monthly, no caching
- about $1,360
How the cached Sonnet 5.5 call is worked out: 1,500 uncached input tokens at $2 per million is $0.0030, 4,500 cached tokens at $0.10 per million is $0.00045, and 500 output tokens at $10 per million is $0.0050, so about $0.0085 per call. Four calls per task and 20,000 tasks give about $676. The small premium for writing to the cache is left out because it is paid once per cache window, not per call.
Three things change this number more than the model price does:
- Caching. Reusing the stable part of the prompt roughly halves the bill here.
- Routing. Sending easy steps to a small model and only hard ones to a larger model lowers the average cost per task; at these list prices the gap between the two tiers is about 19x, so routing matters more than it did a year ago.
- Tokenizer. Anthropic notes that Claude 4.7 and later models use a tokenizer that produces about 30% more tokens for the same text, so estimates made with an older tokenizer will run low.
The same agent at 2,000, 20,000 and 100,000 tasks a month
Token cost grows in a straight line with volume; the build price does not move. Multiplying the per-call figures above by four calls per task gives these monthly totals:
| Tasks a month | Haiku 5.5, cached | Haiku 5.5, no cache | Sonnet 5.5, cached | Sonnet 5.5, no cache |
|---|---|---|---|---|
| 2,000 | about $4 | about $7 | about $68 | about $136 |
| 20,000 | about $36 | about $68 | about $676 | about $1,360 |
| 100,000 | about $178 | about $340 | about $3,380 | about $6,800 |
Monthly token cost by volume (4 calls per task, list prices checked Oct 29, 2026)
- Haiku 5.5, cached
- about $4
- Haiku 5.5, no cache
- about $7
- Sonnet 5.5, cached
- about $68
- Sonnet 5.5, no cache
- about $136
- Haiku 5.5, cached
- about $36
- Haiku 5.5, no cache
- about $68
- Sonnet 5.5, cached
- about $676
- Sonnet 5.5, no cache
- about $1,360
- Haiku 5.5, cached
- about $178
- Haiku 5.5, no cache
- about $340
- Sonnet 5.5, cached
- about $3,380
- Sonnet 5.5, no cache
- about $6,800
Read across a row and the cheapest option is always the small model with caching; read down a column and only volume changes the bill. At 2,000 tasks the model is a rounding error next to hosting. At 100,000 it is a real line, and caching and routing decide whether it is $178 or $6,800.
On top of tokens, budget for hosting the agent service, logs and traces, and scheduled evaluation runs. These depend on your cloud and your retention rules, so treat them as their own line rather than guessing a percentage.
What an AI agent costs to maintain after launch
Maintenance is the engineering that keeps an agent correct while everything around it changes. The model bill is predictable; these four jobs are what surprise budgets:
- Model and price changes. Vendors retire models and change prices; each switch means rerunning the evaluation set before the new model goes live.
- Evaluation reruns. Every prompt change, tool change or new edge case from production goes through the full test set, and the set grows as users find new cases.
- Monitoring and traces. Someone reads the logs of failed and escalated tasks each week and turns them into fixes or new test cases.
- Integration drift. When a connected CRM, ERP or API changes a field or an auth flow, the agent starts failing without an error message unless a test catches it.
Our builds include 30 days of support after launch. After that, owners usually choose small fixed-price change requests for occasional updates, or a Dedicated Team when the agent has a roadmap of its own. We don’t publish a maintenance percentage of the build price, because it depends on how many integrations can drift and how often your process changes, not on what the build cost.
Why AI agent cost estimates range from $5,000 to $400,000+
Published estimates span two orders of magnitude because they put very different systems under one word. The cost guides that ranked for “AI agent development cost” when we checked on October 29, 2026 put an agent anywhere from about $5,000 to more than $400,000, and few of them show how they got there.
- The low end, roughly $5,000 to $25,000, is a rule-based bot or a prototype: one data source, read-only, no evaluation set, no approvals.
- The high end, $150,000 to $400,000 and more, is a multi-agent system in a regulated industry, built by a full team over six months or longer.
- The middle is a production agent that reads and writes real systems, with approvals, an audit log and an evaluation set. Our fixed-price band, $25k–$120k, covers that middle; a prototype costs less (our discovery sprint ends with one, for $5,000), and larger programs are split into phases.
Treat any published range as a way to sort scopes, not as a price. The number that counts is a fixed quote against a named scope.
Why quotes for the same AI agent differ so much
Two quotes for the “same” agent usually describe different systems. One vendor prices a prototype with a read-only connection; another prices writes, approvals, an audit log and a test set. Before comparing totals, line the quotes up against six questions:
| Check | What a complete quote states | What a thin quote leaves out |
|---|---|---|
| Integrations | Each system named, read or write, and who supplies API access | “Integrates with your CRM” |
| Evaluation set | Roughly how many real cases, who writes the expected outcomes, when it runs | “Testing” as one line |
| Approval steps | Which actions need a person and how the approval queue works | Nothing, or “human in the loop” with no detail |
| Audit log | What is logged per action and how long it is kept | Nothing |
| Ownership | Code, prompts, evaluation set and cloud accounts in your name | A license to use the vendor’s platform |
| Post-launch support | A fixed support window and how changes are priced after it | “Ongoing support available” |
Check every AI agent quote for these six items
- What a complete quote states
- Each system named, read or write, and who supplies API access
- What a thin quote leaves out
- “Integrates with your CRM”
- What a complete quote states
- Roughly how many real cases, who writes the expected outcomes, when it runs
- What a thin quote leaves out
- “Testing” as one line
- What a complete quote states
- Which actions need a person and how the approval queue works
- What a thin quote leaves out
- Nothing, or “human in the loop” with no detail
- What a complete quote states
- What is logged per action and how long it is kept
- What a thin quote leaves out
- Nothing
- What a complete quote states
- Code, prompts, evaluation set and cloud accounts in your name
- What a thin quote leaves out
- A license to use the vendor’s platform
- What a complete quote states
- A fixed support window and how changes are priced after it
- What a thin quote leaves out
- “Ongoing support available”
For the questions to put to the vendor behind the quote, see questions to ask an AI agent development company.
Fixed price vs time and materials for an AI agent
A fixed price after discovery protects the buyer from overruns; time and materials protects the vendor. For AI agents, where the main risk is unknown data and integrations, the fix is to resolve those unknowns first and then fix the price, which is what discovery is for.
| Fixed price after discovery | Time and materials | Dedicated team | |
|---|---|---|---|
| Best for | A defined agent or product | Research with no clear end | An ongoing roadmap |
| Who carries overrun risk | The vendor | You | Shared, scope flexes monthly |
| Scope changes | Change request | Anytime, billed hourly | Anytime |
| Our price | $25k–$120k per project | Not offered | From $12k per month |
Pricing models for an AI agent build
- Fixed price after discovery
- A defined agent or product
- Time and materials
- Research with no clear end
- Dedicated team
- An ongoing roadmap
- Fixed price after discovery
- The vendor
- Time and materials
- You
- Dedicated team
- Shared, scope flexes monthly
- Fixed price after discovery
- Change request
- Time and materials
- Anytime, billed hourly
- Dedicated team
- Anytime
- Fixed price after discovery
- $25k–$120k per project
- Time and materials
- Not offered
- Dedicated team
- From $12k per month
We recommend fixing the price for the first production version, and moving to a Dedicated Team only if the agent becomes a product with its own roadmap. The trade-offs between the contract models are in our guide to fixed price vs time and materials.
When a custom AI agent is not worth paying for
A custom agent is not worth its build price when a product already does the job at your volume for less. The quickest test is arithmetic: multiply the product’s usage price by the volume you expect in year three, and compare it with the build plus three years of running cost.
Two published price lists show what that comparison looks like. Intercom lists its Fin AI Agent from $0.99 per outcome, so 1,000 outcomes a month is about $12,000 a year, well under a $25k build plus hosting and maintenance. Microsoft sells Copilot Studio as packs of 25,000 credits for $200 a month, which suits internal assistants that live inside Microsoft 365. At that kind of volume, inside tools you already use, buying wins on cost.
The arithmetic turns the other way when volume grows, when the agent has to write to your own systems, or when how it works is part of what you sell. A full three-year model, the lock-in questions to put to vendors, and the part-bought, part-built setup most agents end up with are in build vs buy AI agents.
When does an AI agent pay for itself?
An agent pays for itself once the monthly value of the work it takes over, minus its monthly running cost, has added up to the build price. Because our discovery fee is credited to the build, the upfront cost is the build price alone:
Payback in months = build price ÷ (monthly value of work handled − monthly running cost)
Volume decides the answer far more than the build price does. The example below uses stated assumptions; swap in your own. A support agent fully resolves half of the tickets it sees, each ticket takes a person 6 minutes, and an hour of that person’s time costs $40 fully loaded, so each resolved ticket is worth $4. Running cost (tokens, hosting, monitoring) is set at $1,000 a month at 2,000 tickets and $1,500 at 10,000.
| Tickets a month | Value of work handled | Net per month | Build at $25k | Build at $120k |
|---|---|---|---|---|
| 2,000 | $4,000 | $3,000 | about 8 months | about 40 months |
| 10,000 | $20,000 | $18,500 | about 1.4 months | about 6.5 months |
Payback at two volumes and both ends of our build band (assumptions above)
- Value of work handled
- $4,000
- Net per month
- $3,000
- Build at $25k
- about 8 months
- Build at $120k
- about 40 months
- Value of work handled
- $20,000
- Net per month
- $18,500
- Build at $25k
- about 1.4 months
- Build at $120k
- about 6.5 months
Two things follow. At low volume a simple agent can pay back within a year, but a complex one rarely does, so either narrow the scope or buy a product. And the running cost belongs in the formula: leaving it out flatters the result most at low volume, which is exactly where the decision is closest. If the payback runs past two years at your volume, read build vs buy AI agents before you commit to a build.
How to budget for an AI agent project
Budget for the system, not the model. A realistic plan has four lines:
- Weeks 1–2Discovery: $5,000Two weeks, ending with a working prototype and a fixed quote.
- 6–16 weeksBuild: $25k–$120kDepending on agent type, integrations and compliance.
- Every monthRunTokens from a worked estimate like the one above, plus hosting and monitoring.
- OngoingChangeModel and prompt updates as vendors ship new versions, either as small fixed-price changes or a dedicated team.
Then pick one workflow and one number to move, such as hours saved, tickets resolved or decisions made per day, and hold the build to it. That keeps scope honest and makes the return easy to measure. If you want a fixed price for your own agent, our AI agent development team starts with a free AI audit: book the audit and bring the workflow you have in mind.
Sources
- Claude API pricing, Anthropic
- Intercom pricing (Fin AI Agent), Intercom
- Microsoft Copilot Studio pricing, Microsoft
AI Agent Development
We design and build autonomous AI agents and multi-agent systems that read, decide and act across your tools, with human approval where it matters.





