Automate customer support ticket triage with AI — route, prioritize, and summarize

A ticket backlog story: one week that cost a startup its SLAs

Tuesday morning, the founder of a 14-person SaaS wakes up to 142 new tickets. The prior week averaged 80 a day. A feature launch doubled volume overnight. Their SLA promises a first response within four hours. By Friday, they’ve missed 27% of SLAs and comped two enterprise customers a month of service. Two agents stayed late three nights in a row, and the CEO was manually triaging at midnight—tagging and forwarding.

The pain wasn’t technical. It was seconds and minutes lost on a simple decision: what is this ticket, who should get it, and how urgent is it? Multiply that decision by 120+ tickets and you burn hours. Morale drops. The queue snowballs. Small errors—a billing issue routed to product, a password reset labeled as a bug—compound.

The following week they tried something different: a no-code, automated triage that read incoming tickets, labeled them, scored urgency, routed to the right queue, and added a concise summary. Triage time dropped from about four minutes to under 45 seconds per ticket. SLA misses fell below 5% within 10 days.

This article shows you exactly how to do that—how to automate support ticket triage with AI, without engineering—using Zapier or n8n plus your helpdesk (Zendesk, Intercom, or Help Scout).

Why manual triage breaks: the real costs you can measure

Manual triage feels cheap because it’s “just a few clicks.” But the costs stack up:

• Agent minutes per ticket: 2–6 minutes to read, tag, route, and add an internal note
• Misrouting rate: 10–20% of tickets bounce once before they land with the right team
• SLA breach penalties: credits, refunds, or churn when VIPs wait
• Training overhead: new agents take weeks to learn your routing rules
• Context switching: triage interrupts deep work and inflates handle time later

A compact example you can replicate: 80 tickets/day × 4 minutes of triage each = 320 minutes/day. That’s 26.7 hours/week. At $30/hour fully loaded, you’re spending about $800/week purely on decide-and-route work. Add a 12% misroute rate (10 tickets/day) costing five minutes each to unjam (another 50 minutes/day, roughly $125/week). That’s around $925/week before counting SLA penalties, morale, and onboarding drag.

Automating the predictable parts—classification, priority, routing, and a short summary—reliably gives back most of those hours and stabilizes SLAs.

Quick triage audit: what to measure before you automate

You’ll move faster if you baseline first. Spend up to two hours collecting these six metrics:

1. Inbound tickets/day
2. First response time (median and 90th percentile)
3. SLA breaches/week
4. Misrouted tickets (% that get reassigned at least once)
5. Average triage time per ticket (minutes)
6. Common tags/labels (top 10 by frequency)

Where to grab them:

• Zendesk: Explore for FRT/SLA; Admin > Tags for tag counts; Triggers/Events for reassignment signals; export Tickets to CSV if needed.
• Intercom: Reports > Conversations for volume and response times; tags in Inbox; export conversations.
• Help Scout: Reports > Conversations and Productivity; Tags report; export via Mailbox > Export.

Tiny example CSV header you can copy for a quick manual audit:

conversation_id,created_at,subject,first_response_minutes,sla_breached,initial_assignee,final_assignee,triage_minutes,top_tag

Calculate weekly agent minutes lost:

• Weekly triage minutes = tickets_per_day × triage_minutes × 5
• Example: 80 × 4 × 5 = 1,600 minutes/week (26.7 hours)

That’s your savings target.

What an automated triage workflow actually does (high level)

Think of it as a smart front desk that reads messages, tags them, and sends people to the right room.

In practice, it handles four capabilities:

• Automated classification: Identify issue type (billing, bug, access, how-to, sales, abuse, etc.) and product area.
• Priority scoring: Detect urgency (outage vs. how-to) and combine with plan tier and SLA window.
• Tagging/metadata enrichment: Add plan, product, sentiment, language, and any CRM attributes.
• Routing and escalation: Assign to the right team/queue, add SLA target, and auto-flag VIPs.

Plus, it creates a short, 2–3 sentence agent summary so the assignee sees context without reading the whole thread.

Choose your tools: a non-technical stack that actually ships

You can do this with no-code building blocks:

• Orchestration

  • Zapier: Fastest setup, huge app library. Pros: easy, reliable. Cons: per-task cost can add up. Best if you want to move today.
  • n8n (Cloud or self-hosted): Affordable at scale and flexible. Pros: low cost per run, open. Cons: a bit more setup, especially self-hosting.

