Cost-to-Serve Benchmarks by Vertical: What an AI Agent Actually Costs to Run, Industry by Industry

Table of Contents

• Why "cost-to-serve" beats "cost-per-token" as the benchmark
• The anatomy of cost-to-serve for an agent
• Benchmarks by vertical
• Customer support agents
• Coding agents
• Sales development agents
• Legal and contract agents
• Healthcare and clinical agents
• Financial-services agents
• Why the same task costs 10x more in one vertical than another
• How to benchmark your own cost-to-serve
• Insights Most People Overlook
• References

Why "cost-to-serve" beats "cost-per-token" as the benchmark

Talk to most agent founders about their economics and they'll quote you a token price. "We're on the cheap model, it's like fifteen cents per million input tokens." That number is almost useless for understanding whether the business works.

Cost-to-serve is the all-in cost of delivering one unit of customer value, one resolved ticket, one merged pull request, one qualified meeting booked, one contract reviewed. It rolls up every model call, every retry, every tool invocation, every sub-agent spawn, plus the unglamorous stuff: vector storage, orchestration compute, observability, and the human who steps in when the agent gets stuck. Token price is one input. Cost-to-serve is the answer.

The distinction matters because the relationship between tokens and outcomes is wildly nonlinear across verticals. A simple FAQ deflection and a multi-system billing reconciliation both "use tokens," but one resolves in a single call and the other can spawn a dozen tool calls, three retries, and a human escalation. If you benchmark on tokens, you'll conclude they cost roughly the same. They don't. This is the same trap covered in our piece on cost-per-completed-task as the category's core unit, the unit has to be the outcome, not the input.

For GaaS specifically, cost-to-serve is the metric that determines whether per-task or per-outcome pricing can ever clear a margin. If you don't know your true cost-to-serve by vertical, you're pricing blind.

The anatomy of cost-to-serve for an agent

Before the benchmarks, it helps to name the cost components, because the mix differs by vertical and that mix is the whole story.

Inference (the obvious one). Input and output tokens across every model the agent touches. In reasoning-heavy verticals, "thinking" tokens dwarf the visible output, a topic we treat at length in the broader cluster. For most agents this is 40-70% of cost-to-serve, but it is rarely the part that surprises operators.

Retries and reruns. When an agent fails a task and tries again, the meter keeps running. A 15% retry rate doesn't add 15% to cost, because failed attempts often burn nearly a full task's worth of compute before failing, a high-retry vertical can quietly double its cost-to-serve. This is the single most underestimated line item.

Tool and API calls. Every search, every database query, every call to an external paid API (a credit check, a code-execution sandbox, a CRM write). In some verticals these out-of-pocket costs exceed inference entirely.

Sub-agent fan-out. Orchestrator-worker architectures spawn child agents, and each child has its own token bill. Fan-out is great for quality and brutal for cost predictability.

Storage and memory. Vector databases, conversation history, long-running context. Small per-task, real at scale.

Human-in-the-loop. The escalation backstop. In regulated verticals this is the dominant cost, and pretending otherwise is how vendors fool themselves on margin.

Hold those six buckets in mind. The benchmarks below are really just different mixes of the same ingredients.

Benchmarks by vertical

A note on these numbers: they're grounded ranges for mid-2026, assuming frontier-class models for hard steps and cheaper models for routing, with reasonable caching. They are directional, not gospel, your architecture can move you a full tier in either direction. I've expressed each as a cost-to-serve range per completed unit of value, plus the dominant cost driver, because the driver tells you where to optimize.

Customer support agents

Cost-to-serve: $0.03-$0.45 per resolved ticket; outliers to $3+ on complex disputes.

Support is the most-benchmarked vertical and the most bimodal. Tier-1 deflection, password resets, order status, simple FAQ, runs cheap because it's one or two model calls against a knowledge base. But "resolution" hides a long tail. A billing dispute that requires reading the subscription record, checking payment processor logs, applying a refund policy, and writing back to three systems can cost 50-100x a deflection.

The dominant driver here is tool-call volume, not inference. The agent spends most of its budget reaching into your CRM, billing, and order systems. Vendors who quote you "$0.05 a ticket" are quoting deflection economics and quietly eating the tail. For a full breakdown see our unit economics teardown of a customer-support agent at scale.

