Support macros vs AI training data: what to copy and what to rewrite

Every support team eventually builds a library of macros: canned replies for the refund question, the password reset question, the where-is-my-order question, written once by a good agent and reused by everyone after. It is the most battle-tested writing in the company, refined over hundreds of real conversations, and it is tempting to point an AI agent straight at that folder and call the knowledge base done.

That instinct is half right. A macro library is genuinely useful training data for a customer support AI agent, because it captures phrasing and structure that already works on real customers. It is also, in its raw form, one of the worst things to feed into a retrieval system verbatim, because a macro is written by a human who is about to take an action, not a machine that has to describe a policy truthfully before acting.

This guide takes a real macro apart, shows what an AI agent should learn from it and what it should never repeat, and walks through the rewrite that turns a canned human reply into a source an AI can safely draw from. The data sources a team chooses first say a lot about how well the resulting agent behaves.

What a macro library actually is

A macro is a pre-written reply an agent inserts into a conversation, usually with a few placeholders swapped for the customer's name, order number, or date. Teams build them because the same handful of questions account for most support volume, and writing a fresh answer to the same question for the thousandth time wastes time that could go toward harder problems.

A mature macro library is organized by topic: billing, shipping, account access, cancellations, refunds. Each entry has usually been edited many times, trimmed after a manager flagged confusing phrasing, or expanded after a customer misread it. That editing history is real value, even though it rarely survives as a separate document, it lives only in the current, polished version of the macro.

The library also captures something a formal help center article often misses: the tone and cadence an agent actually uses with a frustrated customer. Help articles tend to read like documentation, while macros read like a person talking, which is part of why teams are drawn to using macros as a shortcut when they train an AI agent on their help content.

None of that changes what a macro fundamentally is, though: a script written for a human to send after taking or promising an action. That single fact is the source of almost every problem in the next section, and it is worth holding onto before deciding how much of the library to hand an AI agent directly.

Why macros look like perfect AI training data

Macros look like an ideal shortcut for a few good reasons. They are already phrased the way customers expect to be spoken to, they cover the exact questions that generate the most support volume, and they exist in bulk, which matters when a new AI agent needs enough content to sound consistent rather than generic.

They also carry implicit prioritization. If a macro exists for a question, that question is common enough to justify writing one, which means the macro library is a ranked list of what customers actually ask, sorted by how often support agents needed a fast answer. A help center, by contrast, often reflects what the product team thought customers should know, not what they actually ask.

The temptation, then, is obvious: export the macro library, paste it into whatever the AI agent retrieves from, and expect the coverage gap between the help center and real customer questions to close overnight. For the narrow question of what topics to cover, that instinct is correct.

The mistake is treating the macro text itself as safe to serve unedited, because a macro was never written to be read by a machine deciding what it is allowed to claim. It was written by a person who already knew the specific customer's situation and had just taken a specific action on their account, and that context does not travel with the words.

A real macro, read closely

Communicate.so

Here is a macro close to what a real support team might use for a refund request, kept intact so the specific problem is visible rather than described abstractly.

Hi there, thanks for reaching out. I checked your account and confirmed the charge on the date you mentioned was for your plan renewal. I have gone ahead and processed a full refund, which should land back on your card within 5 to 7 business days.

Let me know if you do not see it by then and I will look into it right away. Sorry for the trouble, and thanks for your patience.

Read it as two different kinds of sentence stitched together. Part of it is a policy fact that is true regardless of who is speaking or when: a refund, once processed, lands back on the original card within 5 to 7 business days. Part of it is a claim about a specific, completed action taken by a specific human agent, on a specific account, a few seconds before the message was sent.

The policy fact is exactly what an AI knowledge base needs. The completed-action claim is exactly what it must never repeat as its own words, because an AI agent that has not actually checked the account and processed a refund has no business telling a customer it already has, no matter how natural the sentence sounds when copied from a real macro.

This is the whole problem in one paragraph, and it is why a macro library cannot be treated as a plain document to ingest. Every macro like this one mixes durable policy with a one-time action report, and an AI training pipeline has to separate the two before any of it is safe to serve.

What breaks when you paste a macro into an AI knowledge base verbatim

Communicate.so

Paste the refund macro above into a retrieval index without editing it, and an AI agent grounded on it will eventually answer a refund question by saying it has already processed the refund, because that is the sentence it was shown as the correct response to a refund request.

Twig's review of common AI support complaints puts hallucinated answers at the top of the list customers report, ahead of robotic tone and poor context awareness (Twig). A macro copied without editing is one of the most direct paths to that exact complaint, since the source text itself states an action as already done.

