claude-mem: 114,000 stars in just a few weeks for persistent agent memory

claude-mem: 114,000 stars in a few weeks for persistent agent memory

🔎 Your coding agents have become brilliant. They're still amnesiacs.

In just a few weeks, an open source plugin went from being a GitHub curiosity to a must-have building block of the agentic ecosystem: claude-mem, by developer thedotmack, shows 114,700 stars to date (June 2026) and sits at the top of GitHub's weekly trending chart, with nearly 9,900 stars gained in just seven days.

The pitch fits in a single sentence, straight from the repo: "Your coding agent forgets everything between sessions. Claude-Mem remembers for it." Your coding agent forgets everything between two sessions. claude-mem remembers for it — and feeds the useful context back exactly when you need it.

Why is everyone scrambling for such a simple building block? Because the model race has changed in nature. With GPT-5.5 (98.2) and Claude Opus 4.7 (94.3) at the top of the agentic rankings, code quality has stopped being the limiting factor for the majority of use cases. Amnesia, however, remains untouched. And memory has just gone from the status of a gimmicky feature to that of infrastructure.

Key Takeaways

• claude-mem is an open source persistent memory plugin for coding agents: 114,700 stars, 110th repo worldwide, #1 on GitHub's weekly trending (~9,900 stars this week).
• The mechanism: a second agent takes notes in parallel with your session, compresses them with AI, and the next session starts with a short index of key points — details are loaded on demand.
• Compatible with Claude Code, Codex, Cursor, OpenCode and 11 other agents; read-only for Copilot CLI, Goose, Roo Code and Warp.
• Trajectory: from 45,000 to over 114,000 stars in just a few weeks (May–June 2026), documented by Reddit, Augmentcode and Star History.
• Our take: memory is no longer an agent feature, it's an infrastructure layer — and it's being standardized outside the platforms, in open source.

Recommended Tools

What claude-mem actually does

claude-mem gives your agent a memory that survives closing the terminal. Not just a conversation history: a system that observes what the agent does, summarizes it, and reinjects the right context at the start of the next session.

The mechanism works in three stages, described in the official repo. During your session, a second agent takes notes in parallel: decisions made, files touched, conventions followed, dead ends explored. At the end of the session, these notes are compressed with AI to keep only the essentials. At the next session, the agent starts with a short index of key points, and can load the details on demand.

The flow: capture, compression, reinjection

Capture is passive: you don't "feed" anything, the observer agent works in the background while you code. This is the fundamental difference from manual memories of the "remember this" type.

Compression is the real technical challenge. Inflating the context with 50,000 tokens of raw history is costly in latency and tokens, and drowns out the useful information. claude-mem compresses: the next session only receives a short index, and fetches the archive only if necessary.

Reinjection, finally, is what you experience: you reopen your terminal, and the agent already knows why yesterday's refactor was abandoned, which convention the team settled on, and where the migration stood.

Why it's clever

Most memory solutions shift the burden onto the human: you have to remember to save, sort, and recall. claude-mem inverts this model. The developer who installs it doesn't change their workflow — they keep it, and gain a past.

This also explains the speed of adoption: zero friction to get started, growing benefits with every session.

The numbers: from 45,000 to 114,700 stars in a few weeks

claude-mem's trajectory is one of the fastest observed on GitHub this year, and it is documented milestone by milestone by independent sources.

In the past week alone, the project gained roughly 9,900 stars — more than 1,400 per day — placing it in first position on the GitHub weekly trending list. Star History also ranks it 110th repo worldwide by total star count, and named it "Trending Repository of the Day".

We were already tracking the project at 108,000 stars in a previous article: the curve still hasn't flattened, and the 120,000 milestone is on the horizon.

A journalistic caveat is in order: stars don't measure the quality of a tool, and star campaigns do exist. But sustained growth over several weeks, confirmed by independent milestones, measures something else: the urgency of the problem being solved. Nobody stars a memory plugin out of curiosity; you star it because you just needed it.

Memory, the missing link of agents

The bottleneck for coding agents is no longer their brain: it's their lack of a past.

Look at the agentic leaderboard. GPT-5.5 dominates with 98.2, ahead of Gemini 3 Pro Deep Think (95.4) and Claude Opus 4.7 (94.3). On most common coding tasks, model quality has ceased to be the limiting factor. By the next session, however, all that know-how evaporates.

Context windows, for their part, have exploded — Gemini 3 Pro Deep Think is the most visible proof of this. But a window is not a memory: it lives for the duration of a session and dies with it. You can cram your entire repository into it; the next session, nothing remains.