• LLM providers (classification + summarization)

  • Cost-focused: OpenAI GPT-4o-mini, Anthropic Claude Haiku, Cohere Command Light. Typical cost: ~$0.10–$0.30 per 1M input tokens and ~$0.60–$1.50 per 1M output tokens (check live pricing pages).
  • Accuracy-focused: Anthropic Claude Sonnet, OpenAI GPT-4o/4.1, Cohere Command R+. Typical cost: higher but better reliability on tricky tickets.
  • Tip: Start cost-focused for classification. Upgrade the model for summarization if needed on complex conversations.

• Ticketing systems

  • Zendesk: Mature triggers, webhooks, custom fields. Great for structured routing.
  • Intercom: Strong Workflows and Inbox automations, easy tagging and assignment. Good for chat + email.
  • Help Scout: Simple and clean, with Workflows, tags, custom fields, and webhooks.

Pricing tiers to aim for: the mid-tier helpdesk plan that supports webhooks and custom fields, Zapier Professional (or Team) or n8n Cloud Basic, and a pay-as-you-go LLM plan. If you want the fastest setup, pick Zapier + OpenAI + Zendesk/Intercom. If you want the lowest per-ticket cost at volume, pick n8n + Claude Haiku + your helpdesk.

Blueprint: an end-to-end no-code triage flow

Here’s the architecture, described like a tour:

1. Trigger (incoming ticket)

• Why: Start the automation as soon as a ticket arrives or updates.
• How: Use a helpdesk webhook to Zapier/n8n, or use the native Zapier trigger for “New Ticket/Conversation.”

2. Enrichment (metadata pull)

• Why: Better inputs = better classification and prioritization.
• How: Add known fields (plan, MRR, product, SLA policy) from the helpdesk or fetch from your CRM by requester email.

3. Classification (LLM or trained model)

• Why: Consistent labels unlock routing and metrics.
• How: Send a compact thread + metadata to an LLM with a strict JSON schema.

4. Prioritization rules (score + business rules)

• Why: Convert signals into an actionable priority level.
• How: Combine AI urgency with plan weight and SLA windows.

5. Tagging and routing actions

• Why: Put work in the right queue with the right labels.
• How: Update ticket fields, add tags, assign to team/agent.

6. Summarization and internal note

• Why: Save 3–5 minutes per ticket by capturing context.
• How: Generate a 2–3 sentence note and add it as an internal comment.

7. Monitoring and alerts

• Why: Catch failures early and track outcomes.
• How: Log outputs and set an alert if JSON is invalid or the model is uncertain.

Persistence: Store the priority score and classification in helpdesk custom fields for analytics. If needed, also log to a Google Sheet or a lightweight DB (Airtable/Postgres) for audits.

Fallback: If anything fails (model error, missing data), assign to human triage and add a “needs_review” tag.

Step 1 — Set up the trigger and enrich the ticket

Zapier (example):

1. Trigger: Your helpdesk app
   • Zendesk: Trigger “New Ticket” or “New Updated Ticket”
   • Intercom: “New Conversation”
   • Help Scout: “New Conversation”
2. Optional: Or use “Webhooks by Zapier” > Catch Hook and point your helpdesk webhook to the generated URL for more control.
3. Enrichment steps:
   • Look up the customer in your CRM (e.g., HubSpot/Stripe/Airtable) using requester email.
   • Add plan, MRR, account age, and VIP flag to the payload.

Fields to pass forward:

• subject, body/description, conversation_id/ticket_id, requester_name, requester_email, tags, language, existing_priority, status, last_message_at, previous_messages (optional snippet), plan, mrr, organization, product/module, sla_policy

n8n (example):

• HTTP Trigger node
  • Method: POST
  • Path: /tickets/incoming
• Zendesk/Intercom/Help Scout webhook points to https://your-n8n-domain/webhook/tickets/incoming
• Add nodes:
  • Set: Map incoming JSON fields
  • HTTP Request: Fetch CRM data by email (optional)
  • Merge: Combine CRM attributes back into the ticket payload

Step 2 — Classify intent and issue type (prompt templates included)

Format your input compactly: include the latest customer message, the subject, and key metadata (plan, product, language, past tags). Keep to a few hundred tokens.

Expected output schema (use this across prompts):

{
  "issue_type": "billing|bug|access|how_to|abuse|sales|other",
  "product_area": "string",
  "sentiment_score": -1.0 to 1.0,
  "language": "ISO-639-1",
  "urgency_reason": "short text",
  "ai_urgency_score": 0 to 5,
  "tags": ["string"],
  "confidence": 0.0 to 1.0
}

