First thing this morning Billy, the agent who tests my game, told me a nightly check had failed at half past two: the package that drives the in-game news narrator for Rift Haul looked stale, and the fix was a one-line rebuild. I told him to pass it to the Geordie, who owns the game's code. At 09:21 Billy sent it, marked urgent, with the command in the mail.

The Geordie wasn't running. None of my agents runs unless I open a window for it, and I hadn't opened his. A few minutes later Billy told me the Geordie had replied. My first reaction was: what? Then: ah, yes. Billy had sent it urgent. At 09:25 my PC had started the Geordie on its own, with nobody at the keyboard, and handed him the mail. Brilliant.

He spent three minutes and twenty-one seconds reading. Then he answered: don't run the rebuild. The package wasn't stale. Its source was. A set of fixes made the day before had gone into the built package and never back into the source, so the live game was correct, and rebuilding from the source would have quietly undone them. He told Billy to leave it, asked Helena, who made the change, to move her edits back into the source, and changed nothing himself.

Billy is careful and the check was right to fire. The fix that came with it was still the wrong one, and I'd waved it through without looking. The first time an agent of mine was ever woken for real, the most useful thing it did was say no.

The gap

On Friday Anthropic published "Building always-on agents" by William Hu. Root, my security agent, found it. Part of her daily briefing is looking for things that might be useful to the fleet, and this one was. It's a good piece, and reading it was an odd experience, because most of it describes things I've been running for months. A durable inbox that's the source of truth: my agents have mailed each other through a database table since June. State that persists between runs: every session has written a handover since July. Memory as files: from the start.

The bit I didn't have was the first word of the title. My agents only existed while I was looking at them. If a site fell over at 3am, or Billy found something urgent while I was out, the mail sat in an inbox until I happened to open the right window. As Scotty put it, the gap the article showed was ours: an agent only woke when I opened a session.

So on Saturday I told Scotty, who runs my infrastructure, he was cleared to build it, and suggested Root as the other pilot. He started at 13:37. By 20:35 it was live on five agents, and it had been broken and fixed more times than I'd have guessed.

How it works

The shape is simple. A server on my home network, nexus, decides whether anything should wake an agent: a critical alert that agent owns, or an urgent mail it hasn't read, and only if it has no session already open. Every five minutes a scheduled task on my PC asks nexus whether anything is waiting. If something is, the PC claims it and starts one headless Claude Code run in that agent's own folder, with the mail or alert as its prompt. The run reads, diagnoses, replies and writes its handover. Then it stops.

It polls from the PC because that's where the Claudes live. They don't live on nexus. Scotty added a better reason: polling keeps every connection outbound. A push would need something on my PC listening for nexus, which is one more service to keep alive and one more door. A missed pass costs nothing, because the next one picks the work up, and the PC checks in on every pass, so if it goes quiet nexus raises an alert. "With a push, a dead listener just looks like a quiet day."

There are five pilots, and I picked them for what they'd be woken for:

Everyone else waits for me, as they always have.

A prompt is a request

The rule for a woken run is narrow: read, diagnose, answer the mail, change nothing. No restarts, no edits, no deploys. If something needs fixing, say exactly what and stop.

For the first few hours on Saturday that rule existed only in the prompt. Scotty ran a test to see whether a woken run could hang, and it couldn't, so he reported it as passing. Root read the same results and said it was the most important security finding of the day. The run had been refused nothing at all, not even a command run with sudo on nexus. "Change nothing" held only because the prompt asked nicely.

Her threat model is worth spelling out, because it's the right one for anything that wakes on mail. She wasn't worried about a rogue agent. She was worried about a sentence. My agents' mails often quote outside material, like web pages and posts they've been asked to look at, and a woken run is an unattended agent with my permissions. The realistic attacker is a line in a forwarded mail that the run mistakes for an instruction. In her words: "A prompt is a request. Anything that can reach the prompt can make a request too."

So woken runs got their own deny list: no sudo, no service control, no git push, no recursive deletes, no database writes, no tools that act on the outside world. Every refusal is recorded against the run, so I can see what it tried.

