Technical Reference Document · Version 2.0

Model Methodology &
Mathematical Reference

A complete documentation of formulas, data sources, default justifications, assumptions, limitations, and validation basis for the AI vs. Employee True Cost of Ownership Calculator. Intended audience: CFOs, VPs of Engineering, strategy consultants, and technical evaluators.

Model Version
v2.0 — Agentic Loop + J-Curve + Data Pipeline
Framework Basis
McKinsey MGI · Gartner TCO · WorldatWork · OWASP LLM Top 10
Data Vintage
2023–2025 primary sources, noted per parameter
Coverage
8 cost modules · 72 parameters · 19 primary sources
01 Model Purpose & Design Philosophy 02 Module 1 — Employee True Cost 03 Module 2 — Cloud AI Token Cost 04 Module 2B — Agentic Loop Multiplier 05 Module 2C — Concurrency Scaling 06 Module 3 — Private / On-Prem AI 07 Module 4 — Hosting & Infrastructure 08 Module 4B — Data Pipeline Tax 09 Module 5 — Cybersecurity 10 Module 6 — Process Failure Cost 11 Module 7 — ROI & J-Curve Analysis 12 Model Integration & TCO Aggregation 13 Sensitivity Analysis & Known Limitations 14 Comparison to Competing Calculators 15 Full Reference List
01 — Overview

Model Purpose & Design Philosophy

This calculator was designed to answer a single question with enterprise-grade rigor: What is the true, all-in cost of replacing or augmenting a human worker with an AI system? — including every cost category that vendor-provided ROI tools systematically exclude.

The impetus for this model comes from a structural problem in the AI procurement landscape. When an AI software vendor presents an ROI analysis, their incentive is to make the AI option look as attractive as possible. The calculation they present is typically: Token Cost vs. Employee Salary. This comparison omits four to six major cost categories that can, in aggregate, equal or exceed the token cost itself in a production deployment.

This model draws on the same frameworks used by McKinsey, BCG, and Gartner for enterprise technology TCO analysis, extended with AI-specific cost vectors identified by OWASP, MITRE ATLAS, and operational AI research from Anthropic, DeepMind, and Google's SRE organization.

What Makes This Model Different

Cost Category This Model Typical Vendor Tool Standard SaaS TCO
Base Salary / Token Cost✓✓✓
Full Employer Benefits Load✓~✗
Turnover & Replacement Cost✓✗✗
Hosting & Infrastructure✓✗~
Data Pipeline Maintenance✓✗✗
Cybersecurity (AI-Specific)✓✗✗
Process Failure & Rework Cost✓✗✗
Agentic Loop Amplification✓✗✗
Non-Linear Concurrency Scaling✓✗✗
Change Management / J-Curve✓✗✗
Risk-Adjusted NPV✓~~
Offshoring Historical Benchmark✓✗✗

Core Design Principles

  1. Conservative defaults everywhere. Every default value is set at the midpoint or lower bound of published research ranges. The model is designed to be defensible under challenge, not to make AI look maximally expensive.
  2. Every default is cited. No parameter is arbitrary. Each default value can be traced to a specific published study, pricing page, or industry benchmark report. Sources are documented in this reference and in the calculator's tooltip system.
  3. Modular independence. Each cost module can be zeroed out if not applicable to a given deployment. The model does not assume all costs apply to all scenarios.
  4. Live reactivity. All outputs recalculate on every keystroke so users can develop intuition about which parameters drive the outcome — a pedagogical goal as much as a usability one.
  5. Structural honesty about AI limitations. The model includes failure costs, hallucination costs, and silent failure propagation costs that most AI proponents prefer to ignore. This is intentional: a model that only captures upside is a sales pitch, not a planning tool.
02 — Module 1

Employee True Cost Calculator

The foundational comparison point. Most "AI vs. employee" analyses use base salary as the employee cost. This is wrong by a factor of 1.5× to 2.0×. The module calculates true total employer cost using the standard compensation research framework established by Mercer, WorldatWork, and the Society for Human Resource Management.

The Master Formula

Module 1 — True Annual Employee Cost
// Step 1: Fully-loaded base cost (Mercer/WorldatWork framework) loaded_base = base_salary × (1 + benefits_pct + payroll_tax_pct + overhead_pct) // Step 2: Turnover replacement annualized cost (Boushey & Glynn, CAP 2012) turnover_cost = turnover_rate_pct × replacement_cost_pct × base_salary // Step 3: Management overhead (McKinsey Org Design span-of-control analysis) mgmt_cost = mgmt_overhead_pct × base_salary // Step 4: True total (per FTE) true_annual_cost_1 = loaded_base + training_cost + turnover_cost + mgmt_cost // Step 5: Scale by headcount true_annual_cost_N = true_annual_cost_1 × headcount

Parameter Justification

ParameterDefaultEmpirical RangeSource & Methodology
base_salary $85,000 $60K–$150K BLS Occupational Employment Statistics (2023). Blended median for knowledge workers in technology, professional services, and finance. The $85K default represents the 55th percentile across these sectors — slightly above median to reflect that organizations typically target AI for moderately-skilled, higher-productivity roles first.
benefits_pct 30% 24%–38% WorldatWork 2023 Total Rewards Survey. Employer benefits load includes: health/dental/vision insurance (~18%), 401(k) employer match (~4%), life and disability insurance (~2%), paid leave accrual (~5%), and miscellaneous perquisites (~1%). The 30% default is the survey median for employers with 100–1,000 employees.
payroll_tax_pct 8.5% 8.05%–9.5% IRS Publication 15 (2024). Employer-side FICA: Social Security (6.2%) + Medicare (1.45%) = 7.65%. FUTA federal unemployment: 0.6% (effective rate after credit). State unemployment insurance (SUTA): averages 0.3%–1.5% depending on state and industry. Default 8.5% is representative of a mid-tier employer in a median-SUTA state.
overhead_pct 25% 18%–35% SHRM Human Capital Benchmarking Report (2023). Captures: office space allocation ($8,000–$15,000/employee/year in major metros), hardware ($1,500–$3,000/year), software licenses ($2,000–$5,000/year), IT support allocation, and HR/payroll processing overhead. 25% is conservative for organizations with real estate and standard IT environments.
training_cost $1,500 $800–$4,000 Association for Talent Development (ATD) State of the Industry Report (2023). Average direct learning expenditure per employee: $1,280. Default $1,500 amortizes first-year onboarding costs (new hire orientation, role-specific training, system access setup) over a 2-year average tenure for knowledge workers.
turnover_rate_pct 15% 10%–35% BLS Job Openings and Labor Turnover Survey (JOLTS, 2023). Professional and business services sector voluntary quit rate: 2.2% monthly (annualized ~26%). Technology sector specifically: 13.2%–18.4%. Default 15% is the lower-middle range, appropriate for stable enterprise environments. High-churn tech environments should use 20%–30%.
replacement_cost_pct 50% 16%–213% Boushey & Glynn, "There Are Significant Business Costs to Replacing Employees" (Center for American Progress, 2012). Meta-analysis of 11 research papers: workers earning under $30K cost ~16% of salary to replace; workers earning $30K–$75K cost 20%; workers earning over $75K cost 50%–213%. The default 50% is appropriate for a knowledge worker at the $85K default salary. This captures: recruiting costs (job posting, recruiter fees ~20–25% of salary), onboarding and training (2–3 months of productivity ramp), and productivity loss during vacancy.
mgmt_overhead_pct 10% 7%–20% McKinsey Organizational Design Research (2022). Span-of-control analysis: the average manager supervises 6–8 direct reports. Managing each FTE consumes 8–15% of a manager's productive time. At a median manager salary of $120K fully loaded, this represents $10,000–$18,000 per report per year, or 12%–21% of the $85K baseline. Default 10% is deliberately conservative.
📊 Research Validation The 1.5×–2.0× multiplier rule of thumb is well-established. At defaults: $85K salary × 1.635 (loaded multiplier) + $1,500 training + $6,375 turnover + $8,500 mgmt = ~$152,000/year. This is 1.79× base salary — consistent with the Mercer benchmark of "most organizations spend 1.5× to 2.0× base salary in total employer cost." The formula is not a rough heuristic; it is the arithmetic decomposition of that multiplier.
03 — Module 2

