Buying software · · 14 min

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.

Quick answer

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:

The three costs of an AI agent
CostWhat it coversOur published priceWhen you pay it
DiscoverWorkshops, a working prototype on your real data, architecture and integration plan, fixed quote$5,000 fixed fee, credited to the buildWeeks 1–2
BuildProduction agent, integrations, guardrails, evaluation set, security review, launch, 30 days of support$25k–$120k per project6–16 weeks, billed in milestones
RunModel tokens, hosting, logging, monitoring, evaluation runs, prompt and model updatesUsage-based (see the worked example below); optional dedicated team from $12k per monthEvery month after launch

The three costs of an AI agent

Discover
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
Build
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
Run
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.

A production agent as seven parts: integrations (auth, limits, errors, tests), approvals (a person on high-impact steps), audit log (every action recorded), evaluation set (real cases, rerun on change) and guardrails (limits, thresholds, rollback), plus two monthly run costs: model calls (tokens) and hosting (logs, traces, monitoring)A production agent as seven parts: integrations (auth, limits, errors, tests), approvals (a person on high-impact steps), audit log (every action recorded), evaluation set (real cases, rerun on change) and guardrails (limits, thresholds, rollback), plus two monthly run costs: model calls (tokens) and hosting (logs, traces, monitoring)
Model calls are one part of seven. The build pays for integrations, approvals, the audit log, the evaluation set and guardrails; model calls and hosting are monthly run costs.

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.

Where common agent types land in a $25k–$120k build
Agent typeWhat it doesTypical scopeWhere it usually lands
Single-task assistantAnswers questions or drafts replies from one knowledge source; a person sendsOne system, read-only, citations, basic evaluationLow end, from $25k
Workflow agentReads and writes two to four systems and takes actions inside rules, with approvalsCRM or ERP writes, approval queue, audit log, evaluation per actionMiddle of the range
Multi-agent systemSpecialist agents work in parallel, process documents and cite every finding to its sourceDocument intelligence, several data feeds, tenant isolationTop of the range, up to $120k; larger scopes are phased

Where common agent types land in a $25k–$120k build

Single-task assistant
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
Workflow agent
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
Multi-agent system
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.

How a typical build price splits on our agent projects (approximate)
  • Integrationsabout 30%
  • Approvals, audit log, security, launchabout 20%
  • Evaluation set15–20%
  • Data prep, admin screens, project management, support15–20%
  • The agent: prompts, tools, orchestrationabout 15%

Rough shares from our own builds. A read-only assistant spends less on integrations; a regulated one spends more on safety and 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.

Cost drivers and how to keep each one down
DriverWhy it costs moneyHow to keep it down
IntegrationsEach system needs auth, rate-limit handling, error paths and tests, and writes need rollbackStart read-only; add writes once the agent’s decisions are trusted
Data readinessScans, inconsistent fields and missing history must be cleaned or worked aroundPrototype on real data in discovery, not a curated sample
ComplianceHIPAA, PCI or SOC 2 controls add hosting constraints, logging and reviewKeep regulated data out of scope for version one where you can
EvaluationEvery action needs test cases that prove correct behavior, rerun on each changeBuild the evaluation set from real past cases you already have
AutonomyThe more the agent does without a person, the more guardrails and approval logic it needsLaunch with human approval on high-impact steps, then relax it with data

Cost drivers and how to keep each one down

Integrations
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
Data readiness
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
Compliance
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
Evaluation
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
Autonomy
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.

Monthly token cost for 20,000 tasks (list prices)
ModelCost per call, cachedMonthly, with cachingMonthly, no caching
Claude Haiku 5.5$0.00045about $36about $68
Claude Sonnet 5.5$0.0085about $676about $1,360

Monthly token cost for 20,000 tasks (list prices)

Claude Haiku 5.5
Cost per call, cached
$0.00045
Monthly, with caching
about $36
Monthly, no caching
about $68
Claude Sonnet 5.5
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.

One cached Sonnet 5.5 call, about $0.0085
  • Output, 500 tokens$0.0050
  • Uncached input, 1,500 tokens$0.0030
  • Cached input, 4,500 tokens$0.00045

Four calls per task and 20,000 tasks: about $676 a month.

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:

Monthly token cost by volume (4 calls per task, list prices checked Oct 29, 2026)
Tasks a monthHaiku 5.5, cachedHaiku 5.5, no cacheSonnet 5.5, cachedSonnet 5.5, no cache
2,000about $4about $7about $68about $136
20,000about $36about $68about $676about $1,360
100,000about $178about $340about $3,380about $6,800

Monthly token cost by volume (4 calls per task, list prices checked Oct 29, 2026)

