agentmemory: persistent memory for coding agents

Everything worth knowing about rohitg00/agentmemory: a local, dependency-free memory runtime that automatically captures what coding agents do, compresses it, and hands it back when the next session starts.

What agentmemory is

agentmemory is a persistent memory runtime for coding agents. It’s not a library or a vector store — it’s a single process, built on the iii engine (iii-hq/iii), that combines automatic capture, hybrid retrieval, consolidation, and sync, with no external databases, queues, or vector stores.

Its purpose, as the README states it, is to solve the problem laid out in its opening lines: “Every session you explain the same architecture. You rediscover the same bugs. You re-teach the same preferences. Built-in memory (CLAUDE.md, .cursorrules) hits a 200-line ceiling and goes stale.” agentmemory silently captures what the agent does, compresses it into searchable observations, and injects the relevant context when the next session starts — with a single command, across different agents.

As of August 29, 2026, the project documents an MCP server with 54 tools and 130 REST endpoints, 12 automatic capture hooks, 17 skills (9 invokable, 8 reference), a real-time viewer on port 3113, and compatibility with 20+ coding agents. It’s written in TypeScript and licensed under Apache-2.0.

Origin

The repository was created on February 25, 2026 (first commit on February 27) by Rohit Ghumare (rohitg00), an engineer and DevRel based in the UK, identified on his GitHub profile as “Engineer | DevRel | GDE | CNCF Ambassador | Docker Captain | AWS CommunityBuilder,” with prior experience at Solo.io, Cerbos, Oracle, and Reliance Jio. The project’s MAINTAINERS.md lists him as the sole active maintainer since January 2026.

The origin story available in the sources consulted doesn’t include a launch post with anecdotes, unlike other projects on this list; context here is reconstructed from the project’s own documents:

The mission stated in GOVERNANCE.md: “deliver a persistent, local-first memory runtime for coding agents” that requires no external databases, works with any MCP-compatible client, stays compatible with the open Model Context Protocol, and keeps data on the user’s machine by default.
Rohit Ghumare’s “LLM Wiki v2” gist (gist 2067ab416f7bbe447c1977edaaa681e2) extends Andrej Karpathy’s original LLM Wiki idea with “lessons from building agentmemory” — it describes the memory lifecycle (confidence scoring, supersession, Ebbinghaus-curve forgetting, consolidation layers) and hybrid BM25 + vector + graph search. The gist claims agentmemory has “20K+ stars”; that’s an author-stated figure, not a measurement from this research.
The first tagged GitHub release is v0.9.0 (April 18, 2026), “visibility and correctness”: landing site, filesystem connector, a standalone MCP that actually talks to the running server, and a closed audit. The release cadence since has been high: v0.9.29 (August 16, 2026) is the latest of 30 releases published on GitHub.

Philosophy and principles

Principles verifiable in the project’s own documentation:

Local-first by default: every piece of user data stays on the user’s machine; no SaaS, no billing, no commercial licensing (ROADMAP.md explicitly declares “out of scope”: hosted SaaS, subscriptions, commercial licenses).
Zero external dependencies: one database, one queue, one vector store — none of them. Everything lives in a single process on top of the iii engine.
MCP as an interface, not a privilege: any MCP-compatible client can use it, and everything exposed over MCP has a REST twin (the contribution guide requires adding both at the same time).
Immutable provenance: every observation and memory carries a source channel sealed at the moment it’s captured, saved, or imported (user, agent, tool, import, or shared).
Reproducible evidence: the 95.2% R@5 on LongMemEval-S they publish is the project’s own measurement, with published methodology (benchmark/COMPARISON.md, npm run bench:longmemeval) and an explicit disclaimer that competitor numbers are vendor-stated, on different benchmarks, not reproduced by them.
Formal governance from early on: modeled on the Linux Foundation’s Minimum Viable Governance, with documented processes for appointing maintainers, voting on decisions, and managing breaking changes, plus a stated plan to diversify maintainership (currently a single maintainer).

How it works

The site and README describe three layers:

Capture — 12 automatic hooks wired into agents. Every tool call, prompt, and stop becomes a compressed observation, sealed with its source channel and agent.

