Basic Memory MCP alternatives
Basic Memory keeps an agent's memory as plain Markdown files in a folder you choose, readable in Obsidian or any editor. Observations and wiki-link relations inside notes are parsed into a graph and indexed in SQLite with hybrid full-text and vector ranking, and the 1.0 server exposes 17 bm_ tools for writing, editing, searching and traversing notes. Basic Memory Cloud serves the same tools over OAuth with shared workspaces.
It is one of the most transparent designs on this list: you can read, edit and version every memory. What it shares with most of the field is that memory exists only when the agent writes a note. If you want memory that is recorded from the work instead, Glen comes first.
The 9 best alternatives
- GlenOur pick
Memory recorded from the work, not notes the agent remembers to write
Basic Memory holds the notes an agent chose to write. Glen holds what the team actually worked out, recorded from every session and tool, and returns it as one cited answer instead of files to read.
Recorded automaticallyClaude CodeCodexCursorSlackGitHubLinearNotionCall transcriptsOne memory for your orgSourced, permissioned per fact, newer decisions winEvery teammate's agentClaude CodeCodexCursorGets one cited answer, injected into the session before it goes looking.29%fewer tokens across 100 replayed PRs21%faster, measured end to endParity+quality on withheld testsBasic MemoryGlenWho writes memoryThe agent, via bm_writeRecorded from every session and toolWho can read itOne folder or Cloud workspaceYour whole org, permissions per factWhat the agent getsMatching notes to readOne cited answer, injected in-sessionWhen a decision changesSomeone edits the noteThe newer decision replaces the older The closest to Glen in mechanism: claude-mem records sessions through hooks in Claude Code, Codex, Cursor and others, compresses tool use into observations with an observer model, and injects context when a session starts. The difference is scope. Memory lives in SQLite on one machine, grouped by project, and TeamBrain, its sharing feature, was a pilot with no public pricing when we checked. It is good memory for one developer, and your teammates' agents never see any of it.
Set up claude-mem →The smallest memory server there is: Anthropic's reference implementation keeps entities, relations and observations in one JSONL file on your disk, behind nine tools and an npx command. Nothing is recorded unless the agent calls create_entities or add_observations, search_nodes matches substrings rather than meaning, and the file belongs to one machine. It is the right place to learn the pattern and the wrong place to keep a team's history.
Set up Memory →Mem0 runs an LLM over whatever the agent passes to add_memory, extracts discrete memories, and returns them through semantic search from a hosted endpoint at mcp.mem0.ai. It is built for per-user memory inside an application: every memory hangs off a user_id, agent_id or run_id, nothing is written unless the agent decides to call add_memory, and search hands back matching memories rather than an answer with sources. The self-run mem0-mcp package is archived and Mem0's OpenMemory was sunset in July 2026, so the hosted server is the only maintained route.
Set up Mem0 →MemPalace keeps conversations and files verbatim, without summarizing, and files each piece into wings and rooms so a search can be scoped to one person or project; ChromaDB with local embeddings does retrieval, and a SQLite graph tracks facts with validity windows. Hooks for Claude Code, Codex and Cursor save sessions automatically. A palace lives on one machine unless you run your own HTTP hub, search returns raw drawers for the agent to read rather than an answer, and its 47 tool definitions sit in every session's context window.
Set up MemPalace →Cognee runs an LLM pipeline over what it is given, extracting entities and relationships into a knowledge graph beside vector embeddings, and recall picks among graph, RAG, temporal and Cypher strategies. It runs locally on SQLite, LanceDB and an embedded graph and needs your own LLM key. Each MCP client writes to its own dataset by default, so Claude Code and Cursor on one machine don't share memory unless you change COGNEE_MCP_AGENT_SCOPED, and nothing is stored until the agent calls remember.
Set up Cognee →Graphiti, the open-source library under Zep's commercial product, is the most careful about time of anything on this list: facts are graph edges with validity timestamps, and a newer episode that contradicts an older fact invalidates it. You run it yourself on FalkorDB or Neo4j with your own LLM and embedding keys, and the README calls the MCP server a reference implementation with no authentication, so anyone who reaches the port can read or clear the whole graph. Episodes still arrive only when the agent calls add_memory.
Set up Zep Graphiti →Supermemory's hosted server turns content the agent saves into documents, extracts memories from them asynchronously, and returns matches with a similarity score and the source document's ID. Spaces partition memory per project or user, and clients with MCP Apps support get a space picker and an interactive memory graph. Through this server, memory enters when the agent or the user calls a save tool, so what a space holds is whatever someone remembered to store.
Set up Supermemory →ByteRover keeps project knowledge as topic files in a .brv/context-tree directory inside the repository, with git-style branches and merges and optional cloud sync for a team. Its MCP server is deliberately small: brv-query runs BM25 over the tree and brv-curate saves a topic the agent wrote. Knowledge enters only when an agent or a person curates it, so the tree holds what someone chose to document, which is the AGENTS.md problem with better tooling.
Set up ByteRover →
How to choose
Basic Memory is a good choice if you want memory as human-editable Markdown you own, locally or in shared Cloud workspaces. For a team whose agents should start each task with what the team already decided, recorded automatically and reconciled as it changes, Glen fits better. claude-mem and MemPalace record sessions automatically on one machine; ByteRover keeps a curated context tree in the repo; the Memory reference server is the minimal local graph.
FAQ
- What is the best Basic Memory alternative?
- Glen, if you want memory recorded from every session and shared across a team without anyone writing notes. ByteRover, if you want curated knowledge files that live in the repository.
- Can I use Basic Memory and Glen together?
- Yes. They are separate MCP servers. Basic Memory holds notes you curate; Glen holds what your team's sessions and tools recorded.
- Is Basic Memory Cloud a team product?
- Cloud workspaces can be shared with members, and the notes in them are shared. Notes are still written by agents or people calling the write tools, not recorded from sessions.