Coding agents

Cost-to-serve: $0.40-$12 per completed task (merged change); large refactors run higher.

Coding agents are expensive because the work is reasoning-dense and verification-heavy. A real "completed task", a merged PR that passes CI, involves reading a codebase, planning, generating, running tests, reading failures, and iterating. The iteration loop is where cost lives. It's not unusual for a single non-trivial task to involve dozens of model calls and several full test runs in a code-execution sandbox, which is itself a metered cost.

The dominant driver is the retry/iteration loop plus sandbox compute. Coding agents have the widest intra-vertical spread of any category: a one-line fix and a multi-file feature are both "tasks" but differ by an order of magnitude. Anthropic's own engineering writeups on multi-agent systems make the point that agentic coding workflows trade token spend for capability, you're buying iterations. Our coding-agent unit economics teardown digs into the at-scale picture.

Sales development agents

Cost-to-serve: $0.08-$0.60 per qualified lead action; $2-$8 per booked meeting.

SDR agents look cheap per email and expensive per outcome, which is exactly the lens you should use. Drafting a personalized outreach email is a few calls plus some enrichment lookups. But the meaningful unit is a booked meeting, and conversion math means you're paying for dozens of outreach actions per meeting that lands.

The dominant driver is data-enrichment API costs, not inference. Pulling firmographic and contact data from paid providers often costs more than the model does. This is the vertical where "we'll just pass through model costs" pricing collapses fastest, because the model isn't the cost. See the sales-development agent teardown.

Legal and contract agents

Cost-to-serve: $1.50-$25 per reviewed contract; higher for complex M&A or multi-document work.

Legal flips the cost profile entirely. Documents are long, so input-token volume is enormous, and the work demands the most capable (most expensive) models because errors carry real liability. Reasoning depth is high, the agent isn't pattern-matching, it's analyzing clauses against playbooks, jurisdictions, and prior versions.

The dominant driver is input tokens on premium models plus mandatory human review. Almost no serious legal agent runs fully autonomous; a lawyer checks the output, and that human time is the real cost-to-serve. Vendors who exclude it from their economics are publishing fiction.

Healthcare and clinical agents

Cost-to-serve: $0.50-$15 per completed task, with compliance overhead layered on top.

Healthcare cost-to-serve carries a tax that pure-token analysis never captures: audit logging, PHI handling, redaction pipelines, and human clinical review for anything touching patient care. A clinical-documentation agent summarizing a visit is moderately expensive on tokens; the compliance and review wrapper around it is where the money goes. McKinsey's work on generative AI's productivity potential repeatedly flags healthcare as high-value but high-friction, the friction is literally cost-to-serve.

The dominant driver is compliance overhead and mandatory human-in-the-loop. Autonomy is deliberately capped, which protects patients and inflates per-task cost.

Financial-services agents

Cost-to-serve: $0.20-$10 per completed task; fraud and underwriting at the high end.

Finance sits between support and legal. Simple tasks (transaction categorization, balance inquiries) are cheap. Underwriting, fraud investigation, and reconciliation are expensive because they fan out across many data sources and external paid services, credit bureaus, KYC providers, sanctions screening, each with its own per-call fee.

The dominant driver is third-party data and verification API costs, plus heavy audit requirements. Like legal and healthcare, regulatory exposure keeps a human in the loop on consequential decisions.

Why the same task costs 10x more in one vertical than another

Strip away the specifics and four structural forces explain the entire benchmark spread.

Reasoning depth. Some verticals need shallow pattern-matching; others need multi-step analysis. Deep reasoning means more thinking tokens, pricier models, and more iterations. Legal and coding sit at the deep end; tier-1 support at the shallow end. a16z's analysis of how AI is eating services frames this as agents climbing from low-value to high-value work, and the cost climbs with them.

Verification burden. The cost of being wrong sets the cost of being right. Where errors are cheap (a slightly-off support reply), you can run autonomous and skip review. Where errors are catastrophic (a misread indemnification clause, a wrong dosage), you bolt on human review and redundant checks. Verification burden is the single biggest swing factor between verticals, and it's almost entirely a human cost. We quantify this in how much "reliability" costs per task.

