The TCO model is the artifact that decides whether your agent program survives the next CFO line-item review. It is also the artifact most architects build badly. The classic failure is a one-page spreadsheet that lists "OpenAI API: $25K/year, Platform: $30K/year, Engineering: $400K/year" and concludes "Total: $455K." That model does not survive the second question from a finance director. The CFO-grade TCO model is line-item, time-phased, risk-adjusted, and honest about the things that always cost more than you planned. This lesson is the model — seven cost categories, 24 months, with the math you will copy into a spreadsheet and present in October when budget season starts. The version you build for an 80,000-conversation customer-service agent that costs $1.4M over 24 months will look superficially different from the version you build for a 12,000-research-query knowledge agent that costs $640K over 24 months. The shape is identical.

Why a Bad TCO Model Kills a Good Agent Program

An agent program with a 3x ROI can lose its budget if the TCO model the architect brought to the budget meeting was wrong by 40%. The CFO does not see a 3x ROI. The CFO sees a number you missed by 40% and quietly stops trusting any number you bring next. Once trust is gone, the program is on borrowed time.

The model exists for three audiences. The CFO wants confidence intervals and total spend. The CIO wants to understand the operational shape — what scales with usage, what does not, where the risks are. The CEO wants to know whether the program returns its investment and when. A model that serves only one audience fails with the other two in the room.

The best TCO models are not the most optimistic. They are the most honest. A model that says "$1.8M plus or minus $200K over 24 months" survives scrutiny. A model that says "$1.2M, definitely, no risk" gets re-litigated for 18 months.

The Seven Cost Categories

Every line item in an agent TCO model fits in one of seven categories. Build the model around these and you will not miss anything material.

1. Platform license. What you pay the vendor whose platform the agent runs on (Agentforce, Copilot Studio, Sierra, Lindy, etc.) or the horizontal stack license (LangSmith, Helicone, Vercel AI SDK Pro).
2. LLM tokens. The pay-per-call cost of foundation models. Scales linearly with usage. The line item that most teams overrun by 2-5x in year one.
3. Integration. The cost of building and maintaining the connectors that talk to your existing systems (CRM, ticketing, data warehouse). Mostly one-time but includes ongoing maintenance.
4. Eval and quality. The cost of building and maintaining the eval suite — eval set authoring, human review labor, LLM-as-judge spend, eval-platform license.
5. Observability and telemetry. The cost of seeing what the agent is doing — trace storage, dashboards, alerting, the proxy layer.
6. On-call and operations. The cost of humans being available when the agent breaks at 2am — pager rotation, runbook maintenance, incident response.
7. Risk-adjusted incident cost. The expected value of agent failures — wrong refunds issued, sensitive data leaked, customers escalating to legal. This is the line that most models omit and that CFOs ask about within three minutes.

The first six are direct costs. The seventh is a risk-adjusted expected value. A complete model has all seven.

Category One: Platform License

Platform license is the easiest line to model because the vendor will quote you a price. The trap is taking that price at face value. The actual annual license cost depends on volume bands, year-over-year price increases, and bundled SKUs you have to buy to make the headline price work.

How to model it

• Base price for year 1. The contract you signed.
• Year-2 and year-3 escalators. Most enterprise contracts include 5-12% annual price increases. Build them in. If the contract has none, ask the vendor to put that in writing — they will not.
• Bundled SKUs. Data Cloud for Agentforce. M365 Copilot per-seat for Copilot Studio's embedded scenarios. Service Cloud + Agentforce for Salesforce. The list price does not include these by default.
• Volume bands. Per-conversation, per-credit, per-seat pricing has bands. The blended cost per unit at 200K conversations is different from 80K. Model both endpoints and the realistic mid-point.

Worked example. An 80K-conversation/month customer service agent on Sierra. Year 1: $112K/month blended ($1.34M/year). Year 2: 7% escalator = $1.43M. Year 3: 7% again = $1.53M. Total 24-month license: $2.77M for years 1+2, or $3.30M plus year 3 if you anchor on 3 years. The CFO needs to see the year-2 escalator separately — it is the line that surprises them most.

Common pricing mistakes

• Using list price instead of negotiated price. List price is a starting point; enterprise contracts typically negotiate 20-40% off list.
• Not modeling the renewal jump. Most vendors negotiate aggressive year-1 pricing to win the contract and recover margin at renewal. Year-3 renewal commonly carries a 30-60% increase unless you have credible exit leverage (lesson 4).
• Forgetting the bundled minimums. Agentforce without Data Cloud is half a product; you need both line items in the model.

Category Two: LLM Tokens

