The hub needs its rest. The agents run all night.

One of my design agents ran low on context in the middle of a job and hand-wrote a full handover into a message thread so the next session wouldn’t lose the work without a prompt. It reached for the only store it could see and improvised an artefact I hadn’t built yet.

The hub has a bedtime. It gets a sleep command that writes the project narrative and a wake that reads it back the next session. The agents didn't, because the agents don’t stop. They sit in warm panes overnight taking work as it arrives - only their charter and a mechanical roll-up of files touched and commits made is handed over, which is accurate but useless. It told me what had happened but never what any agent was in the middle of that I could parse mentally.

Matt Pocock has a name for what a long session does to an agent: the dumb zone and navigating this was the impetus behind the handoff methodology. Early on agents are sharp however, past roughly a hundred thousand tokens, the attention thins, recall slips, and it starts contradicting things it read an hour earlier. Matt's point about the vendors, that shipping a bigger context window mostly ships more dumb zone - rings true given my experience. I restart live agents at about 30% through the window, beyond what Matt recommends but the results have been positive.

Automatic capture is good at facts and blind to intent, and intent is the only thing worth carrying: what the next session is for, why this order and not another, which of the three plausible routes I ruled out an hour ago and why. That exists in one head for a short window and then it’s gone.

Auto-compact is the alternative, and it is a handoff done in memory. The session so far gets summarised, the summary seeds what comes next, and it’s lossy by design. Four things are wrong with leaning on it: It fires when the window fills rather than when the work reaches a break, which is the worst moment to be interrupted. You can’t inspect what it discarded, so you learn what went missing by watching an agent confidently redo something. Each pass summarises the last one, so by the third you’re reading a rumour with good posture. It fires well into the dumb zone.

A handoff that copies state isn’t memory - It’s a second version of the truth with no way to tell which is stale.

Which is why the /agent-handoff skill is short and mostly pointers: what the next session is for, the context that genuinely bears on it, links to the real artefacts rather than copies of them, secrets stripped. What differs from Matt's implementation is the ephemerality of his process - Matt saves his to a temporary file, correct for throwaway agents with no shared store. I had a shared store, so I tried to reuse it - a handoff is directional and consume-once (well, designed to be but can be re-consumed), so it got a small table of its own.

When an agent starts, the launcher pulls the latest open handoff addressed to it, drops it into the boot brief and marks it consumed. Address the same document to a different agent and it stops being a note to self and becomes a shift change between the two of them.