In February 2024, Klarna announced that an AI customer service assistant had handled 2.3 million conversations in its first month — work it equated to roughly 700 full-time agents — and projected about $40 million in annualized savings. Resolution time dropped from 11 minutes to under two. The story became the reference case for AI replacing white-collar labor at scale.
By mid-2025, Klarna's CEO was telling reporters the company had pushed automation too far. Customers were unhappy with generic answers on complicated cases — disputes, hardship situations, nuanced refunds — and Klarna began rehiring human agents for exactly those categories. The savings were real. So was the quality problem the initial dashboard didn't show. Both things were true at once, because Klarna had automated a mixed population of tasks — some cheap to get wrong, some expensive — as if it were one uniform task.
That's the pattern this article is about. AI doesn't have a fixed ROI. It has a cost curve that depends entirely on the shape of the task — its volume, its error tolerance, its variability, and how expensive a mistake is to catch and fix. Get the shape right and AI is often the best capital allocation decision a team will make all year. Get it wrong and the "savings" show up in the first-month dashboard while the costs quietly accumulate somewhere no one is tracking — in support tickets, in legal exposure, in the hours a senior employee spends re-checking a junior AI's work.
The Real Equation: Two Kinds of Cost
Most AI cost conversations only account for one side of the ledger: the direct, visible, itemized cost — the subscription tier, the per-token API bill, the compute for a fine-tuned model, the vendor contract. These costs are easy to model because someone sends you an invoice for them.
The second category is indirect and largely invisible in procurement conversations, because no one sends an invoice for it. It shows up instead as extra hours on someone's calendar, a slower quarter, a customer complaint, or a legal bill eighteen months later. This is the category that determines whether a deployment that looked profitable in month one is still profitable in month twelve.
In 2024, Air Canada's support chatbot invented a bereavement-fare policy that didn't exist. A tribunal ruled the airline liable for what its own chatbot told a customer, ordering it to honor the fabricated policy and cover damages. The chatbot itself was cheap to run. The cost that mattered was a legal ruling, a disabled product, and a story that outlived the savings by years. This is the hidden-cost category that almost never appears in an ROI spreadsheet: the cost of being wrong at the exact moment it's expensive to be wrong.
Where AI Reliably Saves Money
Across the deployments that hold up over time, a consistent shape emerges. AI saves money reliably when a task has most of these characteristics:
- High volume, low variance. The same kind of request, repeated thousands of times — categorizing tickets, extracting fields from invoices, drafting first-pass responses to routine questions. Fixed setup cost gets spread across enough units that the marginal cost per unit falls well below a human's.
- Cheap, fast-to-catch errors. If a mistake is caught within the same workflow — a formatting error, a mis-tagged category — the cost of being wrong is a re-run, not a customer escalation.
- A clear, checkable ground truth. Tasks where "correct" is unambiguous (did the invoice total match, is the code syntactically valid, does the summary include the key figures) are far easier to verify cheaply than tasks requiring judgment calls.
- Work that was previously a bottleneck, not a specialty. First-draft generation, transcription, data entry, and boilerplate code are usually bottlenecks that skilled staff resented doing — AI removing them frees up expensive human time for the parts of the job that actually need judgment.
- 24/7 coverage requirements. Tasks that would otherwise require shift staffing, overtime, or outsourced night coverage — after-hours support triage, monitoring dashboards, basic status updates — get cheaper almost by default, because the alternative was already expensive.
Klarna's early results were not fake. Two-thirds of a very large volume of genuinely routine conversations — password resets, order status, simple refund questions — were exactly the profile where AI's marginal cost advantage is real and durable. That part of the deployment kept working. It's the part that didn't fit this profile that caused the reversal.
Where AI Quietly Costs More
The same technology, applied to a task with the opposite shape, produces the opposite outcome — and it usually takes months to become visible, because the visible cost (the subscription) stays flat while the hidden cost accumulates elsewhere in the organization.
Low volume, high variance
If a task only happens occasionally and every instance looks different, there's no repetition for a fixed setup cost to amortize against. You pay integration and prompt-engineering costs for a task that a person could have just done directly, faster.
Expensive failure modes
When an error is discovered late — after it reaches a customer, a regulator, or a financial statement — the cost of that single failure can exceed years of subscription savings. This is the category the Air Canada case sits in: cheap per-interaction cost, catastrophic tail risk.
The verification tax
Every AI output that carries real consequences needs a human to check it. If checking takes nearly as long as doing the task would have, the "automation" has really just moved the work from doer to reviewer — often without reducing headcount or cost, only shifting where the effort sits.
Integration and pipeline debt
Connecting a model to real systems — CRM data, internal documents, authentication, audit logs — is where most of the actual engineering cost lives, and it doesn't shrink just because the per-token price of the underlying model does. This cost is paid once but maintained forever, through API changes, schema updates, and breaking changes upstream.
Shadow spend and tool sprawl
Individual teams adopting their own AI subscriptions — a writing tool here, a coding assistant there, a meeting-notes tool somewhere else — accumulates into a line-item nobody owns, with overlapping capabilities and no consolidated negotiating power.
Model drift and re-tuning
A model that performed well at launch can degrade as the real-world data it encounters shifts away from what it was tuned or prompted against, or as the underlying vendor model itself is silently updated. Nobody notices until output quality has already slipped for weeks.
Trust repair after a visible failure
Once a customer or employee has been burned by a bad AI output, rebuilding trust costs more than the original task would have — in support time, in churn, in the internal political cost of "we tried that and it didn't work" blocking future initiatives, including good ones.
The AI Cost Pipeline: Where Hidden Costs Enter
Just as with data bias, hidden AI costs don't appear at one single point — they accumulate across the lifecycle of a deployment, and the earlier you plan for them, the cheaper they are to manage.
The Break-Even Curve: Why Volume Changes the Answer
Because AI deployments typically carry a real fixed cost (integration, prompt design, evaluation, governance setup) alongside a low marginal cost per unit, the honest comparison against a human-staffed process isn't a single number — it's two lines that cross at a specific volume.
This is precisely why blanket claims like "AI cuts support costs by X%" travel so well and mislead so often — the percentage is true at the volume it was measured at, and silently false below the break-even point. Before approving an AI project, ask what volume it needs to reach to clear its fixed cost, and whether that volume is realistic for the specific task, not the department as a whole.
A Decision Framework: Should You Automate This With AI?
Rather than asking "can AI do this task," ask a sharper question: does this task have the cost shape where AI's advantages outweigh its liabilities? The following framework walks through the questions that matter most, roughly in the order they should be asked.
Six Real-World Use Cases, Scored
Applying the framework above to common business use cases produces a consistent, predictable split — not because AI is inherently good or bad at any of them, but because each carries a different volume, error-cost, and verifiability profile.
| Use case | Verdict | Why |
|---|---|---|
| 01 | Saves money | Invoice data extraction at high volume — repetitive, easy to spot-check against totals, cheap failure mode. |
| 02 | Mixed | Customer support triage — routine tier-one questions save money reliably; complex disputes and hardship cases quietly cost more once verification and trust-repair are counted, as Klarna found. |
| 03 | Costs more | Bespoke legal or policy answers delivered directly to customers with no review step — low volume, high error cost, exactly the shape behind the Air Canada ruling. |
| 04 | Saves money | First-draft code for well-specified, well-tested functions — fast to verify against existing test suites, high volume across a dev team. |
| 05 | Costs more | One-off strategic analysis or board memos — low volume, high stakes, and the verification time approaches the time it would have taken to write it directly. |
| 06 | Mixed | Marketing content drafting — cheap and fast for high-volume, low-stakes formats (social captions, product descriptions); costlier once brand risk and legal review are added for flagship campaigns. |
Prevention: How to Keep the Ledger Honest
- Model the fixed cost, not just the marginal cost. Before approving a project, estimate the integration, prompt-design, evaluation, and governance setup cost as a real number, and calculate the volume needed to clear it.
- Put a verification budget on every workflow, not just a token budget. If checking the output takes nearly as long as doing the task, the workflow isn't saving money — it's moving the work.
- Separate "cheap to be wrong" from "expensive to be wrong" before you scope the project, not after an incident. The same model can be deployed with light-touch review on one task and mandatory sign-off on another.
- Track total cost of ownership on a schedule, not just at launch. Re-run the ROI calculation quarterly — drift, tool sprawl, and vendor price changes all move the number after the initial business case was approved.
- Consolidate tool spend centrally. An inventory of every AI subscription across departments, reviewed quarterly, usually surfaces overlapping tools long before finance would otherwise notice.
- Price in the reversal cost. If the deployment fails, what does it cost to unwind — rehiring, retraining, rebuilding customer trust? Klarna's answer to that question in 2025 was expensive enough to make headlines twice.
The cheapest AI mistake is choosing the wrong task to automate. Every other cost on this page is a consequence of that first decision.
A Quick Pre-Deployment Checklist
- Fixed setup cost estimated in real currency, not "it's basically free to try"
- Break-even volume calculated and checked against realistic task volume
- Failure cost for a wrong output identified — and whether it's cheap or expensive to catch
- Verification time budgeted explicitly, with an owner assigned
- Human sign-off required for any output reaching a customer, regulator, or contract
- Tool added to a central inventory to avoid duplicate departmental spend
- Quarterly re-evaluation scheduled to catch model drift and price changes
- A named person accountable if the deployment needs to be unwound
Frequently Asked Questions
Yes, and it's more common than either extreme. Many deployments land close to break-even once verification time is counted honestly — the real benefit shows up as freed-up time for higher-value work rather than a direct cost reduction. That's still a legitimate reason to automate, but it should be evaluated on those terms, not sold internally as a straightforward cost cut.
Run a small pilot and time how long a qualified reviewer actually takes to check a representative sample of AI outputs, including the ones that need correction, not just the easy ones. Compare that to the time the task would have taken a person to do directly. If verification time is more than roughly half of the original task time, the automation case is weak unless volume is very high.
The early numbers were genuinely accurate for the population of tasks measured — mostly high-volume, low-complexity queries. The problem was applying one aggregate success metric to a mixed population that included harder, lower-volume, higher-stakes cases. The dashboard reported an average; the costly failures were hidden in the distribution around it.
Low volume combined with an expensive failure mode. That combination almost never clears its fixed setup and verification cost, no matter how capable the underlying model is. It's less a technology problem than a task-selection problem, which is why the decision framework in this article starts with volume and error cost, not with model capability.
Not necessarily — smaller teams can still benefit from low-fixed-cost tools (off-the-shelf assistants rather than custom integrations) applied to genuinely repetitive tasks, where the setup cost is small enough to clear break-even quickly even at modest volume. The framework still applies; the fixed-cost side of the equation is just smaller when you avoid custom-building everything from scratch.
Related Reading
This article is part of a series. These go deeper on ideas introduced above: