agentmemory: Persistent Memory for Claude Code and AI Agents

6,865 stars in one week

rohitg00/agentmemory jumped to the top of GitHub's weekly trending chart this week with nearly 7,000 new stars, landing at over 10,000 total. That kind of velocity usually signals one of two things: a viral demo or a tool that scratches a genuine itch. In this case it is the latter. The repo solves the persistent pain of stateless AI coding agents - every session starts blank, every project preference has to be re-explained, every architectural decision gets rediscovered from scratch. agentmemory wires a structured memory layer under your existing agent setup without requiring a new database server, a cloud account, or changes to your workflow.

What it does

agentmemory is a local MCP server that captures, compresses, and retrieves context across agent sessions. It runs as a background process and connects to your agent through the MCP protocol or via REST. Once connected, it hooks into 12 lifecycle events - SessionStart, SessionEnd, UserPromptSubmit, PreToolUse, PostToolUse, PostToolUseFailure, PreCompact, SubagentStart, SubagentStop, and Stop - and records observations automatically. You do not write memory manually. The agent's own tool calls become the input.

Internally, memory moves through four tiers: working memory holds raw observations from the current session, episodic compresses those into session summaries, semantic extracts durable facts and patterns, and procedural captures workflows and decision patterns. The system applies Ebbinghaus decay - frequently accessed memories strengthen, stale entries evict automatically. This means the memory store stays relevant rather than accumulating noise over months.

Retrieval uses a triple-stream approach - BM25 keyword matching, vector cosine similarity over local embeddings, and knowledge-graph traversal - fused with Reciprocal Rank Fusion. On the LongMemEval-S benchmark, the project reports 95.2% R@5 retrieval accuracy and a Mean Reciprocal Rank of 88.2%. That compares favorably to mem0 (53k stars), which the README benchmarks at 68.5% R@5.

The MCP surface exposes 51 tools split across a core set (recall, save, smart-search, sessions, timeline, profile, export, compress-file) and an extended set that adds pattern detection, knowledge-graph queries, team sharing, audit logging, and governance controls.

Storage is SQLite with an in-memory vector index. The embedding model ships locally (all-MiniLM-L6-v2 via @xenova/transformers). No Postgres, no Redis, no external vector database.

Install and try it

Getting started takes under two minutes:

npx @agentmemory/agentmemory

The first run from v0.9.16 onward prompts for global install automatically. If you prefer explicit control:

npm install -g @agentmemory/agentmemory
agentmemory

The server starts on port 3111. A real-time viewer launches on port 3113 and shows a live observation stream, session explorer, memory browser, and knowledge graph visualization - no extra setup.

To wire Claude Code specifically:

agentmemory connect claude-code

That command writes the MCP configuration and installs the 12 hooks into Claude Code's settings. From that point forward, every session is recorded and every new session starts with relevant context injected automatically (controlled by the AGENTMEMORY_INJECT_CONTEXT flag, off by default).

For self-hosted deployment, one-click templates exist for Fly.io, Railway, Render, and Coolify. The Coolify template provisions persistent /data storage, which aligns well with teams already running Coolify for their CI stack.

Who should use it

The clearest use case is solo developers who work across multiple projects with the same AI agent and are tired of the context reset penalty. If you spend the first five to ten minutes of every session re-orienting Claude Code about your stack, conventions, and recent decisions, agentmemory is addressing exactly that problem.

Teams using multiple specialized agents - one for code review, one for test generation, one for documentation - benefit from the multi-agent coordination layer. A single agentmemory server can handle 15+ simultaneous agents, and the team-share tools in the extended MCP set allow shared memory across agent roles.

Developers experimenting with long-running agent workflows, where a subagent fires off to do research and reports back, will appreciate the SubagentStart and SubagentStop hooks. Those hooks let the system track what subagents learned so the parent session can recover that context without re-running the whole chain.

The tool also makes sense for anyone running agentic pipelines on CI - the persistent memory means a nightly agent that reviews PRs builds up project-specific knowledge over time rather than starting from the same generic baseline every run.

One group that might not benefit immediately: developers who already maintain a detailed CLAUDE.md and rarely switch projects. The overhead of running a background server and managing memory tiers adds friction that manual context files avoid - though the project's own benchmark puts agentmemory at 92% fewer tokens than the manual approach at scale.

Relation to the DevDigest ecosystem

agentmemory lands at the intersection of three areas the DevDigest site covers directly.

The hook system - all 12 lifecycle hooks agentmemory uses - are the same hooks covered at hooks.developersdigest.tech. Claude Code's hook architecture lets external tools intercept every tool call and session event, and agentmemory is one of the most complete examples of that capability being put to production use. The hooks post on that site walks through setting up your own hooks if you want to understand what agentmemory is doing under the covers before committing to it.

The MCP surface is equally relevant. agentmemory registers 51 tools through the MCP protocol, the same protocol indexed at mcp.developersdigest.tech. If you are building a custom agent setup and selecting MCP servers to include, agentmemory is one of the more complete examples of a server that adds stateful capability rather than just wrapping an external API.

Finally, the built-in skills (/recall, /remember, /session-history, /forget) follow the same pattern as the Claude Code skills indexed at skills.developersdigest.tech - reusable agent commands that users invoke by name rather than writing prompt instructions each time.

Honest assessment

The retrieval benchmark numbers are strong, but they come from the project's own README and should be treated as directional rather than definitive. LongMemEval-S is a real benchmark, and the comparison to mem0's reported 68.5% R@5 is plausible, but independent third-party reproduction has not been widely published at the time of writing.

The dependency on the iii-engine binary is a real friction point on Windows, where users must download a prebuilt binary separately or fall back to Docker. Linux and macOS installs are smooth. The local embedding model requires @xenova/transformers as an optional peer dependency for full offline support - skipping it means falling back to a cloud embedding provider.

The feature flag system is deep, with several capabilities disabled by default (AGENTMEMORY_AUTO_COMPRESS, AGENTMEMORY_REFLECT, AGENTMEMORY_INJECT_CONTEXT). This is deliberate - the project explains that auto-inject can interact badly with certain recursive agent patterns - but it means the out-of-box experience is more passive than the star count implies. You get capture without retrieval injection unless you opt in.

For a week-old trending tool at v0.9.x, the architecture is serious and the documentation is thorough. Worth a try against a real project before committing.

References

• agentmemory GitHub repository
• LongMemEval benchmark paper
• agentmemory npm package
• Claude Code hooks documentation
• MCP server directory
• Claude Code skills directory
• iii-engine releases