Should your Zendesk AI agent reply autonomously or work as a sidebar copilot?

Run a Zendesk AI agent autonomously on high-volume, low-risk categories like order status and password resets, and keep it as a sidebar copilot on anything where a wrong answer costs a customer, money or a contract. The same agent, with the same instructions, tools and knowledge, can run either way. The only mechanical difference is whether it has a trigger.

Autonomous mode: the agent reads new tickets, reasons through them, and replies to customers directly. No human in the loop.

Sidebar copilot mode: the agent lives as a widget in the Zendesk agent workspace. Your teammates ask it to summarize tickets, look things up and draft replies. The human still hits send.

Most teams end up using both. The question is which workflow gets which mode, and that decision matters more than which AI model you pick.

When should a Zendesk AI agent reply on its own?

Autonomous mode is what people imagine when they hear "AI customer support." A ticket arrives, the agent handles it, and the customer gets an answer without waiting for a human shift to start.

It works well for:

• High-volume repetitive categories: order status checks, password resets, shipping questions, refund eligibility, return label requests. Pull a month of your own solved tickets and count these; they are usually the biggest single block in the queue.
• Low-risk decisions: anything where a wrong answer costs you a follow-up ticket, not a lost customer or legal liability.
• Time-sensitive responses: when first-response time drives CSAT. An agent replying in seconds beats a human replying the next morning.

You set it up with a trigger, most commonly Ticket Created, and the agent runs on every new ticket that matches. See the autonomous triggers guide for setup details.

The constraint: in autonomous mode, write operations execute immediately. The agent doesn't ask permission before posting a public reply, updating a status, or processing a refund (if you've given it that tool). That's the deal. You configure it carefully, you test it carefully, then you trust it.

When should the agent stay in the sidebar as a copilot?

Copilot mode keeps a human in the loop. The agent surfaces inside Zendesk as a sidebar widget on the agent workspace. Your team chats with it: "@refundAgent what's the status on ticket #4821?" The agent reads the ticket, looks up the order in Stripe, checks the customer's history, and drafts a reply. Your teammate reviews, edits if needed, and sends.

It works well for:

• Complex, ambiguous or sensitive tickets: angry customers, legal-adjacent questions, cancellation requests, anything where tone matters.
• Low-volume but high-stakes work: enterprise account issues, B2B escalations, anything where the relationship is worth more than the time saved.
• Onboarding the agent: while you're still learning what the AI does well and where it slips, copilot mode lets you watch its reasoning without exposing customers to mistakes.
• Research for human agents: "summarize this thread," "pull the customer's last three orders," "draft a polite no." The agent works for your team, not as a customer-facing voice.

Write operations in copilot mode require explicit confirmation. The agent drafts a refund and pauses; your teammate clicks "Confirm" to process it. That's the safety net.

Zendesk sells the same split natively: its AI agents are billed per automated resolution, and its Copilot add-on is $50 per agent a month on Suite Professional and above. On Macha both modes sit on one plan priced by ticket volume, and a Copilot chat counts as one ticket, the same as an autonomous thread.

Can one setup run both modes at once?

Yes, and for most support teams that's the honest answer:

• Autonomous mode handles tier 1: the high-volume, low-risk, repetitive categories
• Copilot mode handles tier 2: the work humans still do, just faster and better informed

You can run this two ways, and either works:

Option A: Separate agents per mode

You build one autonomous agent scoped narrowly to safe categories ("only handle order status, shipping questions, and refund-under-$50 requests") with a trigger on Ticket Created. Anything outside those categories, the agent escalates with a private note tagged "needs-human."

You build a separate copilot agent with broader tool access and looser instructions, available as a widget for your team on the hard tickets.

Option B: One agent, both modes

You configure one agent with full tool access and instructions that say "only auto-reply if you're highly confident in the answer; otherwise escalate." The trigger fires the agent autonomously; the same agent is also available in the sidebar. Same brain, two interfaces.

Option A is cleaner if you want strict separation of concerns. Option B is simpler to manage if you trust your instructions to handle the gating. Most teams start with A and move to B as confidence builds.

How do you decide which mode each ticket category gets?

Three factors:

1. Volume

If a category has fewer than about 50 tickets a month, autonomous mode probably isn't worth setting up: your team handles them faster than you can build and test the trigger. Copilot mode fits low-volume work because the setup cost is lower (no trigger, no confidence threshold).

If a category has 500 or more tickets a month, autonomous is the clear choice. The arithmetic wins.

2. Risk tolerance

For each category, ask: what's the cost of the agent getting it wrong?

• "Wrong tracking info given": low cost. The customer asks again, the agent corrects, no harm done. Autonomous.
• "Processed a refund that shouldn't have been processed": moderate cost. Reversible but messy. Copilot, or autonomous with a strict dollar cap.
• "Told an enterprise customer the wrong contract terms": high cost. It damages a multi-thousand-dollar relationship. Copilot, always.

3. Team trust

This matters more than people admit. If your support team doesn't yet trust the AI, autonomous mode breeds resentment: they'll feel the AI is making them obsolete, and they'll lose context when handoffs happen mid-conversation.

Start in copilot mode for the first month. Let the team use the AI, see what it does well, see what it gets wrong. Then graduate the safe categories to autonomous one at a time. The team will pull for it once they see the AI handling the boring tickets they didn't want anyway.

What changes in the setup between the two modes?

Mechanically, the modes differ only in the trigger:

• Autonomous: add a trigger (Ticket Created, Comment Added or Custom Webhook). The agent runs without human input. See the trigger setup guide.
• Copilot: no trigger needed. Install the Macha widget in your Zendesk agent workspace from the marketplace. Team members invoke the agent on demand.

Same agent. Same tools. Same knowledge. Same model. You switch modes by adding or removing the trigger. The pattern isn't Zendesk-only either: Macha runs on Zendesk, Freshdesk, Gorgias, Front, HubSpot or Intercom.

What's a safe way to start?

If you're new to AI agents in Zendesk and not sure where to begin:

1. Build one agent with access to your Help Center, Zendesk tools, and one external system (for example your e-commerce platform or payment processor).
2. Run it in copilot mode for two weeks. Let your team chat with it on real tickets. Watch where it shines and where it slips.
3. Pick one safe, high-volume category, usually order status or refund-eligibility questions.
4. Add an autonomous trigger scoped narrowly to that category. Use Test Run on 10 historical tickets before going live, and remember a test run takes real actions, so point it at tickets where a reply is harmless.
5. Monitor for a week. Measure resolution rate, CSAT and reopened-ticket rate.
6. Expand to the next category if the numbers hold, or tighten instructions if not.

By month three you'll know which categories want autonomous and which want copilot. The split is rarely all one way: the sensitive categories tend to stay in copilot for good.

Ready to start? The complete setup walkthrough takes you through both modes step by step. Or compare with Zendesk's native AI Agents to see which platform fits your team.