The automatic capture layer: 12 hooks that turn tool calls, prompts, and stops into compressed, sealed observations

Recall — hybrid retrieval: BM25, vector, and knowledge-graph signals are scored together and reranked on-device. With no embeddings provider configured, it runs in “keyless” mode on BM25 alone (86.2% R@5 on LongMemEval-S, per the project). Superseded memory versions are excluded from every retrieval path; the version chain preserves history.

Hybrid retrieval: BM25, vector, and knowledge-graph signals scored together and reranked on-device

Consolidation — with an LLM provider key configured, at session end: raw observations get compressed into semantic memories, duplicates get merged, stale rows decay by a retention score, and an audit row records the operation.

End-of-session consolidation: compression into semantic memories, duplicate merging, Ebbinghaus-curve decay, and an audit trail

Architecture details verified in the documentation:

Four local ports: 3111 (REST/MCP HTTP), 3112 (iii streams), 3113 (real-time viewer), 49134 (iii worker WebSocket). With --instance 1 the quartet shifts to 3211/3212/3213/49234.

Local-first architecture with no external dependencies: a single process, four local ports, no external database, queue, or vector store

Persistent state per platform: ~/Library/Application Support/agentmemory (macOS), $XDG_DATA_HOME/agentmemory or ~/.local/share/agentmemory (Linux), %APPDATA%\agentmemory (Windows).
MCP surface: 54 tools by default (AGENTMEMORY_TOOLS=all); AGENTMEMORY_TOOLS=core trims it to 8 essentials; the registry’s base set has 14.

Dual MCP + REST surface: 54 MCP tools and 130 REST endpoints, every MCP capability paired with a REST twin

17 skills in <dir>/SKILL.md format: 9 invokable (/recall, /remember, /session-history, /forget, /recap, /handoff, /lesson, /commit-context, /commit-history) and 8 reference skills the agent loads on demand (memory discipline, MCP tools, REST API, configuration, agents, hooks, architecture, skill authoring). The README notes the reference skills’ data tables are generated from code so they can’t drift out of sync.
Privacy: filters secrets (API keys, tokens) before saving.
Multi-agent: leases, signals, and peer-to-peer (mesh) sync between nodes; agentId on save/recall to scope memory per agent.

Multi-agent ecosystem: leases, signals, and mesh sync between agents, with 17 invokable and reference skills

Built-in Obsidian export and JSONL session import (for example, Claude Code’s history under ~/.claude/projects/).
Four “UIs”: the :3113 viewer, the iii console :3114, a KV state browser, and OTEL traces.

Quick-start guide

Installation and first boot

Requirements: Node >= 20. On macOS/Linux the runtime auto-downloads the iii engine pinned to v0.11.2 into ~/.agentmemory/bin (needs curl, sh, and tar); on native Windows the engine is installed manually (v0.11.2 ZIP) or via WSL2/Docker Desktop.

# Zero-install path (the README's recommendation):
npx -y @agentmemory/agentmemory@latest

The first boot is an interactive setup: pick which agents to connect (Claude Code, Cursor, Codex, Gemini CLI, OpenCode, …) and an LLM provider — or go keyless. It seeds configuration, starts the memory server and its pinned iii engine, and offers to install the binary globally so agentmemory works anywhere. Equivalent alternative: npm install -g @agentmemory/agentmemory then agentmemory. Once running, the server sits at http://localhost:3111 and the viewer at http://localhost:3113 (no extra install or config). agentmemory demo seeds 3 sessions and demonstrates hybrid retrieval with real data. Via Docker: the iiidev/iii:0.11.2 image with AGENTMEMORY_USE_DOCKER=1, and the README has a “Deploy to fly.io” button.

Common workflows

Start and verify: run agentmemory (or the npx path), open http://localhost:3113, and watch the live observation stream; each tab refreshes as hooks fire, and any past session replays in the viewer.
Connect an agent with one command: for example, agentmemory connect copilot-cli merges mcpServers.agentmemory into ~/.copilot/mcp-config.json (or $COPILOT_HOME/mcp-config.json) while preserving existing servers; agentmemory connect warp and agentmemory connect antigravity do the same for their respective files; agentmemory connect dsh --with-hooks adds both the MCP connector and hooks for DeepSeek Harness. The contribution guide documents connect adapters for 18 agents.

