---
title: "Mem0 alternatives for agent memory in 2026"
description: "A comparison of mem0 alternatives including Zep, Letta, Supermemory and past.dev by architecture, deployment, inputs and changed-fact handling."
canonical: https://past.dev/blog/mem0-alternatives
date: 2026-08-30
category: Engineering
authors: The past.dev team
---
# Mem0 alternatives for agent memory in 2026

Teams evaluating mem0 alternatives commonly compare mem0, Zep, Letta, Supermemory and past.dev. All five provide memory-related functions for AI agents. Their architectures and deployment models differ. This article summarizes each product using its public documentation.

The comparison covers product design. Our [benchmarks page](/benchmarks) reports past.dev accuracy and cost. We do not publish direct product scores until the tested product has been configured and the test can be reproduced.

## mem0

[mem0](https://github.com/mem0ai/mem0) is an Apache 2.0 memory system with Python and TypeScript SDKs. An application sends conversations through `add()`. A language model extracts memories. `search()` retrieves them later.

Memories can be scoped by user, session or agent. They are stored in a configured vector store. mem0 can run as a library, self-hosted server or managed service. Its managed service also provides a graph view and hosted MCP server.

mem0 is designed for user preferences and profile facts in conversational products. During evaluation, test whether the extractor stores every required fact and how the system handles conflicting values. See [past.dev vs mem0](/vs/mem0) for a detailed comparison.

## Zep

[Zep](https://www.getzep.com/) is a memory service based on the Graphiti temporal knowledge graph. It accepts conversations, JSON and documents as episodes. It extracts entities and relationships. Facts include timestamps, and older relationships can be marked as expired when new information arrives.

Retrieval combines semantic search, keyword matching and graph traversal. Graphiti is open source and runs on a graph database. Zep is suitable for teams that want to operate a temporal graph themselves. See [past.dev vs Zep](/vs/zep).

## Letta

[Letta](https://docs.letta.com/), previously MemGPT, is an Apache 2.0 platform for stateful agents. It provides memory blocks inside the agent's context window and archival memory outside the window. The agent reads and edits memory through tools.

Letta can run as a self-hosted system or through Letta Cloud. It includes an interface for inspecting and editing agent memory. Letta supplies an agent runtime as well as memory. It can also call an external memory API through a tool. See [past.dev vs Letta](/vs/letta).

## Supermemory

[Supermemory](https://github.com/supermemoryai/supermemory) provides context and memory infrastructure. It ingests text, chats, files, PDFs, images and video through connectors and extractors. It also provides retrieval and user profiles.

Supermemory offers a hosted API and SDKs. Its MIT-licensed repository supports self-hosting. It is suitable when an application requires many input formats and prebuilt connectors. See [past.dev vs Supermemory](/vs/supermemory).

## past.dev

past.dev is a memory API that exposes ingestion, status, recall and deletion, plus audiences and an identity directory. It does not provide an agent framework or runtime. `POST /api/v1/ingest` accepts timestamped source text.

Once ingestion completes, `POST /api/v1/recall` requires an identity and returns ranked documents with dates and source excerpts. The application applies its own sufficiency policy.

The [benchmarks page](/benchmarks) documents past.dev's method and results. Sign-up is self-serve and starts with free credits, and past.dev runs as a managed service or, on an Enterprise agreement, in your own cloud.

## Selection guide

- Choose **mem0** for extracted user preferences and profile memories in a conversational product.
- Choose **Zep or Graphiti** when you want to operate an open-source temporal graph.
- Choose **Letta** when you need an agent runtime with agent-managed memory.
- Choose **Supermemory** when you need broad file-format support and connectors.
- Choose **past.dev** when you need timestamped ingestion and grouped recall documents with dated source excerpts through an API.

During evaluation, test how each system handles a changed fact and an unsupported question. Also measure retrieval accuracy, latency and cost on your own data. See [What is agent memory?](/what-is-agent-memory) for the core concepts and the [quickstart](/docs/memory-api/quickstart) for the past.dev API.

For the head-to-head detail behind this guide, the comparison series walks each pair: [Mem0 vs Zep](/blog/mem0-vs-zep), [Mem0 vs Supermemory](/blog/mem0-vs-supermemory), [Mem0 vs Letta](/blog/mem0-vs-letta), [Mem0 vs Cognee](/blog/mem0-vs-cognee), [Mem0 vs LangMem](/blog/mem0-vs-langmem), and the [three-way shortlist](/blog/mem0-vs-zep-vs-letta).