The pricing gap that keeps sneaking up on CFOs

Every AI vendor's demo makes the math look great. "Our agent handles this task for two cents. Multiply by your volume. Compare to a human. Profit."

Six months into production, the actual bill is 4-8x that number, and finance is asking pointed questions. We've watched this exact conversation happen at multiple clients in the last twelve months. The gap isn't fraud; it's the difference between what a vendor shows in a demo and what a real production deployment actually costs.

This is the honest, itemized breakdown of what a mid-complexity enterprise AI agent costs to build and run in 2026. Numbers are based on real deployments we've shipped — for a customer support agent, a sales research agent, and a document classification agent — normalized to comparable scale. Your specific numbers will vary. The line items will not.

The example agent we'll cost

For this analysis, assume a moderate-complexity enterprise agent:

• Volume: 20,000 agent invocations per day.
• Task complexity: each invocation runs 5-15 LLM calls (planning, retrieval, reasoning, tool use).
• Tools: 8 tools connected (CRM, ticketing, knowledge base, email, calendar, etc.).
• Storage: ~2 million historical conversation logs, 500K embedded documents.
• Users: ~500 concurrent users at peak, 3,000 daily active.
• SLAs: 99.5% uptime, p95 latency under 3 seconds.

This is a real-shape workload we've deployed multiple variants of. Not massive scale, not toy scale.

What the vendor demo shows

The pitch: "Our agent handles a support ticket for $0.05. You're paying humans $8 to do the same thing. Massive savings."

$0.05 x 20,000 = $1,000 per day = ~$30K per month. Sounds great.

Reality is different.

The real monthly bill

Here's the itemized reality, from our production deployments.

Model / API costs

The vendor's "$0.05 per invocation" number is usually the raw inference cost of one LLM call. But agents run 5-15 calls per invocation (planning, retrieval, generation, verification), so the multiplier is 5-15x.

• Frontier model calls (planning, hard reasoning): ~$0.15-0.35 per invocation.
• Cheap model calls (routing, classification, formatting): ~$0.03-0.08 per invocation.
• Embedding generation (for new documents and query embeddings): ~$0.01-0.03 per invocation.
• Rerankers: ~$0.01-0.02 per invocation.

Realistic per-invocation model cost: $0.20-0.48. Monthly at 20K/day: $120,000-$288,000.

Your mileage will vary. Some workloads have cheap paths that dominate; some have expensive ones. The point is that "$0.05 per invocation" is almost never the real number.

Vector store and retrieval infrastructure

• Vector database (Pinecone-tier managed or self-hosted equivalent): $1,000-3,000/month.
• Embedding storage costs: $200-500/month.
• Retrieval hosting: ~$500-1,000/month.

Monthly: $1,700-4,500.

For smaller workloads, pgvector on your existing Postgres drops this materially. See our vector DB buyer's guide for the trade-offs.

Agent orchestration and compute

• Compute for the agent runtime (Cloudflare Workers, Lambda, or Kubernetes): $500-2,000/month.
• State storage (Durable Objects, Turso, or Postgres): $200-800/month.
• Queue infrastructure for async work: $100-400/month.

Monthly: $800-3,200.

Observability

You can't debug what you don't log.

• LangSmith, Langfuse, or self-hosted equivalent: $500-2,000/month for a workload this size.
• Log aggregation: $300-800/month.
• Monitoring and alerting: $200-500/month.

Monthly: $1,000-3,300.

For details on what to actually monitor, see the agent observability post.

Third-party tool costs

Every integrated tool has its own cost.

• CRM API access: may or may not incur per-call fees depending on your CRM contract.
• Search APIs (if the agent does web search): $500-2,000/month.
• External enrichment APIs: varies wildly.

Monthly: $500-3,000, highly dependent on the specific tools.

Model provider surcharges and enterprise features

• Enterprise contracts (higher rate limits, guaranteed availability): $2,000-10,000/month depending on provider and volume.
• Data residency options: premium tiers.
• Zero-retention agreements: premium tiers.

Monthly: $2,000-10,000.

For our KSA and UAE clients, data residency alone typically adds a meaningful premium.

Engineering maintenance

Someone has to keep this running.