Connect any MCP client by hand: merge this block into the target agent’s existing mcpServers object (don’t replace the file):

{
  "mcpServers": {
    "agentmemory": {
      "command": "npx",
      "args": ["-y", "@agentmemory/mcp"],
      "env": { "AGENTMEMORY_URL": "http://localhost:3111" }
    }
  }
}

Backfill an old history: with Claude Code, use the JSONL import flow (import-jsonl) to index transcripts from ~/.claude/projects/; each entry gets indexed for search, sealed with an import source channel, and mined for its session “crystal” and lessons.
Remote or protected deployment: launch the agent with AGENTMEMORY_URL and AGENTMEMORY_SECRET set; the plugin and MCP shim inherit both values, and if AGENTMEMORY_URL is empty the shim falls back to http://localhost:3111.

Essential configuration

Setting	What it’s for
`AGENTMEMORY_DATA_DIR` / `--data-dir`	Where iii’s state lives; reuse the same value across restarts.
`AGENTMEMORY_URL`	Memory server address; the MCP shim falls back to `http://localhost:3111` if empty.
`AGENTMEMORY_SECRET`	Authentication for remote or protected deployments.
`AGENTMEMORY_AUTO_COMPRESS=true`	Enables LLM-written observation compression (also needs a provider key).
`AGENTMEMORY_TOOLS`	MCP surface exposed: `core` (8 tools), the base set (14), or `all` (54).
`--instance N`	Multiple instances, each with its own port quartet (e.g. `--instance 1` → 3211/3212/3213/49234).

Common pitfalls and fixes

The iii engine is pinned to v0.11.2: a plain install.sh | sh installs the engine’s latest version, which agentmemory doesn’t support (v0.11.6 introduces a new sandboxing model agentmemory hasn’t been refactored against yet). Always use npx -y @agentmemory/agentmemory@latest or the pinned Docker image. They also warn the engine is a precompiled binary, not a crate — don’t try cargo install.
Claude Code deletes old transcripts: cleanupPeriodDays in ~/.claude/settings.json (default 30) removes JSONL files older than that window. Install agentmemory on top of a months-old history and anything past 30 days is already gone; the documented fix is running import-jsonl on a cron, raising cleanupPeriodDays, or turning on automatic capture hooks so every turn lands live.
Sandboxed MCP clients (Flatpak, Snap, restrictive containers) can’t reach the host’s localhost: add "AGENTMEMORY_FORCE_PROXY": "1" to the env block and point AGENTMEMORY_URL at a reachable address (e.g. the LAN IP).
Native Windows: only agentmemory connect copilot-cli is automated; every other agent is configured by hand with the MCP block, and connect under WSL only works if the target agent is also installed inside that same WSL.
“The engine process started but the REST API never responded”: check the four derived ports are free, verify the pinned iii.exe is still alive, and relaunch with --verbose to inspect the engine’s captured stderr.
The MCP block merges, it doesn’t replace: if the file already has other servers, agentmemory should be added as another key inside mcpServers.

Integrations and migration

The main integration is the universal MCP block (above), which covers Claude Desktop, Cursor, Cline, Roo, Windsurf, Gemini, Warp, Droid, Kiro, Antigravity, Qwen, and similar clients; Devin (cloud) uses the same package over STDIO with AGENTMEMORY_URL and AGENTMEMORY_SECRET pointing at a network-reachable deployment. The 17 skills self-install via vercel-labs’ skills CLI into the native directories of 50+ agents. There are first-party plugins for Hermes (Python plugin + YAML config), OpenClaw (gateway plugin), Pi, and a filesystem connector (@agentmemory/fs-watcher). To migrate away from a CLAUDE.md/CLAUDE.local.md approach, the documented path is JSONL-importing the agent’s history; to migrate to Obsidian, built-in export exists. The repository’s deploy/ directory holds deployment profiles (Docker, fly.io) for team installs.

