Automations
An automation is a piece of standing work you set up once, in a sentence, and then never think about again. Watch a page and tell me when it changes. Email me the numbers every morning. Screen every lead my form collects and file the serious ones. You describe the outcome; the assistant assembles the recipe; the platform runs it on its own — quietly, cheaply, and indefinitely — repairing itself when something upstream breaks.
What an automation is
- Set up by
- Describing the outcome in one sentence
- Runs on
- A schedule, an incoming webhook, an email, or another automation finishing
- Cost to run
- Near zero — most runs spend no AI at all
- You inspect
- Its run history, never a diagram of nodes
- When it breaks
- It diagnoses itself, then repairs or tells you what happened
- It never
- Finishes — it has a pulse: last run, next run, health, spend
Most work in the platform is a conversation: you ask, the agent acts, the turn ends. Some work is a project with a beginning and an end: that is a mission. An automation is the third kind — work with no end. It is a behavior you want the platform to keep doing: every morning, every time a form is submitted, every time a page changes. You install it once and it becomes part of the furniture.
The point of an automation is to take mechanical, recurring work off your plate entirely — not to make it faster to do, but to make it something you no longer do. Once it is running, the only time it asks for your attention is when it has something for you (a change, a digest, a lead that needs a decision) or when it genuinely cannot continue without you.
You describe, it builds
The whole idea rests on one inversion: you never author the machinery.
Traditional automation tools ask you to build the thing yourself — to drag nodes onto a canvas, wire them together, map fields, and write little expressions in the gaps. That is real work, and it is the reason most people never automate anything: the tool makes you the engineer.
Here the contract is inverted. You state what you want in a sentence, and the assistant compiles the recipe for you — choosing the sources, the checks, the transformations, and the destination. The only two things you ever see are the outcome you asked for and the history of what actually happened on each run. You never see, edit, or debug a flowchart, because there isn’t one to hand you.
Built with AI, runs without it
The assistant is expensive and brilliant. Your automation should not need it on every run.
An automation is compiled by the assistant once, at build time. After that, it runs on its own on the platform’s infrastructure, and the overwhelming majority of runs spend no AI at all — checking a page, comparing it to what it saw last time, shaping some data, and delivering the result are all deterministic operations that cost effectively nothing. That is what makes it sane to run something every minute, forever.
Intelligence enters at exactly two moments, and only when the work actually needs it:
| Moment | What happens | Cost |
|---|---|---|
| A step needs judgment | Reading and classifying a lead, summarizing what changed, drafting a message — a single, bounded call to a model you chose | A fraction of a cent, only on runs that reach that step |
| The automation breaks | A source moved or a login expired; the assistant is woken to diagnose and repair it | Only when something is actually wrong |
This is the ladder that keeps automations cheap: a free scheduled check at the bottom, a small judgment call in the middle only when a run needs a decision, and the full assistant at the top only when a repair is required. Cost scales with how much thinking the work genuinely demands, and idle watching demands none.
A pulse, not a finish line
Automations are the one kind of work that never completes — so they are measured differently.
A mission has a percent-complete and an end. An automation has a pulse: when it last ran, when it will run next, whether it is healthy, and how much it has spent this month. It is never “done.” You do not wait for it; you glance at it.
| A chat ask | A mission | An automation | |
|---|---|---|---|
| Shape | One request, one answer | A project with a plan | A standing behavior |
| Ends? | When the turn ends | When the plan completes | Never — you pause or retire it |
| Measured by | The reply | Percent complete | Its pulse: last run, next run, health, spend |
| Runs on AI | Every turn | Every step | Only on judgment steps and repairs |
When to reach for one
The test is simple: would you otherwise do this again, and again, on a rhythm?
If a task is a one-off, just ask for it in chat. If it is a project, it is a mission. If it is something mechanical that recurs — on a clock, on an event, or whenever a source changes — it is an automation. The clearest signal is that you find yourself typing nearly the same request more than a few times.
| You catch yourself… | Make it an automation |
|---|---|
| Re-checking a page or feed for updates | A watch that only speaks up on a real change |
| Copying the same numbers into a message every morning | A daily digest, delivered where you want it |
| Triaging inbound form or email submissions by hand | A pipe that screens, files, and routes each one |
| Sending the same follow-up sequence to new contacts | A drip that paces itself and asks before it acts |
| Pasting receipts or documents to pull out the fields | An intake address that extracts the fields for you |
Anatomy of an automation
Every automation, however simple or elaborate, is the same three things.
Under the plain-language surface, each automation is a trigger, a recipe, and a destination.
| Part | What it is | Examples |
|---|---|---|
| Trigger | What makes it run | A schedule, an incoming webhook, an email to a private address, a page or feed changing, or another automation finishing |
| Recipe | The ordered work it does each run | Fetch a source, decide something about it, shape the result, and hand it off — with each step allowed to run only when a condition holds |
| Destination | Where the result lands | A message in its home conversation, an email, a Slack channel, or an action in one of your connected tools |
Every automation also gets a home conversation — a normal chat thread that belongs to it. That is where it delivers chat results, where it posts its diagnosis if it breaks, and where you talk to it to change it. Because it is a real conversation with a visible transcript, there is never any hidden background process: everything the automation does has a place you can read.
From sentence to standing behavior
What happens between describing an automation and it running on its own.
When you describe an automation, the assistant compiles the recipe, checks that any tools it needs are connected, estimates what it will cost to run, and confirms the plan with you before arming it. If a required connection is missing, it lands as a draft and tells you exactly what to connect; the moment you do, it arms itself. From then on it runs on its trigger, writing a record for every run that matters so you can always see what it did. You can pause it, edit it by talking to its home conversation, or retire it at any time. The full path is covered in Building an automation.
What people build
A cross-section, from a one-line watch to a multi-destination pipeline.
A watch that respects your attention
“Keep an eye on this page and tell me here if anything changes.” It becomes a watch that checks the page on a rhythm and only speaks up when the change is meaningful — a genuinely new sentence, not a rotating timestamp or a visitor counter ticking over. When it fires, you get a short readable note in the conversation. Prefer email? Say so, and the same automation is updated in place to deliver there instead.
A morning digest from live data
“Every weekday at 8, email me the top five stories from this feed.” A schedule fires each morning in your own timezone, the automation pulls the current items, summarizes them with a model you picked, and sends the digest. No AI is spent on the days nothing qualifies.
A lead pipe with a judgment gate
“When my form is submitted, read the lead, save the serious ones to my CRM and open a task, email me a heads-up, and drop the junk.” You get back a private webhook URL to point your form at. Each submission is screened by a model, the serious ones flow to your connected CRM and task tool with a note to you, and the junk is dropped silently. Duplicate submissions are ignored automatically.
An intake address that reads documents
“Give me an address I can email receipts to, and pull the vendor, date, and total into a sheet.” The automation hands you a private email address; anything you forward there is read by a vision model that lifts exactly the fields you named and files them.
A follow-up sequence that asks first
“When a new contact comes in, wait a day, then send an intro; wait three more, then a nudge — but let me approve the nudge before it goes.” Each contact moves through the sequence on its own clock, and the automation pauses at the approval step and waits for your yes before it sends. Nothing goes out without you.