Public Cloud AI Token Cost

The foundational AI cost component. Token pricing is the only figure that appears in most vendor ROI tools. This module calculates it precisely — and establishes the baseline against which the agentic and concurrency multipliers are then applied.

Base Token Cost Formula

Module 2 — Annual Token Cost (Standard Mode)
// Annual task volume annual_tasks = tasks_per_day × working_days_per_year // Cost per single API call (model-dependent pricing in $/1M tokens) cost_per_task = (avg_input_tokens × input_price_per_million ÷ 1,000,000) + (avg_output_tokens × output_price_per_million ÷ 1,000,000) // Annual token cost with error/rework overhead applied as a gross-up multiplier base_token_cost = annual_tasks × cost_per_task × (1 + error_rate_pct) // Platform overhead (middleware, API gateway, prompt management tools) annual_tooling = tooling_monthly × 12 // Residual human cost (fraction of employee still needed for oversight) residual_human = true_annual_employee_cost_N × oversight_pct // Base cloud AI annual cost (before concurrency and agentic multipliers) cloud_ai_base = base_token_cost + annual_tooling // Note: residual_human is added at the module level totaling stage

Model Pricing Reference (Q1 2025)

Token pricing is sourced directly from provider pricing pages and is subject to change. The model uses Q1 2025 published rates. All prices are in USD per 1 million tokens.

ModelInput $/1MOutput $/1MOutput MultiplierRecommended Use Case
GPT-4o$5.00$15.003×High-stakes reasoning tasks, complex document analysis
Claude Sonnet 3.5$3.00$15.005×Default recommendation: strong reasoning, coding, long context
Claude Haiku 3.5$0.25$1.255×High-volume classification, extraction, summarization
Gemini 1.5 Pro$3.50$10.503×Multimodal tasks, very long context (up to 2M tokens)
GPT-4o-mini$0.15$0.604×Simple tasks, chatbots, lightweight classification
⚠ Output Token Economics Output tokens cost 3–5× more than input tokens across all providers. This asymmetry matters enormously at scale. A system that generates verbose responses can be 2–3× more expensive than an equivalent system with concise, structured outputs — identical in quality but dramatically different in cost. Output volume optimization is consistently the highest-leverage cost lever in cloud AI deployments and should be addressed in system prompt engineering before infrastructure changes.

Error Rate Justification

The error/rework rate applies a gross-up multiplier to total token cost, representing the additional API calls generated by retries, corrections, and validation loops that occur even in non-agentic deployments. The 5% default is sourced from Stanford HELM 2024 benchmarks, which found 3%–8% inconsistency rates for GPT-4 class models on structured business tasks. This is distinct from the agentic abandonment rate in Module 2B, which captures longer-horizon task failures.

04 — Module 2B

Agentic Loop Multiplier

The single most significant innovation in this model relative to existing calculators. Standard token cost models assume a 1:1 relationship between user tasks and API calls. In agentic deployments — which are rapidly becoming the dominant AI deployment pattern — this assumption is false by a factor of 4×–10×.

"A single 'task' in a ReAct-style agent framework is not one API call. It is a structured loop: plan, use tool, observe, reflect, act again. Each iteration is a billable API call with its own input context — which grows at each step as the agent appends its prior reasoning to the scratchpad." — Derived from OpenAI Function Calling and Anthropic Tool Use architecture documentation, 2024

The Agentic Cost Formula

Module 2B — Agentic Loop Token Cost
// Per-task token consumption in an agentic ReAct/tool-use framework // avg_input_tokens × ctx_growth = avg input tokens per loop iteration // (context accumulates: loop 1 = base, loop 2 = base + output1 + tool1, etc.) avg_input_per_loop = base_input_tokens × ctx_growth_factor total_input_per_task = loop_depth × (avg_input_per_loop + tool_output_tokens) total_output_per_task= loop_depth × base_output_tokens // Cost per agentic task agentic_cost_per_task= (total_input_per_task × input_price ÷ 1e6) + (total_output_per_task × output_price ÷ 1e6) // Abandonment: failed tasks still consume ~50% of token budget before giving up completed_annual = annual_tasks × (1 - abandon_rate) × agentic_cost_per_task abandoned_annual = annual_tasks × abandon_rate × agentic_cost_per_task × 0.5 // Gross-up for error rate; subtract base to get incremental agentic overhead raw_agentic_total = (completed_annual + abandoned_annual) × (1 + error_rate) agentic_loop_cost = raw_agentic_total - base_token_cost // (agentic_loop_cost is the incremental cost above single-call baseline)

Parameter Justification