Official and semi-official status

agentmemory isn’t a formalized standard and isn’t verifiably backed by any foundation in this research. What the sources do document:

Trendshift: the README carries the official Trendshift badge (trendshift.io/repositories/25123); the site claims a #19 “NEW 2026” placement.
The site’s “As featured in” (agent-memory.dev): AlphaSignal (which the site presents as having 180K technical subscribers), “Agentic AI Foundation — Linux Foundation backed,” Trendshift, and Product Hunt. These are project-stated claims; the relationship to the Agentic AI Foundation and the Product Hunt upvote count were not independently verified here (the Product Hunt page blocked the query behind bot verification).
Cursor Marketplace: the README says the Cursor plugin listing is “in review” — not yet approved as of the date checked.
Claude Code: it installs as a first-class native plugin (hooks + MCP + skills), but no acceptance into an official Anthropic marketplace was found in the sources consulted.
Roadmap: the Q4 2026 plan mentions a security audit “LF-funded if foundational acceptance lands before quarter-end,” which confirms no foundational acceptance had materialized as of the date checked.

In practice, the combination of 20+ compatible agents, a standalone MCP package, and documented adoption (see community reception) gives it de facto reference weight in the coding-agent memory niche, without a formal designation.

The ecosystem

First-party packages and repositories

@agentmemory/agentmemory (npm): the full runtime + CLI. Downloads per the npm API on August 29, 2026: 7,671 in the last week and 33,042 in the last month.
@agentmemory/mcp (npm): standalone MCP server, “a thin shim that re-exposes @agentmemory/agentmemory’s MCP entrypoint”; 6,815 downloads in the last week. Proxies the 54 tools when AGENTMEMORY_URL points at a running server; with no reachable server it offers 7 local tools.
@agentmemory/fs-watcher (npm): the filesystem connector (integrations/filesystem-watcher/), versioned independently.
iii-hq/iii (the iii engine): the execution base agentmemory is built on, pinned to v0.11.2.
In-repo integrations: integrations/hermes/ (Python plugin for Hermes Agent), integrations/openclaw/ (gateway plugin), integrations/pi/, integrations/filesystem-watcher/, and plugin/ (the Claude Code plugin, hook manifests for Codex/Copilot/Droid, an OpenCode capture plugin, and the skills).
Rohit Ghumare’s “LLM Wiki v2” gist: a pattern document extending Andrej Karpathy’s original LLM Wiki with lessons pulled from building agentmemory; it’s the project’s conceptual reference.

akitaonrails/ai-memory — 5,131 stars (August 29, 2026). “A long-term memory solution for coding agent CLIs, and to facilitate handoff between different agent vendors.” It grew directly out of its author’s public criticism of agentmemory (see “How the community received it”) — it’s the most visible derivative project found.
taichuy/agentMemory — 24 stars, created April 2026: “项目级的开发记忆目录” (a project-level development memory directory). It’s the most visible Chinese-language project in the search; it was not verified to be a literal port of the repository.
diqierjia/StrataGate-AgentMemory — 17 stars: local-first, cross-session memory for DeepSeek Harness (DSH), with automatic capture.
jayzeng/agentmemory — 17 stars: a same-named repository, described as “persistent memory for coding agents (Claude Code, OpenAI…).”
AzureCosmosDB/AgentMemoryToolkit — 14 stars: Microsoft Azure Cosmos DB’s agent memory toolkit.
MukundaKatta/hermes-agentmemory — 10 stars: “a pull-model episodic memory plugin for Hermes Agent. Real deletes, audit trail, BYO Claude. MIT” (published May 15, 2026; it has its own Show HN, thread 48162360).
shawnfromportland/agentmemoryforcursor — 11 stars: Cursor-oriented persistent memory.
agentmemoryprotocol/agentmemoryprotocol — 6 stars: “Agent Memory Protocol (AMP) — an open standard for portable, structured memory.”
JordanMcCann/agentmemory — 46 stars: an independent implementation claiming 96.2% on LongMemEval (481/500) and beating every published system, including agentmemory (Show HN thread 47536877, 1 point). That’s the author’s own claim, not an independent evaluation.

