Developer Handover Pack

Developer Handover Pack

Support Ticket Triage & Routing

Reads the incoming ticket body and extracts the issue type, customer sentiment, and any critical keywords that signal urgency or special handling. Uses natural language understanding to categorize the problem and flag emotional tone. This agent replaces the manual steps of reading the ticket body, identifying the category, and assessing urgency.

// Input
Zendesk ticket object {
  ticket_id: string,
  subject: string,
  description: string (full body),
  requester_email: string,
  created_at: ISO8601,
  custom_fields: object
}

// Agent processing
1. Tokenize and clean ticket text
2. Extract named entities (product, payment status, keywords)
3. Apply category classifier (billing | technical | account | feature | complaint)
4. Compute sentiment score (negative, neutral, positive) via LLM
5. Identify urgency signals (service down, payment failed, angry tone, multiple messages)
6. Assign priority: high (urgency signals + negative sentiment), normal (neutral tone), low (feature/question)

// Output
Classification object {
  ticket_id: string,
  category: 'billing' | 'technical' | 'account' | 'feature' | 'complaint',
  sentiment: number (-1.0 to 1.0),
  urgency_signals: string[],
  priority: 'low' | 'normal' | 'high',
  confidence: number (0.0 to 1.0),
  reasoning: string (human-readable explanation)
  timestamp: ISO8601
}

Takes the categorized ticket from the Ticket Analyzer and matches it against routing rules and team availability. Selects the best queue or agent based on expertise, current workload, and SLA targets. Escalates edge cases to a human reviewer. This agent replaces the manual assignment step and optimizes for speed and accuracy.

// Input
Classification object from Ticket Analyzer {
  ticket_id: string,
  category: string,
  priority: 'low' | 'normal' | 'high',
  confidence: number,
  sentiment: number,
  requester_email: string
}

// Agent processing
1. Query routing rules table: category -> queue or agent pool
2. Look up customer tier in HubSpot by email (enterprise, premium, standard, free)
3. Apply SLA from rules: e.g., high + enterprise = 2hr response time
4. Poll Zendesk queue depth and agent availability (agents with < 5 open tickets)
5. Score each eligible agent: (expertise match + capacity + recent assignment history)
6. If high priority, bypass normal queue and assign directly to senior agent or escalation queue
7. If category is uncertain (low confidence from Analyzer), route to triage team lead instead
8. Return assignment decision and SLA deadline

// Output
Routing decision object {
  ticket_id: string,
  assigned_queue: string,
  assigned_agent_email: string | null,
  sla_target_hours: number,
  sla_deadline: ISO8601,
  assignment_reason: string (human-readable),
  escalation: boolean,
  timestamp: ISO8601
}

// TRIGGER: Zendesk webhook fires on new ticket creation
POST /webhook/ticket-created
Payload: {
  ticket_id,
  subject,
  description,
  requester_email,
  channel (email | web | chat),
  created_at
}

// AGENT 1: Ticket Analyzer
Input: ticket object from Zendesk API GET /tickets/{ticket_id}
Process: NLP classification on subject + description
Output: {
  ticket_id,
  category: 'technical' | 'billing' | 'account' | 'feature' | 'complaint',
  priority: 'high' | 'normal' | 'low',
  sentiment: float (-1.0 to 1.0),
  confidence: float (0.70 to 1.0)
}

// AGENT 2: Smart Router (receives Analyzer output)
Input: Classification from Agent 1 + requester_email
Lookup 1: HubSpot GET /crm/v3/objects/contacts (filter by email)
  Returns: customer_tier, customer_id, account_name
Lookup 2: Zendesk API GET /queues or /agent_groups
  Returns: agent availability, queue depth, SLA rules
Process: Match category to routing rule, select best agent/queue
Output: {
  ticket_id,
  assigned_queue: 'billing_queue' | 'technical_queue' | ...,
  assigned_agent_email: 'agent@company.com' | null,
  sla_deadline: ISO8601,
  escalation: boolean
}

// WRITE 1: Update Zendesk ticket
PATCH /tickets/{ticket_id}
Fields: {
  custom_field_category: category from Analyzer,
  custom_field_priority: priority from Analyzer,
  custom_field_sla_deadline: sla_deadline from Router,
  assigned_group_id: queue_id from Router,
  assigned_user_id: agent_id from Router (if direct assign),
  status: 'assigned' (was 'new')
}

// WRITE 2: Send Slack notification
POST https://hooks.slack.com/services/YOUR_HOOK_ID
Message: {
  channel: '#support_' + assigned_queue,
  text: ':ticket: New ' + priority + ' ticket',
  blocks: [
    { type: 'section', text: { type: 'mrkdwn', text: 'From: ' + requester_email } },
    { type: 'section', text: { type: 'mrkdwn', text: 'Issue: ' + subject } },
    { type: 'section', text: { type: 'mrkdwn', text: 'Category: ' + category } },
    { type: 'section', text: { type: 'mrkdwn', text: 'SLA: ' + sla_deadline } },
    { type: 'actions', elements: [ { type: 'button', text: 'Open in Zendesk', url: zendesk_ticket_url } ] }
  ]
}

// WRITE 3: Log to HubSpot CRM (customer context)
POST /crm/v3/objects/tickets
Fields: {
  hs_ticket_id: ticket_id,
  hs_ticket_subject: subject,
  hs_ticket_category: category,
  hs_ticket_priority: priority,
  hs_ticket_assigned_to: assigned_agent_email,
  hs_ticket_sla_deadline: sla_deadline,
  hs_ticket_triage_timestamp: now(),
  associated_contact: customer_id
}

// DECISION: Is priority == 'high'?
If yes:
  POST /notify-team-lead
  Message: Urgent ticket {ticket_id} assigned to escalation queue

// OUTPUT: Automation complete
Time elapsed: ~2-3 seconds (vs 37 minutes manual)
Result: Ticket is categorized, assigned, notified, and logged.