Customer Support

How to triage customer support tickets with AI

Customer Support3 AI tools7 steps6 friction points

Want an agent to handle this on your live data? See the Starch version →

Customer support ticket triage is the work of deciding, before anyone writes a single reply, which tickets need immediate attention, which are routine, and which can wait. For most small teams, that sorting happens manually — someone reads the queue, makes judgment calls, and routes accordingly. It's not hard work, but it's constant work, and it compounds: a backlog of 50 unsorted tickets is manageable; 500 is a crisis.

Ticket triage feels like an AI problem because the core task is classification. You're reading a message, extracting intent, and assigning a category or priority — exactly the kind of pattern-matching that language models do well. The signal that something should be escalated urgently (an angry enterprise customer, a billing failure, a potential churn signal) is usually right there in the text, and a model can surface it reliably if you prompt it correctly.

ChatGPT, Claude, and Gemini can all contribute meaningfully here today. Paste in a batch of tickets, describe your priority tiers and routing rules, and you'll get reasonable classifications back. Claude tends to handle nuanced tone detection well. ChatGPT with a system prompt is good for consistent structured output. Gemini can process longer batches. None of them are connected to your actual support inbox, but for teams willing to copy-paste, they produce usable results.

Skip the manual work → See the Starch version

Customer Support3 AI tools7 steps6 friction points

AI walkthrough

How to do it with AI today

A practical walkthrough using ChatGPT, Claude, and other off-the-shelf LLMs — what they're good at, what you'll have to do by hand.

Tools that work for this

ClaudeChatGPTGemini

Step-by-step

1 Export a batch of raw tickets from Zendesk, Intercom, Freshdesk, or Help Scout — however you pull a CSV or copy a queue view. You need the ticket text; customer name and ID are useful context.

2 Open Claude or ChatGPT and write a system prompt that defines your triage logic: priority tiers (P1 = billing failure or churn risk, P2 = broken feature, P3 = general how-to), routing rules (P1 goes to senior support, P2 to engineering, P3 to a canned-response queue), and any escalation triggers specific to your product.

3 Paste in your ticket batch — typically 20-50 tickets at a time to stay within context limits — along with the system prompt. Ask the model to return a structured table: ticket ID, one-sentence summary, assigned priority, recommended routing, and a flag if any ticket looks like a churn risk.

4 Review the output. Spot-check five to ten classifications against your own read. Adjust the prompt if the model is over-escalating routine questions or missing genuine urgency signals — this calibration takes two or three iterations.

5 For tickets the model flags as P1 or churn-risk, paste just those into a second prompt asking for a draft first response. Give it the customer's account context if you have it — plan tier, how long they've been a customer, whether they've complained before.

6 Copy the classifications back into your support tool manually — paste priority labels, copy draft replies into tickets, update status fields by hand. This is the step that takes the most time in the raw LLM workflow.

7 Repeat the whole sequence the next time your queue needs sorting. Nothing from this session carries forward automatically.

Prompts you can copy

You are a customer support triage assistant. Classify each ticket below as P1 (urgent: billing failure, data loss, churn risk), P2 (functional issue), or P3 (general question). Return a table with: ticket ID, one-sentence summary, priority, and routing recommendation. Tickets: [paste here]

Review this support ticket and tell me: Is this customer likely to churn? What's the core issue in one sentence? What should the first response say? Customer plan: Pro. Ticket text: [paste here]

Here are 30 customer support tickets. Flag any that mention billing problems, cancellation intent, or compare us unfavorably to a competitor. Return only the flagged tickets with a one-sentence reason for each flag. [paste tickets]

Draft a reply to this support ticket. Tone: helpful and direct, no corporate filler. The customer is on our Starter plan. Don't promise anything about timelines. Ticket: [paste here]

Categorize these tickets into: account setup, billing question, bug report, feature request, or other. Return as JSON with keys: ticket_id, category, confidence (high/medium/low). [paste tickets]

Reality check

Where this gets hard

The walkthrough above works — until your numbers change, the LLM hallucinates, or you have to re-paste everything next month.

No live connection to your inbox — every triage session starts with a manual export or copy-paste from Zendesk, Intercom, or whatever support tool you use.

Context window limits mean you can process 20-50 tickets per run comfortably; large queues have to be chunked manually, and the model has no memory across chunks.

Classification logic lives in your prompt, not in a system — so if a teammate runs it next week with a slightly different prompt, you get inconsistent priority labels and routing decisions.

The model has no access to customer account data — plan tier, billing status, past ticket history — unless you paste that context in manually for each ticket, which defeats the speed benefit.

Nothing persists after the session. Draft replies, priority flags, and routing decisions all have to be copied back into your support tool by hand, one ticket at a time.

Outputs drift over time — the structured table format you carefully prompted in January may not match what the model returns in March without re-tuning the prompt.

Tired of the friction?

Starch runs the whole workflow on live data — no copy-paste, no hallucinated numbers, no re-prompting next month.

See the Starch version →

Starch alternative

The same workflow on Starch

Starch is an agentic operating system — it builds and runs persistent software on your live business data, so instead of re-running a prompt chain manually every day, you describe the triage system you want and an agent builds it as a running app connected to your actual inbox and customer records.

Connect Zendesk, Intercom, Freshdesk, or Help Scout from Starch's integration catalog — the agent queries your live ticket queue when the app runs, so triage happens on real data, not yesterday's CSV export.

Describe your priority logic in plain English and Starch builds the classification app around it: 'Flag any ticket mentioning billing failure or cancellation as P1, route to senior support, and draft a first reply automatically.' It runs on every new ticket, not just when you remember to prompt it.

Starch's CRM starter app connects Gmail or Outlook so the agent can pull customer email history alongside tickets — meaning it knows this person emailed about billing last month before it decides how urgent today's ticket is.

Customer Support Agent — coming soon — will handle the full resolution loop: answering routine questions instantly from your knowledge base and escalating complex tickets with full context, so your team only touches the work that actually needs a human.

Automations trigger on a schedule or on new ticket events — no manual queue exports, no copy-pasting labels back into your support tool. The agent writes the classification back to the ticket and Slacks your team about P1s automatically.

Tell Starch what you want in plain English: 'Build me a daily support triage dashboard that shows open P1 tickets, average response time by priority tier, and a list of customers who've submitted more than two tickets this week.' The agent builds it; it stays current.

Get closed-beta access →

Toolkit