Agentmemory
Open-source memory runtime that gives coding agents persistent recall between sessions, stored on your machine.
If your agent forgets your codebase every session, Agentmemory is the most complete self-hosted fix we've reviewed — auto-capture hooks, local hybrid recall, and a reproducible 95.2% recall@5 on LongMemEval-S (the vendor's own number on their own benchmark, so read it with normal skepticism). The tradeoff is honest: you run a local runtime and keep it updated. Teams that need a hosted control plane, RBAC or SSO should look at managed memory services instead.
Verified 5d ago · liveness 76/100 · cite: rightaichoice.com/tools/agentmemory
- Developers running Claude Code, Cursor or Codex who lose project context between sessions
- Teams on large codebases where re-explaining architecture and commands wastes hours each week
- Self-hosters who want persistent agent memory with no external database or cloud account
- Builders wiring custom MCP clients who want memory behind a local REST surface
- Teams that need a fully managed cloud service rather than a self-hosted runtime they operate
- Organizations requiring multi-user permissions, RBAC or SSO out of the box
- Developers who would rather call a hosted memory API than run and update a local process
We scan live Reddit threads, YouTube comments, X posts, G2 reviews and other communities — and hand you an honest verdict in under a minute.
- Honest verdict, not marketing
- Real pros & cons from real users
- Attributed quotes with receipts
3 free scans · no card needed
Skip agentmemory if you need memory as a hosted API with per-user permissions, rather than a Node process running on your own machine with state on disk.
Compression, summarization, consolidation and graph extraction only activate once you set a provider key — you pay your LLM provider's token rates for those sweeps, on top of the free runtime.
The runtime itself costs nothing: it's Apache-2.0 and self-hosted. Your real spend is your LLM provider key, which is only required for compression, consolidation and graph extraction — capture and recall work keyless. Against managed memory services such as mem0 or Letta, that shifts cost from a subscription to tokens plus your own infra time. Budget-conscious solo developers win; teams without someone to babysit a Node process may not.
In short
Agentmemory — Open-source memory runtime that gives coding agents persistent recall between sessions, stored on your machine. Best for Developers running Claude Code, Cursor or Codex who lose project context between sessions, Teams on large codebases where re-explaining architecture and commands wastes hours each week, Self-hosters who want persistent agent memory with no external database or cloud account. Free to use.
What's new in Agentmemory
Checked 5 days agoAcross the latest 1 update: 1 changelog entry.
What people actually say about Agentmemory — is it worth it?
We ran a structured research pass across product reviews, community discussions, and post-purchase forum threads to surface the patterns vendors won't publish themselves. Below: the recurring strengths, the hidden costs people mention most, and the cohort that consistently regrets adopting this tool.
60 mentions across 6 sources (Hacker News, YouTube, Product Hunt, Bluesky, GitHub, Lemmy) · researched Jul 6, 2026.
Average across the 6 sources that answered — each source counts once, not each post.
- +Free and open-source (MIT) with no external databases required.
- +Excellent benchmark: 95.2% recall on LongMemEval-S.
- +Triple-stream retrieval (BM25, vector, knowledge graph) is unique and effective.
- +Works with 10+ coding agents via MCP and REST.
- +Reduces token usage by ~92%, saving cost and context window.
- −Crashes under large datasets (370K+ observations reported).
- −Some early adopters retracted after production use.
- −Tier 1 cap may limit truly infinite memory scenarios.
- −Manual pruning needed for contradictory or stale memories.
- −No clear business model raises questions about future support.
- • No paid tier or cloud version currently; self-hosting costs (server, storage) are on you.
Viability Score
How well maintained and how widely used is Agentmemory? Built from what the vendor actually publishes (docs, changelog, tutorials, integrations, pricing), whether the site is live, and how much real users discuss it. How we calculate this
Last calculated: October 2026
How we score →Key Features
- Auto-capture hooks fire on prompts and tool calls into a local server on 127.0.0.1:3111
- Restart-safe capture: events spool to disk if the server is down (v0.9.30)
- Dual indexing: BM25 terms for exact words plus local vectors for meaning
- Local embeddings that work with no API key
- Session-end consolidation collapses related observations into one linked memory
- Hybrid recall in 14 ms median over BM25, local vectors and the knowledge graph
- 95.2% recall@5 on LongMemEval-S (vendor-run benchmark)
- About 92% fewer input tokens than pasting full history into context
- PreCompact hook re-injects memory when the agent compacts its context window
- REST API now requires auth by default (v0.9.30)
- Import existing Claude Code JSONL transcripts to backfill memory
- Shared local memory server across Claude Code, Cursor, Codex and other agents
- Obsidian export as frontmatter-tagged markdown
- Mesh federation between machines over authenticated links
- Vectors survive force-kill (v0.9.30 durability release)
About Agentmemory
Agentmemory is an Apache-2.0 memory runtime for AI coding agents — the layer that stops your project context from vanishing when the terminal closes. It is aimed at developers running Claude Code, Cursor, Codex, OpenClaw, OpenCode and other MCP-compatible agents who are tired of retelling their codebase every morning. The pipeline runs on hooks: prompts and tool calls post to a local server on 127.0.0.1:3111, each event becomes an observation, and observations get indexed twice — BM25 terms for exact words and local vectors for meaning, with no API key needed. When a session ends, related observations collapse into one memory that keeps links back to its source events; the next session opens with that memory already in context. A PreCompact hook re-injects memory when your agent compacts its window, so recall survives compaction. The published numbers are concrete: 95.2% recall@5 on LongMemEval-S, a 14 ms median hybrid recall over BM25, local vectors and the graph, and 92% fewer input tokens than pasting your whole history (a month of cross-agent work is cited at 19,462 tokens against 1,571 tokens injected). Import your existing Claude Code transcripts with import-jsonl and day one is not empty. v0.9.30 is a durability and safety release: capture survives restarts and outages, vectors survive force-kill, and the REST API requires auth by default. Everything binds to 127.0.0.1. Choose this over managed memory if self-hosting and local-only storage are requirements; choose a hosted memory API if you would rather not run and update the runtime yourself.
Behind the Verdict
Where Agentmemory earns its place is the local-first bet. Nothing leaves your machine by default: it binds to 127.0.0.1 with auth on by default, and v0.9.30 made that baseline stricter while making capture survive restarts and outages. If your team cannot send source-adjacent context to a third party, that combination is the reason to pick this over anything managed. In practice the loop is fast. A median 14 ms recall over local BM25, vectors and the graph means the agent gets context without a network round trip. The token math matters more than the latency: the site cites a month of cross-agent work at 19,462 tokens versus 1,571 tokens injected, roughly 92% fewer input tokens than replaying history. On a long-running project that is real budget. Pick this when you already juggle several agents on one repo. Claude Code, Cursor, Codex and the rest share one local memory server, so a fix found Tuesday in Cursor is available Wednesday in Codex. Backfilling with import-jsonl is the sleeper feature — replaying a past month of transcripts makes the first day feel like month three. We'd pass if you want a managed dashboard with seats and permissions. There is no hosted control plane here, and running a local process is a genuine operational cost: someone owns updates, the port, and the store on disk. If your team would rather pay for a service than operate one, a managed memory API is the easier answer. The closest alternative is a hosted memory API — more turnkey, less control, your data off-site. Compared with heavier self-hosted stacks that ask you to stand up a vector store or graph database first, Agentmemory's pitch is that there is nothing else to run. That is the whole comparison in one line. Two caveats before you commit. The headline benchmark is vendor-run on
Researching Agentmemory? Get your full AI stack in 60 seconds.
Free, no signup — tell us your goal and get tools matched to your budget & existing stack.
Real-world workflow fit
Concrete scenarios for the personas Agentmemory actually fits — and what changes day-one when you adopt it.
Installs the plugin, lets the 12 auto-capture hooks record prompts, tool calls and stops across a week of sessions, then adds an Anthropic key so consolidation compresses raw observations into semantic memories on session stop.
Outcome: The next session opens with decisions and patterns from previous days already available via memory_recall, instead of a fresh re-explanation of the codebase.
Each developer runs their own agentmemory node, registers the others as peers, and pushes and pulls memories over authenticated HTTPS with a bearer token.
Outcome: A decision made on one machine is recallable on a teammate's agent in their next session, while the local JSON state stays per-developer.
Points agentmemory at the existing JSONL transcripts to rehydrate sessions, indexes them for search, and lets crystal and lesson extraction derive rules from what it finds.
Outcome: Months of prior work become searchable memory, and lessons resurface later by relevance with confidence and recency reranking.
Use Cases
- Install agentmemory via npm and connect Claude Code so your agent remembers project decisions across sessions.
- Use hybrid triple-stream recall to retrieve past code decisions, commands and architecture notes from earlier agent sessions.
- Capture every tool call and prompt as observations automatically, then consolidate them into semantic memories on session stop.
- Export compressed memories as Obsidian-compatible markdown for human review and knowledge management.
- Register a peer node and federate memories across team members over authenticated HTTPS.
- Import a Claude Code JSONL transcript to rehydrate a full session including observations, tool uses and timeline.
- Backfill a month of Cursor agent transcripts so past decisions resurface in new sessions.
- Open the port 3113 viewer to replay any past session, browse memories by confidence, or inspect the knowledge graph.
Models Under the Hood
as of 2026-10-17
Limitations
- Recall and capture run without any LLM provider key, but the features that make the memory useful long-term — compression, summarization, consolidation and knowledge-graph extraction — need a provider key.
- Memory lives on a single disk-backed runtime, so there's no redundancy if the node or volume goes away.
- There is no built-in multi-user permissioning, RBAC or SSO, so memory is scoped per agent, not per human role.
- Mesh federation requires a bearer token and a reachable HTTPS endpoint on each node, which means a reverse proxy or tunnel if you want cross-network sync.
- The viewer and engine console occupy ports 3113 and 3114 by default.
as of 2026-10-02
Verification history
We have re-verified Agentmemory 10 times since . Each pass re-reads the vendor's own pages and re-checks every listed field against that evidence; passes where nothing had changed are marked as such.
- — re-verified summary, description, our verdict, our analysis, pricing model, pricing tiers, features, integrations, who it suits, who should skip it
- — re-verified summary, description, our verdict, our analysis, pricing model, pricing tiers, features, integrations, who it suits, who should skip it
- — re-verified summary, description, our verdict, our analysis, pricing model, pricing tiers, features, integrations, who it suits, who should skip it
- — re-verified summary, description, our verdict, our analysis, pricing model, pricing tiers, features, integrations, who it suits, who should skip it
- — re-verified summary, description, our verdict, our analysis, pricing model, pricing tiers, features, integrations, who it suits, who should skip it
- — re-verified summary, description, our verdict, our analysis, pricing model, pricing tiers, features, integrations, who it suits, who should skip it
Showing the 6 most recent of 10 verification passes.
Free to cite with attribution — this page re-verifies continuously.
12-month cost
Project the real annual outlay, including the implied monthly cost when only an annual tier is published.
Vendor list price only. Add-on usage, seat overages, and contract minimums are surfaced under Hidden costs & gotchas.
Plans compared
For each published Agentmemory tier: who it actually fits, and what it adds vs. the previous tier. Cross-reference the cost calculator above for projected annual outlay.
Open Source (Community)
$0/mo
Ideal for
Solo developers and small self-hosting teams running Claude Code, Cursor or another MCP agent who are willing to run a Node process
What this tier adds
Starting tier — the whole runtime under Apache-2.0, with your own LLM provider key needed for compression and graph extraction
Where the pricing makes sense
The company stage and team size where Agentmemory's pricing actually pencils out — and where peers do it cheaper.
The runtime itself costs nothing: it's Apache-2.0 and self-hosted. Your real spend is your LLM provider key, which is only required for compression, consolidation and graph extraction — capture and recall work keyless. Against managed memory services such as mem0 or Letta, that shifts cost from a subscription to tokens plus your own infra time. Budget-conscious solo developers win; teams without someone to babysit a Node process may not.
Setup time & first value
How long it actually takes to get something useful out of Agentmemory — broken out by persona, not the marketing-page minute.
Solo developer with an MCP-compatible agent: one npx command and the plugin install puts you at first capture in a couple of minutes, no provider key needed. Team lead wiring peer federation: allow an hour for HTTPS endpoint, bearer token and reverse-proxy setup. Keyless start is the norm — add a provider key later when you want consolidation and graph extraction.
Switching to or from Agentmemory
How to bring data in from common predecessors and how to get it back out — written for the switcher, not the buyer.
- →From a manual notes file or CLAUDE.md: import past Claude Code JSONL transcripts so past sessions become indexed, searchable memory.
- →From mem0 or Letta: port stored facts into agentmemory via the REST surface under /agentmemory/* and stop running the external vector store.
- →From a vector-store-only setup like Qdrant or pgvector: drop the separate service and let the single Node runtime hold state on disk as JSON.
- ↗To Obsidian: export memories as frontmatter-tagged markdown into a sandboxed vault for human review.
- ↗To a managed memory API like mem0 or Letta: read memories back out through the 138 REST endpoints and write them into the hosted service.
Integrations
Resources & Guides
Tutorials & Learning
YouTube returned 1 video for “Agentmemory”, and we withheld 1: 1 could not be judged, because “Agentmemory” is a single word that other videos use for other things. We are showing none, because we could not prove any of them is about Agentmemory.
Official links
Tools that pair well with Agentmemory
Common stack mates teams adopt alongside Agentmemory, with the specific reason each pairing earns its keep.
Powermem
Open-source, self-hosted memory layer that gives AI agents persistent recall via hybrid retrieval.
VCPToolBox
Open-source backend runtime that gives LLMs persistent memory, hot-swappable plugins and multi-agent coordination via the VCP protocol.
Chrome DevTools MCP
Open-source MCP server that gives coding agents live Chrome DevTools for debugging, traces, and browser automation.
Featured Head-to-Head Comparisons
Agentmemory vs Spider Cloud
Choose Agentmemory if you need persistent memory for coding agents across sessions, especially with Claude Code or MCP tools. Choose Spider Cloud if your AI agents or RAG pipelines require real-time web data at low cost. Both are free-tier accessible but solve opposite problems: memory vs. retrieval.
Agentmemory vs Temporal Ai
Agentmemory is the go-to for developers who need persistent memory across coding agent sessions with zero external dependencies and high recall. Temporal AI is better for teams building durable, long-running workflows that require automatic retries, human-in-the-loop, and fault tolerance. Choose based on whether your bottleneck is agent context loss (Agentmemory) or process reliability (Temporal).
Agentmemory vs Voyage Ai
Agentmemory is the no-brainer choice for developers needing persistent agent memory — it's free, self-hosted, and integrates directly with coding agents like Claude Code. Voyage AI wins if you need high-accuracy embeddings for domain-specific RAG (finance, legal), but its enterprise pricing and lack of transparency make it unsuitable for smaller teams. Choose by need: agent memory vs. search retrieval.
Alternatives to Agentmemory
View all
Powermem
Open-source, self-hosted memory layer that gives AI agents persistent recall via hybrid retrieval.
VCPToolBox
Open-source backend runtime that gives LLMs persistent memory, hot-swappable plugins and multi-agent coordination via the VCP protocol.
Chrome DevTools MCP
Open-source MCP server that gives coding agents live Chrome DevTools for debugging, traces, and browser automation.
Frequently Asked Questions
Used Agentmemory? Help shape our editorial sentiment research.