When your AI agent chains steps: what changes, what to watch

A customer cancels Tuesday's 7pm appointment. Until fairly recently, the best an automated system could manage was "your appointment has been cancelled, thanks" — everything after that was yours to sort out. Now there are agents that take the same message and do five more things: free the slot, check who's on the waiting list, message that person, book the new appointment and leave you a summary. That isn't answering any more. That's running a chain. And it moves the thing you need to watch: the risk is no longer in what it says, it's in where it breaks.

A chain is not the old if-this-then-that flow

Stringing several steps together isn't new. What changed is how the next step gets decided.

Classic automations were decision trees. If the customer types "cancel", send message 3. Somebody had to write every branch by hand, and they worked beautifully as long as reality matched the drawing. They fell over the moment a customer replied "well, or Thursday if you've got anything" instead of a clean yes or no.

An agent that chains steps doesn't follow a tree. It reads the result of the previous step and decides what to do next. If nobody on the waiting list fits the slot, it doesn't hang around waiting for a branch nobody wrote — it takes a different route. That's why it copes with real life, where messages arrive half-finished, misspelled and with three separate requests jammed into one paragraph.

The price of that flexibility: you can no longer look at the chain and know exactly what will happen. You know what it's allowed to do and where its limits are, which is a different kind of certainty. Everything below follows from that.

Step 1 almost never fails. Step 4 is the problem

When a single automated reply goes wrong, the blast radius is small — a customer gets an odd message and life goes on. When step four of a six-step chain fails, the damage is different in kind: your business is left half-done.

Back to the cancellation. The agent frees the slot, finds someone on the waiting list, and right there the message fails to send. Where does that leave you? An open slot nobody knows about, a person still waiting who was never contacted, and a calendar that says something other than what you believe. Worst of all, you've mentally filed it as handled, because "the agent takes care of that".

So here's the question to ask anyone selling you multi-step automation, and almost nobody asks it: what happens when a step fails halfway through? There are two acceptable answers. Either it undoes what it already did and puts things back, or it stops dead, touches nothing else and tells you. Anything that sounds like "it retries and carries on", with no further detail, means nobody has thought about it.

The three actions you can't take back

Not every step in a chain carries the same weight. Most are reversible: looking something up, writing an internal note, moving a record. If they go wrong you fix them and nobody notices.

Then there are three families with no undo button:

• Anything that leaves the building. A WhatsApp, an email, an SMS to a customer. You can write again to correct it, but they've already read the first one.
• Anything that moves money. Taking a payment, issuing a refund, raising an invoice. Fixable, sure — with paperwork and an awkward phone call attached.
• Anything that deletes or cancels. Voiding an appointment, closing an account, removing a record. Sometimes recoverable; sometimes you've just wiped the history.

This distinction is the single most useful idea here, because it tells you exactly where the brake goes. The approval point sits immediately before the first irreversible action — not at the start, where it adds nothing and makes you rubber-stamp trivia, and not at the end, where it's too late. The first three steps that only look things up and tidy them? Let it run those alone. Step four, the one that messages a customer, comes to you until you trust it.

Writing a chain that won't leave you stranded

Before you build anything, write the chain out on paper. Numbered, in plain English, marking what's reversible and what isn't. Something like this:

1. Read the message, spot that it's a cancellation   reversible
2. Free the slot in the calendar                     reversible
3. Find the best fit on the waiting list             reversible
4. Message that person offering the slot             IRREVERSIBLE
5. Confirm and book the new appointment              reversible
6. Leave you a summary                               reversible

With that in front of you, three rules that hold for any chain:

1. It must not repeat itself. If the chain somehow runs twice — a duplicate message, a retry after a wobble — step 4 can't send two offers and the payment can't go out twice. Every step needs to be able to ask "have I already done this?" before doing it. It's the difference between grown-up automation and the kind that one day fires three identical WhatsApps at the same customer.
2. It must leave a trail. A readable log, in normal language, of what it did, when, and with which details. Not to audit anyone — so that when something looks off you can spend thirty seconds finding the step that went sideways instead of reconstructing it by interrogating customers.
3. When in doubt, stop. If the agent isn't sure which appointment, which amount, which person, the correct move is to halt and ask you — not to pick the most likely option and press on. One wrong step early in a chain gets multiplied by the five behind it.

When not to chain anything

The honest caveat, because chaining doesn't always pay off.

Don't chain when every case really is different. If ten similar situations get handled eight different ways depending on the customer, there's no chain there — there's your judgement. Automate it and you'll build something so riddled with exceptions you'll switch it off within a month.

Don't chain when the cost of one mistake dwarfs the saving. Payroll, tax deadlines, contracts, anything with legal teeth. The agent can prepare the whole thing and leave it ready, but you press the button. Every time.

Don't chain low volume, either. If a situation comes up three times a month, building and maintaining six steps costs more than it gives back. Chains earn their keep on things that happen daily, or close to it.

One more: if the input data is shaky, don't chain. A six-step chain built on bad information doesn't give you one error. It gives you six.

Start short

The sensible way in isn't to automate the longest process you own. Take a three- or four-step chain with a single irreversible action at the end, and run it for a week with your approval sitting in front of that last step. Watch what it proposes. Once you've clicked "yes" twenty times without thinking, that step is ready to let go. And on the one occasion you stop and look twice — that's the rule you hadn't written down yet.

Our operations agent works exactly this way: it chains the boring steps of a process, stops wherever you tell it to, and hands you a summary of what it did. You approve, it executes — which is the right order round, now that AI has stopped replying and started doing.