How to Categorize Support Tickets with AI

Automatically categorize incoming support tickets using AI.

What This Integration Does

Support inboxes pile up faster than humans can triage. This workflow watches Front for new conversations, asks an AI Agent to categorize each one against your known buckets, then tags the conversation in Front so the right team picks it up. The same pattern works for prioritization, sentiment scoring, or routing to a specific inbox.

The workflow runs on every new conversation. The AI Agent returns a single label from a closed list (plus a confidence score and a short rationale), so categorization is deterministic and machine-readable. Low-confidence results route to a Human step instead of being blind-tagged, keeping precision high.

Prerequisites

A Front connection with permission to read conversations and apply tags.
An AI Agent enabled in Spojit.
A defined taxonomy of categories - keep it under 10 buckets for best accuracy.
Pre-created Front tags matching your taxonomy.

Step 1: Trigger on New Conversations

Add a Trigger node. Use a Webhook trigger and configure Front to POST to it whenever a conversation is created. For accounts without webhook access, use a Schedule trigger every 2-5 minutes and call front list-conversations filtered to the last 5 minutes.

Step 2: Load the Conversation

Add a Connector node calling front get-conversation with the incoming conversation ID. Capture the subject, sender, and the first message body - that's almost always enough to classify accurately.

Step 3: Classify with the AI Agent

Add a Connector node in Agent Mode with Structured Output enabled. The schema is what forces the output into your taxonomy:

{
  "category":  {
    "type": "string",
    "enum": ["billing", "technical", "feature-request", "bug-report", "account", "other"]
  },
  "priority":   { "type": "string", "enum": ["low", "normal", "high", "urgent"] },
  "confidence": { "type": "number", "description": "0.0 to 1.0" },
  "rationale":  { "type": "string", "description": "One sentence explanation" }
}

Prompt:

You are a support triage assistant. Pick exactly one category from the
enum. If the message could fit two, choose the more actionable one. Use
"other" only when no category fits at all.

Subject: {{ convo.subject }}
From:    {{ convo.recipient.handle }}
Body:    {{ convo.lastMessage.text }}

Step 4: Branch on Confidence

Add a Condition node: if confidence >= 0.75, continue to tagging. Otherwise route to a Human node that pages the on-duty triage lead in Slack for review. This single check keeps low-quality auto-tagging out of your inbox.

Step 5: Apply the Tag in Front

Add a Connector node calling front add-tag with the category name. If you also store priority, add a second tag prefixed (e.g. priority:urgent). For urgent tickets, fan out with a Parallel node and also post into the on-call slack channel via send-message.

Step 6: Log for Continuous Improvement

Add a Connector node writing the classification + rationale to mongodb insert-documents (or any datastore). Once a week, review where the AI disagreed with human re-tagging and adjust the prompt, the enum, or the confidence threshold accordingly.

Tips

Use Claude Haiku or Gemini Flash for this - classification is light work and you want the cheapest model.
Include 2-3 worked examples in the prompt (few-shot) for tricky categories - the lift in accuracy is significant.
Surface the AI rationale as a Front internal comment so agents can sanity check the tag without re-reading the message.

Common Pitfalls

Open-ended outputs - without an enum in the schema, the model invents categories ("billing question", "billing-issue", "Billing"). Always constrain with enum.
Long threads - if a conversation has 30 messages, sending all of them blows budget and hurts accuracy. Classify on the first message and a summary of replies, not the whole transcript.
Tag drift - if marketing renames tags in Front but the workflow still posts the old name, Front creates duplicates. Source the enum from the same place humans manage tags.

Testing

Pull 50 historical conversations that humans already tagged. Run them through the workflow with tagging disabled and write the predictions to a side collection. Compare against the human tags - if agreement is above ~85% you're production-ready. Below that, refine the prompt or trim the enum before enabling.