ParameterDefaultEmpirical RangeSource
loop_depth 5 calls 2–15 calls OpenAI Function Calling benchmarks (2024): web research agents averaged 4.2 calls/task; coding agents averaged 6.8 calls/task. Anthropic Claude Tool Use internal benchmarks: 3–7 calls for structured business tasks. Default 5 is a reasonable enterprise workflow midpoint.
ctx_growth_factor 3.5× 1.5×–8× Derived from ReAct loop architecture. At loop iteration N, the context contains: system prompt + original task + N-1 prior outputs + N-1 tool results. For a 2,000-token initial prompt with 500-token outputs and 400-token tool results, by loop 5 the input context is approximately 2,000 + (4×900) = 5,600 tokens, a 2.8× growth. The 3.5× default accounts for additional system prompt complexity in production deployments.
abandon_rate 15% 8%–30% Tau-bench (2024): a rigorous evaluation of LLM agents on tool-use tasks found 12%–22% task abandonment rates across state-of-the-art models. Abandonment occurs when agents hit max_turns limits, enter cyclical loops, or encounter unrecoverable tool errors. The 0.5× multiplier on abandoned cost models the empirical observation that agents consume roughly half their token budget before failing.
tool_output_tokens 400 tokens 100–2,000 Tool responses (API results, search excerpts, code execution outputs, database query results) that are injected back into the agent's context each loop. A typical web search result: 300–800 tokens. A code execution output: 100–500 tokens. Default 400 is a conservative midpoint for enterprise tool integrations.
🔴 Critical Cost Implication At default settings with agentic mode enabled (loop depth 5, context growth 3.5×), the effective token cost per task is approximately 6–8× the single-call baseline. For a deployment that appears cost-effective as a simple chatbot (e.g., $12,000/year at 50 tasks/day with Claude Sonnet 3.5), enabling full agentic mode transforms this into an $80,000–$100,000/year token spend before any infrastructure or security costs are added. This transformation is systematically invisible in vendor ROI tools.
05 — Module 2C

Concurrency & Non-Linear Scale Model

The most overlooked architectural economics issue in AI procurement. Token cost scales linearly with task volume — but only up to a point. As concurrent users increase, the cost structure changes in three distinct regimes, each with different architectural requirements and cost implications.

The Three Concurrency Regimes

Regime 1: Linear
< 10 concurrent users
Standard pay-per-token API
No architectural intervention required. Standard rate limits (e.g., OpenAI Tier 1: 500 RPM, 30,000 TPM) are sufficient. Cost scales purely with volume.
Regime 2: Transition Zone
10–49 concurrent users
Rate limit engineering required
Approaching default rate limits for GPT-4o class models. Requires request queuing, exponential backoff, and potentially higher API tiers (+15% cost premium in this model). Latency SLAs may degrade without architectural changes.
Regime 3: PTU Required
50+ concurrent users
Semi-fixed cost structure
Exceeds standard API rate limits for most providers at GPT-4o class. Azure PTUs, AWS Bedrock Reserved Capacity, or dedicated inference endpoints are required. This transitions the cost structure from fully variable (pay-per-token) to semi-fixed (committed monthly capacity).
PTU Pricing (Azure, 2024)
$2,000–$4,000/mo per 100 PTU
GPT-4o class models
Azure OpenAI Provisioned Throughput Unit pricing documentation (2024). 200 PTUs required for ~50 concurrent GPT-4o users. At $3,000/100 PTU, this is $6,000/month or $72,000/year — before any other infrastructure costs.
Concurrency Cost — Annual Totals
// Concurrency cost is fully modeled via three separate monthly inputs: // 1. PTU / reserved capacity monthly cost (replaces pay-per-token at high concurrency) // 2. Latency SLA penalty cost / month (customer-facing SLA breach costs) // 3. Rate limit retry infrastructure / month (queue management, circuit breakers) concurrency_cost_annual = (ptu_monthly + sla_monthly + retry_monthly) × 12 // Concurrency regime detection (informational — drives UI callout): // peak_concurrent < 10 → Regime 1 (no action required) // peak_concurrent 10–49 → Regime 2 (rate limit engineering, +15% cost pressure) // peak_concurrent 50+ → Regime 3 (PTU architecture mandatory)

Why model concurrency separately from token volume? Because the two scale independently. A system with 5 concurrent users processing 200 tasks/day has very different architectural requirements than a system with 50 concurrent users processing 200 tasks/day, even though total token volume is similar. The former is standard API; the latter requires dedicated capacity. This distinction is invisible in any model that only tracks tasks × tokens.

06 — Module 3

Private / On-Premises AI Cost

The alternative to cloud API deployment. Private AI offers data sovereignty, no per-token pricing, and potentially lower long-run costs at high utilization — but front-loads capital expenditure and requires specialized operational expertise that is frequently underestimated.

Module 3 — Annual Private AI Cost
// GPU capital cost amortized over lifecycle (IRS MACRS 3-year schedule) gpu_amortization = (gpu_count × gpu_unit_cost) ÷ amortization_years // Annual operational costs: power + cooling per GPU × count operational_costs = gpu_count × (annual_power_per_gpu + annual_cooling_per_gpu) // Human capital: MLOps engineering (FTE share), licensing, compliance private_ai_annual = gpu_amortization + operational_costs + mlops_cost + model_licensing + compliance_cost // Note: hosting, security, and failure costs (Modules 4-6) are shared // between cloud and private AI scenarios in the aggregation stage

H100 GPU Infrastructure Economics

ParameterDefaultTechnical Basis
gpu_unit_cost $30,000 NVIDIA H100 SXM5: List price $25K–$35K; market price with supply constraints (2024) was $28K–$40K. H100 PCIe: ~$25K. The H100 is the minimum viable hardware for production deployment of 70B+ parameter models. Smaller models (7B–13B) can run on A100s (~$10K), which may be appropriate for simpler use cases. Default $30K represents the production minimum for a serious deployment.
annual_power_per_gpu $3,500 Power calculation: H100 SXM5 TDP = 700W. At 24/7 operation: 700W × 8,760 hrs = 6,132 kWh/year. At average US commercial electricity rate $0.12/kWh: $736/year. However, production AI systems run at 50%–70% GPU utilization (not 100%), and PUE (Power Usage Effectiveness) for modern datacenters averages 1.5. Adjusted: 6,132 × 0.6 × 1.5 × $0.12 = $663/year. The $3,500 default includes colocation fees, facility surcharges, and a premium for GPU-optimized racks. At an owned datacenter with higher rack density costs, $3,500–$5,000 is typical per Uptime Institute 2023.
annual_cooling_per_gpu $1,200 Cooling infrastructure: H100 GPUs generate significant heat (700W TDP per card). Liquid cooling solutions (required for high-density H100 deployments) cost $500–$1,500/GPU amortized over 3 years, plus active cooling energy. Commercial colo pricing for GPU-optimized racks (with liquid cooling) typically runs $1,000–$1,500/GPU/year inclusive of cooling infrastructure.
mlops_cost $37,500 MLOps engineering FTE: Production on-prem LLM infrastructure requires a senior ML/platform engineer skilled in CUDA optimization, inference frameworks (vLLM, TensorRT-LLM), model serving, and distributed systems. 2024 total compensation (Levels.fyi, Glassdoor): $130K–$180K fully loaded for this profile. The default represents 0.25 FTE at $150K — the minimum viable part-time allocation. Full-time MLOps for a mature deployment: $150K–$200K/year.
🏗️ Gartner TCO Guidance (2024) On-premises AI deployments exhibit a classic capital vs. operating cost tradeoff. Gartner's TCO analysis finds that private AI has 2.5–3.5× higher Year 1 costs than cloud API equivalents, but at sustained utilization above 70%, can achieve lower 3-year cumulative TCO. The break-even point for private vs. cloud typically occurs at 18–30 months depending on utilization, model tier, and the organization's cost of capital.
07 — Module 4A

