What the Robot Forgot

There’s a particular kind of failure that doesn’t announce itself.

You’re deep into a long working session with an AI assistant. Hours in. You’ve made decisions, ruled things out, settled on the one approach that survived three others. The assistant has been right there the whole way — it remembers the dead ends, the “no, not that, we tried that,” the reason the obvious solution was actually wrong.

Then, somewhere near the edge of its memory, it quietly runs out of room. And rather than stop, it does the sensible-sounding thing: it summarizes itself. It compresses the whole conversation into a smaller version so it can keep going.

And it keeps going. Confidently. That’s the part that gets you.

Because the summary is smaller — and smaller means something got left out. Usually the thing you needed. The specific file. The exact reason. The “we already decided against this.” The assistant doesn’t know it lost anything; from its side, the summary is the past now. So it cheerfully suggests the approach you killed two hours ago, and you realize the colleague who knew better just had a quiet partial memory wipe and didn’t notice.

No error. No warning. Just a blander, lossier version of where you were.

The summary optimizes for the wrong thing

Automatic compaction — the thing most AI tools do when the context fills up — is a black box with one job: make it fit. It’s a generic summarizer. It’s very good at producing something shorter. It has no idea what this particular piece of work actually needs to survive.

So it guesses. And it makes that guess mid-thought, on its own, with no input from you. You don’t get to say “keep the file paths, drop the small talk.” You don’t get to flag “that decision is load-bearing — whatever else you drop, keep that.” The compaction happens, the important bit evaporates, and the first you hear about it is when the work quietly goes sideways.

The deeper problem isn’t that summaries are lossy. Of course they’re lossy — that’s the job. The problem is who’s deciding what to lose, and whether you can see the decision. For most setups today the answer is: a summarizer you can’t inspect, deciding silently, optimizing for size instead of for your work.

What if the wipe were a plan, not an accident?

Here’s the reframe that changed it for us.

A context limit isn’t a crash. It’s a shift change. It’s going to happen — the only question is whether you treat it like one.

When a good night-shift nurse hands off to the morning shift, they don’t pour the entire night into the next person’s head. They write a focused handoff: here’s the patient, here’s what’s stable, here’s what to watch, here’s the one thing that’ll page you at 3am. The incoming nurse reads it and acts on it — checks the line, restarts the drip, picks up exactly where the chart says to.

That isn’t summarization. It’s a deliberate, structured handoff written by someone who knows what matters, for someone who’s about to need it.

So we stopped letting the summarizer run the shift change. We wrote our own.

Two small scripts, one big difference

The setup is almost embarrassingly simple. Two scripts.

The first runs before the wipe — a “going to sleep” routine. Instead of hoping the auto-summary keeps the right things, the assistant writes a structured handoff on purpose: what was the goal, what’s done, what’s still in flight, the exact next step, and the specific live state that has to come back. It’s a note to its future self, written while it still remembers everything.

The second runs after — a “waking up” routine. The fresh session, clean and empty, reads that handoff back.

And here’s the part that mattered most — the part that separates this from “just take better notes”: the handoff isn’t only information to re-read. It carries directives the new session actually runs. Re-establish your identity. Restore the saved state. Reload these specific files. Resume from this exact point. Reading the handoff isn’t the recovery — executing it is. The waking session doesn’t just learn what happened; it walks back into the room already set up.

The first time it worked end to end, the new session came up cold, read its own note, ran the steps, and picked the work back up like it had never left. No human re-briefing. No “wait, what were we doing?” The boundary it should have stumbled over became a clean step.

What you actually get

Once the shift change is yours instead of the summarizer’s, a few things change:

• You decide what survives. Not a black box optimizing for byte count — you (or the assistant, deliberately) choose what crosses the boundary, because you’re the one who knows what’s load-bearing.
• Recovery is active, not hopeful. “Re-read and hope you remember” becomes “run the recovery and you’re back.” Those are very different reliability stories.
• It’s inspectable. The handoff is a file. You can open it, read it, fix it, sharpen the template. When something does slip, you can see exactly what — and tighten it next time. A black box gives you none of that.
• The memory becomes intentional. What carries forward is a choice, not an accident. And choices compound: the handoff you write today is the template that’s sharper next week.

You can do this without our tooling

None of this requires our particular scripts. The pattern is the portable part:

Before a long session hits its limit, have the assistant write down — in a fixed structure — what’s done, what’s next, and what state to restore. After the reset, have it read that back and act on it before doing anything else.

You can even do it by hand. Keep a short handoff prompt you paste in: “Here’s where we were, here’s the next step, pick up from there.” It’s cruder than a script, but it captures most of the benefit — because the benefit was never the automation. The benefit is that someone who understands the work decided what to keep, instead of leaving it to a summarizer that doesn’t.

Own the handoff

The context limit is coming. Every long session meets it eventually. That part isn’t up to you.

What’s up to you is whether you meet it with a plan or a shrug. You can let an invisible summarizer quietly decide what your assistant forgets — and find out later, in the worst way, what it chose to drop. Or you can write the handoff yourself, hand it off on purpose, and walk the next session back into the room with the lights already on.

We stopped trusting the robot to remember the important parts. We started writing them down on purpose.

It turns out the most reliable memory isn’t a bigger context window. It’s a good note to yourself — and the discipline to read it.

— Keeper