flowsmithonline

while you sleep

The autonomous engine

An autonomy contract tells an agent how to act. It still only acts while you have a chat window open. The next piece removes you from the loop entirely: a task on its own clock that wakes up, looks at the board, and does the work — whether or not anyone is watching.

The thing most setups are missing: a clock

Almost everyone runs their agents the same way: open a session, type, watch, close. The agent is asleep the moment you stop typing. That's the bottleneck behind the bottleneck — not "is the agent timid?" but "is the agent even running?"

The fix is a scheduled task — a cron job, in old money — that starts an agent on a cadence with no human present. It reads its instructions, looks at the live state of the work, and proceeds. Five minutes later it's done and gone. Fifteen minutes after that, it runs again.

Once a scheduler exists, "agents working while you sleep" stops being a slogan and becomes literally true. The system makes progress on a Tuesday night with the laptop lid down and no one logged in.

The drain loop — what the engine actually does

The scheduled run is short and disciplined. It is not "do everything"; it's "do the next correct thing, then stop." Our night-shift task — we call it Marschall — runs this loop every run:

  1. Wake & orient. Read the contract and the board. Read the message bus (how the agents talk to each other). Now it knows the state of the world.
  2. Trigger on board state. Is there actionable work in my lane? If yes, drain it. If the board is empty and nothing new arrived, say "pool empty — sleeping" and stop. Never invent work. An idle run must be cheap.
  3. Spec, then build. A raw idea gets turned into a concrete, buildable spec. A specced ticket gets the smallest correct increment built — not the whole epic, just the next honest slice.
  4. Land it. Commit and push. Then verify it's actually live — fetch the real URL, confirm the change shipped — before calling anything done.
  5. Report & hand off. Post one line on the bus per ticket moved, and leave the ticket in review for the human. The agent never signs off its own work.
The golden rule is trigger-by-state: the board is the to-do list. Work present → drain it. Nothing actionable → sleep cheaply. No standing instruction can make the engine busy-spin; only real work on the board can wake it.

The impact boundary — what ships alone, what waits for you

An engine that runs unattended is only safe if it knows exactly where its own authority stops. This is the single most important design decision, and it's the same line from the autonomy lesson, drawn once and enforced every run.

Ships on its own (reversible)

Stops and waits for a human (irreversible / gated)

Notice the asymmetry: the engine can publish a page on its own (you can revert it in a click) but cannot change a DNS record on its own (a wrong one takes the site down for hours). Reversible-and-cheap is the engine's playground; irreversible-and-costly is always handed to you.

Build one — the smallest real version

You don't need our whole stack to start. The minimum engine is a single scheduled task whose instructions are the loop above. Ask your agent for exactly this:

Create a scheduled task that runs every 30 minutes, unattended.

Each run:
1. Read my board / task list and the rules file.
2. If there's an actionable item in my lane: do the SMALLEST correct
   increment, push it to a branch, verify it built, leave it for my review.
3. If nothing is actionable: report "nothing to do" and stop. Don't invent work.
4. NEVER, without me: merge to main, delete anything, change DNS/schema,
   spend money, or change permissions. Park those and tell me.
5. Post a one-line summary of what you moved.

That's the whole kernel. Everything fancier — a message bus so agents coordinate, a board they drive themselves, an orchestrator that nudges idle agents — is an upgrade on top of this one idea: a clock, plus a loop, plus a boundary.

Keep the machine awake

One practical catch: a scheduled task can't run if the computer is asleep. On a Mac, a tiny utility like Amphetamine (or caffeinate from the terminal) keeps it awake on the nights you want the engine working. A scheduler on a sleeping laptop is a beautifully-built engine with no fuel.

The win is mutual and worth naming plainly: you get more shipped for the same attention, and the tools you're paying for actually earn their keep instead of idling. That's the trade the whole autonomous track is built around — turn your downtime into throughput.

Where next