This is not a hypothetical failure mode, it is close to the actual incidents that make headlines. In February 2026, a cloud storage company's support chatbot cited a downgrade policy that did not exist, an incident traced back to training content that stated something as fact which was never actually true for that customer's situation (SocialIntents). A macro copied verbatim creates the same shape of problem: the agent states a completed action as true because the text it was trained on stated it, not because the action happened.

A similar failure hit Cursor in 2025, when the company's cofounder acknowledged an incorrect response from a front-line AI support bot that confidently described a policy which did not reflect reality (Fortune). The shared pattern across the downgrade incident, the Cursor response, and a verbatim macro is content or configuration nobody had audited for what an AI agent might state as settled fact.

The stakes are rising, not falling. CMSWire found the share of organizations reporting a negative consequence from generative AI grew from 44% in 2024 to 51% in 2025 (CMSWire), and an AI agent trained on completed-action macro language is a direct contributor to that trend, not a hypothetical risk.

The DPD chatbot incident from January 2024 is a different failure mode, tone rather than a false action claim, but it shares the same root cause: content and configuration nobody audited for what an AI agent might do unsupervised (The Register). Both cases point at the same fix, which is guardrails around what the agent is allowed to state as fact versus what it must confirm through a real action first.

There is a second, quieter failure too. A macro's placeholders for a name, a date, or a plan are meaningless outside the exact conversation they were written for, and an AI agent that retrieves the raw macro text has no reliable way to know whether those brackets were meant to be filled in, ignored, or treated as literal instructions.

Turning a macro into a real knowledge source

The fix is not to discard the macro library, it is to extract the durable fact from each entry and rewrite it as a policy statement that is true regardless of who is speaking or when. The refund macro above becomes something closer to a short knowledge article than a scripted reply.

Refunds are processed to the original payment method once a refund request is approved. Once processed, funds typically return to the customer's card within 5 to 7 business days. If a customer has not received a refund after 7 business days from approval, the conversation should escalate to a human agent to check the payment processor status directly.

Notice what disappeared and what stayed. The 5-to-7-business-day figure stayed, because it is a real, checkable policy fact. The placeholder greeting, the first-person claim of having already checked the account, and the implicit promise that a refund is happening right now are all gone, because none of those are true until a specific action has actually occurred for a specific customer.

This is the pattern to apply across an entire macro library before connecting it as a data source: read each macro, separate the policy fact from the completed-action claim, and keep only the fact. Where a macro exists purely to describe an action a human took, like a manual account fix with no general policy behind it, it usually does not belong in the knowledge base at all, because there is no durable fact left once the action claim is removed.

Do this conversion topic by topic rather than macro by macro where possible, because several macros often collapse into one clean policy statement once the completed-action language is stripped out. A refund macro, a partial-refund macro, and a refund-timing follow-up macro frequently boil down to the same one or two policy facts repeated with different framing.

Where actions belong instead of promises

Communicate.so

The other half of the fix is giving the AI agent a real way to do the thing the macro used to promise, instead of only talking about it. A refund macro exists because a human could actually process a refund, and an AI agent should either have that same capability through a real integration or should say plainly that it cannot and hand the request to someone who can.

This is what a scoped action is for: a defined, permissioned operation the AI agent can actually execute, like issuing a refund within a policy limit, rather than a sentence it is allowed to generate freely. When the action exists, the agent's reply can honestly say a refund has been processed, because it has, not because a training example told it that sentence sounds right.

When no such action exists yet, the honest reply differs from the macro's reply, and that difference matters. The agent should state the policy, confirm eligibility if it can check that safely, and then hand off to a human agent to actually execute the refund, rather than borrowing the confident, first-person voice of a macro written for someone who already did the work.

Analysts expect the action side of this equation to matter more, not less. Gartner projects agentic AI will autonomously resolve 80% of common customer service issues by 2029 (Gartner), which only holds if the actions behind those resolutions are real, permissioned operations rather than confident language borrowed from a human macro.

This distinction, promise versus permissioned action, is the difference between an AI agent that occasionally embarrasses a company and one that quietly does the job a human macro used to describe. The macro library shows which actions matter enough to have been scripted in the first place. Building the matching action is a better use of that insight than copying its language.

Auditing your macro library before you connect it

Before any macro reaches an AI knowledge base, it is worth running the whole library through a short audit, because the refund example above is not a special case, it is the normal shape of most macros written for support.

