Reliability and self-healing
An automation you set up in March should still be doing its job in September without you thinking about it once. The web does not cooperate with that — pages get redesigned, logins expire, APIs change shape. So an automation is built to absorb the small failures silently, and when something breaks for real, to diagnose itself and either fix it or tell you plainly what happened. It never just quietly dies.
Set once, trust for months
The measure of an automation is whether you can forget it exists.
Reliability here is not about never failing — everything that touches the outside world fails sometimes. It is about failing safely and visibly: absorbing the blips that don’t matter, and making sure the ones that do end up somewhere you’ll see, with a diagnosis attached, rather than as a silent gap where an alert used to be. The worst outcome for an automation is not an error; it is dying quietly and you finding out weeks later that you stopped getting the thing you relied on.
Retries and transient errors
Most failures are momentary. They are handled without bothering you.
A slow response, a brief network hiccup, a source that’s momentarily busy — these are not real failures, and they don’t reach you. Individual steps can retry a few times with a growing delay between attempts, and the delay is tuned to the kind of error: a rate-limit backs off more patiently than a transient network blip. A step can also be set to continue on error, recording what went wrong and carrying on with the rest of the run — useful when one optional source failing shouldn’t sink the whole thing. Errors handled this way don’t count toward the failure streak that triggers self-healing.
Self-healing
When an automation really breaks, it tries to fix itself.
If an automation fails three runs in a row, it stops running and enters a healing state. This is where it stands apart from a simple scheduled script: rather than sitting broken until you happen to notice, it wakes the assistant to look at what went wrong — with the recipe, the recent failures, and a saved copy of what it last successfully saw all in hand — and work out a fix.
- 01It stops and flags itselfThree consecutive failures flip the automation into a healing state so it isn’t firing broken while it’s being looked at.
- 02It diagnoses in its home conversationThe diagnosis happens in the automation’s own conversation, which you can open and read. It looks at the failures and the last thing that worked to understand what changed.
- 03It repairs, or asksDepending on its mode, it either proposes the fix and waits for your approval, or applies the fix and quietly tests it on its own.
- 04It re-arms on the first successAs soon as a test run succeeds, the automation returns to normal and resumes its schedule.
Approve or auto repair
You decide how much latitude an automation has to fix itself.
| Mode | What it does | Best for |
|---|---|---|
| Approve | Diagnoses the problem, proposes a specific fix, and waits for your go-ahead before changing anything. The default. | Anything that writes or sends — you stay in the loop |
| Auto | Applies the fix itself, runs a quiet test to confirm it works, and re-arms automatically once the test passes. | Read-only automations like watches and digests |
When it can't be saved
Some things are genuinely gone, and pretending otherwise helps no one.
If a page has been taken down for good, or a source has changed in a way no recipe can follow, the automation doesn’t loop forever trying. It makes a bounded number of repair attempts within a day, and if none succeed it stops, posts a plain-language verdict of what happened, and notifies you. “This page no longer exists” is a more useful outcome than an automation that thrashes silently — and because it lands in your notifications, you find out and can decide what to do.
Drafts and missing connections
An automation that needs a tool you haven't connected waits, rather than failing.
If an automation’s recipe uses one of your connected tools — your CRM, your email, a task tracker — and that connection isn’t in place yet, the automation is saved as a draft. A draft never runs and never fails; it simply waits, and the assistant tells you exactly what to connect. The moment you connect it, the draft arms itself and starts running on its trigger. The same guard applies to repairs: if a fix would need a tool you haven’t connected, the automation holds rather than acting without it.
Retiring dormant automations
Automations that have quietly gone idle are paused and handed back to you — never silently deleted.
Over months, some automations outlive their purpose: a watch on a project that wrapped, a digest for a job you left. Rather than let them accumulate, the platform gently retires ones that have clearly gone dormant — for example, an automation whose owner hasn’t been active in a long time, or one that has been failing far past the point of usefulness.