How to use AI to generate support macros from past tickets

What "generating macros from past tickets" actually means

A macro is a saved bundle of a canned reply plus a set of ticket actions (set status, add tags, change assignee) that an agent applies with one click. Macros are manual by design, the agent picks and applies them, unlike triggers and automations that fire on their own, as Zendesk documents.

The hard part has never been applying macros. It's writing them. Most teams have a handful of macros somebody created in a hurry two years ago, while the actual repeat questions, the ones eating your agents' afternoons, never got templated because nobody had time to comb through the ticket history and spot them.

That's the gap AI closes. There are two distinct things AI can do with your ticket history, and people constantly conflate them:

The first, applying an existing macro, is the one most native helpdesk AI does: it reads the open ticket, matches it against past tickets, and suggests which of your saved macros fits. Useful, but it can only recommend macros you've already written.

The second, creating new macros, is what this guide is really about: AI reads through your resolved tickets, finds the recurring replies your agents type by hand over and over, and proposes brand-new macro templates for the gaps. This is where the time savings live, and it's the part teams most often ask us for. Across our own sales calls, training the AI on a company's own past tickets is the single most-requested capability we hear, full stop.

What you'll need before you start

This is a how-to, so let's be concrete about the prerequisites:

• Access to your resolved ticket history. Most helpdesks let you export tickets to CSV, or reach them via API. You want resolved tickets specifically, the ones an agent actually answered, not spam or auto-closed noise.
• A sense of your volume. A few hundred resolved tickets per common topic is a healthy floor. Below that, AI is guessing from too little signal. (Zendesk's own model won't even turn on under 100 tickets, more on that below.)
• Somewhere to review drafts. Whether that's a spreadsheet, a doc, or an AI tool's review screen, you need a place where an agent can read and edit each draft before it becomes a live macro.
• An AI layer. Either your helpdesk's native AI add-on, a general-purpose LLM you paste tickets into, or a dedicated tool like eesel AI that connects to the helpdesk and does the whole loop for you.

Here's the end-to-end pipeline before we walk each step:

Step 1: Pull and clean your past tickets

Start by exporting a representative slice of resolved tickets. "Representative" is doing real work in that sentence, this is the step that quietly decides how good your macros end up being.

A few things worth getting right:

• Sample across time, not just last week. A month of tickets is skewed by whatever happened that month. Pull from a longer window so seasonal spikes don't dominate. One flower-delivery brand we worked with on Gorgias was deliberate about this: they wanted 300 random tickets per month across ten months, excluding their Valentine's Day and Mother's Day spikes, because those weeks were nothing like a normal day and would have biased every macro toward "where's my bouquet."
• Only real, rep-handled tickets. Strip out auto-replies, spam, and tickets that closed without an agent answer. You're trying to learn how your team responds, not what your existing automations already cover.
• Keep the resolution, not just the question. A ticket is only useful here if it includes the agent's actual reply. The reply is the raw material for the macro text.

If you've never looked at your ticket data this way, a support ticket analysis pass is worth doing on its own, it tells you which topics are even worth templating before you write a line.

Step 2: Let AI cluster the repeat questions

Now hand that pile of tickets to AI and ask it to group them by intent. You're looking for clusters like "where is my order," "how do I reset my password," "request a refund," "change my shipping address," the questions that show up hundreds of times with only the details swapped out.

This is the step that's genuinely tedious by hand and genuinely fast for a model. A good AI pass will come back with something like: "47% of your tickets fall into 9 recurring topics; here are the 9, ranked by volume, with a sample ticket for each." That ranking is your macro to-do list, written for you.

The same clustering logic underpins AI ticket classification and triage, so if you've already set up auto-tagging or routing, you may have half of this work done. The tags themselves are a head start on the clusters.

Step 3: Turn each cluster into a macro draft

For each cluster, ask the AI to draft a macro: a reusable reply written in your team's tone, generalised from the real replies your agents sent, with placeholders where the specifics go.

This is where training on your tickets beats a generic template library. Anyone can hand you a stock "refund request" macro. Only your own ticket history knows that your team always opens with "Totally understand the frustration," always links the returns policy, and always asks for the order number in the same breath. A macro drafted from your history sounds like you; a stock one sounds like a form letter.

A subtle trap here is audience. We've seen teams whose knowledge base is written for administrators while their tickets come from end-users, a transit-tech support team, for instance, whose docs targeted bus-fleet admins but whose tickets came from riders. If your past replies were written for the right audience, your AI macros inherit that. If they weren't, fix the source replies first or the macros will be confidently wrong for the people reading them.

Good macros also capture institutional knowledge before it walks out the door. One French public-sector IT firm came to us precisely because two senior agents with deep ERP troubleshooting knowledge were leaving that year, and they wanted that expertise "put into AI" before it left. Generating macros from those agents' past tickets is one of the cleanest ways to bottle that knowledge.

Step 4: Review, edit, and add the actions

Never ship an AI-drafted macro straight to customers. Every draft is a first draft.

