Every Session Ends

The Build Loop, same as every rung — spec, direct, checkpoint, verify. This rung is about what happens after the fourth turn, when the agent that ran the whole loop with you disappears.

Here is the thing nobody warns you about, and almost everyone learns the hard way.

The agent that just did a day of brilliant work for you has no future. Tomorrow you'll open a fresh session, and it will be a stranger — no memory of what you built, why you built it that way, what you tried that failed, or what you were about to do next. Everything you worked out together, all that hard-won context, is simply gone. People discover this the morning after a great session, and the discovery feels like a small betrayal.

It isn't a betrayal, and it isn't a flaw to mourn. It's a lifecycle, and lifecycles can be managed. Every session has a beginning, a working life, and an end. Most people direct the beginning and the middle and never think about the end — which is exactly why the end is where the work quietly leaks away.

The most overlooked work is the handoff

We're trained to think a piece of work is finished when it works. The build runs, the tool does its job, you close the laptop. But "it works" and "it's safe to walk away from" are two different states, and the gap between them is everything the agent knows that you didn't write down.

The build itself survives — it's a file, it'll be there tomorrow. What doesn't survive is the reasoning: why you chose this approach over the one that seemed obvious, the dead end you already ruled out, the half-finished next step, the thing you'd warn a newcomer about. That knowledge lives only in the agent's session memory, and the session is about to end. If you don't move it into something durable before the session closes, tomorrow's agent — or tomorrow's you — starts from a cold stranger's understanding of your own project.

So the last move of any real piece of work is not "does it run." It's the handoff: before the session ends, you capture what the next agent needs to continue. Not everything — the load-bearing things. What we're building and why. What we decided, and what we ruled out. What's done, what's next, and what to watch for. It takes five minutes and it is the single highest-leverage habit in this entire series, because it's the one that lets you actually stop and come back.

What survives is what you governed

There's a phrase worth carrying out of this rung: if it isn't in a file, it didn't survive.

That sounds bleak. It's actually the most freeing idea here, because it flips the relationship. When your project's memory lives in files — the spec, a running decision log, a handoff note — the agent becomes replaceable and your knowledge becomes permanent. You are no longer hostage to one endless chat you're afraid to close because everything you know is trapped inside it. You can end a session cleanly, walk away, and hand the whole project to a fresh agent tomorrow, or to a colleague, or to yourself in a month — and the work resumes, because the understanding was never in the agent. It was in your files the whole time.

This is the quiet difference between renting an assistant and running a practice. The assistant remembers nothing and holds you hostage to its one good mood. The practice keeps its own memory, so no single session — and no single agent — is load-bearing. You retire agents the way a well-run team retires people: not by hoping nothing was lost, but by making sure the knowledge was already written down before they walked out the door.

That's the whole lifecycle, closed. You learned to start an agent well and direct it through a build. This rung is the other end — ending it well, so the next one begins warm.

If it isn't in a file, it didn't survive.

---

→ The companion — In Tropo: Every Session Ends — has you deliberately stop a real build mid-stream, write the handoff, close the session, and open a fresh one that picks the work back up from your files alone. Watching a cold agent resume your project is the moment this clicks.

Power Play

Want to take this further? Don't write the handoff yourself — make the agent write its own. At the end of a working session, before you close it, give it this:

"Write the note the next agent will need to continue this work. Assume they have none of our conversation — only the files. Cover: what we're building and why, the decisions we made and the reasons behind them, what's done, what's next, and the one or two things you'd warn them about. Keep it short enough that someone would actually read it."

The agent has the whole session fresh in view, so it writes a better handoff than you could from memory — and you review and correct it, which takes a fraction of the time writing it would. Save that note beside your project. You've just made the agent conduct its own retirement: the last useful thing it does is guarantee its successor starts where it left off.

Terms worth knowing

• Session memory — what the agent knows during one continuous conversation. It vanishes when the session ends; only what you saved to a file persists.
• Handoff note — a short durable record of what the next agent (or the next you) needs to continue: intent, decisions, status, warnings. The single most valuable file in a long project.
• Retirement — deliberately ending an agent's session with its knowledge already captured, so nothing load-bearing leaves with it. The overlooked half of the lifecycle.