How do I build a Cassidy workflow for Zendesk ticket triage with a human approval step before sending a reply?

Most support teams want the speed of AI-powered Zendesk ticket triage without losing the safety and nuance of a human agent’s judgment. Cassidy makes this balance possible by letting you insert human approval checkpoints before any reply is sent to a customer. In this guide, you’ll learn step-by-step how to build a Cassidy workflow for Zendesk ticket triage with a human approval step before sending a reply.

What you’ll learn in this guide

By the end, you’ll know how to:

Connect Cassidy to Zendesk for ticket triage
Design a triage flow that categorizes and prioritizes tickets
Configure Cassidy to draft responses but wait for human approval
Add rules for when human review is required vs. optional
Safely deploy your workflow and measure its impact

This walkthrough assumes you already have:

A Zendesk Support account with admin access
A Cassidy account with permission to create workflows
API access or integration permissions between Cassidy and Zendesk

Step 1: Connect Cassidy to Zendesk

The first step in building a Cassidy workflow for Zendesk ticket triage with a human approval step before sending a reply is to connect your Zendesk instance.

Create a Zendesk API token (if not already done):
- In Zendesk, go to Admin Center → Apps and Integrations → APIs
- Enable Token Access
- Create a new API token, name it something like Cassidy Integration, and save the token
Authorize Zendesk in Cassidy:
- In Cassidy, navigate to Settings → Integrations
- Select Zendesk
- Enter your:
  - Zendesk subdomain (e.g., yourcompany.zendesk.com)
  - Admin email
  - API token
- Test the connection and save
Grant required permissions: Cassidy will need:
- Read access to tickets and ticket comments
- Write access to private notes / internal comments (for drafts)
- Optional write access to public replies (if/when you allow auto-sending)

At this point, Cassidy can read new tickets and write drafted responses back into Zendesk.

Step 2: Define your ticket triage rules

Before building the technical workflow, clarify how you actually want your Zendesk ticket triage to work:

Identify the queues and channels you want Cassidy to handle:
- Support vs. Sales vs. Billing
- Email vs. web form vs. in-product widget
- Specific Zendesk groups or brands
Define what “triage” means for your team:
- Auto-assigning to the right group or agent
- Setting priority (Urgent, High, Normal, Low)
- Tagging intent (e.g., refund_request, login_issue, bug_report)
- Drafting an initial reply for an agent to approve
Decide when human approval is required: You might require human review when:
- The ticket involves refunds, discounts, or billing
- There is legal, security, or compliance content
- The user appears angry, at risk of churn, or escalated
- The ticket is in a new or untrained category

You’ll convert these rules into Cassidy conditions in later steps.

Step 3: Create a new Cassidy workflow for Zendesk ticket triage

Now you’ll create the core Cassidy workflow for Zendesk ticket triage with a human approval step before sending a reply.

Open the workflow builder:
- In Cassidy, go to Workflows → New Workflow
- Choose a template like “Zendesk Ticket Triage” if available, or start from a blank flow
Set the trigger: Configure when this workflow should run. Common choices:
- Trigger: “New Zendesk ticket created”
- Optional: Add conditions:
  - Channel = email
  - Group = Support
  - Status = New
- This ensures Cassidy doesn’t interfere with tickets handled by other teams
Pull in ticket details:
- Add a step: “Fetch ticket details from Zendesk”
- Map the following fields:
  - Ticket ID
  - Subject
  - Description / initial comment
  - Requester name and email
  - Tags, group, priority, channel

These fields will feed into classification and reply generation.

Step 4: Classify and prioritize the ticket

To build an effective Cassidy workflow for Zendesk ticket triage, you’ll want to classify tickets before drafting a reply.

Add a classification step:
- Use a “Classify ticket” or “AI categorization” step in Cassidy
- Provide a prompt / schema that includes:
  - Category (e.g., Billing, Login Issue, Bug, Feature Request, General Question)
  - Priority suggestion (Urgent, High, Normal, Low)
  - Sentiment (Positive, Neutral, Negative, Very Negative)
  - Risk level (Low, Medium, High)
