How a task lives, from the way in to the receipt.
People make four decisions: what to do, whether the plan is right, whether the result is right, and whether it goes live. Everything between those four moments is a machine's job, and the machine can't hold keys, can't spend past its permission slip, and writes down every attempt, including the refusals.
Seven stages. Four human decisions. One record underneath.
Solid cards are in use. Dashed in ink is built and not switched on. Dashed in grey is not built. The diagram draws the weaker claim wherever built and running disagree.
- You askA task, in your own words
- A scheduleNightly checks, weekly reports
- A signalA form, a webhook, a threshold
- A comment · built, not switched onOn a page, a doc, a video
- A task appearsIts skill, inputs, owner and evidence
- One organisation · plannedRuns refuse a blank one; tasks have no such field
- A planning pass · built, not switched onDrafts the scope, the workflow and the budget
- It reads the past · built, not switched onThe reader is built; no recap exists yet
- Gate 1 — the plan · built, not switched onNo threshold ruled; every plan comes to you
- The dispatcher · built, not switched onHires a worker per job. No standing AI in charge
- Headless workers · built, not switched onHard caps on time, count and budget
- Checker jobs · built, not switched onPart of the workflow, not an afterthought
- A screenshot judge · built, not switched onBefore and after. Three tries, then a person
- A working preview · built, not switched onVisual work cannot reach you without one
- Gate 2 — the resultBound to the fingerprint on the card
- The review room · built, not switched onLook and discuss together, clients invited
- One approvals rowNever two places that separately approve
- A typed actionAllowlisted, with a snapshot first
- Ten checks firstAny one of them refuses, with its reason
- The key stays putThe teller does the deal, not the agent
- Receipt and auditWhat ran, what it touched, what it refused
- A plain recap · built, not switched onIts door is written; no run has produced one
- Filed in Docs · built, not switched onUnder the client, linked from the task
- 01
Ways in
Four doors, and every one of them makes the same thing: a task.
You ask. A schedule fires. A signal arrives (a form, a webhook, a threshold). Or a comment on a page starts work, which is built and dark.
- 02
The task
One record, and it can't exist without an organisation.
The task carries its owner, its organisation and the skills a run may use. Internal work picks the agency. Nothing runs against nobody.
- 03
The plan
A cheap pass drafts it, and you say yes once.
A cheap model reads the client's past recaps and connections and proposes scope, a job workflow and a token budget. Gate 1 approves the plan. It's skipped for low-stakes work, so nobody taps twice for trivia.
- 04
The run
One worker hired per job, capped, and checked as it goes.
A boring background program, the dispatcher, hires a headless worker for each job. No standing AI orchestrator. Hard caps on time, concurrency and budget. Checker jobs are part of the workflow, and visual changes get a screenshot judge.
- 05
Your desk
The second of your four decisions, on the exact version.
Visual work can't reach the desk without a working preview link. The looking and discussing happens in the review room. The decision lands on one approvals record, bound to a fingerprint. Edit the payload and the approval dies.
- 06
It acts
Typed, allowlisted, fail-closed, and never holding a key.
Ten checks stand in front of every action. The broker turns a signed, short-lived grant into one scoped call. The agent never sees the key.
- 07
After
The receipt is automatic. The recap is the memory.
Events, audit rows and refusals are written by the machine. The last job of every workflow writes a plain-language recap into Docs under the client: what was asked, done, decided and learned. The next plan reads it.
Done is done. A person ticking a task done cancels the run: spend stops, the run settles as cancelled by a person. Cancelling never un-publishes. Undo is its own deliberate act.
Two sentences on this page look like they contradict each other, and they don't. The approval chain (task → staged artefact → gate on an exact version → executed action → receipt) has fired end to end once, on a real website change. The run chain of stage 04 (a job claimed off a queue, worked, settled back into the ledger) has never travelled all the way through. The schema for it is applied. The driver is the build.
Your desk is a review queue, not an inbox.
What to do
You create the task, or route the signal that becomes one. Everything downstream inherits its organisation and its owner.
Whether the plan is right
Gate 1. One yes on the proposed scope, workflow and budget. Skipped when the stakes are low, because routing it is the approval.
Whether the result is right
Gate 2. Bound to the exact version on the card. The review room is where you look; the approvals record is where you decide.
Whether it goes live
Reversible actions publish behind a pull request or a staged version. Fixed actions, the ones that spend money or can't be undone, are recommendations. A human executes them.
Sixteen marks, drawn by hand, and every diagram uses them.
What kind of work a node is, who made the thing it holds, how hard that thing is to take back, and what the run is doing at this step. One ink per mark. A stipple is the same ink at reduced coverage, never a second colour.
Structure · What a node is.
One bounded step with one owner and one typed output. Not a persona.
A real dependency. The next job genuinely needs something from the last.
A named human decision on an exact version, required before anything continues.
An action a human executes personally, because it spends money or can't be undone.
One execution of a graph, for one task. A stair: discrete steps, one direction.
A person entering the graph. A request, a comment, a signal that starts work.
Provenance · Who or what made the thing a job is holding.
Brand voice, pillars, do and don't-say. The run reads it and never edits it.
Ads, GA4, Search Console, the raw schemas, the record every job reads and writes.
Research, a draft, a page, a recommendation. Not live until someone signs for it.
Temperature · How hard it is to take back. One footprint, three weights.
Runs and chains freely. Throw it away and make it again.
Staged, then approved. It can go live and be pulled back.
It leaves the system and stands: a report someone acts on, a record.
Action · What the run is doing at this step.
A checker that wrote none of it. The sceptic is a job, not a mood.
A revision cycle. At most two, then a human with the screenshots.
Independent jobs run at the same time against one run.
What this run learned, filed for the next one to read.
Every connection climbs four rungs. Most never reach the top.
Observe
Health only. Is the connection alive.
Read
Bounded client data, scoped to one client, revocable in minutes.
Draft
Prepare, don't publish. A paused campaign, a staged container version, a pull request.
Execute
The executor only. Exact approved action, immutable receipt.
Seven steps, and the question each one asks.
- 01
Choose one outcome worth paying for
“What useful change should exist when this run is finished?”
- 02
Shadow the human before automating
“What would a careful person actually do, and what do they notice that the written process misses?”
- 03
Define the shared state
“What must the next job know, and which exact version must it rely on? Unknown, stale and refused are honest states.”
- 04
Map jobs and real dependencies
“Does the next job genuinely need this output, or are we waiting because the old process was linear?”
- 05
Attach skills, models and connections
“What specialised method does this job need, and what is the least authority it requires?”
- 06
Add tests, tripwires and human gates
“How could this look successful while being wrong, unsafe or irrelevant?”
- 07
Run manually, learn, then increase autonomy
“What did this run teach that should make the next one safer, faster or clearer?”
An agent output can be plausible, well-written and completely wrong.
Contract
Inputs, outputs, versions, required fields.
Logic
Calculations, ordering, stop rules, invariants.
Permission
The allowed identity succeeds. The denied identity fails. Both, every time.
Experience
A real browser, a real route, visible state and controls.
Shadow run
Compare against a human before granting execution.
Fix a spelling mistake. Five skills, one gate, one afternoon.
A comment on a page says a word in the services section should be spelt the Australian way. This is the deliberately boring task the platform holds itself to for its first end-to-end run.
| Skill | Tier | Reads | Produces |
|---|---|---|---|
| find-the-component | T1 | Comment, page URL, repo | The one component and line the comment points at |
| copy-not-code-check | T1 · sceptic | The matched lines, brand vocabulary | Which string is safe to change, and what to leave alone |
| propose-copy-change | T1 → T2 at merge | The one approved string | Pull request, one commit |
| prove-nothing-broke | T1 · probe | Pull request | Build result and visual diff evidence |
| close-the-thread | T1 | Deploy receipt | Drafted reply, sent by a human |