I have four projects, three AI agents, and exactly zero of them remember yesterday.

That’s the thing nobody warns you about when you start running agents across a real workload. The models are powerful. The context windows are enormous. The tool use is genuinely impressive. And every single session starts from scratch. What does that cost across seventeen sessions a week?

In tabletop RPG terms, Session Zero is the planning session before the campaign starts. You don’t roll dice. You don’t fight anything. You sit around a table and establish who’s in the party, what the mission is, and what everyone already knows.

Every dev session needs a Session Zero. The problem is, most of us skip it.

I tried the obvious fixes first. I’ll just remember where I left off. That lasted about three days before I opened Claude Code, typed “continue the thing,” and watched the Dwarf Warrior confidently march into the wrong dungeon.

Then I tried structured session notes — a markdown file per project tracking active goals and open items. Better. But still manual. Still friction. And friction is the enemy of consistency, especially with an ADHD brain that wants to start building, not start organizing.

The wrong theory was that the agents needed to be smarter about remembering. The right answer was that I needed a control surface — something between me and the party that assembled context before the session even started. Secure the campsite before you send anyone exploring.

The Launcher

So I built one. A Python/Tkinter GUI that sits between me and every agent session. Dark theme, four project cards, three agent buttons each. It looks like a mission control screen because that’s exactly what it is.

The Garret Launcher — four project cards, recipe buttons, wrapup resume dropdown, and health indicators

What happens when you type a focus and hit launch:

  1. Reads the active intent — each project has a CURRENT_INTENT.md with a ## Active Goal section. The launcher parses it.
  2. Reads the last wrapup — my end-of-session skill generates wrapup files with a “Recommended Next Session” section. The launcher finds the latest one.
  3. Queries the RAG API — my cross-project knowledge base gets a ping for relevant patterns and past fixes.
  4. Assembles the warm-start prompt — all three sources compress into a single context block and pass to the agent as its initial input.

Claude Code receiving the warm-start context block — last wrapup recommendations and session focus pre-loaded

The agent doesn’t start blank. It starts mid-conversation — knowing the goal, the last session’s unfinished business, and the relevant cross-project knowledge. Session Zero, automated.

The Dwarf Warrior walks in already briefed. The Diviner already knows which rooms to scry first. Even the Rogue shows up having read the map. Nobody wastes their first twenty minutes asking “so what are we doing today?”

What the Control Surface Shows You

Each project card displays:

  • Git status — clean, modified, untracked. How dirty is this project right now?
  • Intent freshness — green if updated in the last three days, yellow with age if stale
  • Service health — colored dots for Ollama, RAG API, wrapup availability, intent file

There’s a wrapup resume dropdown. Not just the latest — the last ten wrapups, sorted by date. You can pick any past session to continue from. This matters because sometimes the best next step isn’t the most recent one. Sometimes you need to reach back two sessions to the thread you actually care about.

Recipe buttons across the top: Morning Standup, Curate Inbox, Deploy Valkyrie. One click fires a pre-configured session — project, tool, focus, optional prompt — in a new Windows Terminal tab.

Weekly stats in the footer. Last week: 17 sessions across two projects. That’s the kind of operational tempo that makes you want a control surface instead of a guessing game.

Rook Mode

The architecture decisions that kept this from becoming a second problem:

  • Context via temp file, not shell args. The assembled context gets written to .context_tmp. The launch script reads it at runtime: command "$(cat /path/.context_tmp)". Zero quoting hell. This alone saved hours of debugging escaped quotes inside escaped quotes.
  • Concurrent health checks. Git status, intent parsing, Ollama ping, RAG health — all run in parallel threads on startup. Results render as colored status indicators.
  • Graceful degradation. If the RAG API is down (5-second timeout), the launcher still works. Context assembles from local sources only. No hard dependencies on network services.
  • Singleton guard. File-based lock using msvcrt.locking(). One instance. No accidental double-launches spawning duplicate sessions.
  • Explicit Git Bash path. Hardcoded to C:\Program Files\Git\bin\bash.exe. Avoids WSL confusion, avoids PowerShell, avoids path ambiguity.
  • Mobile bridge. A Termux script on Android connects over SSH and runs the launcher in CLI mode. Same context assembly, different surface.

The whole thing is 1,056 lines of Python. No framework. No dependencies beyond tkinter and the standard library. Boring tech that works every time.

The scar here isn’t technical. It’s about agency.

I spent months building increasingly powerful agent workflows — hooks, skills, cross-project knowledge bases, automated extraction pipelines. Each piece made the agents more capable. And somewhere in that process, I realized I was losing track of what they were doing. Not because they were doing anything wrong — because I didn’t have a surface to see the state of the whole system at a glance.

The launcher isn’t automation. It’s the opposite. It’s the last human decision point — the moment where I look at four projects, check their health, choose which agent gets which context, and press the button. Every session starts with a deliberate choice, not a default.

Build the tools. Automate the boring parts. But keep one screen where the human makes the call. That’s Session Zero — the clipboard the player holds while the party does the work.