Build an AI Ticket Classifier: Open Source, Self-Hosted, Zero Vendor Lock-in

Every support team wastes hours manually triaging tickets into the right buckets. An AI ticket classifier solves this — but most SaaS options charge per ticket and lock your data into their cloud. This guide shows you how to build your own AI ticket classifier using Zylos, the open source agent framework, with full data sovereignty, fixed hosting costs, and multi-channel routing via HxA Connect.

What is an AI ticket classifier?

An AI ticket classifier is a system that automatically reads incoming support tickets and determines what they're about, how urgent they are, and who should handle them — without a human reading every one. Under the hood, it's an LLM-powered agent that performs multi-dimensional classification: category (bug, feature request, account issue, billing question), priority (critical, high, medium, low), sentiment (frustrated, neutral, positive), affected component (login, payments, dashboard, API), and recommended assignee (the team or individual best equipped to resolve it).

Unlike keyword-based rules ("if ticket contains 'password' → route to IT"), a modern automatic ticket classifier understands context. The same word "freeze" means something completely different in a banking ticket ("account freeze") vs a SaaS ticket ("dashboard freeze"). LLM-based classification handles this ambiguity because it reads the full ticket description, not just pattern-matches keywords.

The state of the art in 2026 is a layered architecture: a fast rules engine handles obvious cases (zero LLM cost), an embedding-based model catches the middle tier, and the LLM only fires for the ~15% of tickets that are genuinely ambiguous. This hybrid approach delivers 90%+ classification accuracy while keeping per-ticket AI costs near zero.

Build vs buy: why self-host your AI ticket classifier

The market for AI ticket classification tools is crowded — Zendesk Intelligent Triage, Intercom Fin, Forethought, and Twig all promise to classify and route tickets. But every SaaS option comes with the same three trade-offs:

1. Per-ticket pricing adds up fast. At $0.99–$5 per classified ticket, a team handling 5,000 tickets/month pays $4,950–$25,000/month — before their helpdesk subscription. A self-hosted AI ticket classifier on a $40/month VPS handles the same volume at fixed cost.
2. Your ticket data trains their models. Every SaaS classifier improves by learning from your support data. Your team's institutional knowledge becomes part of their product — and you can't take it with you if you switch vendors.
3. Integration is limited to what they support. Most SaaS classifiers integrate with Zendesk, Freshdesk, and maybe Jira. If your team uses Lark, Telegram, Linear, or a custom internal tool, you're out of luck — or paying for a custom integration.

Building your own AI ticket classifier with Zylos flips all three: fixed hosting cost regardless of volume, full ownership of your classification logic and training data, and native multi-channel routing to any system via HxA Connect's 10+ adapters.

How to build an AI ticket classifier with Zylos

Zylos is an open source autonomous AI agent framework with persistent memory, multi-channel communication, and extensible skills. It's the engine that powers the classifier. Here's how to build your AI ticket classifier in four steps.

Step 1: Set up the Zylos agent framework

Start by cloning the Zylos Core repository and installing dependencies. You'll need Node.js ≥ 18 and an API key from your preferred LLM provider (OpenAI, Anthropic, Gemini, or a local model via Ollama).

# Clone and install
git clone https://github.com/coco-xyz/coco-core.git
cd zylos-core
npm install

# Configure environment
cp .env.example .env
# Edit .env: set LLM_API_KEY, LLM_MODEL (gpt-4o / claude-sonnet-4-6 / gemini-2.5-pro)

# Start the agent
npm start
# Agent running on http://localhost:3456

Verify the agent is alive by sending a test message. If it responds, you're ready to teach it classification.

Step 2: Define your ticket classification schema

The classification schema is the taxonomy your AI ticket classifier uses to label every ticket. Define it once, and the agent applies it consistently. Here's a production-ready schema you can adapt:

