I'm going to tell you what actually happened when we moved our support escalations onto an agent, because the before and after are less dramatic than you'd think, and the details we kept human are the part nobody writes about.
Support escalations were the obvious workflow to automate. They were repetitive. They followed a pattern. And they were drowning the humans who answered them. Every day, tickets that should have been handled with existing context bounced to a person who had to rebuild that context from scratch.
We didn't automate escalations to save money. We did it because the people answering them were spending their time on paperwork, and the customers were waiting.
The workflow we built
We started small. One path: incoming ticket, classification, context gathering, draft reply, send.
The classification agent decides what the ticket is. Billing, bug, onboarding, account access. That's the first thing it does, and it does it fast, because classification is cheap and the cost of being wrong is another agent correcting it later.
The context agent pulls everything relevant to the ticket. The account history, the last three messages, the plan they're on, the bug report if there's one. That context becomes the draft's raw material.
The drafting agent writes the reply. Then the sending step pauses.
That pause is the whole ballgame, so let me talk about it properly.
What we kept human
We kept one thing human: the send.
Every reply the agent writes gets looked at by a person before it goes. Not for tone. The agent's tone was fine from week one. A person looks at it because a support reply that's wrong in a way the customer will catch costs us more than the seconds of review do. A wrong refund amount. A promise that contradicts the plan. A fix that doesn't apply to their environment.
The reviewer sees three things. The draft. The ticket. And the context the draft was built on. Not a dump. Three readable blocks. Approve, edit, or send.
What surprised us was how fast the approval got. Week one, reviewers were editing half of them. Week four, maybe one in ten needed a touch. The agent learned the house style not through prompting but through edits. We didn't tell it to sound like us. We reviewed it into sounding like us.
Week six, the same reviewer who'd been drowning in tier-one escalations was handling the intro level and the escalated level, because the agent absorbed the first two hours of her day.
The numbers
Four months in, the numbers aren't dramatic. That's the honest part.
Time-to-first-reply dropped from 3.1 hours to 19 minutes.
The volume of tier-one tickets a human touched dropped about 70 percent.
Net promoter stayed flat, which in support terms is a win. Customers didn't notice the change because nothing got worse. That was the goal.
The dramatic part was what the reviews freed. The humans who used to write sixty replies a day now write the ones that matter, and they have time to call customers. That's the outcome nobody puts on a dashboard, and it's the one that changed the most.
What we did not do
We did not automate the apology. Any ticket where the customer already escalated twice, or mentioned leaving, or used an angry word, gets routed to a person immediately. No agent draft, no speed. A human. Because at that point, speed is less important than not feeling like a bot, and we decided that's a trade we never make.
We did not let the agent invent facts. If the context pull didn't find an answer, the draft says so and asks for help. No confident wrong answers. That's a rule the checkpoint enforces, and it's the reason reviewers stopped catching things around week four.
We did not let the agent see outbound promises. Billing guarantees, SLA claims, anything a customer might hear and later hold us to. Those stayed human-written for the first three months. We moved them over only when the reviewer's edit rate on them dropped below five percent.
The people part
The thing that almost killed it wasn't technical. It was the team.
The reviewers thought the agent was coming for their jobs. We told them the opposite, and then we proved it by giving them the escalated bucket and the callbacks it made possible. Thirty days in, the two reviewers who'd been loudest were the ones suggesting what to automate next.
People who do support aren't there because they love copying and pasting statuses. They're there because they like helping. We removed the copying. They got more helping. That's the whole story.
If you try this
Three rules from what we learned.
Start with one path, not a system. One ticket type, one pipeline, ten percent of volume. Prove the checkpoint works on a negligible flow before you let it touch real customers.
Give the reviewers the right context or none of it works. The moment a reviewer has to go hunting, the checkpoint becomes the bottleneck and the whole thing fails. Three blocks. That's the limit.
And expect the edit rate to fall on a curve. If it doesn't, don't assume the agent is doing well. Check what the reviewers are actually changing. If it's the same thing every time, fix the agent, don't accept the edits.
We kept one human moment in the whole pipeline, and it's the reason this story has a happy ending. Not because the agent can't be trusted. Because one review point made the entire system trustworthy to everyone else.
The humans wrote the hard replies. The agent got them time to.
Agent notes, once a week. No noise.
One email a week. What we're seeing in real agent setups, what worked, what didn't. Unsubscribe anytime.