Customer support was always going to be one of the first places AI agents landed at scale. The inputs are natural language. The tasks require judgment. The volume is high. The cost of manual handling is significant. It’s a near-perfect fit.

A year into seeing teams deploy support agents on Korelos, a few patterns have become clear about what separates the deployments that work from the ones that don’t.

What’s working

The teams getting the best results are treating agents as a first-pass resolution layer, not a full replacement for human support. An agent handles the 70% of tickets that follow recognisable patterns: order status, refund requests, password resets, account questions. It escalates cleanly when it encounters something outside its scope.

This approach consistently achieves 60-70% ticket deflection without degrading CSAT scores, which was the fear going in for most teams. When the agent escalates well, users don’t feel like they’ve been stonewalled. They feel like the agent tried and knew its limits.

What isn’t working

Two failure modes come up repeatedly. The first is over-scoping the agent’s initial capabilities. Trying to make one agent handle everything creates a system that handles nothing particularly well. Starting narrow and expanding beats starting broad every time.

The second is poor escalation design. An agent that can’t gracefully hand off to a human, complete with the context of what it tried and why it failed, creates a worse experience than no agent at all. Escalation is a feature, not a fallback.

The tools that matter most

Across all the support agent deployments we’ve seen, there are four tool integrations that show up in every high-performing setup:

• Order/account lookup (read access to your core data)
• Ticket creation (for creating support records and escalating)
• Knowledge base search (for policy and product questions)
• Action execution (refunds, cancellations, plan changes — with appropriate guardrails)

The last one is where most teams are cautious, and reasonably so. Giving an agent write access to take actions on behalf of users requires careful scoping and robust logging. But it’s also where the biggest resolution rate gains come from.

Getting started

If you’re considering a support agent deployment, the fastest path to something useful is to pull your last 500 tickets, categorise them by type, and identify the three highest-volume categories that follow a predictable pattern. Build an agent that handles exactly those three categories well. Ship it. Measure. Expand from there.

The teams that try to solve every ticket type in the first version rarely ship. The teams that start with a narrow scope almost always do.