Two vendors quoted the same customer support agent last quarter. One came back at $28,000. The other at $310,000. Same intake form, same three systems, same volume estimate. Neither quote was dishonest.
The $28,000 vendor was pricing a working demo: a model, a retrieval index over the help center, and a chat surface. The $310,000 vendor was pricing a system that could issue refunds without a human watching, with an audit trail, a labeled eval suite, permission scoping per action, and a rollback path. Both used the word "agent." Only one of them was quoting the thing that survives contact with real customers.
This is why the published cost ranges you find when you search - $8K to $400K, $5K to $180K - are accurate and useless at the same time. They are averaging across two different products. What follows is the actual line-item structure, scoped ranges with the assumptions written down, and the math on when a build beats a subscription.
The Ten Cost Lines Behind Every Agent Quote
The single most useful thing you can do before signing anything is force every proposal into the same ten buckets. Vendors who only price three of them are quoting a prototype.
| Cost line | Share of year-one budget | What it actually buys |
|---|---|---|
| Discovery and process mapping | 5-10% | Written definition of the workflow, volume data, current failure rates, decision boundaries |
| Integration and data access | 15-25% | Read and write connectivity to CRM, helpdesk, ERP, billing, plus auth, rate limits, sandbox environments |
| Eval and test set construction | 10-15% | A labeled set of real cases with correct outcomes, plus graders you trust |
| Application and orchestration | 15-20% | Prompts, tool definitions, routing, retries, state handling, the loop itself |
| Security, permissions, audit | 8-12% | Least-privilege scoping per tool, PII handling, prompt injection defenses, immutable action logs |
| Deployment and infrastructure | 5-8% | Environments, CI/CD, secrets management, load handling, disaster recovery |
| Model usage | 3-10% | Tokens, embeddings, reranking, voice synthesis if applicable |
| Observability and tracing | 3-5% | Per-step traces, cost attribution, alerting, replay of failed runs |
| Maintenance and iteration | 10-20% | Edge-case review, prompt and tool updates, model version migrations |
| Change management and training | 5-10% | Reviewer workflows, escalation rules, operator training, documentation |
Notice that the model call - the thing everyone thinks they are buying - is the ninth largest line. This is not a new pattern. A 2015 NeurIPS paper on hidden technical debt in machine learning systems made the same observation about a previous generation of models: the code that does the prediction is a small box in the middle of a large diagram. Configuration, data plumbing, monitoring, and process management surround it. Agents inherited that shape and made it worse by adding tool calls that mutate production systems.
A useful sanity check: if a proposal spends more than a third of its budget on the model and prompt layer, the vendor is either reusing an integration they already own (good, ask them) or has not looked closely at your systems (bad, ask them harder).
Scoped Ranges by Workflow Complexity
Ranges only mean something with assumptions attached. Here are three tiers with the assumptions stated. These reflect senior-led implementation in North America or Western Europe, where blended rates typically land between $120 and $220 per hour. Offshore delivery can cut build cost 40-60%, and shifts risk toward the integration and eval lines, which are the ones that require sitting in your systems.
Tier 1 - Assisted output. The agent drafts, classifies, or summarizes. A human sends everything.
- Assumptions: one or two source systems, read-only, 10-25 distinct intents, eval set of 100-200 labeled cases, no autonomous writes
- Build: $18,000 to $45,000
- Run: $300 to $900 per month
- Timeline: 3 to 6 weeks
Tier 2 - Contained execution. The agent acts inside a bounded set of reversible operations. Humans approve anything outside the boundary.
- Assumptions: three to four systems including at least one writeback target, 25-60 intents, eval set of 300-600 cases, approval queue for high-value actions, SSO and role-based permissions
- Build: $45,000 to $120,000
- Run: $900 to $4,000 per month
- Timeline: 8 to 16 weeks
Tier 3 - Autonomous multi-system. The agent resolves end to end across systems, with audit requirements and a real blast radius.
- Assumptions: five or more systems, irreversible or financial actions, 60+ intents, eval set of 1,000+ cases with regression gating, SOC 2 or HIPAA constraints, on-call ownership, multi-language or voice
- Build: $120,000 to $350,000 and up
- Run: $3,000 to $15,000 per month
- Timeline: 4 to 9 months
Most teams asking for Tier 3 need Tier 2. The discipline of shipping a contained execution agent first is what makes the Tier 3 version buildable later, because you finish Tier 2 holding a labeled eval set and a map of where the workflow actually breaks. We wrote about how to sequence those in ai-agent-pricing.
The 20/80 Split: Prototype Cost Versus Production Cost
Here is the number that reorganizes most budgets: a convincing prototype costs about 20% of the production system, and it is usually built in the first two weeks.
That ratio is why so many pilots stall. Gartner predicts that over 40% of agentic AI projects will be canceled by the end of 2027, citing unclear business value and escalating cost. The escalation is not a surprise if you know the split. Leadership sees a working demo, assumes the project is 80% done, and budgets accordingly. Then the team hits the parts nobody demoed.
What lives in the other 80%:
- The long tail of intents. Your demo handled the top 10 request types. Production traffic has 60, and the bottom 40 are where the angry customers are.
- Writeback safety. Reading data is easy. Updating a subscription without double-charging on a retry requires idempotency keys, reconciliation, and a rollback path.
- Permission scoping. An agent with your admin API key is a liability. Scoping each tool to the narrowest possible permission takes real engineering time, and skipping it is how you end up in the incident report. IBM's Cost of a Data Breach report is a useful reference point for what that failure costs relative to what prevention costs.
- The eval suite. You cannot improve what you cannot measure, and generic metrics do not work here. Someone has to sit down with 400 real cases and label the correct outcome. This is unglamorous and it is the single highest-leverage spend in the project.
- Reviewer workflow. Somebody has to look at what the agent did. Designing that queue, training the people in it, and defining escalation rules is a change management project, not a coding project.
Hypersense's analysis of hidden TCO reaches a similar conclusion from the vendor side: the post-launch lines compound while the build line is one-time. Budget the first year, not the build.
Run-Rate Math: Tokens Are Cheap, Retries Are Not
Model usage scares finance teams more than it should. Let me show the arithmetic.
Take a support resolution that requires six model calls in the tool loop. Each call sends roughly 8,000 input tokens (system prompt, tool definitions, retrieved policy text, conversation history) and returns 800 output tokens. At mid-tier frontier pricing of roughly $3 per million input and $15 per million output (see Anthropic and OpenAI for current rates):
- Per call: $0.024 input + $0.012 output = $0.036
- Per resolution at six calls: about $0.22
- At 5,000 resolutions per month: about $1,080
Now add reality. Failed paths, retries, and abandoned conversations add 40-60% on top. Call it $1,600 per month. Then turn on prompt caching, where the static system prompt and tool definitions are read from cache at roughly a tenth of the base input rate. Cached input drops that same workload closer to $500 per month.
Two things follow. First, the model bill for a mid-volume agent is smaller than one engineer-day per month. Second, the difference between a $500 bill and a $4,000 bill is architecture, not model choice: how much you cache, how many turns your loop takes, whether you route simple intents to a smaller model, and how often you retry blind. That is why a cost-conscious design review pays for itself.
And the trend is in your favor. a16z's analysis of LLM inference cost decline found roughly a 10x annual drop in the price of achieving a fixed capability level. The token line in your three-year model should shrink, not grow. The maintenance line will not.
We ran a detailed version of this arithmetic on a real workload in the-50-a-day-agent.
Owned Build Versus Per-Resolution SaaS
The honest buy-versus-build comparison is a crossover calculation, and it is volume-driven.
Per-resolution platforms price around $0.99 per resolved conversation (Fin's published pricing is the market reference point). Model it against a Tier 2 custom build at $90,000 plus $2,000 per month to run.
At 5,000 resolutions per month:
| Year | Per-resolution SaaS (cumulative) | Custom build (cumulative) |
|---|---|---|
| 1 | $59,400 | $114,000 |
| 2 | $118,800 | $138,000 |
| 3 | $178,200 | $162,000 |
Crossover lands around month 31.
At 1,000 resolutions per month, SaaS costs $11,880 a year and the custom build never catches up on pure cost. If your volume is under roughly 1,500 resolutions per month and your workflow is ordinary, buy the platform. Anyone telling you otherwise is selling.
The build case is not a savings case at that volume. It is a control case. You build custom when the workflow does not fit the platform's model of a "conversation," when the writeback logic is specific to your ERP, when you need the agent to run inside your VPC, when you want the code and the eval set as an asset you own, or when per-resolution pricing punishes exactly the growth you are planning for. Klarna's AI assistant handling two-thirds of chats is the case study everyone cites for the upside. The less-cited follow-up, where they rebuilt human capacity for complex cases, is the case study for why the escalation design matters as much as the deflection rate.
The framework for choosing sits in ai-agent-platforms-vs-custom-built.
One more variable people forget: internal engineering cost is not free. At US median software developer compensation, a two-engineer team for four months is roughly $110,000 fully loaded before anyone writes an eval. "We'll build it in-house" is a budget line, not an alternative to one.
How OpenNash Can Help
If you are holding two quotes that differ by 10x, the problem is scope definition, not vendor selection. That is the part we do first.
An OpenNash engagement starts with an audit that maps the workflow, pulls actual volume and failure data, and puts a boundary around what the agent will and will not do. That produces a scoped estimate against the ten cost lines above, with the assumptions written down so you can hold anyone to them. Design comes next: guardrails, approval points, and failure handling defined before a line of orchestration code exists. Build and deploy follow, with the eval suite, traces, runbook, and source all handed over as yours.
Some readers should not hire anyone yet. If your volume is under 1,500 resolutions a month and the workflow is standard, buy a platform and revisit in a year. If you cannot name the three systems the agent needs to write to, you are not ready to scope. If nobody internally will own the weekly edge-case review, the agent will drift regardless of who builds it.
If you can name the workflow and the systems, book a call and we will map this to your numbers and give you a scoped estimate you can take to finance.