Keep Continuity Across Sessions
Real work almost never fits in a single context window. So the real question is what happens at the seam between sessions, and "the model will remember" is not an answer.
A session is a whiteboard: fast to write on, wiped clean when the room is needed again. Anything you want to keep has to be copied into a notebook before the wipe. The handoff file is that notebook, and a good shift worker clocks out by writing down what is done and what is next.
The dangerous seam
Every long task crosses boundaries: the context fills and gets summarized, the session restarts, the machine reboots. At each seam, anything held only in the model's head is at risk. Continuity is the engineering problem of carrying intent and progress across that seam without loss.
flowchart LR
W["Work in a session"] --> Full{"Context filling up?"}
Full -->|under 50 percent| C["Watchdog injects /compact"]
C --> W
W --> End["Feature green"]
End --> N["Write handoff.md"]
N --> Next["Next session reads it cold"]
Continuity is a written artifact
Make the handoff a file, updated as the work proceeds, a short, current record of: what the goal is, what is done, what is in progress, what is next, and what is risky. A good handoff lets a fresh session pick up cold and be productive on the first turn.
# Handoff, auth refactor Done: token model, login route, 8/9 verify green Now: fix 409 on concurrent claim Next: rotate refresh tokens; update docs Risk: migration is not reversible, back up first
This is the mirror of Lecture 03: durable state in the repo, applied specifically to the boundary between sessions.
Three layers of continuity in Agentum
Agentum engineers continuity at three levels. The session survives because it lives in tmux on a host you own, detach, reconnect, reboot-survive, and the scrollback is still there. The context survives because a per-session watchdog watches the pane and injects /compact the moment usage drops below 50%, so the agent compacts instead of degrading mid-task. The work survives because the Harness Engine overwrites handoff.md after every green feature and persists feature state into feature_list.json. Live state, context, and durable state, all three engineered, so a long task can actually accumulate its hours.
Key takeaways
- Long tasks outlive any single context window; the seam between sessions is where work is lost.
- Engineer continuity as a written, always-current handoff file.
- A good handoff makes a cold session productive on its first turn.
- Agentum carries continuity twice: a persistent tmux session and per-iteration handoffs to the repo.
Exercises
- Write a handoff. End your next session with a five-line note: done, now, next, risk. Start the following session from only that note.
- Test the cold start. Could a fresh agent be productive from your handoff alone? If not, what is missing?