You are reading Chapter 33 of 36 in the AI Bootcamp, AI Central's free course for professionals who want to use AI in their own work. The chapters build on each other, so if this is your first one, Chapter 1 is the place to start. All of them sit on the AI Bootcamp page, and three more arrive every week.
To make one job run across several apps with AI, build three parts and as little else as possible: a trigger in one application, a single step where the assistant does the thinking, and a landing that writes the result where a colleague will find it. That sequence is called a chain, and you design its failures in before you build, because a chain fails more often than its individual steps suggest. This chapter covers what a chain is, one worked example built with its checks already in it, why chains break, and how many steps to keep.
It builds on Chapter 26's connectors and everything up to Chapter 32 (available from 18 November). Bring one working connector, one automation you have already shipped, and the recurring job from your Chapter 29 audit that needs more than one trigger and one action.
We publish AI systems like this for 300,000+ senior professionals at AI Central, and more of them live in the AI Central Library.
A chain is the same sequence, with you taken out of it
Chapter 16 ran a long job as a series of steps in one conversation, with you pasting the input and reading each result. A chain is that same sequence, started by an event and run without you.
Run by hand: you see every step and act as the error handling, so mistakes are caught immediately. But it only happens when you sit down, and it takes the same 20 minutes every time.
Run as a chain: it starts on an event in one system, passes results along unread, and writes to another system whatever happened in the middle. It can run 40 times a month at no extra effort, including while you are travelling or ill. But nobody rejects a bad intermediate result, and a wrong answer ends up written down as the official record.
The steps are identical. What changes is who notices when one fails.
The three parts
A trigger. A file lands, a form arrives, a date comes up.
A thinking step. The one part only an assistant can do.
A landing. The result written where a colleague will find it without being told to look.
Where to build it
Inside the assistant, using the connectors from Chapter 26. Cheapest to try, weakest at scheduling and at telling you when something breaks.
A dedicated automation platform: Zapier, Make or n8n. Built for unattended runs, with a record of every run.
Inside your company suite. Microsoft and Google both build their own automation, and your IT team may have a view on which you use.
Connecting assistants to other systems is getting easier. The Model Context Protocol (MCP) is an open standard for it, supported across Claude, ChatGPT and most developer tools, so connecting is becoming a setting rather than a project. The risks come with it, and Anthropic's own documentation lists them: custom connectors can reach unverified services, a malicious one can inject instructions you never typed, and some modes use tools without asking. Grant access to as few things as possible, using the permission decisions from Chapter 27.
Before you build, write three one-line answers on paper: what happens in the first system, what only the assistant can do with it, and where the result lands. If you cannot write all three, you do not have a chain yet.
One chain, built with its failures already in it
Here is the worked example. Signed agreements arrive as PDFs from suppliers and customers, get saved, and never get logged. Then a renewal fires and nobody knows the notice period, because it sits somewhere in a 14-page PDF in somebody's downloads folder.
The chain has five stages:
Trigger: a PDF lands in one named folder, and only that folder.
Check: the file contains readable text. A scan stops the run and names the file.
Assistant step: it returns five named fields, or "not stated" for any it cannot find. Structured data, not a summary.
Check: no field is empty. An empty field flags the row and tells you.
Write, then notify: append one row to the tracker, then post one line to the team channel.
The two checks were designed in from the start, and on most platforms they are the cheapest part of the chain. The details that make it work:
A narrow trigger. A broad one picks up screenshots, drafts and duplicates, and each of those costs a full run.
Five fields: counterparty, start date, end date, annual value and notice period. A missing value is "not stated", and the assistant must never infer it from context.
"Not stated" is not the same as empty. "Not stated" is a valid answer. Empty means something failed upstream, so the chain writes the row anyway, marks it, and tells you.
Write before you announce. If the notification fails, the record still exists. The other order leaves an announcement about a row that does not exist.
Draw your own version on one sheet before you open any tool: three steps, two checks and one notification.
A chain fails more often than its steps suggest
Every step multiplies the chance of failure. Assume each step works 95% of the time, which is generous:
1 step: 95% of runs finish clean.
3 steps: 86%, so about 1 run in 7 fails.
5 steps: 77%, about 1 in 4.
8 steps: 66%, about 1 in 3.
Eight steps at 95% over 100 runs a month gives you 34 broken runs. At 99% per step, the same eight steps finish clean 92% of the time. Fewer steps and better steps are the two levers you have.
Real chains do worse than this arithmetic, because failures are connected: one odd input breaks step two, which hands bad data to step three. Research from METR on AI agents shows the same shape over task length, with near 100% success on tasks under about 4 minutes and under 10% on tasks over about 4 hours. That study measured agents on long tasks rather than app-to-app automation, so treat it as the shape of the curve, not a statistic about your chain. Length is what lowers reliability.
Loud failures are cheap. Quiet ones are not
Loud: the run stops, writes nothing and emails you. It costs you about 10 minutes.
Quiet: a plausible wrong value passes through and gets written, and the run shows green. Three contracts with renewal dates in 1926, found in week six.
So set every step to stop by default, and give each one a failure route that notifies you rather than skipping ahead. Never set a step to ignore errors and continue. Zapier automatically retries errored runs on paid plans, which helps with a temporary outage but does nothing for an unreadable document. Add explicit checks that turn quiet wrong answers into loud stops.
Most breakages come from the shape of the input, not from the assistant: "3/4/26" (March or April?), "1.2m" stored as text, "Smith, Jane" stored backwards, a photographed PDF with no text in it, an out-of-office reply that triggers the flow, an attachment buried in a thread. Check the shape before the assistant sees the input, and again before anything is written.
Two steps that work beat eight that mostly do
Ask these questions of each step, in order:
Could a person do it in under 10 seconds once the result lands? Cut it, and let the person do it.
Does it only reshape data for the next step? Fold it into the next step as an instruction.
Does it write somewhere a colleague relies on? Keep it, and add a checkpoint.
Does the chain give a wrong answer without it? Keep it.
Most steps people add fall into the first two.
What it costs
The platforms charge for different things, checked in September 2026:
Zapier counts each successful action. Free gives you 100 a month, and Professional starts at $29.99 for 750. Triggers, filters and paths are free.
Make counts each module action as a credit. Free gives you 1,000 a month, and Core is $12 for 10,000. Routers and error handlers are free.
n8n counts whole runs, not steps. Starter is EUR 20 for 2,500 runs a month, and there is a free self-hosted edition.
Microsoft's automation is priced per user, at $15 a user a month on an annual plan. Better value for a whole department, worse for a single chain.
Take a 5-action chain that fires 20 times a business day: about 400 runs and 2,000 successful actions a month. On Zapier that is 2,000 tasks, nearly three times the 750 in the $29.99 tier. On Make it is 2,000 credits, inside the $12 plan's 10,000. On n8n it is 400 runs, inside 2,500. The same chain can cost several times more on one platform than another.
The bigger cost risk is a trigger that is too wide, not a chain that is too long. Checks are usually free, so there is no cost reason to skip them. The last test before you switch it on: would you let the step that writes to a shared system run while you sleep? If that is not an easy yes, it needs a person in the loop.
3 exercises before Chapter 34 (about 15 minutes)
Write the chain. Take the recurring job from your Chapter 29 audit. Before opening any tool, write one line each for what happens in the first system, what only an assistant can do with it, and where the result must land.
Design the failures. Before building, answer three questions: the wrong-shaped input you can already picture, the step that must stop the whole run, and who gets told and how.
Cut and select. Count the steps. If there are more than four, run each through the cut questions above and write a shorter version. Then name the one step you would not want running unwatched.
What actually changes
Before this chapter, a job that crossed three applications needed you to sit down and carry it between them. After it, you can build a workflow that spans those applications, and say before it runs where it will break and how you will find out.
You take two things into Chapter 34 (available from 23 November): your chain on one page with its steps counted, and the one step you would not leave unwatched. Chapter 34 covers where a checkpoint is worth its cost, what a good approval request asks, and the jobs that should never run unattended.
If the thinking step is the part you want to get right, the 26 principles of prompt engineering covers how to write the instruction inside it, and our guide to Claude workflows goes further on building with Claude. More guides like this live in the AI Central Library.
Frequently Asked Questions
How do I make one job run across several apps automatically?
Build three parts: a trigger in one application, one step where the assistant does the thinking, and a landing that writes the result somewhere a colleague will find it. Add a check before the assistant step and another before the write, and set every step to stop and notify you on failure.
Should I use Zapier, Make or n8n for AI automation?
It depends on how your chain is shaped. Zapier counts each successful action, Make counts each module action as a credit, and n8n counts whole runs, so a chain with many actions can cost several times more on one platform than another. A 5-action chain running 400 times a month fits inside Make's $12 plan and n8n's EUR 20 Starter plan, but needs nearly three times Zapier's 750-task Professional tier.
Why do multi-step AI automations fail so often?
Because failure compounds. At 95% reliability per step, a 3-step chain finishes clean 86% of the time and an 8-step chain 66% of the time. Most breakages come from the shape of the input, such as ambiguous dates, numbers stored as text or scanned PDFs, rather than from the assistant.
How many steps should an AI workflow have?
As few as possible. Cut any step a person could do in under 10 seconds once the result lands, and fold any step that only reshapes data into the next step's instruction. Two or three steps that work beat eight that mostly do.
What is MCP in AI?
The Model Context Protocol is an open standard for connecting AI assistants to outside systems, supported across Claude, ChatGPT and most developer tools. Custom connectors can reach unverified services and can carry instructions you never typed, so grant access to as few things as possible.