Zero-shot intent classifier (copy/paste):

You are a support triage classifier. Read the ticket and return JSON matching this schema exactly:
{ "issue_type": "billing|bug|access|how_to|abuse|sales|other", "product_area": "string", "sentiment_score": -1.0 to 1.0, "language": "ISO-639-1", "urgency_reason": "short text", "ai_urgency_score": 0 to 5, "tags": ["string"], "confidence": 0.0 to 1.0 }

Rules:
- If payment/charges/refund: issue_type = billing
- If feature broken/errors/crash: bug
- If login/reset/2FA: access
- If "how do I"/usage: how_to
- If harassment/spam: abuse
- If pre-sales/pricing: sales
- Else: other
- Prefer fewer tags, all lowercase, hyphenated.
- If unsure, confidence <= 0.6

Ticket:
Subject: {{subject}}
Latest message: {{latest_message}}
Metadata: plan={{plan}}, product={{product}}, language={{language}}, prior_tags={{prior_tags}}
Return JSON only.

Few-shot issue type examples (add below the rules when accuracy matters):

Examples:
- Input: "I was double-charged this month. Please refund."
  Output: {"issue_type":"billing","product_area":"billing","sentiment_score":-0.2,"language":"en","urgency_reason":"duplicate charge","ai_urgency_score":3,"tags":["billing","refund"],"confidence":0.9}
- Input: "App crashes when I click Export in Reports."
  Output: {"issue_type":"bug","product_area":"reports","sentiment_score":-0.4,"language":"en","urgency_reason":"crash on export","ai_urgency_score":4,"tags":["bug","reports"],"confidence":0.88}

Multi-label tagging (optional second pass):

Task: Suggest up to 5 tags from this controlled list: ["vip","enterprise","billing","refund","bug","reports","login","password_reset","how_to","outage","abuse","sales","feature_request"]. Return JSON: {"tags":["..."]}
Context: Subject={{subject}} Message={{latest_message}} Plan={{plan}} Product={{product}}
Rules: Only choose from the list. 2-4 tags typical. JSON only.

Tips to reduce hallucination:

• Force the JSON schema and ask for “JSON only.”
• Include 2–3 examples for your most frequent cases.
• Provide a controlled tag list when possible.
• If confidence < 0.6, add a “needs_review” tag and route to a general queue.

Step 3 — Prioritize with rules and an AI score

Turn model signals into a number you can act on. A simple composite:

• AI urgency score (0–5) × 1.0
• Plan weight: enterprise +2, pro +1, free +0
• SLA window proximity: if FRT due < 60 minutes, +1; if due < 15 minutes, +2

Example:

• Ticket: AI urgency = 3.5 (crash report), plan = enterprise (+2), FRT due in 40 min (+1)
• Composite priority = 3.5 + 2 + 1 = 6.5
• Map to levels: 0–2 Low, 2–4 Normal, 4–6 High, >6 Urgent
• Result: 6.5 → Urgent (add tag “urgent,” set priority field = urgent)

Store the numeric score in a custom field (priority_score) and the level in the native priority or a custom dropdown. That lets you graph outcomes later.

Step 4 — Tag, route, and create the agent-facing summary

Routing map (keep it simple):

• issue_type = billing → Billing/Finance queue
• bug with product_area = reports → Product/Reports queue
• access → Support/T1
• how_to + non-VIP → Support/T1; how_to + VIP → Customer Success

Tag taxonomy (2–4 tags typical):

• Core: billing, bug, access, how_to, abuse, sales
• Modifiers: vip, outage, refund, reports, login, feature_request

Agent summary template:

Write a 2–3 sentence internal summary for a support agent. Include who the customer is (plan), the problem, any error codes, and the requested outcome. No fluff.
Input: Subject={{subject}} Message={{latest_message}} Prior context (1–2 bullets): {{context}}
Return plain text under 60 words.

Example summaries:

• “Enterprise customer on ACME plan reports crash when clicking Export in Reports. Error appears after selecting CSV. They need a workaround to deliver a file today.”
• “Pro user can’t reset 2FA after phone change. Tried backup codes, none available. Requesting manual reset to regain access.”

Add this as an internal note or prepend to the ticket so the assignee saves 3–5 minutes.

Example configs: Zendesk, Intercom, and Help Scout

Zendesk (Zendesk AI triage alternative)

• Custom fields to create:
  • priority_score (integer)
  • ai_priority_level (dropdown: low, normal, high, urgent)
  • ai_issue_type (dropdown)
  • ai_product_area (text)
  • ai_confidence (decimal)
