Most memory layers answer "what's similar?" Ferrosa Memory also answers "what changed, what's connected, why does this exist, and can I safely remove it?" Here's how that differs from Mem0, Zep/Graphiti, Letta, and the vector+RAG baseline — fairly, and grounded in each project's own docs.
Each competitor cell is drawn from that project's own public documentation or repository. Where the public docs don't clearly establish a capability, the cell is marked Unclear rather than guessed. This is capability framing only — no benchmark, latency, or scoring numbers.
| Capability | Ferrosa Memory | Mem0 | Zep / Graphiti | Letta | Vector + RAG |
|---|---|---|---|---|---|
| MCP-native tools | Yes21 tier-1 + 58 tier-2 tools | Partialvia OpenMemory / mem0-mcp; OpenMemory deprecated | YesGraphiti mcp_server |
MCP client onlyuses external MCP tools; no official Letta MCP server | Partialsome vector-DB MCP servers; not inherent |
| Typed knowledge graph | Yestyped entities + edges | Partialentity linking; standalone graph store being deprecated Apr 2026 | Yestyped entities / edges / episodes | Partialvia pluggable graph backend; not core | No |
| Bi-temporal facts (supersession history) | Yestimestamped facts, supersession chain stays inspectable | Nono validity-interval model documented | Yest_valid/t_invalid + ingest timestamps; invalidate-not-delete |
Unclearno bi-temporal model documented | No |
| Hybrid retrieval (lexical + vector + graph + recency) | YesRRF over ~11 signals incl. PageRank | Partialsemantic + BM25 + entity boost; no graph/recency fusion documented | Partialsemantic + BM25 + graph traversal; recency via temporal metadata | Partialtiered vector + recall search; no documented fusion | Novector similarity, optional keyword |
| Explainable / derived facts (rules) | YesDatalog-derived facts with proof trace | Noextracted text, no rule engine | Partialepisode provenance + temporal lineage; no logical rule engine | Notransparent edits, no rule derivation | Nosource-traceable chunks, no derivation |
| Forgetting w/ blast radius + reversible retraction | Yes0.15 feature: blast-radius preview + journal | Partialdelete exists; no blast-radius / reversible audit documented | Partialinvalidate-not-delete preserves history; no blast-radius UX documented | Unclearblock / passage CRUD; no reversible-retraction feature documented | Nodelete-by-ID only |
| Automatic consolidation | Yesbackground "dream cycle" | Partialadd-pipeline reconciliation / dedup; no consolidation cycle documented | Partialincremental graph updates / invalidation; not a scheduled cycle | Unclearagent-driven edits; no automatic consolidation documented | Nomanual |
| Durable storage + tiering | YesFerrosa DB backend, S3 tiering | Partialvector / graph store; cloud-managed; no S3 tiering documented | Partialgraph DB; cloud-managed; no S3 tiering documented | PartialPostgres + pluggable stores; no S3 tiering documented | Partialdepends on chosen DB |
| Self-hostable | Yes | Yeslibrary + self-hosted server | YesGraphiti OSS; full Zep CE deprecated Apr 2025 | Yes | Yeswith OSS components |
| Managed cloud | Nodeveloper preview / self-host | Yesapp.mem0.ai | YesZep Cloud | YesLetta Cloud, app.letta.com | Yese.g. Pinecone, managed Weaviate / Qdrant |
Legend: Yes = documented / supported · No = documented absence or not applicable · Partial = exists in limited or indirect form (see cell note) · Unclear = public docs do not establish it. Where a capability is available only through an external component, that's noted in the cell. Ferrosa Memory's column reflects the product's stated 0.15 capabilities and is not independently third-party verified here.
The agent-memory space is moving fast. These summaries reflect each project's current public posture, including notable 2025–2026 shifts — stated neutrally and factually.
An open-source "memory layer" for AI agents that remembers user preferences and facts across sessions. An LLM extracts memories from conversations and stores them as embeddings with user / session / agent scoping, retrieved by a hybrid of semantic search, BM25 keyword matching, and entity linking. Ships as a Python / JS library, a self-hostable server, and a managed cloud (app.mem0.ai), under Apache-2.0.
How fmem differs: Mem0 centers on LLM-extracted free-form memories; Ferrosa Memory keeps a typed bi-temporal graph with rule-derived, explainable facts and auditable forgetting on a durable S3-tiered backend.
2025–2026 nuance: as of the April 2026 algorithm change, Mem0's standalone graph_store / enable_graph config is being deprecated in favor of vector-centric entity linking; its MCP story (mem0-mcp and OpenMemory) is in flux, with OpenMemory documented as sunset in favor of the unified self-hosted server.
Graphiti is an open-source temporal knowledge-graph engine (Apache-2.0) that is the core of Zep's commercial Context Graph platform. It ingests conversational and structured data into typed entity nodes, relationship edges, and episodes, and is explicitly bi-temporal: edges carry validity windows (t_valid / t_invalid) plus ingest timestamps, and conflicting facts are invalidated rather than deleted. Retrieval is hybrid — embeddings + BM25 + graph traversal.
How fmem differs: Zep/Graphiti is the closest match on the typed bi-temporal graph story. Ferrosa Memory adds a Datalog rule/derivation engine, a dream-cycle consolidation pass, and a blast-radius forgetting UX — none of which Graphiti documents as such.
Credit where due: Zep has a battle-tested commercial offering and a peer-reviewed temporal-graph architecture paper behind it. 2025 nuance: Zep's self-hostable Community Edition was deprecated (April 2025) and is unmaintained, so self-hosting today means running the Graphiti library yourself.
An open-source framework (Apache-2.0) for building stateful agents that manage their own memory, descended from the Berkeley MemGPT "LLM-as-OS" work. Memory is organized into labeled in-context "memory blocks" across OS-inspired tiers — core memory (always in-context), archival memory (external vector / graph store), and recall memory (searchable history). The agent actively edits its own memory via tool calls. Available as OSS and as Letta Cloud.
How fmem differs: Letta centers on agent-driven self-editing memory blocks; Ferrosa Memory provides a typed graph, bi-temporal supersession, multi-signal fusion retrieval, and rule-based derivation as first-class server features rather than agent-managed state.
2025–2026 nuance: Letta is documented as an MCP client — its agents attach and call external MCP tools — but it is not itself an official MCP server exposing its memory as tools (a community-built Letta MCP server exists). Letta has a polished managed cloud, a large community, and broad framework integrations.
The default "roll-your-own" pattern (a category, not a product): store conversation or document chunks in a vector database — Pinecone, Weaviate, Qdrant, pgvector — and wire retrieval with a framework like LangChain or LlamaIndex, or simply lean on a long context window. Retrieval is vector similarity, optionally plus keyword or metadata filters; some frameworks add reranking. Both OSS components and managed clouds exist.
How fmem differs: the baseline answers "what's similar?"; Ferrosa Memory adds a typed graph, bi-temporal history, multi-signal RRF fusion, explainable derivation, automatic consolidation, and auditable forgetting beyond delete-by-ID.
Credit where due: the vector + RAG baseline wins on ubiquity, simplicity, and ecosystem familiarity — for many teams "Pinecone / pgvector + LangChain" is the fastest path to good-enough memory.
Ferrosa Memory's differentiator is breadth and rigor in one self-hostable package: native MCP tooling, a typed bi-temporal graph, multi-signal RRF retrieval including PageRank, Datalog-derived explainable facts, dream-cycle consolidation, and reversible forgetting with blast radius — all on a durable S3-tiered Ferrosa DB backend. No single competitor combines all of these in one product today.
We won't pretend to be more mature than the incumbents. Mem0 and Letta both offer polished managed cloud platforms, large active communities, and broad framework integrations — while fmem is developer-preview and self-host only, with no managed cloud. Zep has a battle-tested commercial offering and a peer-reviewed temporal-graph architecture paper behind it. The vector + RAG baseline wins on ubiquity, simplicity, and ecosystem familiarity.
fmem's credible pitch is depth and correctness for teams that need explainable, auditable, temporally-correct memory and are comfortable self-hosting today — not "more mature than the incumbents."
Competitor capabilities above are grounded in each project's own public docs and repositories. The key vendor sources are linked here so the matrix can be verified independently.
Mem0: GitHub repo, Graph Memory / migration docs, OpenMemory, mem0-mcp, "What is AI Agent Memory".
Zep / Graphiti: Graphiti repo, "What Is a Temporal Knowledge Graph?", Zep paper (arXiv 2501.13956), CE deprecation announcement.
Letta: GitHub repo, MCP overview docs, archival memory docs, "Memory Blocks".
Vector + RAG components: Pinecone, Weaviate, Qdrant, pgvector, LangChain, and LlamaIndex — characterized at the category level from their respective public documentation.
Read how the typed graph, bi-temporal facts, hybrid retrieval, and auditable forgetting fit together — then browse the MCP tools your agents call.