Why AI support needs guardrails on destructive actions
By Caden Boatright
Most AI customer service failures are recoverable. The agent gives a wrong answer; the customer comes back; a human cleans it up. But some actions can't be undone. A cancelled order shipped an hour later. A deleted account with two years of billing history. A refund issued when the customer only meant to ask about the return window.
Destructive action guardrails exist to insert a human-comprehensible confirmation step before anything irreversible happens.
What makes an action “destructive”
An action is destructive if its consequences are difficult or impossible to reverse, and if they could be materially harmful to the customer. Some examples:
- Always destructive: Account deletion, subscription cancellation, order cancellation (once in fulfillment), permanent data exports with deletion.
- Often destructive: Refund initiation (difficult to reverse once processed), address change on a shipped order, downgrade from a paid plan.
- Rarely destructive: Order status lookup, billing history view, password reset (reversible, low stakes).
The classification depends on your specific system. What matters is that you make the decision deliberately rather than treating all actions the same.
The confirmation pattern
A well-designed destructive action flow has three parts:
- Inform: Tell the customer exactly what's about to happen. “This will cancel your subscription, which is currently active through April 30. Your account will revert to the free tier on May 1.” The more specific, the better.
- Confirm: Require an explicit acknowledgment. Not “is that okay?” (too soft) but “Reply ‘confirm’ to proceed, or ‘cancel’ to keep your subscription.” The bar for confirmation should scale with the severity of the action.
- Execute: Only after confirmation, call the API. Log the confirmation with a timestamp. If the API call fails, surface the failure clearly rather than silently dropping it.
What can go wrong without guardrails
AI models are confident by default. Without a confirmation step, the model may:
- Misinterpret intent: “Can I cancel my subscription?” becomes an immediate cancellation rather than an inquiry about the cancellation process.
- Act on ambiguous context: “Cancel that” in a conversation about multiple topics becomes an ambiguous destructive action.
- Chain unintended consequences: A refund for one order might trigger cancellation logic elsewhere in the system if the API is called without scoped parameters.
How to implement this in Velor
In Velor's action system, you mark an action as destructive with a single flag in the action definition. The agent runtime automatically:
- Intercepts the decision before calling the webhook
- Shows the customer a confirmation card listing the exact parameters the action will be called with
- Waits for explicit confirmation before dispatching the signed request
The card is built from the request itself, not from a description the model wrote: each parameter the action declares is listed with the value that will be sent (order, amount, currency and so on), and one the agent left out reads “Not specified” — so a refund with no amount is visible as one before anyone confirms. Confirming binds the dispatch to exactly those values.
Destructive action guardrails don't reduce the agent's capability — they make it safer to grant the agent more capability. A team that trusts their agent won't cancel orders by accident can give it access to more of the billing API. The guardrail is what makes the access appropriate.
Numbers in this post that cite no source are rules of thumb, not Velor measurements. Velor has no customer deployment to measure yet.