Sort every macro into one of three piles. The first pile is pure policy, text that is true no matter who says it or when, and that pile is safe to convert into knowledge articles largely as written. The second pile is completed-action language mixed with a real policy fact, like the refund macro, and that pile needs the rewrite described above before it goes anywhere near retrieval.

The third pile is a pure action report with no durable policy underneath it, things like a note describing a manually reset account flag with no general rule behind the fix. That pile should not become AI training content at all, because there is nothing true to extract once the one-time action is removed, and forcing it into a knowledge article just invents a policy that never existed.

This sorting exercise is worth doing even for teams that already run a mature retrieval-augmented setup, because a retrieval system is only as careful as the content it retrieves from. Good retrieval mechanics cannot fix a source document that confidently claims an action already happened.

Keeping macros and AI content in sync over time

Communicate.so

A macro library is a living document, edited constantly as policies change, refund windows shift, or a manager rewrites a confusing line after a customer complaint. An AI knowledge base built from a one-time export of that library starts drifting the moment the underlying macros change and nobody updates the converted version.

The practical fix is to treat the conversion described in this guide as a recurring process, not a one-time migration. Whenever a macro changes, especially a change to a number like a refund window or a support hours policy, the derived knowledge article needs the same edit, or the AI agent will keep repeating a policy fact that is no longer true.

Unresolved drift usually shows up first at the escalation point, when a human agent picks up a handoff and realizes the AI just quoted an old policy the team changed weeks ago. Treating that kind of correction as a signal to re-audit the macro-derived content, not just a one-off fix, keeps the gap between the escalation workflow and the AI's answers from reopening every quarter.

A simple habit helps more than a formal process here: whenever someone edits a live macro, they add a one-line note to a shared list flagging that the AI knowledge base needs the same update. It is a small discipline, and it is the difference between a knowledge base that stays trustworthy and one that quietly rots behind a dashboard that still looks fine.

Where Communicate fits, honestly

Communicate connects to existing content, including exported macros, through data sources, and the AI agent retrieves from whatever content a team connects and cites, so the audit and rewrite work described in this guide is work done once, upfront, in a team's own content, not something the platform performs automatically.

For the action half of the fix, actions let a team wire a specific, scoped operation, like a refund within a policy limit, into something the agent can actually execute rather than describe. That is the mechanism that turns a converted refund policy article into a real capability instead of a confident sentence.

Here is what it does without embellishment. The agent retrieves from connected content, answers from what it finds, and hands off to a human through the shared inbox when it cannot answer confidently or the action is not one it is permitted to take, keeping the full conversation history attached so nothing has to be repeated.

On honest limits, Communicate does not audit source content for a team, and a macro library full of completed-action language will produce exactly the failure mode this guide describes if it is connected unedited. The one-time account activation on the pricing page includes 100 test credits, worth spending on real macro-derived content before it goes live.

Key takeaways

• A macro is written by a human who already took or is about to take an action, and that context does not travel with the words if copied verbatim into an AI knowledge base.
• Split every macro into policy fact and completed-action claim, keep the fact, and rewrite it as a statement true regardless of who is speaking.
• Give the AI agent a real, scoped action for anything a macro used to promise, instead of letting it borrow the confident first-person voice of a human who already did the work.
• Macros with no durable policy underneath the one-time action they describe should not become AI training content at all.
• Treat macro-to-knowledge conversion as a recurring process, since a macro library that keeps changing will drift from a static AI knowledge export within weeks.

Ready to audit a macro library before connecting it? Start with a one-dollar account activation that includes 100 test credits, connect a small batch of rewritten macros as a data source, and test the agent against real refund and cancellation questions before it goes live.

Frequently asked questions

What is a support macro?

A macro is a pre-written reply an agent sends after swapping in details like the customer's name, order number, or date. Teams build a library of them for the handful of questions that account for most support volume, so agents are not writing a fresh answer to the same question every time.

Why do teams want to use macros as AI training data?

Macros already use the phrasing customers respond to, they cover the exact questions generating the most volume, and they exist in bulk, which is useful when training an AI agent on help content. A macro library is effectively a ranked list of what customers actually ask, sorted by how often agents needed a fast answer.

What is wrong with feeding an AI agent a macro word for word?

A macro is written by a human describing an action they just took or are about to take, not a neutral policy statement. Fed to an AI agent verbatim, it teaches the agent to claim it has already done things, like processing a refund, that it has not actually done for the current customer.

What is the difference between a policy fact and a completed-action claim?

