Triage and Route Tickets by Topic With AI

This guide builds the agent that takes that job off your plate. When a new ticket arrives, Macha reads the full content, classifies the topic, infers priority and sentiment, tags it, and routes it to the right group or agent — in seconds, on the Zendesk you already run. Macha isn't a helpdesk and it isn't replacing Zendesk; it's an AI agent layer that sits on top of it and takes the same actions a human dispatcher would, through the connector's real write tools.

What "triage" actually means here

Triage is three decisions stacked on top of a classification:

1. Classify — what is this ticket about? (Billing, shipping, a bug, a refund, an access problem…)
2. Prioritize — how urgent is it, and how is the customer feeling?
3. Route — which queue or person owns it, and what tags/fields should travel with it?

A rules engine can do a crude version of step one with keyword matching, but keywords don't understand intent — "charged twice" and "I see two of the same line on my statement" are the same problem in different words, and a keyword rule catches one and misses the other. That's why rules-based routing tends to plateau around 40–50% accuracy, while LLM-based triage on mature deployments lands much higher — eesel's published triage guide reports a 1,000-ticket-per-month jewelry retailer hitting roughly 93% triage accuracy (eesel, updated Jun 2026), and aggregated routing benchmarks put advanced AI first-attempt accuracy around 94–96% versus ~77% for a human dispatcher (approximate, vendor-aggregated figures — treat as directional, not gospel). The point isn't the exact number; it's that reading intent beats matching strings.

Macha's triage agent reads intent because it's a language model with the whole ticket in front of it — subject, description, the full comment thread, custom fields, and even image attachments via AI vision (it can read a screenshot of an error or a receipt). Then, instead of stopping at a label, it acts.

A real example, end to end

Here's the worked case from Macha's use-case library. A customer opens a ticket that reads:

"My account was charged but I never received access to the premium features I paid for."

A keyword router sees "charged" and "premium" and might fling it at general billing. The triage agent does the full job:

• Classify: Topic → Billing → Access Issue.
• Prioritize: Priority → High. Sentiment → Frustrated.
• Route: Assigned to the Billing Team, priority set to High, tags added: billing, access-issue.

That's a single inbound message turned into a fully-routed, correctly-prioritized, tagged ticket sitting in the right queue before a human ever opens it. The agent under the hood is doing exactly two connector operations — Get Ticket to read everything, then Update Ticket actions to write the decision back — but the classification in between is where the value lives.

Build it: the auto-classifier

You don't write routing rules; you describe the desk in plain language and let the agent reason. In the Macha builder you create a triage agent, point it at your Zendesk connector, and give it instructions that map your topics to your actual teams and priorities. That prose lives in the Instructions panel shown in the agent above ("You are a ticket triage agent. When a new ticket comes in, read it carefully and classify the type of request…") — the agent never sees the name or description, only these instructions, so this is where the real configuration happens.

A solid set of instructions for the classifier covers four things:

• Your topic taxonomy — the categories that mean something on your desk (e.g. Billing, Shipping, Returns, Technical/Bug, Account/Access, Sales). List them explicitly; ambiguity is what produces sloppy routing.
• Priority rules — when something is urgent vs high vs normal vs low. Tie it to real signals: a payment failure for an active subscriber, a frustrated tone, a VIP, an outage keyword.
• Sentiment — instruct the agent to read tone (frustrated, anxious, neutral, happy) and let it influence priority. A technically trivial issue from a furious customer can legitimately outrank a complex one from a calm one.
• Routing map — which topic goes to which group, and any exceptions (e.g. anything tagged legal or chargeback skips straight to a senior queue).

Because it's an LLM, the classifier handles the messy reality keyword rules choke on: typos, multi-issue tickets ("my order's late and I was double-charged"), non-native phrasing, and screenshots. You can run it on Macha's default GPT-5.4 Mini for high-volume desks (a triage classification is essentially one model response), or move to a stronger model where the taxonomy is subtle. Credits are charged per AI action — see the pricing page for the per-model breakdown — so a triage-only agent is one of the cheapest agents you can run.

The tools that do the routing

Classification is the brain; the Zendesk connector's write tools are the hands. The triage agent has a tight, purpose-built toolset:

