The chatbot model failed. That doesn't mean agents can't do support.
For a decade, companies bolted chatbots onto their help centers and told customers "chat with us!" The bots couldn't help. They could only match keywords. Customers learned to type "agent" into every one.
LLM-based agents can actually read a ticket, understand the problem, search your docs, and resolve it. The ones that don't work are the ones built with the chatbot mindset: scripted flows, keyword match, deflection as the goal.
This module is 90 minutes of building a support agent that works. By the end:
- A triage agent that reads an incoming ticket and classifies it.
- A resolution agent that drafts a reply, cites its sources, and knows when to escalate.
- A measurement loop: is it actually resolving, or just deflecting?
Thinker.
Resolution is the goal. Deflection is the failure mode that looks like success.
- Resolution: the customer's problem is solved. Measured by: did they come back in 48 hours with the same question? If no, resolved.
- Deflection: the customer stopped asking. Not necessarily because you solved it. Maybe they gave up.
Teams that optimize deflection ship bots customers hate. Teams that optimize resolution ship agents customers don't realize are agents.
The support agent pattern
Two agents, not one:
- Triage. Reads the ticket, classifies (category, severity, confidence). Passes to resolution if confidence is high. Escalates if not.
- Resolution. Drafts a reply. Cites sources. Marks the ticket resolved or flags for human review.
The escalation contract
Every support agent has a clear "I don't know, human please" path. The agent's job is to do the 70% it can do well, fast. Escalating the other 30% is success, not failure.
Talker.
The triage prompt
You are a support-triage agent for [product].
Read the ticket below. Return JSON with exactly these fields:
- category: one of [billing, bug, feature_request, how_to, other]
- severity: one of [critical, high, normal, low]
- confidence: 0.0 to 1.0
- summary: one sentence under 20 words
- needs_human: boolean. True if any of:
- severity is "critical"
- confidence is below 0.6
- customer uses words like "legal", "lawyer", "press"
Ticket: [inbound message]The resolution prompt
You are a support-resolution agent. You draft replies grounded
in the docs below.
Rules:
- Every factual claim must cite a doc by path or URL.
- If the docs don't cover the question, reply "I don't have
this documented yet, escalating to a human" and set
needs_human to true.
- Tone: the voice from company-voice skill.
- Reply length: 80 words max, unless the customer asked a
procedural question.
Return JSON:
- draft_reply: the text to send
- sources: list of doc paths/URLs cited
- needs_human: boolean
- reasoning: one sentence on why you made this decision
Ticket: [input]
Docs: [top-5 search results, paths and content]The "needs_human" flag is the escape hatch. It's mandatory.
Rememberer.
Support agents have four memory surfaces:
- Ticket history per customer. So the agent doesn't treat every message as a first contact.
- Docs corpus. Your help center, searchable.
- Resolution patterns. What worked for similar tickets. A small cache of (input → draft → result) triples.
- Escalation log. Every ticket that went to a human, with why. Gold for agent improvement.
Where it lives
[support-agent]/
docs/ (your help center content)
cache/
resolutions.db (recent successful resolutions)
logs/
tickets/ (one file per ticket, full trace)
escalations.jsonlThe escalation log is the most valuable file
Every week, read 10 random escalations. Patterns emerge. Build skills, add docs, tune prompts. The log is your agent's performance review.
Doer.
Twelve minutes. A real support agent on real tickets.
Step 1. Stage the docs (2 min)
Point the agent at your actual help docs, or at a folder with the 20 most-used articles. Flat markdown files work fine for a start.
Step 2. Build triage (3 min)
SDK app (Module 016) with the triage prompt from Talker. Takes a ticket, returns JSON.
Step 3. Build resolution (4 min)
Second agent with the resolution prompt. Takes the triaged ticket plus top-5 doc matches (naive search is fine for now). Returns draft reply + sources + needs_human.
Step 4. Run on 10 real tickets (2 min)
Take 10 tickets from your last week of support. Run them through the pipeline. Read every output. Would you send it? If no, why not?
Step 5. Log and iterate (1 min)
The first 10 tickets are diagnostic. Note what broke. Fix the prompt, not the pipeline. Ship v2 next week.
A two-agent pipeline. ~100 lines of code total. Handles 40-60% of real tickets in v1. That's a win.
- Resolutions hallucinate: the docs weren't actually passed in, or they were passed as a summary. Pass the full text of the top-5 matches.
- Never escalates: needs_human threshold is too low. Raise the confidence bar.
- Escalates everything: docs don't match the tickets. Audit whether your docs actually cover what customers ask.
Rookie.
Failure 1. Optimizing for deflection
You measure "tickets closed by agent" and celebrate a 40% deflection rate. A month later, churn is up. Customers gave up.
Fix: measure resolution, not closure. Reopen rate within 48 hours is the signal.
Failure 2. Hallucinated help
Agent confidently tells a customer to click a button that doesn't exist. One bad interaction blows more trust than 10 good ones build.
Fix: citation is mandatory. Agent cannot make a factual claim without a source. If there's no source, it escalates.
Failure 3. No handoff
Ticket gets escalated. Human opens it cold, no context. Customer has to repeat the entire problem. Worst experience.
Fix: the escalation always includes the agent's summary and what it tried. Human picks up mid-conversation, not from scratch.
Manager.
Support agents change the shape of the team. Plan for it.
The shifted roles
- Tier-1 agents: the LLM handles most. Human tier-1 team shrinks or shifts to quality work.
- Tier-2 agents: the humans who handle escalations. Their job is now more valuable, each ticket they see is already hard.
- The docs team: now the most leveraged role in support. Every doc they write becomes source material for the agent.
The weekly tuning session
One hour a week. Read 20 random conversations. Look for patterns. Update the prompt. Add docs where docs are missing. Retire resolution patterns that stopped working.
The handoff protocol
When the agent escalates, what does the human see? Design the handoff, don't let it emerge by accident. Customers should feel continuity, not rupture.
Chief.
Risk 1. Support as a legal surface
Agents give advice. Sometimes that advice has legal implications (refunds, contracts, warranties). A bad agent response can create liability.
Governance: legal reviews the prompt and the escalation triggers. "Never discuss [topics]" rules are explicit. Compliance gets a seat at the table.
Risk 2. Brand voice in every ticket
Agents are the voice of your brand, at scale, every day. If the agent sounds wrong, it sounds wrong 10,000 times a week.
Governance: the company-voice skill (Module 019) is loaded by default. Voice reviews are part of weekly tuning.
Risk 3. The economic shift
Headcount plans built on "we need 20 more support agents next year" break when LLM agents resolve 60% of tickets. Don't budget naively. The capacity curve is different now.
Founder.
Solo founder running their own support: the agent replaces you for 50-70% of inbound, freeing you for real product work.
The solo support stack
- Triage + resolution agents from this module.
- Docs in a single markdown folder.
- Escalation goes to your email with the agent's summary.
- Every escalation you handle, you ask: would a doc have solved this? If yes, write it. Next time the agent handles it.
The weekly compounding
Every escalation you handle produces one improvement: a new doc, a tuned prompt, or a new resolution pattern. After 10 weeks, the agent handles what used to take you a full morning.
Deflection is a metric. Resolution is the goal.
The difference shows up in churn, not in dashboards. Design for resolution, measure for resolution, tune for resolution. The best support agent is the one whose existence customers don't resent.