Agents That Work While You Sleep

• 77posts built on one wrong fact overnight
• 18items in the corrections register

There is a particular satisfaction in waking to find work you queued at 10pm done by 6am, ready to read with a brew. There is also a particular horror in finding the same machinery has cheerfully copied one misunderstanding into seven documents while you slept. I had both in the same week.

I have a home energy project: solar, a battery, a hot water tank that thinks too much, a spreadsheet habit that has spiralled into a small data platform. In the evenings I want more done than I have hours for, so I write briefs for an agent to execute overnight, unattended. The setup is unglamorous: a scheduler, a prompt, an output folder. The interesting part is everything that breaks when you take the human out of the loop.

The brief is the entire job

Sitting next to the agent, a vague instruction is fine. You see the first draft and redirect. Asleep, none of that exists. Whatever you wrote at 10pm is what the agent is staring at at 2am with no one to ask. I’ve written a brief I thought was clear and woken to find the agent had taken one ambiguous phrase and built three hours on the wrong side of it.

A brief that survives the night, for me, says:

1. Read these specific files first. Not “the relevant context”, because relevance is a judgement the agent will make differently from me.
2. Write this, and put it at this exact path.
3. Check it before calling it finished, usually with two passes of structured critique against a metric I’ve already written down.
4. Update the knowledge file, the memory and the tracker.
5. This brief is self-contained, because the agent remembers nothing of the conversation that produced it.

That last point took me a while. In a live session I lean on shared context: the file we just looked at, the correction I made twenty minutes ago. An overnight run starts cold. Every assumption in my head has to be in the brief or in a file the brief names. If it’s in neither, it doesn’t exist.

The briefs that work read like a recipe for a stranger. They’re boring to write. They’re the difference between finished work and a tidy pile of confidently wrong output.

Why the tracker is load-bearing

With several things running overnight, the agent finishing job A at 1am has no idea what the agent finishing job B at 4am needs to know. So every piece of work has a ticket, and every overnight run is told to update it: what it produced, what it found, what it left open, what should happen next.

This isn’t a project-management story. It’s a handoff story. The tracker is the only place the work persists in a form the next session, me or the agent, can pick up cleanly. It’s the shared brain the morning session and the 3am run both read from. Without it, every morning starts with archaeology.

The same goes for the project knowledge file, which holds the hard rules and patterns I never want to relearn, and the running memory of decisions and corrections. Every session reads them first and updates them last. Together with the tracker they form a small three-layer state that survives the gap between runs. I have a rule for this now, lifted from a bruising lesson: every session and every scheduled task ends with a sweep of all three. Skip it and the next run starts blind, and blind runs are how mistakes spread.

The night seven posts caught fire

I had queued an overnight run to draft seven posts in the energy series. The briefs were tight and the quality framework was in place. I went to bed pleased with myself.

What I hadn’t noticed was that a foundational fact was wrong in the knowledge file: how feed-in tariffs are priced, and whether the headline number includes network charges or only the wholesale part. I’d written it months earlier with the wrong mental model and never corrected it. The agent read the file at the start of every run, took the fact as given, and built seven posts on it. By morning I had a folder of confident, well-structured, internally consistent prose, wrong in the same way in seven places.

The diagnosis was easy. The fix wasn’t. Each post had to be reread and the wrong claim traced through, because if you misunderstand how a price is built, you also misunderstand the economic argument on top of it, the chart caption on top of that, and the conclusion on top of the chart. I wrote a corrections register eighteen items long and fed it into a rerun of every post. The rerun is what you’re reading. This post was drafted by a scheduled task told to read the register first.

Two lessons, pulling in opposite directions.

The first is that the machinery worked as designed. One fact at the bottom moved seven outputs at the top. That is leverage, and when the fact is right it is the whole point.

Diagram to come

The second is that leverage cuts both ways. The error that hurts most in unattended work is the quiet, plausible, propagating one: not the brief that fails loudly, but the brief that succeeds confidently on a wrong premise. The defence isn’t better prompts. It’s making foundational facts auditable by dating them, citing their source, and reviewing the knowledge file like any other deliverable. The knowledge file now has to pass its own quality check.

The morning the dashboard ate itself

A smaller failure from the same week taught a different lesson.

I spent an evening hand-building a dashboard, the fiddly layout work that’s hard to brief and easy to do live. Next morning at 9am a scheduled task that rebuilds that dashboard fired on its weekly cadence and helpfully overwrote everything. It had no idea a human had touched the file. It just did what it was told.

The lesson isn’t “don’t schedule rebuilds”. The fix is unglamorous: a timestamp check, a manual-deployment flag, or not scheduling rebuilds on things I’m actively editing. But the lesson is wider. It’s that an unattended run needs to know whether it’s about to overwrite live work. Any run that writes to something a human also writes to needs an answer to “is it safe to clobber this right now?” If the answer is “I don’t know”, it should stop and write a report. It isn’t about whether the agent can do the work. It’s about whether it has the right to do it at the moment it happens to wake up.

What I’d tell myself a month ago

The brief is everything, and a good one is shockingly explicit. Not because the agent is stupid (it isn’t) but because it works alone. There’s no live conversation to repair an ambiguity mid-flight. Write it the way you’d write a note for a house-sitter who has never been inside your house and has to leave the job finished before you get home.

The persistence layer is the product. A run’s outputs are perishable. The knowledge file, the memory and the tracker are what compound. A run that produces something beautiful and updates none of them is one-off labour, and the next run will redo half of it.

Propagation is the failure to design against. One wrong fact, lovingly read by every brief, appears in every output. The defence isn’t vigilance. Vigilance is what you ran out of when you went to bed. Hold your foundational notes to the standard of your deliverables, and date your facts so you can tell the audited ones from the ones inherited from the version of you that wrote them at midnight.

I’m still figuring this out. The agent is patient. The night is long. I’d rather wake up to seven things that need light editing than seven that need arguing with, and most mornings now I do.