Agents While You Sleep: The Safe-Setup Playbook

Most people picture an AI agent as a chatbot: you type, it answers, you type again. That's the small version — you're in the loop for every move. The powerful version is different. You give it a goal once, and it runs on its own in a loop: it tries something, checks the result, tries the next thing, over and over, for hours — while you're asleep. You wake up and the work moved without you.

That's also the version that makes people nervous, and they're right to be. Something acting on your accounts, unattended, for hours? If it goes wrong, you find out after the damage is done. The good news: unattended agents are made safe by two specific, boring properties — not by trusting the model to behave. Get both in place and “leave it running overnight” goes from reckless to routine. This guide is those two properties, plus exactly how to set them up and test them.

The first thing that makes an overnight run safe is that every move is written down as it happens — what it tried, what worked, what it skipped, what it decided not to do, and why. In the morning you scroll back through it like a diary of the agent's night. Builders call this property observable: nothing happens in the dark, and nothing is something you have to take on faith.

Why it matters: when an agent runs for hours unattended, the only way to trust the outcome is to be able to audit it. A run record turns “it said it's done” into “here are the 40 steps it took, in order, and I can read any of them.” It's also how you debug a bad night — you find the exact step where it went off the rails instead of guessing.

Observability lets you review the night after the fact. The approval gate is what stops the night from doing harm in the first place. The rule is simple: the agent works freely on safe, reversible steps, but it stops and waits for your explicit “yes” before anything irreversible. Sending an email, spending money, deleting a file, publishing something public, changing a production setting — it pauses at the edge and asks. Builders call this a human-in-the-loop approval gate: one clear stop between the agent and the action.

The mental model that makes this practical: sort every action the agent could take into two buckets — reversible (reading, drafting, searching, running things in a sandbox, writing to a scratch file) and irreversible (anything that leaves your machine, costs money, or destroys data). Let it run wild in the first bucket. Make the second bucket require a human “yes” every time, by default. When in doubt, an action belongs in the irreversible bucket.

Observability and the approval gate aren't alternatives — they cover different failure modes, and an unattended agent needs both. The gate stops harm before it happens (the irreversible action never fires without your yes). The run log lets you catch the rest after — the subtle wrong turns in the reversible work that no gate would have flagged.

Vendor-neutral and copy-pasteable. Works whether you're wiring this in a coding agent, a no-code automation, or your own script. Do these in order; don't skip the test at the end.

Never leave a fresh setup running unattended on day one. Prove the two properties work while you're watching, then walk away. Run these four tests first — each one checks one thing that has to hold before “while you sleep” is earned.

These two properties make an unattended agent workable — they don't make it foolproof, and nothing does. A run record can be incomplete, a gate can be set too loose, and a genuinely novel situation can still surprise a model at 3am. The point isn't a guaranteed-safe robot you can forget about; it's a setup where the expensive mistakes get caught before they fire, and the rest get caught in a log you can actually read. Start small, keep the gate tight, widen trust slowly. That's the whole job.