• Webhook setup:
  • Admin Center > Apps and Integrations > Webhooks > Create Webhook
  • Endpoint: your Zapier Catch Hook or n8n HTTP Trigger URL
  • Method: POST, JSON format
• Trigger example:
  • Conditions: Ticket is Created; Channel is Email/Chat; Status is New
  • Actions: Notify active webhook with JSON body including ticket fields (subject, description, requester.email, tags, custom_fields)
• Routing:
  • Use an Automation or Trigger: If ai_issue_type = billing then assign to Group: Billing
  • Set Priority: Map ai_priority_level to native priority
• Adding the summary:
  • Zapier action: Zendesk > Create Ticket Comment (public = false) with the generated summary

Intercom (Intercom AI routing alternative)

• Fields:
  • Use Conversation Attributes (custom attributes) for priority_score, ai_issue_type, ai_confidence
• Webhook/Workflow:
  • Intercom Workflows: On “New Conversation,” add “Call webhook” step to send payload to Zapier/n8n
  • Or Zapier trigger: Intercom > New Conversation
• Routing:
  • Intercom Automation rules or Workflows: If ai_issue_type = billing → Assign to Team: Billing
  • Add tags via “Add Tag” action
• Summary note:
  • Zapier action: Intercom > Create Admin Note on Conversation with the summary

Help Scout

• Fields:
  • Custom fields per Mailbox: ai_issue_type, ai_priority_level, priority_score
• Webhooks:
  • Manage > Apps > Webhooks: conversation.created, conversation.customer.reply → POST to Zapier/n8n
• Workflows:
  • If ai_issue_type = access → Assign to Team: Support Tier 1
  • Add tag: urgent when ai_priority_level = urgent
• Summary note:
  • Zapier action: Help Scout > Add Note to Conversation (private) with the summary

Sample Zap/n8n flow description (text-only):

• Trigger (New Ticket) → Formatter (clean text) → LLM (classify JSON) → Code/Logic (compute priority) → Helpdesk (Update fields) → LLM (summary) → Helpdesk (Add internal note) → Log (Sheet/DB)

Prompt and action library (copy-and-paste ready)

Zero-shot classifier:

[System] You are a precise support triage classifier. Return JSON only. If unsure, set confidence <= 0.6.
[User]
Schema: { "issue_type":"billing|bug|access|how_to|abuse|sales|other", "product_area":"string", "sentiment_score":-1.0..1.0, "language":"ISO-639-1", "urgency_reason":"short", "ai_urgency_score":0..5, "tags":["string"], "confidence":0..1 }
Ticket: Subject={{subject}}
Latest: {{latest_message}}
Meta: plan={{plan}}, product={{product}}, prior_tags={{prior_tags}}
Return JSON only.

Few-shot add-on: include 2–3 representative examples as above.

Multi-label tags:

Schema: {"tags":["string"]}
Choose from: ["vip","enterprise","billing","refund","bug","reports","login","password_reset","how_to","outage","abuse","sales","feature_request"]
Context: {{subject}} | {{latest_message}} | plan={{plan}} | product={{product}}
JSON only.

Agent summary:

Write a 2–3 sentence internal summary under 60 words. Include plan, problem, error codes, and desired outcome. No greetings.
Input: {{subject}} || {{latest_message}} || Context: {{context}}

JSON output schema (repeat for clarity):

{
  "issue_type": "billing|bug|access|how_to|abuse|sales|other",
  "product_area": "string",
  "sentiment_score": -1.0 to 1.0,
  "language": "ISO-639-1",
  "urgency_reason": "short text",
  "ai_urgency_score": 0 to 5,
  "tags": ["string"],
  "confidence": 0.0 to 1.0
}

Example API payloads:

• Zapier Webhook to update Zendesk custom fields (via “Update Ticket”):

{
  "ticket": {
    "custom_fields": [
      {"id": 1234567890, "value": "{{ai_issue_type}}"},
      {"id": 1234567891, "value": "{{product_area}}"},
      {"id": 1234567892, "value": {{priority_score}}},
      {"id": 1234567893, "value": {{confidence}}}
    ],
    "priority": "{{ai_priority_level}}",
    "tags": ["{{tag1}}","{{tag2}}","ai_triage"]
  }
}

• Intercom add tag:

{ "id": "{{conversation_id}}", "tag_id": "{{tag_id}}" }

• Help Scout add note:

{ "text": "{{agent_summary}}", "status": "active", "type": "note" }

