Customer Support Requests
AI reads incoming support messages, categorizes them, scores priority, and prepares a reply draft. The agent reviews the draft and sends. The CRM is updated automatically.
Customer support teams receive messages every day that require someone to read them carefully, understand the issue, decide how urgent it is, write a reply, and log the outcome. In most teams, this is done entirely by hand. Each step depends on the same agent who already has a queue of other messages waiting.
The problem is not that the work is difficult — most support requests follow predictable patterns. The problem is that reading, sorting, and drafting takes time even when the right answer is obvious. An agent who spends most of their time categorizing and writing drafts has less time for the requests that genuinely need careful thought.
This workflow uses AI to handle the reading, categorizing, prioritizing, and drafting — and hands the result to the agent for a quick review before anything is sent. The agent stays in control of every reply that leaves the system. The repetitive work is removed; the judgment stays with the person.
Theoretical estimates based on a team handling 200 support tickets per month. The manual baseline assumes 8–15 minutes per ticket for reading, categorizing, drafting a reply, and logging the outcome in the CRM.
The time reduction comes almost entirely from eliminating the manual categorization, history lookup, and draft writing steps. The agent's remaining task — reviewing the AI's output and approving or editing the draft — typically takes under two minutes. At 200 tickets per month, that frees roughly 23 hours of agent time that can go toward complex requests or other work.
In the manual process, a support agent starts by opening the inbox and reading each message from start to finish. They decide what kind of issue it is — a billing question, a technical problem, a general inquiry, a complaint — and how urgently it needs a response. None of this is written down anywhere; it happens in the agent's head based on experience and judgment.
Once the agent has assessed the message, they open a reply window and write a response. This might involve checking a previous conversation, looking up a policy document, or finding a similar reply they sent before. They proofread the message, decide it is ready, and send it. Then they switch to the CRM, find the correct ticket record, and manually log the category, the priority level, and the outcome.
This full process — from reading the message to logging the result — takes between eight and fifteen minutes per request, depending on its complexity. Most of that time is spent on the reading, sorting, and drafting steps that happen with every single request, regardless of how routine it is.
In the AI-assisted workflow, the moment a new support message arrives, the process starts without any human input. The AI reads the full message, classifies it by topic and sentiment, and assigns a priority level based on the content and the customer's history in the CRM. It then prepares a draft reply using the company's tone guidelines, common answer patterns, and relevant knowledge base articles.
The agent opens a review screen that shows the original message, the AI's category assessment, the priority score with a short explanation, and the draft reply — all on one screen. The agent reads the message, checks whether the AI's assessment seems right, and reviews the draft. If the draft is good, they click approve and send. If it needs changes, they edit it directly and then send. The whole review typically takes two to three minutes.
After the reply is sent, the CRM is updated automatically: the category, priority, outcome, and timestamp are written back without any manual entry. The agent never needs to open the CRM for routine requests. Their attention is spent on the review and on the requests that genuinely need more thought — not on the mechanical steps that happen every time.
Note that the AI does not send anything on its own. Every reply passes through the agent's review screen before it reaches the customer. This is intentional — human review catches the cases where the AI's draft is wrong, and it means the agent stays aware of what is being communicated on their behalf.
The diagram shows how the AI agent is built using LangGraph. Yellow nodes are human-in-the-loop (HITL) checkpoints — the employee confirms the classification, adds context from the customer's history, and approves the draft reply. At each checkpoint they can reject and send the agent back to redo that step.
flowchart TD
START([START]) --> load_complaint
load_complaint["**load_complaint**\nFetch complaint + customer history\nfrom Django API;\nmark complaint in-progress"] --> classify
classify["**classify**\nLLM classifies complaint category\n+ urgency with rationale"] --> await_classification_approval
await_classification_approval{"**await_classification_approval**\n⏸ HITL interrupt\nEmployee reviews classification"}
await_classification_approval -- "approved" --> persist_classification
await_classification_approval -- "rejected (with comment)" --> classify
persist_classification["**persist_classification**\nPATCH /api/complaints/{id}/\nwith confirmed class + urgency"] --> summarize_history
summarize_history["**summarize_history**\nLLM summarizes all prior messages\nwith this customer;\nflags if history is empty"] --> await_history_feedback
await_history_feedback{"**await_history_feedback**\n⏸ HITL interrupt\nEmployee adds guidance (or skips)"}
await_history_feedback -- "comment captured" --> draft_response
draft_response["**draft_response**\nLLM drafts reply using complaint,\nclassification, history + comment"] --> await_draft_approval
await_draft_approval{"**await_draft_approval**\n⏸ HITL interrupt\nEmployee approves or requests revision"}
await_draft_approval -- "approved" --> send_and_persist
await_draft_approval -- "revision requested" --> draft_response
send_and_persist["**send_and_persist**\nPOST outbound message\nmark complaint processed"] --> END([END])
style await_classification_approval fill:#fef3c7,stroke:#d97706,color:#000
style await_history_feedback fill:#fef3c7,stroke:#d97706,color:#000
style await_draft_approval fill:#fef3c7,stroke:#d97706,color:#000
style START fill:#d1fae5,stroke:#059669,color:#000
style END fill:#d1fae5,stroke:#059669,color:#000
The final result is a support workflow where the agent's job is reduced to a single focused decision: read the message, check whether the AI's assessment makes sense, and approve or edit the draft. Everything before and after that step happens automatically.
In practice, the agent opens a review screen that shows four things side by side: the original customer message, the assigned category and urgency level, a short explanation of why that priority was assigned, and the draft reply. The agent reads through it, adjusts the tone or wording if needed, and clicks send. The whole interaction typically takes under three minutes per request.
Requests that are genuinely complex — where the AI's draft is clearly off, or where the situation requires judgment the AI cannot provide — stand out immediately because the draft will be incomplete or the priority score will be flagged for review. The agent spends extra time on those. Routine requests take seconds.
After the reply is sent, the CRM record is updated automatically with the category, priority, response time, and outcome. The agent never opens the CRM for standard requests. At the end of the day, the support manager can see a full breakdown of request types, average response times, and flagged cases — without anyone having to compile it manually.