Omnichannel Support Ticket Triage with AI Routing

Automatically triage support tickets from Zendesk and HubSpot: a ReAct Agent classifies intent and sentiment, a second agent posts a reply to the correct CRM, and a third notifies the owning developer in Google Chat — all from one workflow.

What you'll build

An always-on workflow with two ingestion paths (Zendesk + HubSpot) that converge into an AI triage → reply → notify pipeline.

Architecture at a glance

Before you begin

• A FlowGenX account with access to Design → Flow Designer → Workflow Canvas.
• Zendesk and HubSpot connectors authorized (API token / OAuth).
• An LLM provider API key (OpenAI, Anthropic, Gemini) for the ReAct agents.
• A Google Chat connector authorized, with access to the target space.

Step 1 — Add the Zendesk & HubSpot triggers

Goal: set up the two entry points that subscribe to ticket events from each platform. (~4 min)

1. Drag an App Event Trigger onto the canvas and select Zendesk as the application.
2. Under Credentials / Auth, select your Zendesk connector and add its API key to authenticate the subscription.
3. Choose the ticket event(s) to subscribe to (e.g. ticket.created, ticket.updated), then apply.
4. Drag a second App Event Trigger and repeat for HubSpot, subscribing to its ticket events.
5. Switch each trigger to Listen / test mode and create a test ticket on each platform to confirm a live event arrives.

Step 2 — Fetch ticket details with HTTP Request

Goal: retrieve the full ticket record — subject, body, priority, tags — from each platform's API. (~4 min)

1. Drag an HTTP Request node after the Zendesk trigger and connect the edges.
2. Configure it to call GET /api/v2/tickets/{ticket_id}, mapping ticket_id from the trigger event with a JEXL expression.
3. Add your Zendesk auth in the headers, then click Apply.
4. Drag a second HTTP Request after the HubSpot trigger, calling GET /crm/v3/objects/tickets/{ticket_id}.
5. Map the HubSpot ticket ID from its trigger event, add HubSpot auth, then click Apply.

Step 3 — Fetch the requester's user profile

Goal: look up the person who submitted or is assigned to the ticket so the reply can be personalized. (~3 min)

1. Drag an HTTP Request node after the Zendesk ticket-details node and connect the edges.
2. Call GET /api/v2/users/{user_id}, mapping requester_id from the ticket-details output.
3. Repeat on the HubSpot path with GET /crm/v3/objects/contacts/{contact_id}, mapping the contact ID from the ticket associations.
4. Add the matching auth headers on each node and apply.

Step 4 — Configure the Intent & Sentiment ReAct Agent

Goal: classify the ticket and assign a priority — forcing a mandatory classify_intent tool call first. (~7 min)