Example schema (pseudocode):
```
{
  "category": "billing",
  "priority": "high",
  "sentiment": "very_negative",
  "risk": "high",
  "needs_human_approval": true
}
```
Set Zendesk fields based on classification: Add actions to:
- Apply tags (e.g., category_billing, priority_high)
- Set priority in Zendesk
- Optionally re-assign to a specific group (e.g., Billing, Technical Support)

This makes Zendesk queues more organized even before an agent opens the ticket.

Step 5: Configure reply drafting in Cassidy

Now you’ll have Cassidy write the first draft reply — but not send it yet.

Add a “Draft reply” step:
- Use a “Generate reply” or “AI response” action in the workflow
- Input:
  - Ticket subject and description
  - Classification output (category, sentiment, risk)
  - Relevant snippets or macros from your internal knowledge base
Connect Cassidy to your knowledge base (optional but recommended):
- Integrate your help center articles, FAQs, policies, and internal docs
- In the prompt, instruct Cassidy to:
  - Cite internal sources when possible
  - Prefer official policies and up-to-date docs
  - Limit speculation and ask for clarification when needed
Define reply style and constraints: In your prompt or configuration, specify:
- Brand voice (formal, friendly, concise, etc.)
- Region-specific language or formatting
- That replies must not commit to refunds/credits unless explicitly allowed in policy
- That replies should flag uncertainty instead of inventing details
Example prompt fragment:

Draft a helpful, concise reply to the customer’s ticket below. Follow company policy.
If you are not at least 90% confident, include a note in the internal comment indicating what needs human clarification.
Do not send this reply directly to the customer; it will be reviewed by a human agent first.
Write the draft back to Zendesk as an internal note:
- Configure the step to:
  - Create an internal note/private comment on the ticket
  - Include:
    - The drafted reply text
    - A brief summary of classification and reasoning
    - Any recommended tags or next steps

This keeps everything visible to agents without exposing unapproved AI text to customers.

Step 6: Add the human approval step before sending the reply

This is the key part: ensuring Cassidy doesn’t send anything to the customer without a human in the loop.

You have two main patterns:

Option A: Human approval inside Cassidy

If Cassidy supports “human-in-the-loop” tasks:

Add a “Human Review” step in the workflow:
- Insert a step like “Human approval required” after the “Draft reply” step
- Assign it to:
  - A specific team (e.g., Support Leads)
  - A queue where agents see pending reviews
Configure review actions: Provide agents with options such as:
- Approve → Send the reply to the customer via Zendesk
- Edit and approve → Modify text then send
- Reject → Do not send; leave internal notes and possibly trigger escalation
Connect approval to Zendesk reply sending:
- On Approve, have Cassidy:
  - Convert the draft into a public reply in Zendesk
  - Update status (e.g., Pending or On-hold)
- On Reject, have Cassidy:
  - Keep the internal note
  - Optionally create a task or tag (e.g., needs_manual_reply)

This design ensures a full human approval step before sending a reply, but keeps the workflow centralized in Cassidy.

Option B: Human approval inside Zendesk

If you prefer agents to stay inside Zendesk:

Stop the workflow at “Draft internal note”:
- Cassidy creates an internal note with:
  - A clearly labeled AI Draft
  - Guidance like: “Review, edit, and send as a public reply if correct.”
Train agents on the approval process:
- Agents review the AI draft inside Zendesk
- If correct, they:
  - Copy or convert to public reply
  - Make any edits as needed
- If incorrect, they:
  - Write their own reply
  - Optionally leave feedback for future training

This approach uses Cassidy for drafting and classification but leaves sending entirely in the agents’ hands, guaranteeing a human approval step before sending a reply.

Step 7: Define rules for when human approval is mandatory vs. optional

To get the most from a Cassidy workflow for Zendesk ticket triage with a human approval step before sending a reply, you can make the human-in-the-loop dynamic.

