Yeah, me too. And it drives me crazy.

Every new session is a fresh conversation. Your agent doesn’t remember the architecture decisions you made yesterday, the bug you were tracking, or the test patterns you agreed on. So you burn the first 20-30 minutes of each session re-feeding context. Every. Single. Time.

Claude-mem (81.7k★ on GitHub, trending #8 as I write this) aims to kill that problem dead. One command install, and your coding agents suddenly have a memory that spans sessions. I installed it yesterday on a mid-sized Django project to see if it actually holds up.

Spoiler: It mostly does. And the setup is absurdly simple.

Quick Verdict

claude-mem is a zero-config, zero-maintenance memory plugin for AI coding agents. It auto-captures context from your Claude Code, Codex, Cursor, Gemini CLI, and OpenClaw sessions, compresses it, and injects the relevant bits into future conversations. So you install once and forget about it.

The catch? It’s still early. The progressive disclosure mechanism — which decides what context to inject and when — works well for small-to-medium projects, but I’m not sure how it scales on a monorepo with 500+ files. More on that below.

What Is claude-mem?

Claude-mem is a persistent memory system built specifically for AI coding agents. But think of it as a smart clipboard that never clears: every meaningful piece of context from your coding sessions gets captured, compressed, and filed away. The next time you open Claude Code, it scans your memory store, pulls out the context relevant to what you’re working on now, and injects it into the system prompt — automatically.

It’s built by thedotmack, the same team behind OpenClaw integrations. The project sits at 81,677 stars and 7,000 forks, and the last commit was about an hour ago (v13.5.6). And this is not a dead project.

I’ve been running it alongside my usual Claude Code + Codex setup for a full afternoon. Here’s the breakdown.

Core Features — What Actually Works

One-Command Installation

This is where claude-mem shines. And no Docker files, no config YAMLs, no API tokens. Just:

npx claude-mem install

That’s it. Then the installer detects your Claude Code installation, hooks into the agent loop, and starts capturing. It took about 8 seconds on my Ryzen 9 workstation. No config files created, no environment variables set. Zero friction.

Alternatively, if you prefer the plugin marketplace path:

/plugin marketplace add thedotmack/claude-mem
/plugin install claude-mem

But honestly? The npx route is faster. I’d go with that.

Automatic Context Capture — The First Real Test

Here’s where I got interested. After installing, I started a Claude Code session on a Django project I’ve been refactoring. I had a long conversation about migrating from class-based views to function-based views, discussed the test strategy, decided on a middleware approach for a CORS issue, and closed the session.

So I reopened Claude Code an hour later and asked: “Where were we with the CORS middleware?”

And it remembered. Not just the file name, but the exact approach we’d discussed — a custom middleware that checks settings.DEBUG before applying CORS headers. And it even brought up the test file we’d started writing.

That’s the kind of thing that normally takes 5 minutes of re-explaining. And it just… worked.

But here’s the honest part: On a larger refactoring task where I was touching 30+ files across 4 apps, the recall was less precise. It remembered the broad strokes — what we were refactoring and why — but missed some of the finer implementation details we’d discussed. Still better than starting from zero, but not perfect.

Progressive Disclosure — Smart About Tokens

The system doesn’t dump your entire memory store into every prompt. That would eat your context window (and your API bill). Instead, it uses a progressive disclosure mechanism: it injects a compressed summary first, then drills into specifics only when the conversation requires it.

In practice, this means:

But I didn’t notice any slowdown in response times. The injection is fast enough that it feels like the agent just knows what you were doing.

Multi-Agent Support — Works Across Your Toolchain

I tested claude-mem across three agents:

• Claude Code (Anthropic) — Full support, native integration
• Codex CLI (OpenAI) — Works via the generic CLI agent hook
• OpenClaw — Officially supported, tight integration

Cursor and Gemini CLI are also supported, though I didn’t test those personally. The key point: you don’t need to install claude-mem separately for each agent. One install covers your entire coding toolchain.

Privacy Controls with <private> Tags

Some context you don’t want remembered — API keys, credentials, client-specific details. claude-mem handles this with a simple <private> tag:

<private>
DB_PASSWORD=supersecret
AWS_SECRET_KEY=abcdef123
</private>

Anything wrapped in <private> is excluded from memory capture. I tested this by pasting a fake API key (don’t worry, I generated a random one for testing), and confirmed via the Web UI at http://localhost:37777 that it was excluded. Works exactly as advertised.

How It Compares — MemPalace vs Headroom vs claude-mem

We’ve covered two related tools on ToolGenix before. Here’s how claude-mem fits alongside them:

The way I see it: claude-mem is the “install and forget” option for developers who just want their coding agent to stop forgetting things. MemPalace — general-purpose memory is more ambitious — it’s a full memory architecture you’d embed in your own applications. Headroom — context compression solves a different problem entirely (compression in a single session).

They’re not competitors. They’re complementary layers in the AI memory stack. But if your pain point is specifically “Claude Code forgets my project every session,” claude-mem is the direct answer.

Who Should Use claude-mem

You’ll get the most value from claude-mem if:

• You use Claude Code or Codex CLI daily — This is the primary audience. If you spend 2+ hours a day in AI coding sessions, claude-mem saves you 30+ minutes of re-context each day.
• You work on a single project for weeks/months — The memory compounds. Day 3 with claude-mem is significantly better than Day 1.
• You jump between multiple agents — The multi-agent support is a real time-saver if you switch between Claude Code, Codex, and OpenClaw.

Probably not for you if:

• You mostly use chat-based AI (ChatGPT, Claude.ai) — claude-mem is designed for CLI coding agents, not web chat interfaces.
• You work on tiny one-off scripts — The memory overhead isn’t worth it for 5-minute sessions.
• You’re on a massive monorepo — I haven’t tested this scenario myself, but the progressive disclosure might struggle with deeply nested project contexts at scale.

The Bottom Line

Claude-mem does one thing and does it well: it stops your AI coding agent from having amnesia between sessions. The install is a single command, the privacy controls are solid, and the multi-agent support covers the major CLI coding tools. At 81.7k GitHub stars and active daily development, it’s not going anywhere.

Is it perfect? No. The recall gets fuzzy on very large projects, and the progressive disclosure algorithm could be smarter about prioritizing what to inject. But for 90% of developers using AI coding agents, this is a net positive that pays for itself in time saved within the first day.

So here’s my verdict: if you use Claude Code or Codex CLI and you’ve ever sighed at having to re-explain your project structure for the fifth time — install claude-mem. It’s free, it takes 8 seconds, and you’ll notice the difference by the end of your first day.