Stop re-explaining your project to your AI every session

Your agent wakes up in Punxsutawney

In the Agent Doctor piece we made the case: sessions rot as they age. Exit before compaction. Don't let auto-compact decide which of your decisions survive.

Starting fresh sessions is right. But almost everyone leaves the most expensive thing behind in the old one.

• You had the agent map the repo in Codex — close the tab, gone.
• You reasoned through the architecture in Claude Code — gone.
• You settled the product language in ChatGPT — gone.
• You prototyped the frontend in Gemini — gone.

Every one of those cost tokens, and cost your time. And the next session wakes up at 6:00 AM in Punxsutawney, radio playing the same song, knowing none of it.

That's the loop. Every new session is Day One. The agent re-learns the town, re-meets the locals, re-reads the repo — and you pay for the same day, every day.

It's like grinding XP on a character that gets wiped at midnight. The level-ups never save.

So you do the same thing every morning: re-explain the project, re-paste the background, watch it re-read files it has read a dozen times. You start every session as a human clipboard.

You're already living like Leonard from Memento

Power users have been coping for a while:

• CLAUDE.md and AGENTS.md
• handoff notes and prompt libraries
• project wikis in Obsidian
• a wall of background pasted at the top of every new session

This is Leonard's system from Memento: tattoos for the rules that must never be forgotten, Polaroids for the current state, and handwritten notes for everything else. It's a rational response to amnesia. It's also — as the movie spends two hours demonstrating — a system that fails in predictable ways:

• Write too little, and the agent misses a hard constraint.
• Write too much, and the context turns dirty again.
• Let a note go stale, and the agent inherits an expired decision. Leonard trusted a stale note and killed the wrong man. Your agent trusts a stale CLAUDE.md and refactors the wrong file.
• And every pause to maintain the notes breaks your own flow.

Worse: manual notes cover one platform. The repo state you mapped in Codex — Claude Code has no idea. The product language you settled in ChatGPT — Codex has no idea. The implementation path you ruled out in Gemini — your next session has never heard of it.

You're not using four AI tools. You're running the Severance protocol: four innies, and none of them are allowed in the same meeting.

At some point, most of us make peace with it. The agent forgets; that's just how it is. Ten minutes per session for the recap. Learned helplessness, priced into the workflow. One must imagine the developer happy.

But resignation doesn't beat the math. The cost of re-explaining grows linearly with your task count. The busier you are, the more you burn.

So the real question was never “does my agent have memory.” It's this: can the useful context scattered across four platforms and dozens of dead sessions converge back — at the exact moment you need it?

Echo warm-up: waking up with yesterday intact

Before a new task, you say one thing to Echo:

Warm up this task.

Echo generates a fresh task context from your past AI work. Not by dumping chat history back into the window — by recomposing, against the current task's intent, five things into a launch pack:

If you read the Agent Doctor piece, you'll recognize the list: these are the five things we told you to carry by hand when switching sessions. The difference is the word hand.

Echo can do this because it doesn't treat one session on one platform as the boundary of memory. The boundary is your work itself. One task flows through Codex, Claude Code, ChatGPT, Gemini, and GitHub — and Echo converges the traces: repo exploration and patch history from Codex, architecture reasoning from Claude Code, product narrative from ChatGPT, frontend drafts from Gemini, what actually landed from your commits, and the dead ends from your failed attempts.

Roguelike players have a word for this: meta-progression. The run still ends. But the resources carry forward, and every run starts stronger. Echo is meta-progression for your agent.

How big the difference is

After a warm-up, the agent's opening move looks like this:

After warm-up

Instead of the one you watch every day:

Cold start

From our own early dogfooding — same task, same repo:

No magic in these numbers — and to be fair, this is one team's dogfooding, not a public benchmark; your ratios will differ. But the direction is hard to miss, because the underlying change is simple: the agent stops spending its turns rebuilding context, and starts consuming memory instead of raw history.

Break the loop once, today

No install required. You can do this on your next task:

1. After the commit, spend two minutes writing a handoff file: goal, files changed, decisions, constraints, failed attempts.
2. Make that file the first message of your new session. Not your chat history.

Done by hand, it works. It's also tedious — and “works but tedious” is exactly the profile of something that should be automated. Echo turns the two minutes into one sentence, and extends the coverage from one platform to all of your AI work.

Keep reading