The author (rohitg00) also maintains a broad collection of agent-ecosystem repositories (for example, awesome-claude-code, awesome-claude-code-plugins, clawdbot, agentbrain), but only the ones above have a verifiable direct relationship to agentmemory.

Repo numbers

Measured August 29, 2026, GitHub API.

Metric	Value
Stars	27,733
Forks	2,393
Watchers	80
Commits	482
Open issues per the API	534
Primary language	TypeScript
License	Apache-2.0
Created	February 25, 2026 (first commit February 27)
Last push	August 24, 2026
Latest release	`v0.9.29`, August 16, 2026

The top contributors returned by the API, by contribution count, were rohitg00 (400), Tanmay-008 (10), honor2030 (8), efenex (5), Rokurolize (4), JasonLandbridge (4), Rex57 (3), and Getty (3). The project is heavily concentrated on a single author.

API notes: open_issues_count (534) includes both open issues and open pull requests — the repository’s PR search returns 724 PRs total — so it shouldn’t be read as an issues-only count. The commit count (482) was obtained from the final page of the commits API’s pagination link with per_page=1.

npm addendum (August 29, 2026): @agentmemory/agentmemory at 7,671 weekly / 33,042 monthly downloads; @agentmemory/mcp at 6,815 weekly.

How to contribute

The process documented in CONTRIBUTING.md is explicit:

