Enterprise AI agent use cases: a practical guide to what survives production

In February 2024, Klarna announced that its AI assistant was handling two-thirds of all customer service chats — 2.3 million conversations in its first month, the equivalent workload of roughly 700 human agents. Fifteen months later, the same company was recruiting humans back into support, with CEO Sebastian Siemiatkowski conceding that cost had been “a too predominant evaluation factor.” Same technology. Same company. Opposite headlines.

That arc is the honest shape of enterprise AI agents as of early 2026. Gartner predicts that over 40% of agentic AI projects will be cancelled by the end of 2027, citing escalating costs, unclear business value, and inadequate risk controls. MIT researchers found that 95% of generative AI pilots deliver no measurable P&L return. And yet, over the same period, companies have shipped agents that autonomously resolve most of their tier-1 support volume — and published the numbers.

Both things are true because failure isn’t randomly distributed. It clusters around specific shapes of use case, and so does survival. This post separates the two lists — the AI agent use cases that keep clearing production, and the ones that get quietly cancelled — then derives five selection criteria you can apply before committing a build budget to either.

The cancellation wave: what the numbers actually say

Start with the scale of the experiment. Deloitte predicted that 25% of companies using generative AI would launch agentic AI pilots in 2025, growing to 50% in 2027 — while warning, in the same report, that agents “can make mistakes and get stuck in loops.” Both halves of that prediction have aged well. Pilots are everywhere. Production is rarer.

McKinsey calls the result the gen AI paradox: nearly eight in ten companies report using generative AI, yet just as many report no significant bottom-line impact. In its analysis, roughly 90% of function-specific “vertical” use cases — the ones that were supposed to move real numbers — remain stuck in pilot mode. The MIT NANDA study reached a similar conclusion from different data: the divide between the 5% that extract value and the rest comes down to integration and workflow fit, not model quality. Notably, purchased vendor solutions in that study reached deployment about twice as often as internally built ones.

Gartner adds a supply-side reason for the mess. Of the thousands of vendors selling “agentic AI,” it estimates only about 130 offer genuine agentic capability — the rest are rebranded chatbots, RPA, and assistants, a practice it calls “agent washing.” Its analysts describe most current projects as early-stage experiments, driven by hype and often misapplied.

So the 40% cancellation prediction isn’t a verdict on the technology. It’s a verdict on use-case selection. Which makes the survivors worth studying closely. (If you want a working definition of what counts as an agent in the first place, we’ve written one that survives contact with production.)

Five AI agent use cases that keep surviving production

These are the categories where, by early 2026, you can find named companies, published numbers, and — crucially — second-year renewals rather than quiet sunsets. Where the numbers come from vendor case studies, we say so; treat them as marketing-reviewed best cases, not audited averages. The pattern across them still holds.

1. Tier-1 customer service deflection

This is the flagship, and the evidence base is the deepest. Salesforce runs its own agent on its public help site and, as customer zero, publishes the telemetry: more than two million conversations handled since October 2024, with the Japanese-language launch alone reaching 50,000 conversations at a 77% resolution rate. The write-up is candid about the method — a deliberately limited rollout, weekly performance reviews, and continuous tuning of content and retrieval based on real transcripts.

Customer examples follow the same shape. Salesforce’s published case studies report that 1-800Accountant reached 70% autonomous resolution of chat engagements during tax season while cutting seasonal hires by half, and that Wiley improved case resolution by over 40% compared with its previous scripted chatbot in the first weeks of use. On the same page, e-paper maker reMarkable reports its FAQ agent went live in about three weeks and has handled over 18,000 service conversations.

Why does this use case survive? Volume is high, intents are repetitive, the answer usually lives in a knowledge base, and the failure mode is graceful — the agent escalates to a human with context. Nobody dies when a password-reset question gets handed off.

2. IT service desk triage and resolution

Internal IT support is arguably an even better fit than customer service, because the users are employees and the requests are ruthlessly repetitive. Moveworks’ case study with Mercari US reports 74% of IT tickets resolved autonomously, with 94% of employees going to the bot first and roughly 8,000 hours of routine IT work saved per month — a vendor’s numbers, but a four-person IT team supporting a growing company is hard to fake.

Worth noticing: Mercari deployed that system in 2021, before the current agent hype cycle. Bounded IT triage worked even with older NLU technology, which tells you the use case’s shape — not the model generation — is what carries it. The category has since been productised outright: Salesforce launched Agentforce IT Service in October 2025, citing research that employees lose an average of 352 hours a year to IT issues. Vendors productise what’s already working in the field, not what might.

