Every morning at 08:10, a job on my laptop pulls the gold daily close and evaluates one sentence: close ≥ threshold. If that sentence stops being true, my Mac notifies me — no browser window, no AI call, no cloud. It has done this every day since I set it up. Cost per day: zero tokens, zero dollars.
The same machine checks a publication backend for new content, assembles the data for my weekly research report, and audits its own oldest automations every night at 22:30 to see whether the world has drifted out from under them. None of this wakes me up unless something is actually wrong.
This used to be a team's job. A junior checks the dashboards every morning. Someone maintains the scripts when sites change. Someone writes the weekly report. I'm one person, and most days I spend under twenty minutes on all of it — reading a list of exceptions, not touring seventeen healthy things to find the three broken ones.
The setup is two parts, and the boundary between them is the entire trick:
The agent is the brain. When I need a new automation — "watch this price", "pull this statement", "collect these posts" — I describe it to my AI agent once. The agent explores the site, figures out the selectors and endpoints, and compiles the whole thing into a plan: a small JSON file with the steps and a machine-checkable definition of success. That exploration costs tokens. Once.
The engine is muscle memory. After that, the plan replays deterministically — same steps, checked against the same success condition, at zero tokens per run. Scheduled with the operating system's own scheduler, not a cloud cron. Running in my own browser with my own logins, so nothing about my accounts ever leaves this machine.
Intelligence is expensive and judgment-shaped; repetition is free and check-shaped. Most automation tools get this boundary wrong in one of two directions: either the AI drives the browser every single time (you pay tokens for repetition, and the run is as reliable as the model's mood), or a dumb script runs blind (nothing checks whether the result is actually true). The plan format forces every automation to carry its own truth condition — so replays are free and honest.
Sites change. Selectors die. A login expires. This is the actual job — not writing automations, but keeping them true. Two things make it survivable for one person:
First, the exceptions surface themselves. Every run's outcome lands in a local ledger; a truth panel ranks what's broken, what's decaying, and what hasn't been verified in too long. My morning starts with that list. Seventeen healthy automations cost me zero attention.
Second, repair is a conversation, not an afternoon. When something drifts, the fix is telling the agent "re-capture this" — it re-explores with the old intent, produces a new plan, and the success condition proves the repair worked. The expensive part (my attention) shrinks to a decision; the mechanical part is the agent's problem.
Because the arithmetic generalizes. If one person can keep a dozen unattended jobs true on a laptop, one person can keep a hundred true for other people — and most people who depend on a website don't want an engine, a plan format, or an agent. They want to hand it to someone and get an email when something needs their attention.
So that's the offer. The engine is free and MIT-licensed — if you're the kind of person who runs their own ops room, take it, it's yours. And if you'd rather depend on a site without babysitting it: tell us which site and what you need. We'll watch it, catch the changes before you hit them, and fix what breaks — on terms where your credentials never leave your machine, because that's architecture, not a promise.