Reliable memory, backed by workflow. A scannable layout for your project's notes (per-session worklogs, atomic decisions and tasks, a generated index over all of it) plus a small set of Claude Code skills that keep it up-to-date as you work with your agents. You stay the driver; the agents do the work and leave a trail of evidence as they go, capturing each decision, dead end, and result in one shared record they can all work from. Pick up exactly where you left off, and keep every step reviewable months later.
Three situations this is built for. The first two are about losing your own thread across a break; the third, the one that grows every time you hand more of the work to an agent, is about losing sight of what the agent did.
You finished a session Tuesday afternoon. It's now Friday. You open the project, stare at the screen, and realize you have to spend the next hour reconstructing where you were before you can do useful work: which open question were you chasing, what did you decide and discard, where exactly in the code you stopped, why the test you'd been writing was even the right test to write. By the time your head is back in the project, you have maybe an hour of real work left in the session.
If you only ever work on one thing for weeks at a time, this isn't your problem. But most people don't. With two or three projects in flight (meetings, teaching, side experiments, etc.), every switch costs roughly an hour of re-onboarding. In a typical 1.5–2 hour work block, that's most of the time: you spend your day getting back to where you were instead of moving forward.
And the agent doesn't rescue you here by default. It's not that it forgets (a session can carry context forward) but that context is a finite, lossy window: a whole multi-month project never fits, and cramming everything in makes the agent slower and less sharp, not more. The fix isn't one endless session; it's a durable trail kept outside the model that either of you can reload from, just the slice you need.
There's a related pain you only notice later. The pipeline you've been running daily for three months feels obvious to you: every design choice has been internalized to the point of of course it works this way, how else would it. Then a deadline arrives and you have to write it up.
You sit down to explain the design to a stranger and most of it is gone: you remember what the thing does, but not the choice you made to get there, not the why, not the how, not the alternatives you tried first, not the specific failure mode that pushed you to the current setup. Reconstructing it costs a day or two of grinding through git history and half-remembered messages, under the wrong intuition that whatever you're doing now must have been the obvious choice from the start. It rarely was: the design is usually more deliberate than memory credits it for, and much of that reasoning happened in dialogue with an agent that no longer has it to hand.
The opposite of forgetting: you hand the work off and stop watching. It's tempting: let the agent run and take the result. But left to run ahead unattended, it makes a dozen design decisions along the way, and now you can't easily say what it chose, why, or whether it's right; reviewing it means reverse-engineering an agent's reasoning from the artifact alone. Do this enough and you become a passenger in your own project: things get built, but you can no longer vouch for them, and the calls that should have been yours were made without you.
This system exists to address all three pain points: a small set of disciplined notes, written into your project in a layout an LLM can scan token-efficiently.
When you sit back down after a switch, one command (/catchup) reads the trail and tells you where you were, what's open, and what to do next. Writing things up three months later, asking Claude to walk your state/INDEX.md surfaces the design decisions and findings you made along the way, often in more detail than you'd remember unaided. And when the agent does the work with /co-work, the same trail keeps you in the driver's seat: every decision it makes is recorded as it goes, so you can review, question, or override any of them without redoing it yourself.