The line that overruns in year one. Model it carefully.

How to model it

Start with the per-call token estimate: average input tokens + average output tokens + retrieval tokens + tool-call response tokens. For a customer service agent in 2026: typically 2,500 input + 600 output + 4,000 retrieval tokens = 7,100 tokens per conversation. For a knowledge agent doing deeper research: typically 6,000 input + 1,500 output + 12,000 retrieval = 19,500 tokens. Multiply by model cost: GPT-5 at $5/$15 per million tokens input/output, Claude Sonnet 4.5 at $3/$15, Gemini 2.5 Pro at $1.25/$10. Most enterprise programs mix tiers.

Worked example. 80K conversations/month at 7,100 tokens each, 80% on a tier-2 model (Claude Haiku 4 at $0.80/$4 per M tokens, blended ~$1.20/M = $0.0085/conversation) and 20% on a tier-1 model (Claude Sonnet 4.5 blended ~$9/M = $0.064/conversation). Weighted cost per conversation: $0.0085 * 0.8 + $0.064 * 0.2 = $0.0196. Monthly: 80K * $0.0196 = $1,568/month. Annual: $18,800.

That number looks small. It usually is, at moderate volume. The problem is when actual usage diverges from estimate. Three common divergences:

• Retry loops. The agent fails to call the right tool, retries 5 times, burns 7x the tokens you estimated. Lesson 1.5.1 covered this. Budget 1.5x your point-estimate for retry overhead.
• Context bloat. Long conversation history accumulates over multi-turn interactions. The 7,100-token first turn becomes a 14,000-token tenth turn. If the agent supports long sessions, multiply by 1.3-1.6x.
• Model upgrade tax. Your team will move to the newer, smarter, more expensive model in year 2. Plan for 30-50% per-call cost increases as models improve.

The honest model for an 80K-conversation/month workload is not $18,800/year tokens; it is $30,000-$45,000 with the realistic divergence factors built in.

Category Three: Integration

Integration is mostly a year-1 cost with ongoing maintenance. Model it as one-time plus 15-25% annual maintenance.

How to model it

List every system the agent talks to. For each, estimate engineering days: 5-15 days for a well-documented REST API with MCP wrapper available; 20-40 days for a custom SOAP or legacy system; 60+ days for a system that requires a new schema or a real-time push. Multiply by engineering loaded cost: $1,200/day for a senior engineer, $800/day for mid-level.

Worked example. An 80K customer service agent needs: Salesforce Service Cloud (10 days, native), Zendesk legacy ticket data (25 days, REST API + edge cases), payment system (40 days, regulated and custom), order management (15 days), email delivery (5 days). Total: 95 engineering days at $1,200 blended = $114,000 year-1 integration. Maintenance: 20% annually = $22,800/year ongoing.

Common mistakes:

• Counting only the "build" days, not the "debug in production for 4 weeks" days. Add 50%.
• Forgetting that the vendor system changes. APIs deprecate, schemas migrate, OAuth flows change. The 20% maintenance is real.
• Forgetting the wrapper layer (lesson 1.3.7, lesson 3.3.4). Tools have to be wrapped, validated, tested. That is engineering time.

Category Four: Eval and Quality

The line that most architects underbudget by 60%. Eval is not a one-time activity; it is ongoing.

How to model it

• Eval set authoring (one-time, year 1). Building the initial eval set: golden examples, edge cases, adversarial cases. Typically 30-60 engineering days = $36K-$72K.
• Eval platform license (recurring). Braintrust, LangSmith, Langfuse. Small team plans $200-$500/month; enterprise tiers $2K-$10K/month.
• LLM-as-judge spend (recurring). The judge model running on every output. For 80K conversations/month at $0.001-$0.003 per judge call = $80-$240/month. Negligible at moderate volume; meaningful at high volume.
• Human review labor (recurring). The stratified sample reviewed by humans (Layer 4 of the four-layer recipe). 5-10% of outputs at $0.50-$1.50 per review. For 80K conversations at 7.5% sample at $1: $6,000/month, $72K/year.
• Eval set evolution (recurring). Adding new cases as the agent grows, refining edge cases. Plan for 5-10 engineering days/month = $6K-$12K/month, $72K-$144K/year.

For an 80K conversation agent: year 1 eval cost is approximately $50K (authoring) + $48K (platform) + $3K (judge) + $72K (human review) + $108K (evolution) = $281K. Year 2: $48K + $3K + $72K + $108K = $231K (no re-authoring). Two-year eval: $512K.

That is the line that surprises most teams. Eval is the second-largest cost category after platform/tokens in many programs. Architects who treat eval as "we'll figure it out as we go" find themselves explaining to the CFO why their $250K budget overrun is the result of "quality engineering."