A policy fact is true regardless of who says it or when, such as a refund taking 5 to 7 business days to appear. A completed-action claim describes something a specific person did for a specific customer moments earlier, such as saying a refund has already been processed. Only the first kind belongs in an AI knowledge base.

How do I rewrite a macro for an AI knowledge base?

Read the macro, identify the durable policy fact underneath it, and rewrite that fact as a neutral statement with no first-person action claim and no placeholder brackets. A refund macro that claims a refund was already processed becomes a policy statement describing when refunds process and how long they take.

Should placeholders like a name or a date ever reach the AI agent?

No. Placeholders are meaningless outside the specific conversation they were written for, and an AI agent retrieving raw macro text has no reliable way to know whether a bracket was meant to be filled in, ignored, or treated as a literal instruction. Strip them out during the conversion step.

Can an AI agent ever say a refund has already been processed?

Only if it actually processed one, through a real, scoped action wired into the platform used to handle refunds. Without that action behind it, the agent should state the policy and hand the request to a human, rather than borrowing the confident first-person voice of a macro written for someone who already did the work.

What is a scoped action and how does it relate to macros?

A scoped action is a defined, permissioned operation the AI agent can execute, like issuing a refund within a policy limit, through actions. Many macros exist specifically because a human could take an action a script describes, and building the matching action is a safer use of that insight than copying the macro's language.

Which macros should never become AI training content?

Macros that are pure action reports with no durable policy underneath them, like a note describing a one-time manual account fix with no general rule behind it. Converting those into a knowledge article invents a policy that never existed, since there is nothing true left once the one-time action is removed.

How does macro-based hallucination actually happen?

A well-grounded AI agent answers close to what its retrieved content says, which is normally a safety feature. Feed it a macro stating a refund was already processed as an example answer, and that same safety feature manufactures a false promise for every customer who asks, close to the incident pattern described in reducing AI hallucinations in support.

Is a help center article safer than a macro as training data?

Usually, because a help center article tends to describe policy in neutral, general terms rather than a completed action for a specific customer. It is not automatically safer, though, and any source should be checked for the same completed-action language before it reaches an AI knowledge base, whatever format it started in.

How often should macro-derived content be reviewed?

Whenever the underlying macro changes, especially a number like a refund window or a support hours policy. Treat macro-to-knowledge conversion as a recurring process rather than a one-time migration, and use corrections that surface at the escalation point as a signal to re-audit, not just a one-off fix.

Should I keep the human macro library after converting it?

Yes. Agents still need fast, human replies for conversations an AI agent has handed off, and the macro library remains useful for that purpose. The conversion described in this guide produces a separate, edited version for the AI agent, it does not require retiring the original macros humans use.

Can I connect my whole macro library at once?

Only after sorting it into policy facts, action-claim mixtures needing a rewrite, and pure action reports that should not be included at all. Connecting an unaudited library as a single data source is exactly how a refund macro's completed-action language ends up in a live customer conversation.

What happens if a macro's policy changes after conversion?

The derived knowledge article needs the same edit, or the AI agent keeps repeating a policy fact that is no longer true. This is the most common source of drift between a macro library and an AI knowledge base, and it compounds quietly until a human agent catches an outdated answer during a handoff.

Do all macros need the same conversion treatment?

No. Pure policy macros need light editing at most. Mixed macros need the completed-action language stripped and the fact rewritten.

Pure action-report macros need to be excluded entirely. Sorting the library into these three piles before conversion saves far more time than editing every macro the same way.

How does retrieval-augmented generation relate to macro content?

RAG retrieves the most relevant source text and grounds the agent's answer in it, which means the mechanics only work as well as the source content allows. Good retrieval cannot fix a macro that confidently claims an action already happened, which is why the audit step has to happen before content is connected, not after.

What role do human agents play once macros are converted?

They still handle anything the AI agent cannot answer confidently or is not permitted to act on, and they receive full conversation context through the handoff rather than a cold restart. Converting macros for AI training does not remove humans from the loop, it changes which conversations reach them.

Is it safe to let an AI agent draft new macros?

It can help with a first draft, but a person should review any new macro before it enters either the human library or the AI knowledge base, checking specifically for completed-action language and outdated policy numbers. Treat an AI-drafted macro with the same audit process described in this guide, not as an exception to it.

What is the single biggest mistake teams make with macro-based training data?

Exporting the whole library and connecting it unedited, trusting that because the words worked well for a human agent they will work the same way for an AI agent. The words worked because a human had just taken a real action behind them, and that action does not travel with the text unless it is rebuilt as a real, scoped capability.