The result: every new session starts from scratch. You re-explain the architecture, the conventions, the decisions made the day before — and why that approach was rejected. Multiply this re-onboarding cost by the number of sessions in a real project, and amnesia becomes the most expensive invisible cost of AI-assisted development.

Then there's the money. Piling history into the window costs tokens on every request; a compressed memory only reinjects a short index. Well-designed persistence isn't just smarter: it's cheaper.

This is exactly the kind of problem that calls for infrastructure, not a feature. The historical parallel is databases for the web: first an optional building block, then a layer so obvious that we no longer even mention it. Agent memory follows the same curve.

The market figured this out before the platforms did. The proof: deepseek-harness, a simple super-agent prototype, captured 16,000 stars in 6 days. The building blocks around agents — memory, harness, orchestration — now command the attention that models were still fighting over until recently.

And autonomous agents — OpenClaw, AutoGPT and the like — need it even more than a coding assistant. An agent that chains tasks across several days without memory isn't autonomous: it's repetitive.

Compatibility: a de facto standard for fifteen agents and more

The stroke of genius behind claude-mem isn't technical, it's strategic: the project doesn't belong to any vendor.

The repo officially lists Claude Code, Codex, Cursor and OpenCode, plus 11 other agents. In practice, the community has plugged it in far beyond that: OpenClaw, Hermes, the Gemini agents. Whatever your stack — the best LLM for coding on one side, a local open source agent on the other — the memory remains the same.

The most interesting detail in the compatibility matrix: Copilot CLI, Goose, Roo Code and Warp can search the memory without recording their own sessions.

Read-only vs read-write

This asymmetry is more powerful than it looks. Concretely: your main agent — say Claude Code — records everything it does. Your secondary agent, a Copilot CLI for quick tasks, consults that memory without feeding it.

A team therefore doesn't need all of its agents to write to the memory to benefit from it. All it takes is one main stream feeding it. One producer, several consumers: that's exactly the architecture that turns a tool into a standard.

A concrete scenario. The senior spends the day in Claude Code on a tricky migration: decisions, constraints, failed attempts, everything gets captured. The next day, one dev picks the project back up in Codex, another opens Cursor: each starts with the same context index. No handover meeting. No document to maintain.

This is also what sets claude-mem apart from the platforms' native memories. Whether you're team Claude or team GPT (our detailed comparison), the memory remains cross-platform. Open source agents like OpenClaw or Hermes access it like any other. Neutrality, here, isn't a marketing positioning: it's the feature.

Competition: worktrunk, billion-context, and the Anthropic factor

claude-mem has the lead, but not the monopoly: the niche filled up as quickly as it opened.

Two challengers regularly appear in discussions: worktrunk and billion-context, which attack the same problem—keeping context alive between sessions—from different angles. Neither currently shows the trajectory of claude-mem, but their mere existence is a signal: the need is real, generalized, and it won't wait for platforms to deign to address it.

The real threat comes from elsewhere. Anthropic has started integrating persistence into its own products: Claude Tag gives Claude persistent memory directly in Slack. When a platform vendor delivers memory natively, the question becomes legitimate: why connect an external layer?

claude-mem's answer is one word: neutrality. An Anthropic native memory will not serve your Codex agent. A claude-mem memory serves the fifteen official agents—and all those the community will connect tomorrow. For a single-tool dev, the native solution may suffice. For a team juggling between Claude Code, Codex, and a local agent, the neutral layer remains the only coherent option.

The story of devtools is repeating itself here in an almost textbook way: the platform always ends up absorbing the layer that works. The only sustainable defense for an independent project is to be useful wherever the platform is not—and a siloed memory will never be that.

Finally, the agent brick ecosystem doesn't stop at memory: morlutorea, for example, teaches your code agent to reverse-engineer code [/article/morlutorea-le-repo-github-qui-apprend-a-votre-agent-de-code-a-retro-ingenierer-n]. Brick by brick, we are witnessing the birth of a true software stack dedicated to agents. Memory is simply the most requested layer.

Getting started with claude-mem: installation and best practices

Installation takes a single command; the real work begins after.

npx claude-mem@latest install

Check the exact command in the repo README: it evolves with versions, and the list of compatible agents keeps growing.

Once installed, don't judge it on the first session. The system needs three to five sessions to build a useful index: on the first, it has nothing to remember yet; by the third, it starts feeding your decisions back in; by the fifth, the effect becomes clear. It's an investment, not a switch.

Two best practices stand out.

Review the index after the first few sessions. You'll want to check that what's being retained matches what really matters — architecture, conventions, structural decisions — and not the noise of ordinary sessions.