Category Five: Observability and Telemetry

Smaller than eval but real. The platform that shows you what the agent is doing in production.

How to model it

• Proxy/gateway license (Helicone, LiteLLM, Portkey). $50-$500/month at moderate volume, $2K-$10K/month at scale.
• Trace storage (Datadog, Honeycomb, in-house). $300-$3,000/month depending on retention and volume.
• Dashboard tooling. Built into LangSmith / Langfuse usually; for custom dashboards add 5-10 engineering days/quarter.
• Alerting integration (PagerDuty, OpsGenie). $20/user/month, usually piggybacks on existing incident tooling.

Worked: $400/month proxy + $1,500/month traces + $200/month dashboards + $200/month alerting = $2,300/month, $27,600/year. Modest.

Category Six: On-Call and Operations

The hidden line. Once the agent runs in production, humans need to be available when it breaks. For a department-scale program, this is a real cost.

How to model it

If the agent has an SLA (response time, uptime, fix-on-failure), an on-call rotation exists. A typical 3-person rotation for a single agent: each engineer carries 1 week in 3 of after-hours pager. Compensation premium for on-call: typically $200-$400/week. Three engineers x 52 weeks / 3 rotation x $300/week = $15,600/year in pager pay. Plus the incident response time itself: assume 8 incidents/quarter at 4 hours each = 128 hours/year of engineer time at $90/hour loaded = $11,520/year.

Plus runbook maintenance: 1 day/month per agent = $14,400/year. Plus quarterly tabletop exercises and post-mortems: 2 days/quarter per engineer = $19,200/year.

Total on-call/ops: ~$60K/year for a department-scale agent. More if SLA is tight or if the agent runs across global time zones.

Category Seven: Risk-Adjusted Incident Cost

The line CFOs ask about within three minutes. Most TCO models leave it out because it is hard to estimate. The CFO knows it exists; if you do not show it, the CFO assumes you have not thought about it.

How to model it

For each plausible failure mode, estimate the expected cost and the annual probability.

Worked example for an 80K customer service agent:

• Wrong refund issued (financial error). Cost per incident: $200-$5,000 depending on amount. Probability per conversation: 0.05% (1 in 2,000) for tier-1 agent, 0.005% (1 in 20,000) once mature. Annual: 80K * 12 * 0.0005 = 480 incidents/year at $500 average = $240K. After maturity at 0.00005: 48 incidents at $500 = $24K.
• PII leak in transcript or response. Cost per incident: $50K-$500K including notification, remediation, regulatory. Probability per quarter: 0.5-2% per agent. Annual: 2-8% probability of $200K average = $4K-$16K expected.
• Brand-damaging response that goes public. Cost: $50K-$500K in PR, sales impact, executive time. Probability per year: 5-15%. Expected: $2.5K-$75K.
• Major outage (3+ hour downtime). Cost: $20K-$100K in deferred resolution, manual handling, customer satisfaction. Probability: 1-3 per year. Expected: $20K-$300K.
• Compliance violation. Cost: $25K-$2M depending on regime (HIPAA, FINRA, GDPR). Probability: 0.5-3% per year if regulated workload. Expected: $250-$60K.

Sum (mid-point, mature agent): $24K (refund) + $10K (PII) + $25K (brand) + $60K (outage) + $20K (compliance) = $139K/year risk-adjusted incident cost.

How to present it without scaring the CFO

Show the calculation. The CFO already mentally accounts for incident cost; making it explicit demonstrates that you have thought through it. Pair the number with the mitigation: guardrails, eval, human-in-loop, observability. The risk-adjusted line is what justifies the eval budget — you are spending $250K/year on eval to keep the $139K incident expected value from becoming $400K.

The 24-Month TCO Table

Putting the categories together for the worked 80K customer service agent example, 24 months on Sierra:

Year 1

• Platform license (Sierra): $1,340,000
• LLM tokens (mostly bundled with Sierra, plus internal eval/judge tokens): $25,000
• Integration (one-time + maintenance): $114,000
• Eval and quality: $281,000
• Observability: $28,000
• On-call and operations: $60,000
• Risk-adjusted incident cost: $200,000 (year 1 higher because agent is less mature)
• Year 1 total: $2,048,000

Year 2

• Platform license (Sierra, 7% escalator): $1,434,000
• LLM tokens: $28,000
• Integration maintenance: $23,000
• Eval and quality: $231,000 (no re-authoring)
• Observability: $30,000
• On-call and operations: $60,000
• Risk-adjusted incident cost: $139,000 (matured)
• Year 2 total: $1,945,000