• On-call engineer (a portion of one engineer's time): ~$3,000-8,000/month at burdened cost.
• Ongoing prompt iteration, eval maintenance: ~$2,000-5,000/month.
• Model provider changes and re-tuning: infrequent but real. Budget ~$10,000-30,000 per year.

Monthly: $5,000-13,000.

This is the line item most vendor pitches skip entirely. Agents are living systems. They need ongoing care.

Compliance and legal

• Legal review for regulated deployments (finance, healthcare, government): $10,000-50,000 one-time, plus $1,000-3,000/month ongoing for reviews.
• Compliance tooling: $500-2,000/month.

Monthly (amortized): $1,500-4,000.

Skip this line item in unregulated deployments; count it in regulated ones.

Incident and failure costs

Realistically, some percentage of agent decisions will be wrong. Remediation costs are real.

• Human review of flagged cases: ~$500-3,000/month depending on flagging rate and reviewer cost.
• Refunds, credits, or make-goods for agent errors: highly variable. Budget 1-3% of the value the agent handles.

Monthly: $500-3,000+.

The total

Total realistic monthly cost for our example agent: $132,000 - $332,000.

Per invocation: $0.22 - $0.55.

Compare to the vendor's $0.05 pitch. The 4-10x gap is the honest one.

Where the money actually goes

Grouping the line items:

• LLM inference costs: 60-75% of total. This dominates. Everything else is meaningful but smaller.
• Engineering maintenance: 10-15%.
• Infrastructure (vector store, compute, storage): 5-10%.
• Observability: 3-5%.
• Compliance, tools, incidents: 5-10% combined.

The strategic implication: the biggest cost lever is model choice. Switching some steps from a frontier model to a smaller model (see small language models) can cut the total bill by 30-50%. Almost no other single change moves this many dollars.

What actually reduces the bill

In our client work, these are the levers that move meaningful money.

1. Model routing

Route steps by task type. Planning and hard reasoning: frontier model. Classification, formatting, extraction: small model. See the AI gateway comparison for the tooling that makes this practical.

Impact: 30-50% cost reduction on typical workloads.

2. Aggressive caching

Cache identical requests. Cache retrievals for common queries. Cache reranker outputs. Every cached response is a saved token.

Impact: 15-30% cost reduction if your workload has repeated patterns.

3. Better retrieval

A better-tuned retrieval pipeline reduces the tokens the LLM has to process. If your retrieval is inefficient, you're paying the LLM to think through irrelevant context.

Impact: 10-25% cost reduction.

4. Prompt optimization

Shorter prompts, tighter instructions, fewer few-shot examples. Every token in every prompt is being paid for on every invocation.

Impact: 5-15%.

5. Volume commitments with providers

Once you know your steady-state volume, negotiate rate cards. Enterprise tiers with committed volume routinely see 20-40% discounts.

Impact: 20-40% of your provider spend once negotiated.

Combine these levers and total bills drop by 50-70% versus the naive first-deployment version. That is the difference between "expensive" and "clearly ROI-positive."

What actually increases the bill

Watch out for these accelerants.

User adoption tail. As users get comfortable with the agent, they use it more. Volume grows over 12-24 months. Model your bill at 2-3x current volume.

Feature expansion. Product teams add use cases. Each new use case might not sound expensive, but the tail adds up.

Model provider price changes. Sometimes prices drop (as with DeepSeek's earlier 2026 moves reversed later in the year). Sometimes they rise. Assume price uncertainty.

Compliance requirements. As deployments move into regulated data, costs increase. Zero-retention agreements, data residency, audit tooling — all real.

Incidents. A single serious incident (see the prompt injection playbook) can eat a quarter's budget in remediation and legal.

What CFOs should actually ask

When the AI vendor pitches:

1. What's your per-invocation cost for our exact workload shape, not the demo shape?
2. How does the cost scale as we grow? Are there volume tiers?
3. What happens to the bill when we double the concurrent user count?
4. What are the additional costs — vector store, orchestration, observability — that aren't in your quote?
5. What's the fully-loaded cost including our team's time to maintain and iterate?
6. What are the industry-typical ROI numbers for this class of agent, and what do they assume?

Get answers in writing. Model your worst case. Budget with margin.

For a more comprehensive treatment of agentic ROI, see our CFO framework post.

Frequently asked questions

Are these numbers realistic for a startup? Numbers scale roughly linearly with volume. A startup doing 200 invocations per day has ~1% of the volume and ~1-3% of the cost. But the per-invocation cost is often higher at low volume (no volume discounts, less optimization).

How does self-hosted change the math? Meaningfully. Small models hosted on your own infrastructure can drop LLM inference cost by 80-95%. See small language models. Trade-off: engineering investment to set up and maintain.

What about open-source models entirely? Viable for parts of the workload. Rarely viable for the whole workload — frontier reasoning is still hard to match with open models. Hybrid is the pragmatic default.

How do I plan for the tail cost? Model year-one, year-two, year-three separately. Assume 2-3x growth in year two, 3-5x in year three. If the ROI still works at year-three costs, the agent is viable long-term.

Is there a way to cap the bill hard? Yes — spend caps at the gateway layer, provider-side spend caps, and platform features like Cloudflare's spend caps. Use them. Any agent without a spend cap is one prompt-injection incident from a five-figure surprise.

The strategic read

AI agents can be genuinely cost-effective at scale. They can also be catastrophically expensive if built without cost discipline. The gap between the two is not luck. It's a set of engineering and operational choices, applied consistently.

Understand the real cost before the vendor negotiation. Model the tail. Set spending controls. Optimize model routing early. And be honest with your CFO — the vendor's demo number is not the number your finance team will see.

At Xenolve we help clients build cost-effective AI agent architectures from day one, and we're often called in after the first quarterly bill lands to help teams cut spending without losing quality. If you're planning an agent deployment and want a realistic cost model up front, or your current agent is more expensive than expected, get in touch. Most bills can be cut by half or more with the right architectural changes.

The agents will keep coming. The finance conversations will keep getting sharper. Better to lead with the honest numbers than to explain them after the fact.