AI agents forget because each session starts with an empty context window, and long sessions get summarized to make room, which drops detail. Built-in memory features store small facts about you and miss the working state of a project. The fix that works is file-based memory: keep plans, decisions, strategy and raw source material in files the agent reads at the start of every session, and pass full sources between steps so details survive.
AI agent memory is the ability of an AI agent to carry context from one session to the next: what you're building, what you decided, what already failed. Most agents have very little of it. Each new conversation starts from zero, and long conversations get compressed as they go. So you end up re-explaining your project to the same tool that helped you build it yesterday.
The practical fix is simple and a little boring. Write the important context into files, and make the agent read them at the start of every session. That's what I do, both for building software and for writing content.
I learned this the hard way. I was deep into a session with Claude, in the middle of executing a 12-step plan we'd worked out together. The session was getting long and I wanted to continue in a fresh terminal. So I asked it how to bring the context of this conversation, specifically the 12-step plan, into a new session. That's when it clicked for me: the hardest UX problem in AI right now is memory, and capability comes second.
Why does Claude forget? How AI memory actually works
It helps to understand the mechanics, because they explain every frustrating moment.
A model like Claude doesn't learn from your conversation. Everything it "knows" about your project lives in the context window: the text of the current session, plus whatever files or instructions were loaded into it. When the session ends, that context is gone. The next session starts empty unless something puts context back in.
Inside a long session there's a second problem. The context window has a limit. Coding agents like Claude Code handle this by compacting: older parts of the conversation get summarized to make room. A summary keeps the gist and drops the details. The exact constraint you mentioned two hours ago, the approach you already tried and rejected, the specific number that mattered. Those are the first things to go.
So "Claude forgot" usually means one of three things:
- New session. The context was never there.
- Compaction. The context was there, then got summarized away.
- Too much noise. The context is technically there, buried under so much other material that the model doesn't weigh it.
Each needs a slightly different fix, but they all point the same way.
What built-in AI memory does, and what it misses
ChatGPT and Claude both now offer some form of memory, and it's useful for what it is. It remembers that you prefer short answers, what your company does, maybe your role.
What it doesn't hold well is working state. The 12-step plan and which step you're on. The three decisions you made yesterday and why. The positioning you settled on after a week of arguing with yourself. That kind of context is too big, too structured and too important to leave to whatever the tool decided to remember.
Here is how I think about it:
| Kind of context | Where it should live |
|---|---|
| Preferences (tone, format, language) | Built-in memory or a standing instruction |
| Who you are, what your company does | A short profile file the agent always reads |
| The current plan and where you are in it | A plan file, updated as you go |
| Decisions and why you made them | A decisions log |
| Strategy, positioning, voice | Dedicated files, reviewed by you |
| Raw source material (notes, transcripts, research) | Saved in full, one file per item |
The top row is the only one I trust to built-in memory.
The fix: treat files as your agent's memory
The pattern that works for me is to treat the filesystem as the AI's persistent memory. Every artifact the agent writes to disk is context that survives the session boundary. The next session, or a different agent entirely, can read it.
In practice:
- Keep an instructions file the agent reads at startup. Claude Code, for example, reads a CLAUDE.md file automatically. Put the stable things there: what the project is, the rules, where other files live.
- Write the plan to a file before you execute it. When I work through a multi-step plan now, the plan lives in a file, and each step gets checked off there. A new session reads the file and knows where we are.
- Log decisions as you make them. One line each: what we decided, why, what we rejected. This is the context that compaction loses first and that you miss most.
- End sessions with a handoff note. Before closing a long session, ask the agent to write down the current state, open questions and next steps. Then start the next session by reading it.
- Save raw material in full. More on this in the next section, because it's the easiest mistake to make.
None of this needs special infrastructure. Plain markdown files in a folder work. The discipline matters more than the tooling.
The second memory problem: lossy compression between steps
Once you fix memory across sessions, you run into a subtler version of the same problem inside multi-step AI systems.
I found it in my own content pipeline. One step researched a topic and pulled in sources. A later step turned the chosen idea into a post. At one point the research step surfaced a source that was directly relevant, the kind of material that should have shaped the whole post. When I traced what the writing step would actually receive, it was a one-line "supporting evidence" note. All the richness of the source was gone before the writer ever saw it, and a writer working from that line can only produce something generic.
That's lossy compression. Step 1 finds something rich. Step 2 summarizes it. Step 3 writes from the summary. The specific numbers, names and quotes that made it valuable get dropped in the handoff, and nothing throws an error. The output just looks fine and says less.
The rule I took from it: in any multi-step AI system, output quality is capped by the narrowest handoff between steps. If a source might shape the result, pass the full source forward and let the later step decide what matters. Summaries are for navigation. The final step needs the original.
AI memory for content creation
This is where AI memory stops being a developer problem and becomes everyone's problem.
When you ask an AI to write a LinkedIn post, it can only draw on what's in its context. If that's a one-line prompt, you get the average post on the topic. I've seen this from the other side too: we once matched a CEO's voice closely from his past posts and he told us the result sounded like every CEO on LinkedIn. Voice was in the context. His strategy, his company's position and his actual opinions weren't.
Good content memory has three layers:
- Your raw thinking. Voice memos, call notes, reactions to news. I record ideas as voice memos and each one is saved as its own dated file, so nothing gets lost and nothing gets pre-summarized. I wrote up the whole voice memo workflow separately.
- Your strategy and voice. Who you're writing for, what you want to be known for, how you sound, what you'd never say.
- A curated reference library. The sources you trust. For my own research I built a notebook from specific voices I follow, plus 349 newsletter posts and 250 podcast transcripts from Lenny's Newsletter, batched by topic so each source kept as much of its original text as possible. What you choose to put in shapes what the AI thinks.
Most AI posts sound like AI because the specifics are missing from the input. Memory is how you get the specifics back in, every time, without retyping them.
This is also why I moved my own content work inside Claude, where it can read these files directly. Liftli runs as a LinkedIn MCP server for exactly that reason: the drafting happens where your context already lives.
A setup you can copy this week
If you want to fix your AI's memory without building anything:
- Create one folder per project or per area of work.
- Add a short
READMEor instructions file: what this is, who it's for, the rules. - Add a
planfile and adecisionsfile. Update them as you work. - Save raw inputs in full: transcripts, notes, research. One file each, with a date in the name.
- Start every session by asking the agent to read the folder's instructions file.
- End every long session with a handoff note.
The narrative I keep coming back to: the best leaders in the AI age are hands-on. You can't lead what you've never touched. Setting up your AI's memory yourself, even once, teaches you more about how these systems actually work than any course.