Tool and data dependency. Verticals that live inside other systems, support reaching into CRMs, sales pulling enrichment data, finance hitting credit bureaus, pay out-of-pocket per action. The model can be cheap while cost-to-serve stays high because the agent is mostly an orchestrator of paid external calls.

Context length. Long-document verticals (legal, some healthcare) eat input tokens by the hundreds of thousands per task. Even at low per-token rates, volume dominates.

Notice that only one of these four, reasoning depth, is really about the model. The other three are about the workflow the vertical demands. That's why benchmarking against another GaaS vendor in a different vertical is meaningless. You don't share a cost structure with them; you share a billing API.

How to benchmark your own cost-to-serve

If you operate an agent, here's a practical sequence to get a real number rather than a comforting one.

Define the unit honestly. Pick the outcome the customer pays for, not the action that's easy to measure. "Resolved ticket" not "message sent." If a ticket reopens, it wasn't resolved, count the rework.

Instrument the full call graph. Tag every model call, tool call, and sub-agent spawn with a task ID so you can roll costs up to the unit. Most operators can't currently answer "what did task #4471 cost end-to-end," and that's the gap. Per-task attribution is the foundation; see cost attribution for shared agent infrastructure for the harder multi-tenant version.

Include the failures. Your cost-to-serve is total spend divided by successful outcomes. Tasks that failed, retried, or escalated still cost money and still divide into a smaller success count. This is the step that turns an optimistic number realistic, often doubling it.

Load in the human and the infra. Add escalation labor, storage, and observability. If a human touches 8% of tasks, that 8% may be 40% of your cost-to-serve.

Segment, then watch the distribution. Report a median and a P90, not just a mean. Cost-to-serve distributions are long-tailed in every vertical; the mean hides the tickets eating your margin. Pricing off the mean while the tail runs unbounded is how usage-based agent businesses quietly go underwater, a dynamic explored in why churn is invisible in GaaS until it's catastrophic.

Do this once and you'll likely discover your true cost-to-serve is 1.5-3x your back-of-envelope estimate. That's not a failure of your agent; it's the difference between token price and reality.

Insights Most People Overlook

The cheapest vertical to enter is the worst one to benchmark against. Support deflection has the lowest cost-to-serve, so it's where everyone starts and where all the public benchmark numbers come from. Founders in legal or finance then anchor on those numbers and underprice catastrophically. The publicly-quoted "$0.05 per task" figures are essentially survivorship bias toward the easiest workflow in the easiest vertical.

Within-vertical variance usually exceeds between-vertical variance. Everyone debates whether coding agents cost more than support agents. But the spread inside coding (a typo fix vs. a migration) is often wider than the gap between the cheapest and most expensive verticals. A single blended cost-to-serve number for your own product is therefore close to meaningless, you need the distribution, and you need to price tiers against it.

Falling token prices barely move regulated-vertical economics. When the model is 60% of cost-to-serve, a token price cut helps. When you're in healthcare or legal and the model is 25% of cost-to-serve, the rest being human review and compliance, halving token prices moves your all-in cost by maybe 12%. The verticals that need cheaper AI the most benefit from it the least, because their costs are structurally human.

Tool-call costs scale with task value, perversely. The more valuable the outcome, the more systems the agent must touch to deliver it, the higher the out-of-pocket tool spend. So your highest-revenue tasks often carry your worst gross margin percentage, the opposite of the SaaS intuition where marginal cost trends to zero. Operators raised on software economics consistently get this backwards.

"Autonomy" is a cost lever disguised as a product feature. Every vertical can dial cost-to-serve down by lowering the autonomy threshold, escalating more borderline cases to cheap pattern-matching or to humans only when truly necessary, and refusing tasks outside the agent's competence. The vendors with the best margins aren't running the smartest agents; they're running the most disciplined ones about when not to engage.

References

• Anthropic, Building Effective Agents
• McKinsey, The Economic Potential of Generative AI: The Next Productivity Frontier
• Andreessen Horowitz (a16z), AI Is Eating the World