In review, an agent should:

• Check the facts. Did the AI invent a policy detail or a refund window? Correct it.
• Tune the tone. Nudge anything that reads slightly off-brand.
• Add the ticket actions. The reply text is only half a macro. The other half is what happens to the ticket: set status to solved, add a refund-processed tag, reassign to the billing group, set priority. AI can suggest these from the patterns in your history, but a human confirms them.
• Mind the placeholders. If you're in Zendesk, escape placeholders correctly on problem/incident tickets (e.g. Hello \{{ticket.requester.first_name}}) so a requester's name doesn't leak across linked tickets.

This review step is the whole reason to keep humans in the loop. The AI removes the blank-page problem; your agents keep the judgment. For refund, exchange, and shipping replies specifically, we've written a dedicated walkthrough of AI macro templates you can lift from.

Step 5: Test on real history before you go live

Here's the step almost everyone skips, and the one that separates a macro library that helps from one that quietly creates rework.

Before you publish a new macro (or let an AI agent start applying it), run it against a batch of past tickets and see what would have happened. Did the "where is my order" macro fire on the right tickets? Did it ever fire on the wrong ones? What's the realistic coverage, and where's the confidence shaky?

This is exactly what eesel AI's simulation mode is built for: it runs your setup over thousands of your real historical tickets and shows predicted resolution rate and coverage before a single customer sees it. You tune, re-run, and only deploy once the numbers look right.

The principle holds even without a dedicated tool: pull 50 recent tickets the macro should match, apply it manually, and eyeball the result. Cheap insurance against a macro that misfires at scale.

Step 6: Publish, then keep it fresh

Once a macro passes review and testing, publish it, as a shared macro so the whole team benefits, not a personal one buried in one agent's list. Then treat the library as living, not finished.

Your products change, your policies change, and new repeat questions emerge that didn't exist last quarter. Re-run the mining pass periodically, monthly is a sensible cadence, to catch new clusters and retire macros nobody applies anymore. This is the same loop behind reducing ticket volume with AI: the history keeps teaching you what to automate next.

Doing this natively in Zendesk, Freshdesk, and Gorgias

If you'd rather stay inside your helpdesk, here's where the native AI sits, and where it stops.

Zendesk

Zendesk has two separate AI-for-macros features, and they map neatly onto the two modes from earlier. Suggested macros (agent-facing) recommends which existing shared macro to apply: its model compares the open ticket against tickets from the last nine months where a macro was applied. You turn it on in Admin Center under Agent tools.

In the agent view, suggested macros surface in a "Suggested for this ticket" section, and with the Copilot add-on each one carries a confidence level.

The feature that actually creates macros from history is Macro Content Suggestions (admin-facing): it detects recurring content across all agent replies in the account and proposes brand-new macros to create, using the previous month's data. The catches: it's part of the Zendesk AI add-on, suggested macros need at least 100 qualifying tickets and 3 shared macros before they'll switch on, and new macros take two weeks to enter the model. Powerful, but plan-gated and slow to warm up.

Freshdesk

Freshdesk leans on Freddy AI for reply suggestions and canned-response assistance, and its auto-triage learns categorisation from past tickets. The macro-generation-from-history story is thinner than Zendesk's, and the strongest Freddy features sit on higher tiers, so many teams pair Freshdesk with a dedicated AI layer for the heavier lifting.

Gorgias

Gorgias is ecommerce-focused and strong on macros tied to Shopify order data, but like the others, the "learn from my whole ticket history and draft new templates" workflow is where a purpose-built tool tends to go further than the native feature set.

The common thread: native helpers are convenient if you're already deep in one platform and on the right plan, but they're locked to that platform, gated by add-ons and thresholds, and offer little to no way to test a macro on history before it's live.

Common mistakes to avoid

• Templating one-offs. If a question shows up three times a year, it doesn't need a macro. Rank by volume and template the top of the list.
• Skipping the human review. AI drafts are first drafts. Shipping them unread is how a wrong refund window ends up in 4,000 replies.
• Forgetting the actions. A macro that writes a lovely reply but doesn't set status or tags just creates a second click. Bundle the ticket actions in.
• Never re-running the mining pass. A library you build once and never refresh goes stale within a quarter.
• Not testing before launch. If your tool can simulate on past tickets, use it. If it can't, do a manual spot-check on 50 tickets.

Try eesel for macros from past tickets

eesel AI is built around exactly this loop. It connects to Zendesk, Freshdesk, Gorgias, and 100+ other tools, trains on your past tickets and knowledge base to draft replies in your team's voice, and, the part that's hard to find elsewhere, lets you simulate the whole thing over thousands of your real historical tickets so you see predicted accuracy and coverage before going live.

There are no seat fees and no per-resolution surprises (see the pricing), and you can start free, so you can mine your own ticket history and see the macros it drafts before committing to anything. If your goal is fewer repetitive replies and a macro library that actually reflects how your team works, this is the fastest way there.