Two of these are worth dwelling on, because they're where naive automations usually go wrong.

Tagging that doesn't clobber. Early on, adding a tag could silently wipe the tags already on a ticket — or report success while applying nothing. Macha's Update Tags tool now reliably applies the new tag and preserves the existing set; removing one tag leaves the rest intact, and the tool reports back the verified final tag list so the agent sees the truth, not just its intent. For a triage agent that's load-bearing: you do not want auto-triage destroying the tags your reporting depends on.

Routing to a queue, not just a person. The Assign Ticket tool accepts a group, an agent, or both, so you can route to "Billing" or "Tier 2 Support" as a queue rather than always picking an individual who might be on leave. Pairing it with List Groups matters because Zendesk routing happens by group ID; the agent looks up the live group list first instead of guessing, which keeps routing correct even after you rename or add teams.

The trigger: fire on every new ticket

The whole flow hangs off one trigger — New Ticket, which fires on the first customer message, before any agent replies. That's the moment triage is worth the most.

A couple of configuration notes that keep this production-safe:

• Debounce. Inbound tickets can emit several events in quick succession (a create, then an edit, then an attachment lands). The New Ticket trigger exposes a debounce control — set a delay in seconds and Macha collapses the burst into a single run, so the agent classifies the settled ticket once instead of firing three times.
• Confirmation on activation. Because a "fire on every new ticket" trigger is high-impact, Macha shows an explicit confirmation modal when you switch it on, plus a persistent advisory card on the agent — a small guardrail against accidentally pointing an untested agent at your entire inbound stream.

Native Zendesk triage vs. an agent layer

Zendesk ships its own Intelligent Triage, and it's good: it classifies tickets by topic, sentiment, language, and custom entities (Zendesk docs). If you're already paying for it, use it — Macha is a layer on top of your helpdesk, not a replacement for it, and the two coexist happily. The practical differences worth knowing:

• Plan gating. Intelligent Triage is part of Zendesk's Advanced AI / Copilot add-on, which sits on the higher plans. Macha's triage agent runs against the Zendesk API via the connector, so it works on the plan you already have.
• **Classify and act.** Native triage predicts fields; you still wire Zendesk triggers/automations to do something with the prediction. Macha's agent does the routing itself — set priority, set type, tag, assign to a group — in the same run, and can keep going (draft a reply, pull order data, escalate) if you let it.
• Open taxonomy. You describe topics, priority logic, and routing in instructions and change them by editing prose, not by retraining an intent model.

This isn't "better than Zendesk" — it's a different shape. Native triage is a managed classifier inside the product; Macha is a configurable agent on top of it that turns the classification into actions. (See Macha on Zendesk for how the layer sits on your instance.)

How this compares to dedicated triage tools

Standalone triage products — IrisAgent, and the routing features inside platforms like Kustomer or SentiSum — solve the same classify-and-route problem, and several do it well. The structural difference is where they live. Most are either a separate system you point your tickets at, or a capability locked to one helpdesk's higher tiers. Macha's triage agent runs on top of the Zendesk (or Freshdesk, Gorgias, Front) you already operate, using that helpdesk's own API as its hands — so the ticket never leaves your system of record, and the same agent that triages can also draft a reply, pull order data, or escalate in the same run. If you want a managed, single-purpose classifier, a dedicated tool may fit you fine. If you want one configurable agent layer that triages and acts across the tools you already use, that's the shape Macha is built for.

The numbers: what auto-triage is actually worth

Manual triage runs roughly one to three minutes per ticket — read it, classify it, set priority, tag, assign. That feels trivial until you multiply it by volume. Taking a conservative ~2 minutes of human handling per ticket:

An agent that classifies and routes in seconds collapses most of that to near-zero — and, more importantly, it does it consistently at 2 a.m. and during a Monday-morning spike alike, where human triage quality sags exactly when volume is highest. (These figures are illustrative arithmetic on the ~1–3 min/ticket baseline, not a Macha guarantee; outcomes depend on your taxonomy and volume.)

