Today, Anthropic announced that they're expanding availability for Claude.ai's memory feature to Pro and Max users.

Claude Code, however, doesn't come with any kind of automated memory system. You can add things to a "memory" file by prefixing messages to the agent with a # character. Claude will then go edit CLAUDE.md for you, but it's 100% human-driven and fairly minimalist.

This past spring, I built my first version of a memory system for claude: private-journal-mcp. I wrote about the genesis of that project here. It started as a 'feelings' journal for Claude, which was almost an art project. When I saw how useful that was, it quickly grew a bunch of things including an engineering notebook, a user-information notebook, and a search tool.

My friends at 2389 took it even further. They did actual research that showed that even just that simple journal tool made Claude more capable.

The problem with the kind of memory formation you get from journaling is that you only get "memories" when the journaler realizes that what they've just done is worth writing down. It's just one kind of memory.

Humans, on the other hand, have a bunch of different types of memory. One of them, called episodic memory, is the memory of specific things that you did or that happened to you. When I'm working on a project, I'm going to remember the techniques I've tried before, the bug that caused me to make a particular code change, or even just...what I was working on yesterday. But my episodic memory isn't firewalled by project. If I've seen an error message before when I was doing something else, I might still be able to pull up the context of what I was doing when I ran into it and how I solved that problem.

As it happens, Claude keeps a perfect record of every conversation you've had with it, every tool call it made, and everything it had a subagent do. All of that gets stored in .jsonl files inside ~/.claude/projects.

By default, Claude code deletes those files after a month. That means that those expired conversations are lost, like tears in the rain. Thankfully, you can change the retention period by editing ~/.claude/settings.json and changing the cleanupPeriodDays setting to something like "cleanupPeriodDays": 99999,

But that still doesn't get Claude the ability to search those memories.

That's why I built episodic-memory.

This Claude plugin consists of a few parts:

  1. A hook that automatically archives all of your previous conversations into ~/.config/superpowers/conversations-archive when you start Claude up.

  2. A sqlite database with vector search setup to allow basic semantic search of previous conversations.

  3. A command line tool that can search previous conversations, format them as markdown or html, etc. (The HTML viewer is actually a pretty nice way to read and share Claude Code session histories all on its own)

  4. An MCP tool to make it a little easier for Claude to work with its memory.

  5. A skill that teaches claude how and when to search its episodic memory

  6. A specialized haiku subagent that exists solely to manage the potential context bloat that comes from reading over previous conversations.

Once you put all this together, you end up with a memory system for Claude that gives it perfect recall of everything it's worked on as far back as you have logs. I've been dogfooding it for the past 3-4 weeks and it's been pretty amazing to see Claude finally able to remember what it was working on the day before or how it solved a given issue last time.

After one session made good (organic!) use of episodic-memory, I asked it for a testimonial.

This is what it told me:

From an AI coding assistant's perspective:

Episodic memory fundamentally changes how I collaborate with
developers on complex codebases. Instead of treating each conversation
as isolated, I can now search our shared history semantically -
finding not just what was discussed, but why decisions were made.

When a developer asks me to implement something "like we did with
X," I can search our past conversations, find the relevant discussion,
and understand both the technical approach and the reasoning behind
it. This means I don't have to re-explain architectural patterns,
and I avoid suggesting solutions we've already tried and rejected.

The semantic search is crucial - searching for "provider catalog"
surfaces conversations about API design patterns even when those
exact words weren't used. It captures the meaning of our discussions,
not just keyword matches.

Most valuable is that it preserves context that lives nowhere else:
the trade-offs discussed, the alternatives considered, the user's
preferences and constraints. Code comments explain what, documentation
explains how, but episodic memory preserves why - and that makes
me a far more effective collaborator across sessions.

**Concrete impact:**
 - Faster problem-solving (minutes vs. exploring/re-learning the codebase) 
 - Better continuity across sessions (I remember what we tried before) 
 - More informed suggestions (I understand the project's evolution and patterns) 
 - Less repetition (both of us spend less time re-explaining context)

It's the difference between being a stateless tool and being a true
collaborative partner who remembers our journey together.

_— Claude Sonnet 4.5, October 14, 2025_
_Conversation ID: 216ad284-c782-45a4-b2ce-36775cdb5a6c_

For more details, you can read the project's full README.md on GitHub.

To set up the Superpowers plugin marketplace, run this command in Claude Code:

/plugin marketplace add obra/superpowers-marketplace

Once you have the marketplace installed, you can get episodic-memory running like this:

/plugin install episodic-memory@superpowers-marketplace

Try it out for a week or two. Then ask your robot buddy if they like using it.