Settle the privacy question before the first save. Your sessions are compressed and stored; depending on the configuration and the compression model, they may pass through a cloud service. With professional code, this decision is made before installation, not after the incident. A fast model like Claude Sonnet 4.6 does this job very well on the cloud side; fully local teams will turn to self-hosted options like GLM-5 or Kimi K2.6.

If you run agents locally (our Ollama guide), claude-mem fits into a 100% local stack — provided you check where the compression happens. And for an agent that needs to stay active continuously with its memory, a small Hostinger VPS is enough, for the price of a few coffees a month.

Limits and blind spots

claude-mem solves amnesia; it does not solve confidentiality, nor trust.

First blind spot: confidentiality. A persistent memory is, by definition, a log of everything your agent has done — code, decisions, sometimes secrets handled in session. Where this log is stored and which model compresses it must be verified in the configuration. In an enterprise, this is non-negotiable.

Second blind spot: memory can be poisoned. An agent that remembers is an agent whose memories can be corrupted — through an injection in a session, a compromised dependency, malicious access. Persistence widens your agents' attack surface, and red teaming, reduced from several weeks to a few hours, becomes a reflex to build in as soon as an agent has a past.

Third blind spot: drift. Projects change; memories less so. A decision recorded in week 1 may be obsolete by week 6, but the agent will reinject it with the same confidence. Without periodic review, your memory gradually becomes a database of bad advice.

Finally, the read/write asymmetry: if your main agent is read-only — Warp, Goose, Roo Code — you depend on another agent to feed the memory. This is not a bug, it's an architectural choice that must be consciously owned.

❌ Common Mistakes

Mistake 1: believing a large context window replaces memory

What goes wrong: with models like Gemini 3 Pro Deep Think or GPT-5.5, many devs think you can cram everything into the context and be done with the problem. Except the window lives for the duration of a session and dies with it.

The solution: treat the two layers as complementary. The window for the current session, memory for everything that came before it. claude-mem is actually designed to avoid bloating the window — short index at startup, details loaded on demand.

Mistake 2: installing claude-mem and never pruning the memory

What goes wrong: capture is passive, so the memory accumulates everything — including dead ends, abandoned refactors, and conventions that have since been replaced. Six weeks later, the agent is re-injecting outdated decisions with disarming confidence.

The solution: review the index every two or three weeks on an active project. Two minutes of cleanup that save hours of mental debugging — and agents defending obsolete positions.

Mistake 3: assuming all your agents access it the same way

What goes wrong: believing that "compatible" means "identical." Copilot CLI, Goose, Roo Code and Warp are read-only: they consult the memory but don't enrich it. Deploying claude-mem thinking every agent feeds the database leaves you with a half-empty memory.

The solution: designate a producer agent — typically Claude Code or Codex — and treat the others as consumers. Check the compatibility matrix on the repo before any team-wide deployment.

❓ Frequently Asked Questions

Is claude-mem really free?

Yes, the project is open source and free. The indirect cost comes from the model used for compression and from any subscription to the host agent (Claude Code, Codex...). On a local stack with a self-hosted model, the overhead can be virtually zero.

Does my code data leave my machine?

It depends on your configuration and the model used for compression. Some setups go through the cloud, others stay local. Check this point in the repo before installing it on professional code, and favor a local stack if in doubt.

Does it only work with Claude Code?

No. The repo lists Claude Code, Codex, Cursor, OpenCode and 11 other agents, and the community has hooked it up to OpenClaw, Hermes or the Gemini agents. Copilot CLI, Goose, Roo Code and Warp work in read-only mode: they can search the memory without saving their sessions.

What's the difference with ChatGPT's or Claude's native memory?

Native memories are siloed to their vendor: ChatGPT's doesn't serve your terminal agent, Anthropic's doesn't serve Codex. claude-mem is a cross-cutting layer shared across fifteen-plus agents, regardless of the vendor — which is precisely what makes it a potential standard.

From how many sessions does it pay off?

As soon as you run three or more sessions in a row on the same project. On a long project, the gain is immediate: no need to re-explain the architecture and conventions at every session. On a ten-minute one-shot task, the benefit is marginal — and that's fine.

✅ Conclusion

Going from 45,000 to 114,700 stars in just a few weeks, claude-mem did more than establish a tool: it established a category — persistent memory as a neutral, multi-vendor infrastructure for coding agents. What happens next will depend on the platforms: the more siloed native memories they ship, the more indispensable the neutral layer will become. Start with the official repo, and to choose the agent that will feed your memory, our selection of the best autonomous AI agents is up to date.