Testing checklist:

• Validate JSON with a schema step (Zapier “Code by Zapier” or n8n Function)
• Log classification vs. final team assignment for 50 tickets
• Spot-check 10 summaries for correctness and brevity
• Watch confidence < 0.6 cases and refine prompts

Cost, ROI, and a two-month projection for a small SaaS

Common cost lines:

• Orchestration: Zapier tasks or n8n runs
• LLM tokens: classification + tags + summary (typically 1–3 calls per ticket)
• Helpdesk plan that enables webhooks/custom fields

Savings formula:

• Weekly savings ($) = (triage_minutes_saved_per_ticket × tickets_per_week ÷ 60) × agent_hourly_cost

Worked example (conservative):

• Volume: 80 tickets/day, 5 days → 400/week
• Manual triage: 4 minutes/ticket; Automated triage: 1 minute/ticket → Save 3 minutes/ticket
• Agent cost: $30/hour
• Savings: (3 × 400 ÷ 60) × 30 = (1,200 ÷ 60) × 30 = 20 × 30 = $600/week
• Costs:
  • Zapier: ~$99/month = ~$25/week
  • LLM: Assume 3 calls/ticket, ~700 tokens total per ticket → ~$0.001 per ticket (with a cost-focused model) → ~$0.40/week
  • Helpdesk: already paid
• Net weekly: ~$600 − ~$25.40 ≈ $574.60
• Payback: Immediate; 2-month impact ≈ $4,600 saved

Aggressive scenario (higher volume + SLA benefits):

• Volume: 140/day → 700/week; Save 3.5 minutes/ticket; Agent cost $35/hour
• Savings: (3.5 × 700 ÷ 60) × 35 ≈ (2,450 ÷ 60) × 35 ≈ 40.8 × 35 ≈ $1,428/week
• Costs: n8n Cloud ~$20/week + LLM ~$1/week → ~$21/week
• Net: ~$1,407/week; Over 8 weeks: ≈ $11.2k

Sensitivity: ROI moves most with ticket volume, minutes saved per ticket, and model cost if you choose a pricier model for summaries. SLA breach reduction has an outsized revenue impact (retention), even if it’s harder to quantify.

Pilot plan: roll out in two weeks and prove value

Phase 1 — Build & local testing (Days 1–5)

• Scope: 1 queue (e.g., email), 3–5 issue types, one priority scale
• Implement flow end-to-end in Zapier/n8n; log outputs to a Sheet
• Success criteria: 90% valid JSON, <5% failures, summary under 60 words

Phase 2 — Shadow mode / holdout (Days 6–12)

• Run automation but don’t auto-assign; compare against human triage on 100–200 tickets
• Track accuracy: issue_type match rate, misroutes avoided, average triage time
• Success criteria: ≥80% correct classification, ≥2 minutes saved per ticket, ≥50% reduction in misroutes for scoped types

Phase 3 — Go live with a small agent team (Days 13–14)

• Turn on routing for scoped types and VIPs
• Communicate: what fields are automated, how to override, where to report bad classifications
• Success criteria (2 weeks): 50–70% reduction in triage time for the scoped queue; SLA breaches down by 30–50%

Rollback plan:

• One switch in your helpdesk trigger to stop routing and revert to manual
• Keep an “ai_triage_disabled” tag to skip automation on sensitive queues

What commonly goes wrong (and how to fix it)

• Hallucinated tags or wrong labels
  • Fix: Provide a controlled tag list and 2–3 examples; drop the confidence threshold to route uncertain cases to a general queue.
• Soft priority drift (everything becomes “high”)
  • Fix: Cap AI urgency at 4; require multiple signals for “urgent” (e.g., VIP + outage keyword).
• Noisy or long summaries
  • Fix: Tighten the word limit and include a negative example; add “No greetings. No speculation.” to the prompt.
• JSON parse errors
  • Fix: Wrap LLM output in a validator step; if invalid, retry once with “Return JSON only”; else fallback to human triage.
• Model over-cost at scale
  • Fix: Use a cheaper model for classification and reserve a higher-accuracy model only for VIP or complex threads.
• Stale prompts as products evolve
  • Fix: Refresh examples monthly; add new product_area examples from misclassifications.

Metrics to watch monthly: correct classification rate, misroute %, average FRT, SLA breaches, minutes saved, and agent override rate.

Scaling, compliance, and data safety for customer messages

