How work flows here
You ask the agent to do things. This page explains how it does them — and how you keep control of anything that goes live. No technical knowledge needed. (This same flow runs in every repo you own — see Set up your repos.)
The whole idea, in five lines
Section titled “The whole idea, in five lines”
- You ask for something — “remember this,” “tidy up,” “publish this change.”
- The agent does it as a few small steps.
- Some jobs finish on their own; others stop and wait for your yes.
- You can always see where a job is: Drafting → Up for review → Live.
- Changed your mind before it went live? Say so — it’s dropped.
Everything below is just detail on those five lines.
A job is a “flow”
Section titled “A job is a “flow””A flow is a named job made of a few small steps — think of it as a recipe the agent follows. A handful come ready to use:
| You say… | The flow | Does it stop for you? |
|---|---|---|
| ”Remember that I prefer X” | jot a note | No — instant |
| ”Tidy up what you’ve learned” | tidy up | Only if something looks off |
| ”Fix the bug in my app” | do a coding job | Yes — before it goes live |
| ”Update your own rulebook” | self-update | No — it’s the agent’s own notes |
| ”Pause and hand off” | wrap up | No |
You pick a job; you never build the steps. Want something new? Ask for it in plain words.
The one place a job stops: your “yes”
Section titled “The one place a job stops: your “yes””Most steps just happen. A job pauses at exactly one kind of moment — right before something becomes real: published, sent, deployed, changed for keeps. There the agent stops and asks “Approve?”
Nothing irreversible happens without that yes — unless you’ve told the agent this kind of job is safe to do on its own.
When it asks vs. when it just does it — your knob
Section titled “When it asks vs. when it just does it — your knob”This is the part worth understanding:
- On the agent’s own notes → it just does it. Low stakes; it’s its own memory.
- On your real work — your code, your published site → it stops and asks first.
Same job, different setting. You decide per area whether that area needs your yes, and you set it once — you don’t rewrite the job.
- ✅ “On my game project, always ask me before anything goes live.”
- ✅ “On your own scratch notes, don’t bother me.”
Knowing where a job is — three words
Section titled “Knowing where a job is — three words”Every job shows one of:
- Drafting — being worked on.
- Up for review — stopped, waiting for your yes.
- Live — done, and confirmed actually live.
You never have to ask “is it done?” The status says so — and Live only appears once it’s truly live, not the moment the agent thinks it finished.
Two yeses that are easy to mix up
Section titled “Two yeses that are easy to mix up”You might be asked to weigh in at two different moments. They are not the same:
- Approve the plan — before: “here’s what I’m about to do — ok?” You’re okaying the approach.
- Accept the result — after: “here’s what happened, and I’ve confirmed it’s live — good?” You’re okaying the outcome.
One is permission to start. One is accepting the finished thing.
Changed your mind?
Section titled “Changed your mind?”Because the agent only pauses right before the point of no return, anything that hasn’t crossed that line can be dropped — just say so. Once something is already Live, “undo” means the agent does a follow-up to reverse it, not magic — so the yes is your real control point. Use it.
A worked example
Section titled “A worked example”“Remember I prefer dark mode.” → jot a note. Three quick steps, no pause, done in a blink. Nothing of yours goes live — it’s the agent’s own memory.
“Fix the login bug in my app.” → do a coding job. The agent makes the change and tests it, then stops at Up for review and asks before anything touches your live app. You approve → it goes Live → it confirms the app is actually running the fix.
Same machine, two outcomes — because one touches only the agent’s own notes, and the other touches your project.
That’s the whole thing
Section titled “That’s the whole thing”You pick jobs. The agent runs them as steps. It pauses for your yes before anything real or irreversible — unless you’ve said that area is safe to auto-run. You always see Drafting / Up for review / Live. And anything that hasn’t gone live can be dropped.
The building blocks
Section titled “The building blocks”Every job is just a few of these, in order:
- Read — look something up.
- Note — add a line to its memory.
- Save — write a file it keeps.
- Record — log a step in its own history.
- Work it out — run the numbers, make the change, run the tests.
- Publish — make something go live. The only piece that can need your yes.
- Approve — your yes (or “do it automatically in this area”).
- Hand off — pass a to-do to another job or another agent.
- Schedule — set something to happen later.
The only piece that ever stops for you is Publish — and only in the areas where you’ve said you want the yes. Everything else just runs.
Next: watch a single flow end-to-end — easy button up front, glass box behind it: ask for an outcome, put your mind on a tool, or how your mind gets smarter.
Behind the scenes (for the curious): this is the agent’s workflow-blocks layer — the technical model lives in the framework wiki (wiki/concepts/workflow.md and the block library). This page is its plain-English face.