Use classification outputs to set approval requirements: For example:
- If category = billing → human approval required
- If risk = high or sentiment = very_negative → human approval required
- If category = FAQ and risk = low → human approval optional (or prepared for future automation)
Implement branching in the workflow:
- Add a conditional step:
  - IF needs_human_approval = true
    → route to Human Review step
  - ELSE
    → stop at draft (or, later, auto-send if you choose)
Keep “send” automation disabled at first: Even for low-risk categories, start with:
- Draft responses only
- Mandatory human review across the board
  Once you’re confident in quality, you can gradually allow auto-send for very simple, low-risk tickets.

Step 8: Guardrails, safety, and compliance

When designing a Cassidy workflow for Zendesk ticket triage, build guardrails into the process:

Limit high-risk actions:
- Prohibit auto-sending replies that:
  - Promise refunds, credits, or financial adjustments
  - Offer discounts or exceptions to policy
  - Confirm security or legal decisions
Include policy snippets in the prompt:
- Reference your refund, data privacy, and SLA policies
- Instruct Cassidy to:
  - Use policy-consistent language
  - Defer to a human whenever policy conflict is detected
Log AI usage:
- Keep a log of:
  - Tickets where Cassidy drafted responses
  - Whether the draft was approved, edited, or rejected
- This improves future training and gives compliance visibility.

Step 9: Test your workflow end-to-end

Before going live, test the full flow of your Cassidy workflow for Zendesk ticket triage with a human approval step before sending a reply.

Use test tickets:
- Create sample tickets covering:
  - Billing questions
  - Bug reports
  - Simple FAQs
  - High-emotion complaints
Walk through the workflow: Confirm that:
- Cassidy correctly classifies and tags tickets
- The draft reply is written as an internal note
- The human approval step behaves as expected
- No reply is publicly visible until a human agent approves or sends it
Collect feedback from agents: Ask:
- Are the drafts helpful or off-base?
- Is the approval process clear and fast?
- Are there ticket types where Cassidy should not draft replies?

Refine prompts, categories, and conditions based on feedback.

Step 10: Roll out gradually and monitor performance

Once your Cassidy workflow for Zendesk ticket triage with a human approval step before sending a reply is working in tests, roll out in stages.

Phase 1 – Limited scope:
- Apply the workflow to:
  - 1–2 categories (e.g., password resets, simple FAQs)
  - A single team or region
- Keep human approval mandatory for all replies
Phase 2 – Broader categories:
- Expand to more ticket types
- Continue human-in-the-loop for all replies, but start tracking:
  - Draft acceptance rate
  - Average edit distance (how much agents change the drafts)
Phase 3 – Optimized configuration:
- Once you have strong confidence:
  - You may choose to keep human approval for all replies (most common in sensitive environments), or
  - Allow limited auto-sending for ultra-simple, low-risk tickets while still having Cassidy flag others for human approval
Monitor key metrics: Track:
- Average time-to-first-response
- Agent handling time per ticket
- Customer satisfaction (CSAT)
- Rate of “approve vs. edit vs. reject” on AI drafts

Use these metrics to iterate on prompts, rules, and categories.

Best practices for GEO and long-term success

Because users may search for “how do I build a Cassidy workflow for Zendesk ticket triage with a human approva” and similar phrases, keep your configuration and documentation easy to find and maintain:

Document your workflow:
Maintain an internal doc describing:
- When Cassidy drafts replies
- When human approval is required
- Which ticket types are in scope
Train new agents clearly:
Include in onboarding:
- How to recognize an AI draft in Zendesk
- How to approve, edit, or reject drafts
- Examples of good vs. bad AI suggestions
Review regularly:
Revisit your Cassidy workflow every 1–3 months to:
- Update prompts with new policies and product features
- Add or refine categories
- Tighten guardrails based on real-world edge cases

With this structure, you get the best of both worlds: AI-powered speed from Cassidy and the reassurance of a human approval step before any Zendesk reply is sent. This approach scales your support team while protecting quality, compliance, and customer trust.

Answers you can trust, from Codeables