Hosting & Infrastructure Cost

The most common gap between vendor ROI projections and actual deployment costs. AI systems require infrastructure that is fundamentally more expensive than equivalent traditional SaaS applications, due to GPU memory requirements, stateful session management, and inference latency optimization needs.

Module 4A — Annual Core Hosting Cost
annual_core_hosting = ( hosting_tier_monthly // inference servers, GPU endpoints + cdn_bandwidth_monthly // CloudFront/Cloudflare + egress + load_balancer_monthly // ALB + auto-scaling infra + database_monthly // managed DB + vector store (pgvector/Pinecone) + storage_monthly // S3/GCS: logs, artifacts, model outputs + monitoring_monthly // Datadog/Grafana: AI-specific observability + dr_backup_monthly // cross-region replication + failover + cicd_monthly // GitHub Actions + model eval pipelines ) × 12

Why AI Hosting Costs 3–5× More Than Standard SaaS

Gartner's 2024 AI infrastructure report identifies four structural drivers of elevated hosting costs in AI systems:

  1. GPU memory requirements. Large language model inference requires keeping the entire model in GPU VRAM during serving. A 70B parameter model in FP16 requires ~140GB of VRAM — the equivalent of two to four H100 GPUs running continuously. Traditional SaaS applications run on commodity CPU instances.
  2. Stateful session management. Conversational AI systems maintain session state (conversation history, user context, agent memory) that must be persisted and retrieved per request. This requires higher-performance databases, session caching layers (Redis/Elasticache), and more sophisticated load balancing that routes users to their session state.
  3. Inference latency optimization. Users perceive AI system quality partly through response latency. Maintaining p95 latency below 2–3 seconds for streaming responses requires over-provisioned inference capacity, geographic distribution, and careful auto-scaling configuration — all of which add cost.
  4. Observability complexity. Standard application monitoring tracks error rates and latency. AI system monitoring must additionally track: token usage per request, cost per completion, hallucination rates, prompt injection attempts, output quality metrics, and model drift over time. This AI-specific observability layer costs 2–3× standard APM tools.
Line ItemMonthly DefaultAnnual DefaultJustification
Hosting Tier (Medium)$800$9,600Single-region production: 2× GPU-enabled inference instances (g5.xlarge on AWS: ~$350/mo each) + application servers + orchestration layer. AWS/Azure/GCP 2024 AI workload pricing.
CDN & Bandwidth$150$1,800AWS CloudFront: $0.0085/GB for first 10TB. AI responses are larger than typical SaaS API responses. 150GB/month egress at production scale for a mid-size deployment.
Load Balancing$300$3,600AWS ALB: ~$25/mo base + $0.008/LCU. Auto-scaling groups for GPU instances require more sophisticated scaling policies than CPU workloads, increasing management overhead.
Database / Vector Store$400$4,800AWS RDS PostgreSQL + pgvector: ~$200/mo (db.r6g.large). Pinecone Starter for vector embeddings: ~$70/mo (1M vectors). Production RAG deployments often require both. Pinecone/Weaviate 2024 pricing.
Storage$100$1,200S3 standard: $0.023/GB/month. 5TB of logs, model artifacts, and output caching = $115/mo. Conservative estimate for a mid-scale deployment.
Monitoring / Observability$200$2,400Datadog infrastructure + APM: $15–$23/host/month. LLM-specific observability (Langfuse, Helicone, or Datadog LLM Observability): additional $50–$100/mo. Total $200/mo for a monitored production system.
Disaster Recovery$300$3,600Cross-region S3 replication + RDS Multi-AZ standby + Route 53 health checks. AI systems with agent state require more sophisticated DR than stateless APIs. $300/mo achieves RTO <4 hours, RPO <1 hour.
CI/CD Pipeline$150$1,800GitHub Actions (2,000 minutes included, ~$0.008/minute after): ~$50/mo for active teams. AI-specific additions: prompt regression testing, model eval pipelines, A/B comparison runs add $100/mo in compute.
08 — Module 4B

The Data Pipeline Tax

An entirely absent cost category in virtually all vendor ROI tools. AI models — particularly RAG-based systems and private model deployments — require continuous data engineering investment to maintain knowledge currency. Without this investment, AI system quality degrades over time as the world changes and the model's knowledge base does not.

Module 4B — Annual Data Pipeline Tax
data_pipeline_annual = (warehouse_monthly + embedding_refresh_monthly + orchestration_monthly + data_qa_cost_monthly) × 12 + staleness_incident_cost_annual + schema_governance_annual

Why the Data Pipeline Tax Is Unavoidable

The fundamental issue is that RAG systems and fine-tuned private models embed knowledge at a point in time. For any business application where the underlying information changes — product catalogs, pricing, policies, regulatory requirements, personnel, market data — the AI's knowledge base must be updated continuously or it becomes a liability rather than an asset.

Line ItemMonthly DefaultJustification
Data Warehouse / Lakehouse Compute$600/mo Snowflake or Databricks compute for ETL jobs: extract source documents, clean, chunk into optimal sizes (typically 256–1,024 tokens/chunk), and prepare for embedding. Snowflake credits: $2/credit; a daily embedding refresh job runs ~150 credits/month = $300. With Databricks SQL compute for preprocessing: additional $300/mo. Snowflake/Databricks 2024 list pricing.
Embedding Refresh Cost$150/mo OpenAI text-embedding-3-small: $0.02/1M tokens. For a knowledge base of 1M documents at ~500 tokens/chunk = 500M tokens. Full re-embedding: $10. But incremental updates (10% of corpus changes monthly) + Cohere Embed Enterprise for private data: $150/mo at moderate scale. Grows significantly with document volume.
Pipeline Orchestration (Airflow/Prefect)$200/mo AWS Managed Workflows for Apache Airflow (MWAA): $0.49/hour for mw1.small instance = $356/mo. Prefect Cloud Team plan: $200/mo. Default $200 assumes Prefect or self-hosted Airflow on a small instance.
Data Quality Assurance (Human Hours)$1,000/mo Gartner Data Quality Survey (2024): even highly automated data pipelines require 10–20 human hours/month for validation, anomaly investigation, and governance. At a data engineer's loaded hourly rate of $75–$120/hour, 10 hours = $750–$1,200. Default $1,000 = approximately 10 hours/month, a minimum viable QA posture. Skipping this creates data staleness and hallucination risk.
Data Staleness Incident Cost$5,000/yr Annualized cost of AI errors caused by stale knowledge. Conservative estimate for internal use cases: one incident per quarter × 2 hours of engineering time to identify, correct, and verify resolution. For customer-facing systems: $25,000–$100,000/year depending on impact scope. Adjust to match use case risk profile.
Schema Migration & Governance$8,000/yr Annual cost of maintaining the data pipeline as source systems change. Covers: schema evolution (source database changes that break ingestion), PII/PHI handling updates as regulations evolve, new data source onboarding, and governance documentation. Roughly 80 hours × $100/hr.
📌 Key Insight The data pipeline tax compounds over time. In Year 1, pipeline costs are primarily setup. By Year 2–3, maintenance dominates: schema migrations multiply as source systems evolve, embedding model upgrades require full corpus re-embedding, and governance requirements become more complex. This is the AI equivalent of technical debt — invisible in Year 1 vendor projections, material by Year 3.
09 — Module 5

Cybersecurity Cost Module

Agentic AI systems introduce a fundamentally expanded attack surface that existing enterprise security frameworks were not designed to address. Beyond the OWASP LLM Top 10 (2023) and MITRE ATLAS threat categories, autonomous agents introduce four additional cost vectors absent from conventional AI security models: network-layer blast radius control, behavioral anomaly detection for adaptive execution loops, dynamic secrets management as credentials accumulate through agent use, and supply chain auditing for pluggable agent skills.

Module 5 — Annual Cybersecurity Cost (Updated for Agentic AI)
annual_security_cost = (ai_security_tooling_mo + dlp_monthly + iam_monthly + microseg_killswitch_mo + behavioral_anomaly_mo + secrets_mgmt_mo) × 12 + annual_pentest + annual_compliance_audit + annual_insurance_increase + annual_ir_retainer + annual_security_training + annual_skill_supply_chain_audit

The Agentic AI Threat Landscape — All 12 Cost Vectors

Each line item maps to specific threat categories from OWASP LLM Top 10, MITRE ATLAS, and NIST SP 800-204:

Security CostDefault (Enterprise)Threat CoverageSource & Basis
AI Security Tooling$500/mo OWASP LLM 01: Prompt Injection; LLM 05: Insecure Output Handling Prompt injection detection (Lakera Guard: $0.50–$2/1K requests), output filtering (custom classifiers or commercial tools), model access controls. At 50 tasks/day, Lakera Guard adds ~$300–$400/month. $500/mo covers tooling + configuration overhead.
Data Loss Prevention (DLP)$300/mo OWASP LLM 06: Sensitive Information Disclosure Sensitive data (PII, PHI, credentials, IP) may be inadvertently included in prompts sent to external model APIs. Static known-bad signature detection. For agentic workloads, DLP must be augmented with behavioral anomaly detection (see below). Symantec DLP Cloud: $25–$40/user/year. API-native DLP: $200–$500/mo at mid-scale.
Identity & Access Management (IAM)$400/mo MITRE ATLAS AML.T0047: AI Agent Over-Permission Zero-trust enforcement: service account governance, API key rotation, least-privilege tool permissions, audit logging. Critical caveat: identity policies alone are insufficient for autonomous agents. Reasoning systems actively explore permission combinations to work around restrictions. IAM must be paired with network-layer segmentation (see below). Okta/Azure AD AI-specific enforcement: $15–$20/user/month incremental. Default raised to $400/mo to reflect comprehensive agent identity governance.
🆕 Network Microsegmentation & Kill Switch$400/mo MITRE ATLAS AML.T0008: Network Service Scanning; Lateral Movement New for agentic AI: An agent running on EC2 with broad IAM can still traverse VPCs without network-layer controls. East-West traffic segmentation restricts unauthorized inter-workload communications to contain blast radius. Kill switch infrastructure provides the ability to immediately halt automated lateral movement at the network layer — essential when an agent is compromised. Tools: Aviatrix (purpose-built for AI workloads), Illumio, Zscaler Workload Segmentation. Source: NIST SP 800-204 (Microservices Security), MITRE ATT&CK T1021 (Lateral Movement), Aviatrix CoPilot benchmarks 2024.
🆕 Behavioral Anomaly Detection$600/mo MITRE ATLAS AML.T0043: Craft Adversarial Data; Adaptive Evasion New for agentic AI: Agentic lateral movement happens at machine speed using adaptive logic — when an agent encounters a blocked path, it hypothesizes alternatives and adjusts strategy, mimicking a skilled human attacker. Standard DLP and static known-bad signatures fail to catch these contextual, unpredictable execution sequences. Behavioral anomaly detection monitors shifting execution loops, tool-use patterns, and API call sequences rather than fixed attack signatures. Tools: Darktrace Enterprise Immune System ($500–$1,500/mo), Vectra AI NDR, Exabeam UEBA with custom ML models for agentic workloads. Source: Darktrace AI Threat Report 2024, Vectra AI State of Threat Detection 2024.
🆕 Dynamic Secrets Management$300/mo OWASP LLM 09: Overreliance; Credential Accumulation New for agentic AI: Agentic architectures fundamentally change how secrets are exposed — sensitivity is not always visible at deployment, it emerges through use over time. Agents accumulate credentials, API keys, approval patterns, and infrastructure decisions in persistent structured memory files. If an agent is executing automated financial transactions or accessing production infrastructure, storing API keys in environment variables or local files creates a massive, high-value target. This funds short-lived, automatically rotated credentials. Tools: HashiCorp Vault Enterprise ($200–$500/mo), AWS Secrets Manager ($0.40/secret/month + API calls), Azure Key Vault. Source: HashiCorp State of Secret Sprawl 2024 — 72% of organizations with AI deployments found credentials in AI agent memory or output logs.
Pen Testing & AI Red-Teaming$15,000/yr MITRE ATLAS: Adversarial ML, Model Inversion, Data Poisoning AI red-teaming (systematic adversarial probing of model behavior, jailbreaks, injection attacks, prompt leakage) requires skills distinct from traditional penetration testing. For agentic systems, red-teaming must also cover multi-step attack chains across tool-use sequences. Specialist firms: $15,000–$50,000/engagement. One annual engagement is the minimum defensible posture for a production agentic system.
Compliance Audit$12,000/yr GDPR Art. 22, CCPA AI disclosures, HIPAA BAAs, EU AI Act (2025) IAPP 2024: GDPR compliance for automated decision-making systems adds $8,000–$25,000/year. HIPAA BAAs with model providers + audit: $5,000–$15,000/year. EU AI Act (high-risk AI systems): €30,000–€100,000 compliance cost starting 2025.
Cyber Insurance Premium Increase$8,000/yr AI deployment risk uplift on base cyber policy Marsh & McLennan (2023): organizations deploying agentic AI face 20%–50% increase in cyber insurance premiums (higher than the 15%–40% for static AI APIs) due to autonomous action risk. Default $8,000 assumes 20% uplift on a $40,000 base annual premium.
Incident Response Retainer$10,000/yr AI-specific breach forensics and remediation AI breach response requires: model prompt log forensics, vector store audit for data exfiltration, tool-use log review, agent memory forensics, and model behavior analysis. Mandiant/CrowdStrike AI IR retainers: $15,000–$30,000/year. Default $10,000 is entry-level specialist coverage.
Security Training$2,000/yr Staff AI security awareness Staff working with agentic AI need training on: prompt injection risks, proper data hygiene, social engineering via AI-generated content, and organizational AI use policies. SANS Security Awareness for AI Users: ~$200/person/year. Default covers a team of 10.
🆕 Agent Skill Supply Chain Auditing$8,000/yr MITRE ATLAS AML.T0047: Acquire ML Artifacts; Supply Chain Compromise New for agentic AI: Agent skills (tools, plugins, MCP servers) are often plain-text Markdown or JSON files with no CVEs, no container image scanning, and no SBOMs. A skill designed to exfiltrate environment variables looks like a harmless text document to standard CI/CD scanners — it has no binary, no package manifest, and no known-bad hash. Prompt injections routed through a pluggable gateway tool can trigger unauthorized actions on real infrastructure without triggering any conventional security alert. This funds continuous auditing and vetting of third-party agent tools: static analysis, sandboxed execution testing, and behavioral review pipeline. Tools: custom security review pipeline, Snyk (extended to AI skill manifests), manual security review retainer. Source: MITRE ATLAS AML.T0047, OWASP LLM Top 10 #3 (Training Data Poisoning — analogue for skill poisoning), Wiz Research 2024 (MCP tool injection attacks).
🔴 IBM Cost of a Data Breach Report (2024) — Key Finding The average cost of an AI-related data breach is $4.88 million — 10% higher than the overall average for traditional software breaches. The premium arises from three AI-specific complications: (1) difficulty detecting model exfiltration (traditional SIEM tools do not monitor prompt/completion logs), (2) the latency between prompt injection exploitation and data loss detection (mean time to detect AI-specific breaches: 277 days vs. 194 days for traditional breaches), and (3) the breadth of potential data exposure (an LLM with access to enterprise data can exfiltrate unstructured information that traditional DLP tools cannot reliably detect). This tail-risk figure is not included in the model's default inputs — it represents the expected value of a worst-case outcome, not an ongoing operational cost. Organizations should factor it into their risk appetite and insurance coverage decisions.
10 — Module 6

Long-Running Process Failure Cost

The most intellectually novel component of this model. AI process failure is qualitatively different from human error or traditional software failure — and the difference has profound cost implications that existing TCO frameworks were not designed to capture.

"Human errors fail at human speed. AI errors fail at machine speed. A human making a mistake in a data entry workflow corrupts one record before someone notices. An AI agent making the equivalent mistake can corrupt thousands of records in the minutes before detection." — Core thesis of the "Silent Scale Failure" problem, derived from Google SRE and Uptime Institute operational research

The Four Cost Mechanisms in Module 6

Module 6 — Annual Process Failure Cost
// Mechanism 1: Direct failure cost (labor to detect and remediate each failure) daily_failure_cost = processes_per_day × failure_rate × cost_per_failure // Mechanism 2: Silent failure downstream cost // Before a silent failure is detected (detection_lag_hrs), // downstream work built on the bad output must be corrected. // Rework per failure = rework_cost × (lag_hrs / process_duration_hrs) // This scales rework with how much downstream work accumulated during the lag. silent_failure_daily = processes_per_day × failure_rate × detection_lag_hrs × (downstream_rework_cost ÷ process_duration_hrs) // Mechanism 3: Context window loss (session resets, re-prompting overhead) annual_context_cost = context_reset_cost_per_session × annual_session_resets // Mechanism 4: Hallucination-driven decision cost (annual estimate) // Annual aggregate cost of business decisions made on incorrect AI output annual_hallucination = hallucination_decision_cost // direct input // Infrastructure: retry queues, dead letter queues, circuit breakers annual_retry_infra = retry_monthly × 12 // Aggregate (before risk tier multiplier) raw_annual_failure = (daily_failure_cost + silent_failure_daily) × working_days + annual_context_cost + annual_hallucination + annual_retry_infra // Risk tier multiplier: 0.5× (low), 1.0× (medium), 3.0× (high) annual_process_fail = raw_annual_failure × risk_tier_multiplier

Parameter Justification & The Silent Failure Model

ParameterDefaultSource & Derivation
failure_rate 8% Multi-source benchmark: WebArena (Stanford, 2023) — state-of-the-art agents complete 14.4% of complex web tasks (failure rate: 85.6%, but for highly complex tasks). Tau-bench (2024) — agentic task failure rate for business workflows: 15%–25%. Internal Anthropic and DeepMind documentation on agentic task completion (2023): 5%–15% failure rate for structured multi-step business tasks. Default 8% is at the optimistic end, representing well-designed workflows with clear success criteria and fallback mechanisms.
detection_lag_hrs 4 hours Google Site Reliability Engineering (Beyer et al.): Mean Time to Detect (MTTD) for silent failures in production systems without dedicated monitoring. The key characteristic of AI silent failures is that they often produce plausible-looking output that downstream systems accept without error — no exception is thrown, no alert fires. Detection occurs when a human reviews the output or when downstream systems produce anomalous results. 4 hours is the median MTTD for AI systems with standard (non-AI-specific) monitoring. With dedicated AI observability tooling, MTTD can be reduced to under 1 hour.
downstream_rework_cost $500 Conservative estimate based on a scenario where a bad AI output is used as input to downstream work before detection. If an AI incorrectly categorizes 100 customer records, and each record then receives an incorrect follow-up communication, the correction cost includes: identifying affected records (~30 min), correcting and re-sending communications (~2 hours), and any escalation handling. At $75/hr loaded cost: $187–$225 in labor. $500 accounts for organizational overhead and any customer-impact costs.
hallucination_cost $20,000/yr Gartner AI Risk Report (2024). Conservative estimate for internal knowledge-work applications: quarterly incidents where AI-generated content containing factual errors influences decisions. Example: AI summarizes a regulatory filing incorrectly; compliance team acts on the summary; correction requires external counsel review ($5,000 per incident × 4 incidents = $20,000). For financial, medical, or legal AI deployments, adjust to $50,000–$500,000/year. This parameter is intentionally highly adjustable.

The Risk Tier Multiplier — Justification

The three risk tiers (0.5×, 1.0×, 3.0×) are not arbitrary. They reflect the fundamental difference in downstream consequences of an AI error by use case:

11 — Module 7

ROI Analysis & Productivity J-Curve

The J-Curve is the single most significant addition in v2 relative to standard AI ROI tools. McKinsey, BCG, and Prosci change management research consistently documents that introducing any major technology change causes a temporary productivity decline before sustained improvement. In AI deployments, this dip is particularly pronounced because workers must simultaneously learn new tools, redesign their workflows, and compensate for AI errors while still meeting output targets.

J-Curve Phase Decomposition

Module 7 — Year 1 Implementation Cost (J-Curve)
// Phase 1: Technical integration (data prep, API build, testing, deployment) phase_1_cost = technical_integration_input // direct input, $15,000 default // Phase 2: Workflow redesign (change management, process mapping, SOPs) phase_2_cost = workflow_redesign_input // direct input, $10,000 default // Phase 3: Productivity dip penalty // The employee delivers dip_pct% less output during the transition period. // Economically: you pay full employee cost + full AI cost but receive only // (1 - dip_pct) of normal output. The dip cost is the value of lost output. phase_3_dip_cost = emp_true_cost_N × dip_pct × (dip_months ÷ 12) // Total Year 1 implementation cost (replaces static "setup cost" from v1) year_1_impl_cost = phase_1_cost + phase_2_cost + phase_3_dip_cost

J-Curve Parameter Justification

PhaseDefault CostResearch Basis
Phase 1: Technical Integration $15,000 McKinsey AI Adoption Study (2023): average internal AI deployment integration budget for mid-scale projects: $25,000–$150,000 for enterprise; $10,000–$50,000 for team/department scale. Default $15,000 represents a single-team deployment with an existing API provider relationship and reasonable data availability. Complex enterprise deployments with legacy system integration should use $50,000–$250,000.
Phase 2: Workflow Redesign $10,000 Gartner (2024): 30%–50% of AI project failures are attributed to change management failures, not technical ones. BCG AI research (2023): organizations that invest in workflow redesign achieve 3× higher AI adoption rates. The $10,000 default represents ~100 hours of an internal PM/BA at $100/hr for process mapping, SOP rewriting, stakeholder workshops, and documentation. External change management consulting: 3–5× this figure.
Phase 3: Productivity Dip (3 months, 15%) $3,188 (at defaults) BCG Change Management Research (2023) and McKinsey survey data: documented productivity dips during technology transitions average 10%–20% below baseline for 2–4 months. The 15% × 3 months default: at $85K salary ($7,083/month): 0.15 × 3 × $7,083 = $3,188. This is the cost of the productivity gap — the organization pays full employee cost but receives 85% of normal output while the team learns the system. Higher dip (25%–35%) is observed for complex agentic workflows requiring significant process redesign.

NPV and Payback Period Formulas

Module 7 — NPV and Payback Calculations
// Annual savings (Year 2+ normalized; Year 1 net of implementation cost) annual_savings = emp_true_cost_N - primary_ai_annual_cost // Payback period: months to recoup Year 1 implementation cost from monthly savings monthly_savings = annual_savings ÷ 12 payback_months = year_1_impl_cost ÷ monthly_savings // If monthly_savings ≤ 0, payback is infinite (AI costs more than employee) // 3-Year NPV at discount rate r (standard DCF methodology) // Year 1: savings minus implementation cost (one-time) // Years 2–3: recurring annual savings only npv = (annual_savings - year_1_impl_cost) ÷ (1 + r)¹ + annual_savings ÷ (1 + r)² + annual_savings ÷ (1 + r)³ // Cost per unit of output (normalized comparison) // AI handles (tasks_per_day × days) annual tasks // Employee (at productivity_multiplier) handles annual_tasks / multiplier tasks cpu_ai = primary_ai_annual ÷ annual_tasks cpu_employee = emp_true_cost_N ÷ (annual_tasks ÷ productivity_multiplier)

Discount rate default (8%): Represents the approximate WACC for a US large-cap technology company as of 2024. For smaller organizations with higher cost of capital, use 10%–15%. For public sector or non-profit contexts, use 3%–5% (government borrowing rate equivalent).

12 — Integration

Model Integration & TCO Aggregation

How the individual modules combine into the final TCO comparison. This section documents the aggregation logic, shared cost allocation, and risk premium application.

Full TCO Aggregation Formula
// ── SHARED COSTS (apply to both Cloud AI and Private AI) ──── shared_costs = annual_hosting // M4A + M4B (hosting + data pipeline) + annual_security // M5 (cybersecurity) + annual_process_fail // M6 (failures, risk-tiered) + residual_human // M2 (oversight fraction) // ── CLOUD AI TOTAL (before risk premium) ──────────────────── cloud_ai_base = cloud_ai_token_cost // M2 (tokens + agentic + concurrency + tooling) + shared_costs // ── PRIVATE AI TOTAL (before risk premium) ─────────────────── private_ai_base = private_ai_cost // M3 (GPU + MLOps + licensing) + shared_costs // Note: hosting/security/failure costs are shared because private AI // deployments still require the same hosting infrastructure, security // posture, and face the same process failure risks as cloud deployments. // ── RISK PREMIUM APPLICATION ───────────────────────────────── // Applied as a gross-up multiplier over ALL AI costs // Represents operational, regulatory, and reputational risks // not fully captured in the individual modules above. cloud_ai_annual = cloud_ai_base × (1 + risk_premium_pct) private_ai_annual = private_ai_base × (1 + risk_premium_pct) // ── EMPLOYEE TRUE COST ─────────────────────────────────────── employee_annual = emp_true_cost_N // M1 (headcount-scaled) // Note: no risk premium applied to employee cost — // employee risk (turnover, error) already embedded in M1 formula.

The "Hidden Cost Exposure" Calculation

The Hidden Cost Exposure panel identifies what percentage of total AI cost comes from the categories vendors exclude from their ROI pitches:

Hidden Cost Exposure
// Components systematically omitted from vendor ROI tools: hidden_total = annual_hosting // hosting + data pipeline + annual_security // cybersecurity module + annual_process_fail // process failure module + agentic_loop_cost // agentic overhead (if enabled) + concurrency_cost // PTU + SLA + retry costs hidden_pct = hidden_total ÷ cloud_ai_base × 100
13 — Sensitivity & Limitations

Sensitivity Analysis & Known Model Limitations

Every model has boundaries. Transparency about limitations is not a weakness — it is the mark of a rigorous tool. The following limitations are documented so that users can make informed judgments about where the model's outputs should be treated as directional estimates versus precise forecasts.

High-Sensitivity Parameters

The following parameters have the largest impact on total cost outcomes and should receive the most attention from users who want to stress-test results:

ParameterImpact DirectionSensitivity Note
base_salaryDrives employee cost, residual human cost, J-Curve dipA 20% salary change propagates through the turnover cost, management overhead, residual human, and J-Curve dip — amplifying the base effect by ~1.6×. The most important single input in the model.
loop_depth (agentic)Multiplies token cost 4–10×At loop depth 8 vs. 3, token cost can differ by 300%–500%. For agentic deployments, this is the most important cost variable and should be validated empirically against actual production logs.
oversight_pctDetermines residual human costMoving from 20% to 5% oversight changes the residual human cost from $30,400 to $7,600 at defaults — a $22,800/year swing. This parameter requires honest assessment; organizations frequently underestimate ongoing human review requirements.
failure_rate + risk_tierProcess failure cost varies 6× across risk tiersThe combination of failure rate and risk tier is the most uncertain combination in the model. Failure rates should be measured empirically after deployment. Risk tier selection requires honest use-case assessment, not aspirational positioning.
conc_peak (concurrency)Triggers PTU regime changeMoving from 40 to 60 peak concurrent users can change the cost structure from variable to semi-fixed, potentially adding $6,000–$12,000/month. This is a step-function change, not a smooth scaling, and is a common deployment planning surprise.

Known Model Limitations

  1. Linear cost scaling within modules. The model scales most costs linearly with headcount. In practice, many AI infrastructure costs exhibit economies of scale above certain thresholds — a single AI deployment serving 10 employees vs. 100 may not cost 10× more. The model will overestimate costs at very large scales without adjusting unit costs accordingly.
  2. Single geography assumption. The model does not account for geographic variation in salary benchmarks, electricity costs, tax rates, or regulatory compliance requirements. A deployment in London vs. San Francisco vs. Bangalore has materially different cost structures that require manual adjustment.
  3. Static pricing assumption. Token prices have declined significantly over time (GPT-4 prices dropped ~75% from 2023 to 2025). The model uses current prices and does not model future price trajectories. Multi-year NPV calculations assume constant AI costs, which is likely conservative for the AI side.
  4. Industry-neutral defaults. The default parameters are calibrated for knowledge workers in technology, professional services, and finance. Healthcare, manufacturing, education, and government contexts may have significantly different benefits loads, regulatory requirements, failure cost consequences, and productivity dynamics.
  5. No modeling of capability improvement. The model captures cost but not the improvement in AI capability over time (better models, improved prompting techniques, accumulated fine-tuning data). The ROI of AI likely improves over time; this model presents a static Year-N snapshot.
  6. The hallucination cost is the least certain parameter. The $20,000/year default for hallucination-driven decision costs is an order-of-magnitude estimate based on Gartner survey data. Actual costs vary enormously by use case. Organizations should replace this default with their own empirical estimates as quickly as possible after deployment.
  7. J-Curve duration and depth are difficult to predict pre-deployment. The 3-month, 15% dip defaults are research-based midpoints. Some organizations adapt quickly (1 month, 5% dip); others struggle (6+ months, 30% dip). The J-Curve is one area where the model strongly encourages users to override defaults with organizational context.
14 — Competitive Positioning

Comparison to Competing Calculators

To establish the model's position relative to existing tools, this section benchmarks against the major categories of AI ROI calculators currently in use in enterprise procurement contexts.

Category 1: Vendor-Provided ROI Tools

Examples: OpenAI for Enterprise ROI Calculator, Microsoft Copilot ROI Guide, Salesforce Einstein ROI estimator.

These tools share a common structural bias: they are designed to accelerate purchase decisions, not to support rigorous capital allocation analysis. Their typical structure is: (Tasks saved per week × hourly rate) − (Token cost per task × volume) = Savings. This omits hosting, security, process failure, data pipeline, and change management costs entirely. In the model's terms, they capture approximately 20%–35% of total AI system cost and 0% of implementation friction.

Category 2: Generic SaaS TCO Frameworks

Examples: Gartner TCO Wizard, generic cloud cost calculators.

Standard SaaS TCO frameworks capture hosting and some security costs but were designed before generative AI became a deployment category. They lack: token cost modeling, agentic loop awareness, AI-specific security threat taxonomy, process failure dynamics (silent scale failure), and data pipeline maintenance costs. They also do not model the productivity J-Curve, which is more pronounced for AI than for traditional SaaS due to the workflow redesign required.

Category 3: Academic / Research Models

Examples: MIT Sloan AI ROI framework, McKinsey's AI value model.

Research models are methodologically rigorous but designed for strategic-level analysis, not operational decision-making. They model productivity multipliers and capability curves but typically lack the granularity to inform infrastructure architecture decisions (hosting tier selection, GPU count) or security budget allocation. This calculator complements rather than replaces them — it provides the operational cost substrate that research models assume as exogenous.

📌 Positioning Summary This model occupies the gap between vendor ROI tools (directionally biased, operationally shallow) and enterprise strategy frameworks (rigorous, but too abstract for procurement decisions). It is designed for the moment when a CFO, VP of Engineering, or Strategy Director needs to make an actual investment decision — not validate one already made. The deliberate inclusion of unfavorable AI cost categories (silent failures, security, data pipeline tax) is what distinguishes this from a sales tool. A model that only captures costs favorable to one option is not a planning tool; it is a pitch deck.
15 — References

Full Reference List

All 19 primary sources cited in the model, with notes on specific claims and default values derived from each.

📋 Model Update Policy Data vintage: All references reflect publications available as of Q1 2025. Three input categories are particularly subject to rapid change and should be reviewed quarterly: (1) Token pricing — model pricing has declined 40%–80% per year across providers; (2) GPU hardware costs — H100 supply constraints have eased significantly through 2024; (3) PTU/reserved capacity pricing — Azure, AWS, and Google are actively adjusting enterprise AI pricing structures. The model's formula structure remains valid; only the default input values require updating as market pricing evolves.

AI vs. Employee TCO Calculator — Model Methodology Reference v2.0 · For planning purposes only · All defaults are midpoints of published research ranges

Related: AI vs. Employee cost by role · Open dataset (132 rows) · Named frameworks · Insights & research · Advisory · Open the calculator