What it really costs to build an AI agent.

The question we hear most on a discovery call is some version of "how much does it cost to build an AI agent?" — and the only honest first answer is another question: which kind, doing what, wired into how many of your systems, held to what reliability bar? The price of an agent is not a number you look up. It is the sum of five drivers, and a build that ignores any one of them is the one that quietly costs the most.

An "AI agent" can mean a single prompt with a retrieval step bolted on, or a multi-agent system that reads your data warehouse, calls six internal services, and takes actions with real-money consequences. Those two things share a name and almost nothing else. Treating them as one line item is the root cause of most blown agent budgets. So instead of a quote, we decompose the spend into drivers you can reason about — and then map them onto complexity tiers so you know roughly which bracket you are in before you talk to anyone.

Throughout, we speak in qualitative tiers, not fixed figures. Model prices, context limits, and benchmark numbers drift faster than any article can stay accurate, so pinning a build to last quarter's rate card is how estimates rot. For where our own engagement shapes and bands actually live, see our pricing.

Scope is the single largest lever, and it is mostly about autonomy, not features. An agent that drafts a reply for a human to approve is cheap to build and cheap to be wrong. An agent that sends the reply, issues the refund, or reconfigures infrastructure has to be right — which means guardrails, approvals, audit trails, and rollback all become part of the build, not afterthoughts. The cost gradient runs along trust:

• Assistive — drafts, summarizes, suggests; a human always acts. Lowest blast radius, lowest cost.
• Supervised — takes actions inside narrow rails with a human approving the consequential ones.
• Autonomous — plans and acts across steps without a human in the loop; every failure mode must be designed for up front.

Every notch up the autonomy ladder multiplies the work on the parts users never see: the tool definitions, the permission model, the "are you sure" checkpoints, and the way the agent reports what it did. That work is where serious agent budgets actually go.

A model talking to itself is a demo. An agent earns its keep by touching your systems — CRM, billing, ticketing, the data warehouse, internal APIs — and that surface is where estimates swing the hardest. A clean, documented REST API with stable auth is a day. An undocumented legacy system with no test environment and a fragile data model is weeks, and most of that time is discovery, not code.

This is also where the tooling standard matters. We expose each system to the agent as a typed tool — increasingly via the Model Context Protocol (MCP), so one integration is reusable across agents instead of re-glued per project. That up-front structure costs more on day one and far less by the third agent. See MCP server development for how we package those integrations, and AI workflow automation for where agents plug into existing operations.

A non-deterministic system needs a test harness as much as any other software — arguably more, because the same input can produce different output and "it looked right in the demo" is not a quality bar. Evaluation is the line item most cheap agents skip, and the reason they get pulled three weeks after launch. The cost here scales with how expensive a wrong answer is.

1. A graded set of representative cases — the inputs the agent will actually see, with known-good outcomes.
2. A scoring method — exact-match where possible, an LLM-as-judge or human review where the output is open-ended.
3. A regression gate — the eval runs on every prompt change and model swap, so a "small tweak" cannot silently degrade quality.

$ run-evals --suite refund-agent --models opus,sonnet CASE  scenario                       score   verdict01    standard refund within window  1.00    pass02    refund past window (deny)      1.00    pass03    partial refund + restock fee   0.92    pass04    ambiguous: ask for order id    1.00    pass05    out-of-scope: escalate human   1.00    pass suite passed (24/24)  — gate: PASSregression check vs last release: no drops

Notice what the harness is and is not. It is not a benchmark score we are reporting as fact — the numbers above are illustrative, built from your scenarios, not a public leaderboard. That is the point: the only eval that matters is one written against the cases your agent will meet in production.

A build cost is a one-time number. An agent is not. It runs against live systems, against a model that gets updated, against user behavior that shifts — and someone is on the hook when it misbehaves at 2am. The teams who only budget the build are the teams who are surprised by the second invoice, which is the operating one. Ongoing cost is not a tail; it is a recurring line that, over a year, often exceeds the build.

• Monitoring and alerting on agent behavior, not just uptime — silent quality drift is the failure that hurts.
• Re-running evals when you change a prompt, swap a model, or add a tool.
• On-call and an incident path for when an autonomous action goes wrong.
• Periodic re-grounding as the underlying data and your own policies change.

Inference cost is the number everyone fixates on and the one that least often decides the budget. It matters at scale, and it is worth engineering for — but for most agents it is a fraction of the people-cost of building and operating well. We pick the right Claude model for each step rather than running the largest one everywhere: Claude Haiku 4.5 for fast classification and routing, Claude Sonnet 4.6 for the working tier, Claude Opus 4.8 where the reasoning genuinely earns it. The current models share a 1M-token context window, which changes how much retrieval plumbing you actually need.

We deliberately do not quote per-token prices here — they move, and a stale number is worse than none. The durable levers are architectural: route cheap steps to small models, cache what repeats, keep context tight, and measure spend per successful task rather than per call. Get the architecture right and model spend becomes a tuning knob, not a budget risk.

Putting the five drivers together gives you a tier — a qualitative bracket, not a quote. Find the row that matches what you are actually trying to ship; the relative effort tells you which conversation to have.

The leap that surprises people is from workflow to autonomous: it is rarely twice the work, because every consequential action adds guardrails, approvals, audit, and a heavier operating commitment. Sovereign and regulated contexts add another layer of residency and review — see sovereign AI for the GCC if that is your world. When you are ready to map a real scope to a real band, our pricing lays out the engagement shapes; a custom platform that an agent lives inside is its own conversation under custom SaaS.

You can get within a tier on your own. Run your idea through the five drivers honestly and the bracket falls out:

1. Scope — does a human act on the output, or does the agent act? Each notch up the autonomy ladder moves you toward a higher tier.
2. Integrations — list every system the agent must read or write. The length and messiness of that list is most of your estimate.
3. Eval rigor — how expensive is a wrong answer? The more it costs to be wrong, the more the eval harness costs to build.
4. Operations — who owns this at 2am, and for how long? Budget the operate cost as a recurring line, not a footnote.
5. Model spend — relevant at scale, but architecture decides it; do not let it lead the estimate.

Do that, and the discovery call stops being a guessing game. You arrive knowing your tier, your integration list, and your reliability bar — and the estimate becomes a conversation about trade-offs rather than a number pulled from the air.

Build on the five drivers and the tier table, and "how much does it cost to build an AI agent?" turns from an unanswerable question into a structured one. The number is whatever scope, integrations, evals, and operations add up to — and the studios worth hiring are the ones who say so before you commit.