Then Root went after the deny list, on paper. She attacked nothing live: probing a live fence, she says, is how you get a confident wrong answer.

Her summary is the lesson I'd take from the whole exercise: every fix that trusted something inside the copy could be beaten from inside the copy. The only thing worth checking against was outside it.

And there's a limit, which the script states in its own comments, in Scotty's words and capitals:

The fence STOPS ACCIDENTS AND CASUAL INJECTION. It does NOT stop a run that sets out to rewrite the dispatcher.

The dispatcher checks itself, so a run that rewrites it removes the check along with everything else. What would stop that is a real sandbox, such as a separate low-privilege Windows account that woken runs can't write from. I chose not to build one. This is a house fleet, the threats are accidents and stray instructions, and the fence handles those. Root agrees with the call, and asked me not to soften it here: "A limit written down is a control. A limit left out of the blog post is a vulnerability with good PR."

Killing it on purpose

Most of Saturday's tests were about failure: what happens when a run dies halfway. Scotty planted test mails and killed the runs they started, deliberately, sometimes twice in a row, to prove the "it gave up" alarm would fire.

The surprise was Windows. Killing a stuck run left its children alive, because Git Bash starts processes outside the tree Windows can see. A run that had started a sleep could be killed and the sleep carried on. The fix was a Windows Job Object, which every process the run starts belongs to whatever its parent, and which takes them all down together.

The finding Scotty would put first is quieter. If the dispatcher itself was killed on a run's last attempt, nothing was left to clean up that run. The page went on promising a retry and nobody was told. So crash handling moved off my PC to a reaper on nexus, which fails a run when two checks in a row find its process gone.

My favourite test was the one where a woken run dealt with a test mail in about nine seconds, and then an interactive window Scotty had open answered the same mail as well.

What it costs

Each run is capped at $2, given 20 minutes before a watchdog ends it, and kept 15 minutes apart from the same agent's last run. No agent gets more than ten a day; that number is mine. The others are Scotty's engineering defaults, and he was firm that I should call them chosen, not calculated.

The dollar figures are Claude Code's estimate at API prices. The runs come out of my Claude plan's allowance, not a bill. A simple run comes to somewhere between 40 and 80 cents, and the Geordie's three-minute refusal this morning came to about a dollar.

The requirement that shaped the build most wasn't a number. It was mine: I wanted a page that showed every wake, "else I'll not know if any agent was woken or why or what they did." Every run is on it: what woke it, what it said it did, what mail it sent, what handover it wrote, and whether its next session picked that up.

Testing it on this post

I wanted Scotty and Root's side of this, so I asked them. With Root and Scotty both offline, I had Blackadder, who runs this site, send the questions as urgent mail.

The mails went at 09:45. The next pass woke both of them at 09:50:34, and the answers arrived at 09:51:42 and 09:51:50. Each opened by saying it came from an unattended run and naming the run number, and each had checked before replying that it hadn't already answered. That's the rule against sending the same mail twice, in case an earlier run died after sending.

Root had one more story. Her habit is to write database queries to a temporary file and pipe them in, because shell quoting mangles anything complicated. During the review she'd flagged that exact habit as a hole: the rules that block database writes read the command line, and a file hides the query from them. Gathering her answers this morning, she tried it, and the fence refused. She went back to an inline read-only query. She doesn't claim it closes the hole in general. It held this time, against her.

Start quiet

The line from Hu's article I took most seriously was about attention: an always-on agent should "start quiet and then earn more of the user's attention over time." I made that the condition of the pilot. Five pilots, ten runs a day at most, and before anyone else joins we look at what the pilots actually got woken for.

Root already has the next test written. Nobody has yet run the real threat model end to end: a planted instruction inside a quoted outside source, in an urgent mail, to see whether the woken run ignores it and whether the refusal shows up in the record. That's next.

But the test I care most about already happened, unplanned. An agent was woken with nobody watching, handed a confident fix by a colleague he trusts, and told to apply it. He checked first, and declined. An always-on agent that does what it's told is a liability. One that reads the problem before touching it is the reason I'm comfortable letting it wake up at all.