2,000
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
20,000
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
100,000
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 every AI agent quote for these six items
CheckWhat a complete quote statesWhat a thin quote leaves out
IntegrationsEach system named, read or write, and who supplies API access“Integrates with your CRM”
Evaluation setRoughly how many real cases, who writes the expected outcomes, when it runs“Testing” as one line
Approval stepsWhich actions need a person and how the approval queue worksNothing, or “human in the loop” with no detail
Audit logWhat is logged per action and how long it is keptNothing
OwnershipCode, prompts, evaluation set and cloud accounts in your nameA license to use the vendor’s platform
Post-launch supportA fixed support window and how changes are priced after it“Ongoing support available”

Check every AI agent quote for these six items

Integrations
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”
Evaluation set
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
Approval steps
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
Audit log
What a complete quote states
What is logged per action and how long it is kept
What a thin quote leaves out
Nothing
Ownership
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
Post-launch support
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.

Pricing models for an AI agent build
Fixed price after discoveryTime and materialsDedicated team
Best forA defined agent or productResearch with no clear endAn ongoing roadmap
Who carries overrun riskThe vendorYouShared, scope flexes monthly
Scope changesChange requestAnytime, billed hourlyAnytime
Our price$25k–$120k per projectNot offeredFrom $12k per month

Pricing models for an AI agent build

Best for
Fixed price after discovery
A defined agent or product
Time and materials
Research with no clear end
Dedicated team
An ongoing roadmap
Who carries overrun risk
Fixed price after discovery
The vendor
Time and materials
You
Dedicated team
Shared, scope flexes monthly
Scope changes
Fixed price after discovery
Change request
Time and materials
Anytime, billed hourly
Dedicated team
Anytime
Our price
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.

Payback at two volumes and both ends of our build band (assumptions above)
Tickets a monthValue of work handledNet per monthBuild at $25kBuild at $120k
2,000$4,000$3,000about 8 monthsabout 40 months
10,000$20,000$18,500about 1.4 monthsabout 6.5 months

Payback at two volumes and both ends of our build band (assumptions above)

2,000
Value of work handled
$4,000
Net per month
$3,000
Build at $25k
about 8 months
Build at $120k
about 40 months
10,000
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:

Four budget lines for an AI agent
  1. Weeks 1–2Discovery: $5,000Two weeks, ending with a working prototype and a fixed quote.
  2. 6–16 weeksBuild: $25k–$120kDepending on agent type, integrations and compliance.
  3. Every monthRunTokens from a worked estimate like the one above, plus hosting and monitoring.
  4. 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.

Related service

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.

Want this applied to your business?
Free 45-min AI audit with a senior architect.
Book the audit
FAQ

Common questions.

How much does it cost to build an AI agent?

At Apptycoons a production AI agent is a fixed-price build of $25k–$120k, delivered in 6–16 weeks, after a $5,000 two-week discovery sprint whose fee is credited to the build. A single-system assistant sits at the low end of that range; a multi-agent system with document processing and several integrations sits at the top.

How much does an AI agent cost to run each month?

Mostly model tokens plus hosting and monitoring. In our worked example, an agent handling 20,000 tasks a month with four model calls per task costs about $36 a month in tokens on Claude Haiku 5.5 and about $676 on Claude Sonnet 5.5 with prompt caching, at list prices checked October 29, 2026. Hosting, logging and evaluation runs come on top, and at low volume they are the larger cost.

Can I build an AI agent for less than $25k?

A prototype, yes. The $5,000 discovery sprint ends with a working prototype on your real data. A production agent that reads and writes your systems, has approval steps, an audit log and an evaluation set costs more, which is why our fixed-price builds start at $25k. If the job is a common one, an off-the-shelf agent may cost less than either.

How long does it take to build an AI agent?

Two weeks of discovery, then 6–16 weeks for the build. Simple agents with one or two integrations land near the start of that range; multi-agent systems with document processing and several systems of record land near the end, or are split into phases.

What is the most expensive part of building an AI agent?

Integrations and evaluation, not the model. On our own builds integrations take about 30% of the build price and evaluation 15–20%, against about 15% for the agent’s prompts and orchestration. Each system the agent reads from or writes to needs authentication, error handling and tests, and every action needs an evaluation set that proves it behaves correctly before real users touch it. Compliance requirements such as HIPAA or PCI add review and hosting work on top.

Why is the price only fixed after discovery?

Because the unknowns that change the price, such as data quality, API access and approval rules, only show up when you touch real systems. Discovery resolves them in two weeks, produces an architecture and integration plan, and ends with a fixed quote that does not move unless you change the scope.

How much does it cost to maintain an AI agent?

Plan for three monthly costs: model tokens, hosting with logs and monitoring, and the engineering time to rerun evaluations and update prompts when models, prices or connected APIs change. Our builds include 30 days of support after launch; after that, changes run as small fixed-price change requests or through a dedicated team from $12k a month.

Why do AI agent development quotes vary so much?

Because the word agent hides scopes that have little in common. One quote may cover a prototype with a read-only integration, another a production system with writes, approvals, an audit log and an evaluation set. Compare the named integrations, the size of the evaluation set, the approval steps, who owns the code and prompts, and the support period, not the total.