24-month TCO: $3,993,000 with +/-20% confidence band: $3.19M to $4.79M.

That is the number you take to the CFO. With the categorical breakdown, the time-phasing, and the honesty about the confidence band.

Building the ROI Side of the Equation

The TCO model is half the conversation. The ROI side justifies the spend. For an 80K customer service agent:

• Deflection savings. 80K conversations/month at 54% deflection (Sierra typical) = 43,200/month not requiring a human agent. At $8 per conversation handled by an outsourced agent: $345,600/month, $4.15M/year. Net of platform cost: $4.15M - $2.0M = $2.15M year-1 savings.
• Speed/satisfaction lift. Faster response times typically lift NPS 3-8 points. NPS lift typically correlates to 0.5-1.5% revenue retention. For a $200M revenue business: $1M-$3M/year additional retained revenue.
• Internal labor reallocation. Tier-1 agent time freed up for tier-3 escalation work. 12 FTE x $80K loaded x 30% reallocated to higher-value work = $288K/year.

Total annual ROI: $2.4M-$5.4M against $2.0M cost. ROI multiple: 1.2x-2.7x year 1, climbing to 2.5x-4x year 2 as costs stabilize and benefits compound.

That is the case. The TCO model and the ROI model together. CFOs approve programs where the math works at the low end of the confidence band, not where it requires the high end.

The Three TCO Anti-Patterns

The one-page summary

"OpenAI: $25K. Platform: $30K. Engineering: $400K. Total: $455K." This is not a TCO model. It is a placeholder. CFOs do not approve programs based on this.

The optimistic model

"We'll save $5M by year 2." The optimistic model omits the integration tail, the eval cost evolution, the risk-adjusted incident cost. It overstates deflection. When the actual outcome is $2M savings against $3M cost, the program loses its credibility.

The vendor-supplied model

The vendor will offer you their TCO spreadsheet. It will compare their platform favorably to the alternatives. Use it as input, never as output. The vendor's model omits the lock-in cost, the price escalators, the eval surface unique to their platform, and the migration cost in year three. Build your own. Use the vendor's as one data point.

Presenting the Model

The presentation. One page summary, two pages detail.

Page 1: The summary

• 24-month total: $X with +/-20% confidence band
• Time to first value: N weeks
• Break-even on cumulative spend: month M
• Annual ROI multiple by year: 1.2x year 1, 2.5x year 2
• Key risks: top 3 with mitigations

Page 2: The seven categories

Table with seven rows, two years, totals. Highlight the lines that scale (tokens, eval) and the lines that don't (platform license, integration).

Page 3: Sensitivity analysis

What happens to TCO if usage is 30% higher? 30% lower? If the vendor raises prices 15% instead of 7%? If we have to migrate in year 2?

The CFO usually approves on page 1. The CIO approves on page 2. The CTO approves on page 3. Bring all three.

When the TCO Model Gets Rebuilt

Plan to rebuild the model twice in 24 months: at month 6 with actual usage data and at month 18 ahead of the year-3 renewal discussion. The model is a living artifact, not a one-time deliverable. The architect who shows the CFO a refreshed model at month 6 with "we're tracking within 8% of plan" buys 12 months of trust. The architect who shows up at month 18 saying "we were off by 40%" buys a project review.

Key Takeaways

• The TCO model is the artifact that decides whether your agent program survives. Build it line-item, time-phased, and risk-adjusted.
• Seven cost categories: platform license, LLM tokens, integration, eval and quality, observability, on-call and operations, risk-adjusted incident cost. Every line item fits in one of these.
• LLM tokens are the line that overruns 2-5x in year 1. Model retry overhead, context bloat, and model upgrade tax. Honest token budget is 1.5-2x the point estimate.
• Eval and quality is the second-largest line item after platform/tokens. Authoring + platform + judge + human review + evolution. Plan for $200K-$300K/year on a department-scale program.
• Risk-adjusted incident cost is the line CFOs ask about. Model it explicitly with failure modes, probability, and mitigation. Pair with the eval budget that justifies it.
• Platform escalators (5-12% annually) and the year-3 renewal jump (30-60% common) are the lines that surprise CFOs. Build them in.
• Three anti-patterns: the one-page summary, the optimistic model, the vendor-supplied model. None of these survive scrutiny.
• Present in three pages: summary for CFO, categorical detail for CIO, sensitivity analysis for CTO. Rebuild at month 6 and month 18.
• The number you present is "$X plus or minus 20% over 24 months" — not "$X definitely." Confidence intervals are credibility.