Automations

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.

Updated today

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.

Failures that can't succeed aren't retried
If a failure is clearly permanent — a page that no longer exists, a login that’s been revoked, a request that will never be accepted — the automation doesn’t waste attempts retrying it. It recognizes the difference between “try again in a minute” and “this will never work” and escalates the second kind straight to a repair.

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.

  1. 01
    It stops and flags itself
    Three consecutive failures flip the automation into a healing state so it isn’t firing broken while it’s being looked at.
  2. 02
    It diagnoses in its home conversation
    The 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.
  3. 03
    It repairs, or asks
    Depending on its mode, it either proposes the fix and waits for your approval, or applies the fix and quietly tests it on its own.
  4. 04
    It re-arms on the first success
    As 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.

ModeWhat it doesBest for
ApproveDiagnoses 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
AutoApplies 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
Repairs can't cheat the test
A self-repair is never allowed to make its test pass by weakening the automation — it can’t change what’s being watched, swap the trigger, or disable the very check that’s failing. A fix has to make the real thing work, or it isn’t accepted.

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.

Paused, ledgered, and resumable — never deleted
Retiring means pausing, not deleting. The automation, its recipe, and its history all stay intact. You get a notification explaining why it was paused, and resuming it is one click — which also grants it a long grace period so it won’t be paused again while you’re using it. Nothing you built is ever thrown away without you.