1. Drag a ReAct Agent onto the canvas after the HTTP nodes, and connect both paths (Zendesk and HubSpot) into it so they converge here.
2. Under Models → LLM Model, choose or create a model.
3. Under Tools, attach the classify_intent tool so the agent returns a structured classification.
4. Under Prompts, paste a system prompt that forces the tool call first (see below).
5. Under Schema → Input, define zendesk_subject, zendesk_description, hubspot_subject, hubspot_description and map them from the HTTP outputs (leave the unused platform's fields empty).
6. Under Schema → Output, define the JSON fields the agent returns (see below), then click Apply.

System prompt — mandatory tool call (excerpt):

STEP 0 — MANDATORY: Call classify_intent before any analysis. No exceptions.
STEP A — Analyze: intent, sentiment, churn_risk, urgency_signals, error_codes,
         affected_features, summary, source.
STEP B — Priority (evaluated most-critical first):
  P0  outage / security_incident / legal / contract signals
  P1  churn_risk=true | angry or panicked | executive escalation
  P2  bug / billing / account_access (no P0–P1 trigger)
  P3  feature_request, single user
  P4  how_to, informational
No CRM/telemetry connected — score from ticket text only; say so in reasoning.

Output JSON schema:

{
  "intent": "bug_report | feature_request | billing | ...",
  "confidence": 0.0,
  "sentiment": "calm | frustrated | angry | urgent_panicked",
  "churn_risk": false,
  "urgency_signals": ["exact phrase from ticket"],
  "error_codes": ["codes found in ticket"],
  "product_hint": "product name or null",
  "affected_features": ["feature names"],
  "summary": "25-word max summary",
  "source": "zendesk | hubspot | both",
  "priority": "P0 | P1 | P2 | P3 | P4",
  "reasoning": "brief explanation of priority"
}

Intent categories:

Priority matrix:

Step 5 — Configure the Ticket Commentator ReAct Agent

Goal: compose a customer reply and post it to the correct CRM with source-based routing. (~6 min)

1. Drag a ReAct Agent after the Intent & Sentiment agent and connect the edges.

2. Under Tools, attach both comment tools: Add a comment to a Zendesk ticket and Add comment to ticket (HubSpot).

3. Under Schema → Input, define source, intent, sentiment, priority, summary, customer_signals, reasoning, zendesk_ticket, hubspot_ticket and map them from the previous agent and the triggers.

4. Under Prompts, paste a reply-writing prompt with the routing logic:

   • source = zendesk → post the reply only to the Zendesk ticket.
   • source = hubspot → post the reply only to the HubSpot ticket.
   • source = both → post to both platforms using their respective ticket IDs.

5. Under Schema → Output, define the confirmation JSON, then click Apply.

Reply-writing rules: max 3–5 sentences; tone follows sentiment (angry/panicked = extra empathy, calm = direct); P0/P1 use escalation language; address contract/churn/legal signals directly; no jargon or placeholders like [NAME]; always end with a clear next step or ETA.

{
  "reply_body": "The composed customer reply text",
  "source": "zendesk | hubspot | both",
  "zendesk_comment_posted": true,
  "hubspot_comment_posted": false,
  "suggested_status": "open | pending | solved | closed"
}

Step 6 — Configure the Notify Developer ReAct Agent

Goal: infer the issue owner from the reply and post a routed message to Google Chat. (~5 min)

1. Drag a ReAct Agent after the Ticket Commentator and connect the edges.
2. Under Tools, attach Create a message in a space — the agent's only tool.
3. Under Schema → Input, define source, suggested_status, zendesk_ticket, hubspot_ticket, reply_body mapped from the previous agent.
4. Under Prompts, paste a prompt that infers the owner from reply_body, forces the tool call, and targets your Google Chat space.
5. Under Schema → Output, define the success / failure JSON, then click Apply.

Owner routing table (customize the mentions to your team):

Message format:
Hey <@mention>, there is a new ticket in <zendesk|hubspot|both> — can you look into it?
Ticket: <#id | Zendesk #X & HubSpot #Y for both>
Issue:  <one-line summary from reply_body>
Status: <suggested_status>

Step 7 — Save and publish

Goal: persist your work and promote it so the triggers can fire it. (~2 min)

1. Click Save (bottom-left of the canvas) — the workflow is saved as a draft.
2. Click Publish (or Republish on later edits).
3. Wait for the success toast: "Workflow published successfully."

Step 8 — Trigger and test with a real ticket

Goal: create a ticket on each platform and watch the agents reason and act. (~3 min)

1. Create a test ticket in Zendesk with a clear subject and body (e.g. a billing question).
2. Confirm the Zendesk trigger fires, both HTTP nodes enrich the ticket, and the Intent & Sentiment agent calls classify_intent.
3. Confirm the Ticket Commentator posts a reply on the Zendesk ticket and the Notify Developer agent posts to Google Chat.
4. Repeat with a HubSpot ticket to verify the second ingestion path end-to-end.

Step 9 — Monitor the execution

Goal: review run history, trace the path, and inspect node-level inputs and outputs. (~2 min)

1. Go to Monitor → Workflow Runs.
2. Select your omnichannel triage workflow to see its execution history.
3. Click the run ID for the test you just executed.
4. Review the end-to-end trace — node_name, node_type, and each node's captured input/output.
5. Click the Intent & Sentiment agent to confirm classify_intent ran and the priority resolved as expected.

You're done — what's next

You've built an omnichannel support workflow that triages tickets from two platforms, replies on the right CRM, and notifies the owning developer. Keep going:

• Introduction to Agents — React, Supervisor, and Swarm patterns.
• Human-in-the-Loop — add approval steps between agents.
• Traceability — full run observability.

Troubleshooting

Glossary

• App Event Trigger — an entry point that subscribes to events from an app (Zendesk, HubSpot) and starts the workflow when an event arrives.
• HTTP Request — a node that calls an external REST API to fetch or send data (here, ticket and user details).
• ReAct Agent — a Reasoning-and-Acting agent that calls tools to take real actions while it works through a task.
• classify_intent — the tool the Intent & Sentiment agent calls to return a structured intent / sentiment / priority classification.
• Source routing — logic that posts a reply to Zendesk, HubSpot, or both based on the ticket's origin.