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 docs don't clearly establish a capability, the cell is marked Unclear.
| 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 | Yesblast-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 · Partial = limited or indirect form · Unclear = public docs do not establish it.
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.
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.
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.
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.
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.
Mem0 and Letta both offer managed cloud platforms and large communities. Zep has a commercial offering and a peer-reviewed temporal-graph paper. The vector + RAG baseline wins on ubiquity and simplicity. Ferrosa Memory is self-host only, with no managed cloud yet.
The credible pitch is depth and correctness for teams that need explainable, auditable, temporally-correct memory and are comfortable self-hosting today.
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.