3. Sales development and lead qualification

The job here is narrow and brutally measurable: respond to inbound leads fast, ask qualifying questions, book the meeting, hand off. Salesforce’s customer stories page reports that equipment maker Equipter cut inbound lead response from nearly a day to just hours with an SDR agent rolled out in a few weeks, and that staffing-software firm Asymbl claims coverage equivalent to a sales team five times larger, saving $575K annually. Vendor-published figures, again — but the underlying mechanism is plausible because speed-to-lead is a well-documented conversion lever that humans are structurally bad at outside business hours.

The error envelope helps too. A slightly awkward qualification email costs a little goodwill. It doesn’t cost a regulatory filing.

4. Knowledge retrieval and grounded internal Q&A

The least glamorous survivor. Agents that answer “what’s our parental leave policy?” or “which contract clause applies here?” from indexed internal content are everywhere, precisely because they’re read-only: a wrong answer wastes minutes, not money, and a citation lets the user verify. McKinsey notes these horizontal assistants scaled faster than any other category — while warning their gains are diffuse and hard to measure.

That warning is the survival condition. In practice, the retrieval agents that persist are the ones with an owner and a metric — search deflection, ticket avoidance, onboarding time — and the ones that get cancelled are the ones nobody measured. Same technology, different discipline.

5. Coding assistants, with a human holding the merge button

Software development has the cleanest controlled evidence of any category. GitHub’s experiment found developers using Copilot completed a standardised task 55% faster — 1 hour 11 minutes versus 2 hours 41 minutes across 95 professional developers. That study dates to 2022, and the tooling has since moved from autocomplete toward genuinely agentic multi-step work.

But note what survives: assistance inside a deterministic verification loop. Code review, tests, and CI form a substrate that catches agent mistakes before they ship. The developer stays accountable for the merge. That’s not a limitation of the use case — it’s the reason it works.

The quiet cancellations: three patterns that don’t make the keynote

Cancelled agent projects rarely get press releases. But the post-mortems that do surface — plus Gartner’s and MIT’s failure analyses — repeat three patterns.

Fully autonomous agents on complex, high-stakes workflows

Klarna is the canonical case precisely because it wasn’t a technology failure. The assistant genuinely handled millions of chats and cut resolution times. What broke was the error envelope: complicated, emotionally loaded cases got generic answers, quality metrics sagged, and by May 2025 the company was rebuilding human support around the AI, with Siemiatkowski insisting customers must always be able to reach a person. The lesson isn’t “don’t automate support.” It’s that autonomy was extended past the point where mistakes were cheap.

The same logic sinks most end-to-end process automation pilots. Every additional autonomous step multiplies the chance that one step is wrong, and long workflows put irreversible actions — payments, cancellations, contract changes — inside the blast radius. Deloitte flagged this in 2024: agents that impress in controlled settings get stuck in loops and make mistakes in the wild. In our experience, these projects don’t fail loudly; they get demoted to “human-in-the-loop drafting tools” and then defunded.

Agents grounded in broken data

MIT’s core finding was that failures trace to flawed enterprise integration — tools that don’t learn from or fit the workflow — not model quality. We see the concrete version of this constantly: an agent pointed at a knowledge base that’s three years stale, duplicate customer records that make account lookups a coin flip, or policies that exist only in a retired employee’s inbox. The agent then answers confidently from bad ground truth, trust evaporates after a handful of visible errors, and the pilot dies in review.

This is why the unfashionable work — deduplication, knowledge-article hygiene, data model cleanup — is the highest-return agent investment most organisations can make. It’s most of what a serious data and AI strategy engagement actually consists of.

The agent-for-everything platform

The third pattern is scope. A program launches with a mandate to “deploy agents across the enterprise,” picks a platform before picking a problem, and eighteen months later has a demo library and no P&L line. Gartner’s agent-washing finding feeds this directly: when only ~130 of thousands of vendors offer real agentic capability, platform-first buying frequently means paying agent prices for a rebranded chatbot. The survivors we listed above all started the other way around: one queue, one metric, one team that owned the outcome.

Five selection criteria that separate survivors from pilot-ware

Put the two lists side by side and the pattern is not subtle:

Dimension	Survives production	Gets quietly cancelled
Scope	One queue, bounded intents	”Transform the enterprise”
Success metric	Deflection, resolution, speed-to-lead — visible weekly	”Productivity”, unmeasured
Cost of a wrong answer	Escalation, mild embarrassment	Irreversible action, compliance exposure
Grounding data	Curated, owned, fresh	Whatever the data lake contains
Execution layer	Deterministic actions (Flow, Apex, API) the agent invokes	The agent improvises the procedure itself