Fork the repository and branch off main: feat/<name> for features, fix/<issue-number>-<name> for fixes, docs/, refactor/, chore/ for everything else.
npm install (Node >= 20 required), npm run build (TypeScript must compile clean), and npm test (the full suite must pass; the single integration test, in test/integration.test.ts, needs a live server at :3111 and can be skipped locally).
Sign with DCO: every commit carries Signed-off-by (git commit -s); PRs without sign-off don’t get merged. No attribution headers (“Generated with Claude Code,” “Co-Authored-By: Claude,” etc.) are allowed in commits or PR descriptions.
Small, focused PRs, one logical change per PR, with a description of what, why, and how to verify; link the issue (Fixes #NNN / Closes #NNN).
CodeRabbit auto-reviews; respond to its comments before requesting human review, and address feedback with new commits (no force-push); maintainers may squash on merge.

Adding an MCP tool has 6 documented steps (a function under src/functions/, an HTTP trigger in src/triggers/api.ts with a matching api_path, an entry in src/mcp/tools-registry.ts, an implementation in src/mcp/standalone.ts, a test under test/, and no touching the CHANGELOG outside release PRs). Releases touch 8 files in lockstep (package.json, src/version.ts, the plugin.json files, packages/mcp/package.json, src/types.ts, and src/functions/export-import.ts), and the “Publish to npm” workflow publishes all three packages with provenance. Implementation questions go to GitHub Discussions; governance questions go to issues tagged governance.

How the community received it

The evidence gathered shows notable adoption, reference-level recognition among competing projects, and public criticism that spawned a large competitor:

Criticism and a consequential fork: in Hacker News comment 48251392, user akitaonrails wrote: “Five days ago I wrote a long post about coding agent memory where I recommended agentmemory as the answer. After a week running it in personal production, I’m retracting that. This post explains what went wrong and the open source project I started building to fix it: ai-memory.” The result, akitaonrails/ai-memory, reached 5,131 stars by August 29, 2026 — a derivative project that grew to be, in star count, a sizable fraction of the original. The full post wasn’t retrieved in this research, so the specific technical diagnosis should be treated as unverified.
Cited as a reference by competitors: in Mnemo’s Show HN thread (48389586, “Show HN: Mnemo – local-first AI memory layer for any LLM (Rust, SQLite, petgraph),” 60 points and 9 comments), user bilbo-b-baggins (comment 48390599) told the author “you forgot BM25” and linked, among other memory projects, github.com/rohitg00/agentmemory#key-capabilities — a sign that agentmemory had become a reference point that newer projects cite and compare themselves against.
A low-traction HN submission: the project’s site was submitted to Hacker News as story 48394857 (“Persistent Memory for Coding Agents,” June 4, 2026), with 1 point and 0 comments. No large dedicated thread about agentmemory was found in Algolia’s HN API queries, so no consensus or discussion volume should be inferred beyond what the sources show.
Product Hunt (not independently verified): Product Hunt’s page blocked the query behind bot verification, so the upvote count couldn’t be verified. The project’s site reproduces, “verbatim from the Product Hunt launch thread,” several comments: Peter Neyra (backfilled a month of Cursor transcripts), Pranav Prakash (two weeks of production use), Alper Tayfur (“tackles one of the biggest pain points in coding agents: losing useful project context between sessions without bloating the context window”), plus Mia Taylor, Thomas Hall, and Zoe Alexandra. These are testimonials cited by the project itself, not independently verified here.
Reddit: Reddit queries (direct API blocked, PullPush as a fallback) returned no substantial threads about agentmemory; the relevant hits belonged to a different project (atomic_agents). No Reddit reception is claimed here.
YouTube: searching “agentmemory rohitg00” returns, among others: “Agent Memory Explained in 5 Minutes” by KodeKloud (~16,600 views, July 2026); “Agent Memory EXPLAINED - Complete Architecture” by Hugging Face and Alejandro AO (~27,600 views, August 2026); “¡Este plugin le da memoria ILIMITADA a Claude!” by Hugo Wong (~3,600 views, April 2026, in Spanish); “AgentMemory: Memoria persistente para agentes de codificación de IA” and a podcast episode (“Creando la memoria de IA definitiva con LLM Wiki v2 y AgentMemory”) by Eddy Says Hi (266 and 615 views, in Spanish); and “Claude Code acaba de obtener memoria a largo plazo” by Build Things With AI (~290 views, in Spanish). View counts are approximate, taken from YouTube’s results page on August 29, 2026.

agentmemory vs. other approaches

Approach	Stars (08/29/2026)	Verifiable overlap	Verifiable difference
`mem0ai/mem0`	64,320	Universal memory layer for agents, vector + graph search, Python and TypeScript SDKs.	An API you call manually (`add()`), external dependencies (Qdrant/pgvector), a managed cloud option; no hook-based automatic capture or local viewer (per the project’s own `benchmark/COMPARISON.md` matrix, which flags itself as project-authored).
`letta-ai/letta`	24,485	Agents with memory; OS-inspired memory tiers.	A full agent runtime, not just memory; requires Postgres + vector; the agent self-edits its own memory.
`khoj-ai/khoj`	36,788	Self-hostable memory / second brain.	Persona-oriented (documents, web, Obsidian/Notion/Emacs), not coding-agent infrastructure.
`supermemoryai/supermemory`	29,130	Memory + context, framework wrappers.	Managed, cloud-only; server-side extraction; no local-first deployment.
`TencentCloud/TencentDB-Agent-Memory`	25,164	Agent memory with integration-free capture (via an LLM proxy).	A team memory hub on top of TencentDB; multi-service Docker deployment; a self-reported PersonaMem benchmark (76%, per the project’s own matrix).
`getzep/graphiti`	30,400	Knowledge graph for agents; temporal dimension.	A temporal graph built in the background (freshly ingested facts take time to become retrievable); not coding-agent session capture.
`akitaonrails/ai-memory`	5,131	Long-term memory for coding agent CLIs; vendor handoff.	Born out of criticism of agentmemory; its stated focus is easing handoff between agents from different vendors.
`JordanMcCann/agentmemory`	46	A memory system publishing LongMemEval numbers.	Claims 96.2% (481/500) and beating every published system; a 16-day build (self-reported in Show HN thread 47536877).

The project’s own comparison (benchmark/COMPARISON.md) also includes MemPalace, oracleagentmemory, Hippo, Cognee, and Zep, with an honest disclaimer: only agentmemory’s 95.2% is its own reproducible measurement; the other numbers are vendor-stated, on different benchmarks (LoCoMo, LongMemEval with GPT-5.5, etc.), not reproduced by them. The star counts in the table above were verified against the GitHub API on August 29, 2026.

Use cases

Individual developers working with Claude Code, Cursor, Codex, or another compatible agent across long sessions: the core documented use case is not re-explaining the architecture every session; hook-based capture plus startup context injection, with a project-measured claim of ~92% less input tokens than resending full history.
People with a long Claude Code history: the import-jsonl flow backfills existing transcripts (the case cited on Product Hunt by Peter Neyra: a month of Cursor transcripts), with the documented cleanupPeriodDays=30 trap that needs a cron job or a raised value to work around.
Teams with multiple agents or multiple developers sharing memory: agentId scopes memory per agent; leases, signals, and peer-to-peer mesh sync support parallel agents, and remote deployment with AGENTMEMORY_URL/AGENTMEMORY_SECRET (including the documented profile for Devin cloud) covers agents that can’t reach a local localhost.
Organizations with data-residency requirements: local-first by default, zero external databases, secret filtering before save, and an audit trail of every mutation. With a verifiable caveat: SSO (OIDC), audit export to S3/Loki, and RBAC are on the Q4 2026 roadmap and not yet available.
Teams auditing or monitoring what their agents learn: the :3113 viewer shows the live observation stream, session replay, the knowledge graph, and health, and built-in Obsidian export folds memory into existing documentation workflows.
Builders of agent products that need an embeddable memory layer: 130 REST endpoints and 54 MCP tools exposed under a single process, with a trimmable surface (AGENTMEMORY_TOOLS=core), serve as a framework-free memory dependency — exactly what the roadmap states as its mission (“agentmemory is a dependency, not a replacement for the agent runtime”).

Resources

Repository: https://github.com/rohitg00/agentmemory
Official site (stack, features, demo, agents, install): https://www.agent-memory.dev
Quick start and Windows notes in the README: https://github.com/rohitg00/agentmemory#quickstart
npm package (runtime): https://www.npmjs.com/package/@agentmemory/agentmemory
npm package (standalone MCP): https://www.npmjs.com/package/@agentmemory/mcp
Benchmark and primary-sourced comparisons: https://github.com/rohitg00/agentmemory/blob/main/benchmark/COMPARISON.md
Governance and contributing: https://github.com/rohitg00/agentmemory/blob/main/GOVERNANCE.md, https://github.com/rohitg00/agentmemory/blob/main/CONTRIBUTING.md
Public roadmap (Q2 2026 – Q1 2027): https://github.com/rohitg00/agentmemory/blob/main/ROADMAP.md
“LLM Wiki v2” gist (the author’s conceptual pattern): https://gist.github.com/rohitg00/2067ab416f7bbe447c1977edaaa681e2
iii engine: https://github.com/iii-hq/iii
Community references: akitaonrails’ critical comment https://news.ycombinator.com/item?id=48251392 (origin of akitaonrails/ai-memory), Mnemo’s story citing agentmemory https://news.ycombinator.com/item?id=48389586, the site’s submission https://news.ycombinator.com/item?id=48394857
Videos: KodeKloud “Agent Memory Explained in 5 Minutes” (youtube.com/watch?v=0P-ACuHyu-0), Hugging Face and Alejandro AO “Agent Memory EXPLAINED - Complete Architecture” (youtube.com/watch?v=aYfZN8t6AQs), Hugo Wong “¡Este plugin le da memoria ILIMITADA a Claude!” (youtube.com/watch?v=9kVVyLVmET4), Eddy Says Hi “AgentMemory: Memoria persistente para agentes de codificación de IA” (youtube.com/watch?v=oslSQiHCKUI)
Trendshift (README badge): https://trendshift.io/repositories/25123

Note: this article combines the repository’s README, CONTRIBUTING.md, GOVERNANCE.md, ROADMAP.md, and benchmark/COMPARISON.md, the GitHub and npm APIs, the Hacker News Algolia API, the official site, and YouTube results consulted on August 29, 2026. Figures change over time; the project’s own claims (for example, the 95.2% on LongMemEval-S or the “As featured in” mentions) are flagged as such and not as independent verification.