Supermemory MCP alternatives
Supermemory runs a hosted MCP server at mcp.supermemory.ai on Cloudflare Workers. Content the agent saves becomes a document, memories are extracted from it in the background, and search_memory returns matches with a similarity score and a pointer back to the source document. Memory is partitioned into spaces, and clients that support MCP Apps get a space picker, a guided save form and an interactive memory graph.
It is a polished memory API, and like most memory APIs it stores what the agent or the user decides to save. Teams evaluating it for coding agents usually want something else as well: memory built from every session, not only the ones someone remembered to save, and shared across everyone's agents. That is what Glen does, so it leads the list.
The 9 best alternatives
- GlenOur pick
Shared memory that fills itself from your team's sessions and tools
Supermemory stores what an agent or user decides to save into a space. Glen records what your team actually worked out, in every session and connected tool, and gives every teammate's agent the same memory.
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 testsSupermemoryGlenWho writes memoryAgent or user saves itRecorded from every session and toolWho can read itWhichever space is selectedYour whole org, permissions per factWhat the agent getsScored matches and a source IDOne cited answer, injected in-sessionWhat you runHostedNothing: hosted, OAuth 2.1 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 →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 →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 →LongMemory, the CaviraOSS project published until recently as OpenMemory and unrelated to Mem0's product of that name, sorts memories into five sectors that decay at different rates and links them through a waypoint graph. It is six tools over a local SQLite file, with a user_id on each call to keep users apart. It records only what the agent chooses to store, and the team-aware rewrite on its main branch was not on npm when we checked.
Set up LongMemory (formerly OpenMemory) →Basic Memory writes memory as plain Markdown in a folder you choose, parses observations and wiki-link relations into a graph, and indexes it in SQLite for hybrid search. The files open in Obsidian and diff cleanly in git, and Basic Memory Cloud serves the same 17 tools over OAuth with shared workspaces. A note exists only when the agent calls bm_write or bm_edit, so the memory is exactly as complete as the agent's judgment about what was worth writing down.
Set up Basic Memory →
How to choose
Supermemory is a strong choice for adding a memory API to an app or a personal assistant, especially if you want MCP Apps in the client. For a team of developers whose agents should share what the team has worked out, Glen is the better fit: it records sessions and tools automatically, keeps one organization-wide memory with per-observation permissions, and returns cited answers. Mem0 is Supermemory's closest peer; claude-mem and MemPalace record sessions automatically but locally; Graphiti, Cognee and MCP Memory Service are engines to run yourself.
FAQ
- What is the best Supermemory alternative?
- For coding teams, Glen, because it records every agent session and connected tool into one shared memory instead of storing only what gets saved. For another hosted memory API with per-user scoping, Mem0.
- Does Supermemory record agent sessions automatically?
- Through its MCP server, memory is added when the agent or user calls add_memory, uses the guided save form or uploads a file. Glen and claude-mem both record sessions through hooks without a save call.
- How do Supermemory spaces compare with Glen's org memory?
- A space is a partition the agent selects or is told to use. Glen has one memory per organization, and access control is applied per observation at recall, so what an agent sees depends on what its user is cleared to see rather than which space it picked.