Spelled out as tests you can apply to any proposal:

• Bounded scope. Can you write the agent’s job description in one sentence, and enumerate the intents it must handle? If the answer is “it depends,” it’s a research project, not a deployment.
• Measurable outcome. Is there a number — with a baseline — that moves within a quarter if the agent works? Every survivor above had one. Salesforce reviews its help-site agent’s metrics weekly; the cancelled projects mostly never defined theirs.
• Tolerant error envelope. When the agent is wrong, what happens? “It escalates with context” is survivable. “A customer’s contract gets cancelled” is not, and Klarna showed that even “a frustrated customer gets a generic answer” compounds at scale.
• Clean grounding data. Does the content the agent will cite actually exist, and is someone paid to keep it current? An agent inherits every defect in its sources, then amplifies them with confidence.
• A deterministic substrate to call. The pattern we recommend in every build: the agent decides whether to act; tested code — a Flow, an Apex method, a versioned API — decides how, identically every time. Agents that improvise procedures fail unpredictably. Agents that invoke procedures fail loudly and safely.

Score a candidate use case against all five. In our experience, four or five yeses describes every production survivor in this post; two or fewer describes the cancellation statistics.

How to score your own AI agent use case before you build

Turning the criteria into a working evaluation takes an afternoon, not a quarter. The sequence we use:

1. Pick the queue, not the platform. Find the highest-volume, most repetitive stream of requests in the business — support tier 1, IT tickets, inbound leads — and pull three months of real transcripts or cases.
2. Classify the intents. Typically a small number of intent types dominate the volume. Those are your agent’s scope. Everything else is an escalation path, on purpose.
3. Price the outcome. Volume × cost per contact × a conservative resolution rate gives you the ceiling of the business case. Run your own numbers through our Agentforce ROI calculator before any vendor runs theirs.
4. Audit the grounding. For each in-scope intent, check the answer exists somewhere authoritative and current. Gaps here are your real project plan.
5. Define the error budget in writing. Which actions may the agent take autonomously, which need approval, which are out of scope entirely — decided before the build, by someone accountable for the queue.

Then launch narrow, watch the transcripts, and expand scope only when the metrics have earned it. That’s not caution for its own sake; it’s the exact method behind the two-million-conversation deployment.

The unglamorous shape of agents that last

There’s a version of this story where the cancellation statistics prove agents were hype. The evidence doesn’t support that reading. It supports something less dramatic and more useful: agents are a real capability with a narrow current sweet spot, and the market is in the process of finding its edges the expensive way.

The trajectory still points up. Gartner expects agentic AI to autonomously resolve 80% of common customer service issues by 2029, and — in the same breath as its cancellation prediction — forecasts that 15% of day-to-day work decisions will be made autonomously by 2028. Both futures arrive through the boring door: one bounded queue at a time, each with an owner, a metric, and a substrate of deterministic actions underneath.

Which means the capability that matters in 2026 isn’t prompt engineering or model selection. It’s use-case selection — the discipline to pick the queue where the volume is high, the errors are cheap, and the data is clean, and to say “not yet” to everything else. Get that right and the production numbers take care of the renewal conversation. Get it wrong and you become part of a Gartner statistic. The good news: unlike model behaviour, this part is entirely within your control.

Understanding the basics

Which AI agent use cases are proven in production?

By early 2026, five categories have the strongest public evidence: tier-1 customer service deflection, IT service desk triage, sales development and lead qualification, grounded knowledge retrieval, and coding assistants. Published deployments report autonomous resolution rates roughly in the 70–85% range for bounded support queues — figures that come from vendors and their customers, so treat them as best cases rather than averages.

Why do so many AI agent projects get cancelled?

Gartner predicts over 40% of agentic AI projects will be cancelled by end of 2027, citing escalating costs, unclear business value, and inadequate risk controls. The common failure patterns are giving agents autonomy over high-stakes workflows where errors are expensive, grounding them in stale or messy data, and platform-first programs that never picked a measurable problem. Model quality is rarely the root cause.

What makes an AI agent use case production-ready?

Five properties, in practice: a bounded scope you can describe in one sentence; a measurable outcome with a baseline; a tolerant error envelope where the worst case is escalation, not an irreversible action; clean, owned grounding data; and a deterministic execution layer — tested code or APIs the agent invokes rather than procedures it improvises. Use cases with four or five of these traits dominate the survivor list.

---

Trying to work out which agent use case in your org would actually survive production? Talk to us — it’s what we do.