The second number to watch is reassignment rate — the share of tickets a human has to re-route after triage. It's the cleanest signal of whether triage is calibrated. Dedicated-tool benchmarks claim a well-tuned AI triage layer drives roughly 50% fewer reassignments alongside 85–95% routing accuracy in mature deployments (IrisAgent automation playbook, vendor figures — treat as directional). Track your own reassignment rate before and after; if it isn't falling, the fix is almost always a tighter taxonomy or routing map — not a bigger model.

On cost, triage is the cheapest agent you can run: each classification is a single AI action, billed in credits, and it runs fine on Macha's default model. Because credits are charged per AI action, a triage-only agent's bill scales linearly and predictably with ticket volume — see the pricing page for the per-model breakdown. The comparison that matters is one classification's credits against the loaded minutes of human dispatch time it removes; for most desks that trade is lopsided in triage's favour.

Watch-outs — when not to point AI at your queue

Auto-triage is one of the safer agents to run, but it isn't a "set it and forget it":

• Don't auto-route blind on day one. Run the agent in a shadow/test mode first, or have it tag and suggest before it assigns, and review a sample. Trust the routing only after you've watched it agree with your team on real tickets.
• Mind the irreversible-ish actions. Setting priority and tags is cheap to correct; reassigning across teams creates churn if it's wrong. Keep your routing map tight and your topic list unambiguous to minimize reassignment rate (the metric that tells you triage is miscalibrated).
• Sentiment is a signal, not a verdict. Let tone nudge priority, but don't let "frustrated" auto-escalate everything to urgent, or urgent stops meaning anything.
• Garbage taxonomy in, garbage routing out. If two of your topics overlap or your group names are inconsistent, the model will reflect that. Clean the taxonomy first; it's the highest-leverage thing you can do.
• It costs credits per ticket. Every classification is an AI action. For very high volume desks, run triage on the cheap default model and reserve heavier models for the genuinely ambiguous slice.

Where this fits in a bigger workflow

Triage is usually the first agent a team builds, because everything downstream gets easier once tickets land in the right place pre-tagged. From here you can layer on:

• An auto-reply agent for the topics that are fully self-serviceable (order status, policy questions).
• A draft-for-review agent that writes a suggested response for the assigned human.
• A VIP/urgent relay that pings Slack the moment triage flags a high-priority ticket from a key account.

The triage agent's tags and priority become the routing signals those agents key off — which is exactly why getting classification right first pays off everywhere else. For the full builder mechanics, see the Triggers and Agents docs.

FAQ

What does the AI use to classify a ticket? The whole thing — subject, description, the full comment thread, custom fields, and image attachments (it reads screenshots and receipts via AI vision). It reasons over intent rather than matching keywords, which is why it catches paraphrased and multi-issue tickets that rules miss.

Can it assign to a team/queue, not just a person? Yes. The Assign Ticket tool routes to a Zendesk group queue, a specific agent, or both, and it uses List Groups to resolve a group name to the correct ID first.

Will auto-tagging overwrite my existing tags? No. Update Tags adds (or removes) tags non-destructively — your existing tag set is preserved, and the tool verifies the final tag list after writing.

How does it decide priority? By the rules you give it, informed by content and sentiment. You define what counts as urgent/high/normal/low; tone (e.g. frustration) can raise priority where you allow it.

Does this replace Zendesk's Intelligent Triage? No — Macha runs on top of Zendesk. If you already use Intelligent Triage, keep it; Macha's agent adds the acting layer (route, tag, assign, then optionally reply or escalate) and works on the plan you already have. See Macha on Zendesk.

How much does a triage agent cost to run? It's credit-based, per AI action — a single classification is essentially one model response, and on the default model that's the cheapest tier. See the pricing page for the per-model credit costs.

Try it

If your queue still gets hand-sorted, this is the agent to build first. Start a 7-day free trial, no credit card required, connect Zendesk, describe your topics, priorities, and teams, and let the classifier route your next ticket before anyone reads it. Read the docs for the full builder walkthrough, or see the Zendesk connector for every tool it can use.

Written by Abbas (Customer Support & AI, Macha) · Reviewed by Ankeet Guha (Co-founder & CTO) · Published 2026-06-24 · Last updated 2026-06-24.