Observability
Because you never draw an automation as a flowchart, the thing you inspect is its history: what it did, when, what each step actually produced, what it cost, and whether it's healthy. The board gives you every automation at a glance with its pulse; each run opens into a readable step-by-step story in plain language. Everything that needs a decision from you is surfaced, not buried.
History instead of a diagram
You inspect what an automation did, not a picture of what it might do.
Traditional automation tools give you a canvas of nodes to inspect — a diagram of the intended flow. That tells you what should happen, not what did. Here it’s the reverse: there is no diagram to hand you, and instead you get the complete record of what actually happened on every run. When you want to know why you got an alert, or why you didn’t, you read the run — the real one, with the real values — not a schematic.
The board
Every automation you have, each on a single card with its pulse.
All your automations live on one board, each as a card. A card is a live thing — it updates as the automation runs — and it’s designed so that a glance tells you whether everything is fine. From the card you can run an automation now, pause it, resume it, and open its history, without leaving the board.
| On the card | What it tells you |
|---|---|
| Status | Armed and healthy, paused, healing, budget-paused, or draft |
| Cadence | How often it runs, in plain terms |
| Last result | A human summary of what the most recent run did |
| Next run | When it will fire next, in your local time |
| This month's spend | Actual AI cost so far, against its cap if it has one |
| Where it delivers | Whether it emails you, posts to Slack, updates your pipeline, and so on |
Reading an automation's pulse
The four numbers that tell you an automation is alive and well.
An automation’s pulse is last run, next run, health, and spend. Last and next runs tell you it’s on rhythm; health tells you it’s not silently broken; spend tells you it’s within budget. You don’t watch an automation the way you watch a running job — you glance at its pulse the way you’d glance at a dashboard light, and only look closer when something’s off.
Run history and traces
Expand an automation to its runs; open a run to its step-by-step story.
Each automation expands to show its recent runs — only the runs that mattered, since idle checks leave no trace. Open any run and it unfolds into a readable trace: each step in order, told in plain language — “read the source,” “made the call,” “delivered it” — with what it produced, how long it took, and what it cost. A failed run keeps its error verbatim, which is both what you read to understand what happened and what a self-repair reads to fix it.
What needs you
Anything that requires a decision is pulled to the surface, never left to be found.
The things you actually have to act on are surfaced right on the automation’s card and in your notifications, so they don’t hide inside run history:
| Signal | Means |
|---|---|
| “N waiting on you” | That many sequence contacts are parked at an approval gate |
| “Trying again soon” | A run hit a transient error and is retrying, with the attempt count shown |
| A source-health note | A watched source has been flaky lately, before it becomes a failure |
| Budget-paused | It hit its monthly cap and is waiting for you to resume or raise it |
| Draft | It needs a connection before it can arm — the card says which |
Approvals, budget pauses, and repair notices also arrive in your notifications, so you find out even if you’re not looking at the board.
Health at a glance
Whether an automation is thriving, wobbling, or stopped — in one look.
Health rolls the recent history into a single read: an automation that’s delivering cleanly looks calm, one that’s retrying or seeing a shaky source shows it, and one that’s healing or stopped is unmistakable. Because a healthy automation genuinely asks nothing of you, a quiet board is the good state — the signals only appear when something wants attention.
Linked dashboards
An automation that accumulates data can maintain a live view of it.
When an automation records a number over time — a price, a count, a ranking — that history charts on its card so you can see the line, not just the latest value. And an automation can link out to a live dashboard it keeps updated, turning “this runs every hour” into “this runs every hour and here’s the always-current view it produces.” The automation becomes the feed behind a living page, not just a thing that fires and forgets.