{
  "classification_schema": {
    "categories": [
      "bug_report",
      "feature_request",
      "account_issue",
      "billing_question",
      "integration_help",
      "performance_degradation",
      "security_incident",
      "general_inquiry"
    ],
    "priorities": ["critical", "high", "medium", "low"],
    "routing": {
      "bug_report":        { "target": "github-issue",  "repo": "org/support-tracker" },
      "security_incident": { "target": "telegram",      "channel": "@sec-alerts" },
      "billing_question":  { "target": "slack",         "channel": "#billing-triage" },
      "feature_request":   { "target": "linear",        "team": "product" },
      "account_issue":     { "target": "lark",          "group": "account-ops" },
      "default":           { "target": "hxa-connect",   "thread": "support-inbox" }
    },
    "confidence_threshold": 0.85
  }
}

The confidence_threshold is critical: tickets classified below 85% confidence get flagged for human review instead of auto-routed. This prevents misroutes on ambiguous tickets while still automating the majority.

Step 3: Connect ticket sources and route to channels

Now wire up where tickets come from and where they go to. HxA Connect — COCO's bot-to-bot messaging server — handles the multi-channel routing so your AI ticket classifier can send classified tickets to any platform.

// In the Zylos agent's skill configuration:
import { HxaConnectClient } from '@coco-xyz/hxa-connect-sdk';

const router = new HxaConnectClient({
  url: 'https://your-hxa-server.com',
  token: process.env.HXA_BOT_TOKEN,
  orgId: process.env.HXA_ORG_ID,
});

// Register ticket intake sources
agent.on('ticket.received', async (ticket) => {
  // 1. Classify
  const classification = await agent.classify(ticket, schema);

  // 2. Route based on classification
  if (classification.confidence >= schema.confidence_threshold) {
    await router.send(classification.target, formatTicket(ticket, classification));
    console.log(`Routed ticket #${ticket.id} → ${classification.category}`);
  } else {
    await router.send('human-review-queue', formatTicket(ticket, classification));
    console.log(`Flagged ticket #${ticket.id} for human review (confidence: ${classification.confidence})`);
  }
});

HxA Connect supports GitHub Issues, GitLab, Lark, Telegram, Slack, Email, Jira, Linear, and custom webhooks out of the box. One integration layer, every destination covered.

Step 4: Deploy, monitor, and iterate

Deploy your AI ticket classifier with Docker for the simplest production setup:

# Build and run with Docker
docker build -t ticket-classifier .
docker run -d -p 3456:3456 \\
  -v $(pwd)/data:/app/data \\
  -e LLM_API_KEY=$LLM_API_KEY \\
  -e HXA_BOT_TOKEN=$HXA_BOT_TOKEN \\
  ticket-classifier

Monitor classification accuracy through the Zylos agent dashboard. The most important metric is acceptance rate: what percentage of auto-classifications does the assigned team accept without correcting? A healthy system reaches 85%+ within the first week and 92%+ after a month of feedback-loop tuning.

AI ticket classifier comparison: Build vs SaaS

Why open source for your ticket classification pipeline

Choosing an open source ticket classifier isn't just about cost — it's about control over the system your support team depends on every day. Here's what that means in practice:

• Custom classification logic. Your support taxonomy is unique to your product and team. An open source AI ticket classifier lets you model categories that match your actual org structure — not a generic "bug/feature/question" template.
• Auditability. Every classification decision has a traceable log. If a critical security ticket was misrouted as "general inquiry," you can replay the classification, see what went wrong, and fix it. SaaS classifiers are black boxes.
• Multi-channel routing, not just helpdesk integration. Your support workflow might involve GitHub Issues for engineering, Slack for billing, Telegram for security alerts, and Lark for account operations. HxA Connect routes to all of them simultaneously from a single classification event.
• No vendor dependency. SaaS pricing changes, features get deprecated, companies get acquired. Your AI ticket classifier built on open source doesn't care — it runs on your server, at your pace, with your rules.

Frequently asked questions

Related articles