• Data minimization: Send only what’s needed (subject, latest message, plan); avoid full transcripts unless necessary.
• Redaction: Strip PII like card numbers; reject or skip PCI-relevant tickets from the LLM path; enforce keyword-based redaction (e.g., 16-digit patterns).
• Opt-out: For sensitive accounts, add a tag to bypass AI (e.g., privacy_optout).
• Rate limits: Batch bursts; add a short delay on spikes; n8n has rate limit nodes; Zapier paths can add filters.
• Storage: Keep enriched fields in your helpdesk; optionally log to a secure database with access controls.
• Governance: Name owners for prompts, keep versions in a doc/repo, and log changes. Enable audit logs in helpdesk and orchestration tools.
• GDPR: Use EU data hosting where possible; include the LLM as a subprocessor in your privacy policy; honor deletion requests by deleting derived logs.

Monetization and affiliate-friendly tool recommendations

Curated picks (practical first, affiliate-friendly where available):

• Zapier: Fastest to ship no-code ticket automation; vast integrations; good for pilots and steady-state under ~2–5k tickets/month.
• n8n Cloud or self-hosted: Best cost control at volume; great for advanced branching and rate limits.
• OpenAI (GPT-4o-mini) or Anthropic Haiku: Strong cost-to-quality for classification; upgrade to Claude Sonnet or GPT-4o for tougher summaries.
• Zendesk, Intercom, Help Scout: All three are proven; choose the one you already run. Their native features pair well with AI triage.

How we keep trust: we may earn a referral if you buy through links, but we recommend tools we actually use to automate support and track ROI.

Ideas to monetize fairly:

• Publish side-by-side tool comparisons and link to free trials
• Offer a 2-week setup service with guaranteed metrics
• Include gentle CTAs to templates and prompt packs

Next 7 actions (a one-page checklist you can use today)

1. Run the 2-hour triage audit (today) — get your six baseline metrics
2. Create helpdesk custom fields for AI outputs (30–45 min)
3. Set up a Zapier or n8n trigger + a test webhook (30 min)
4. Paste the classifier prompt and validate JSON on 20 tickets (60 min)
5. Add the priority rules and map to tags/queues (45 min)
6. Add the 2–3 sentence summary step and send as an internal note (30 min)
7. Launch a 2-week pilot in shadow mode, then go live to one queue (start this week)

KPIs to track first: correct classification rate, minutes saved per ticket, SLA breaches per week.

Appendix: quick reference — sample JSON outputs and test cases

Sample classifier output:

{
  "issue_type": "bug",
  "product_area": "reports",
  "sentiment_score": -0.3,
  "language": "en",
  "urgency_reason": "export crashes",
  "ai_urgency_score": 4.0,
  "tags": ["bug","reports"],
  "confidence": 0.9
}

Sample Zapier webhook payload (from helpdesk to Zapier):

{
  "ticket_id": 12345,
  "subject": "Export fails on CSV",
  "description": "Clicking export crashes the app",
  "requester_email": "user@example.com",
  "tags": ["reports"],
  "plan": "enterprise",
  "product": "analytics",
  "language": "en",
  "prior_messages": "Yesterday it worked...",
  "sla_policy": "enterprise_4h"
}

n8n node setup values:

• HTTP Trigger: Method = POST, Path = /tickets/incoming
• OpenAI/Anthropic node: Model = gpt-4o-mini or claude-3-haiku; Temperature = 0.2; Max tokens = 200
• Function node: Compute priority_score and level mapping
• HTTP Request: Update helpdesk fields via API if the native node isn’t used

Six short test tickets (input → expected):

1. “I was double-charged; need a refund” → issue_type = billing, tags = [billing, refund], urgency = 3
2. “Login blocked after device change; no backup codes” → issue_type = access, tags = [login, password_reset], urgency = 3–4
3. “Export in Reports crashes with error 500” → issue_type = bug, product_area = reports, urgency = 4–5
4. “How to connect Slack integration?” → issue_type = how_to, tags = [how_to], urgency = 1–2
5. “Your agent harassed me” → issue_type = abuse, tags = [abuse], urgency = 4–5 (route to compliance)
6. “Pricing for 200 seats?” → issue_type = sales, tags = [sales], urgency = 2 (route to sales)

Final Thoughts

If your team is still hand-sorting every ticket, you’re paying a quiet tax in minutes, morale, and missed SLAs. AI ticket triage isn’t magic; it’s a well-lit checklist: label, score, route, summarize. Start with one queue, measure hard numbers, and keep humans in the loop for the edge cases. In a month, you’ll wonder why you ever routed tickets by hand.