---
title: "past.dev vs mem0"
description: "How past.dev and mem0 differ: extracted memories in a store versus a temporal graph, what each takes in, how each handles a fact that changed, and which one fits your system."
canonical: https://past.dev/vs/mem0
last-updated: 2026-08-26
---
# past.dev vs mem0

Source: https://past.dev/vs/mem0

mem0 is an open-source memory layer that extracts memories from conversations and stores them in a vector store you configure, scoped per user, session or agent. past.dev is a hosted memory API that takes timestamped text of any kind, builds a temporal graph from it, and answers questions about what currently holds with the dated evidence behind the answer. mem0 optimises for a compact, portable memory you run yourself. past.dev optimises for answering a question whose answer changed.

## What mem0 is

[mem0](https://github.com/mem0ai/mem0) is an Apache 2.0 memory layer for AI agents, with Python and TypeScript SDKs. It can run three ways: as a library inside your process, as a self-hosted server, or as their managed platform. The core surface is small, `add()` writes memories from messages and `search()` retrieves them, and memory is scoped at user, session and agent level.

A language model does the extraction, and the resulting memories are stored in a vector store you configure. The result is a memory you can read: short statements about a user, retrievable per user, portable between projects.

## What past.dev is

past.dev is a hosted API. You `POST` raw text with the timestamp it happened, backdated if you are loading history, and query later. Extraction, entity resolution and graph maintenance run on our side. `/recall` returns ranked evidence with its sources; `/answer` returns a grounded answer, the evidence it used, the dollar cost of the call, and `abstained: true` when the evidence does not establish an answer.

The unit is not a memory about a user, it is a dated fact with the source that stated it. That is what makes the previous value retrievable rather than overwritten.

## Architecture differences

|  | mem0 | past.dev |
| --- | --- | --- |
| Licence | Apache 2.0 | Commercial, with a self-host image |
| How you run it | Library, self-hosted server, or managed platform | Hosted API, or the same image on your own Docker |
| What you send | Conversation messages | Any text plus the timestamp it happened, backdatable |
| Unit stored | An extracted memory | A dated fact, tied to the source that stated it |
| Where it is stored | A vector store you configure | A graph on Postgres with pgvector, ours or yours |
| Scoping | user, session and agent identifiers | Project, with entities resolved inside it |
| A fact that changed | The memory is updated | The new value is current, the previous one stays dated in the history |
| Reading | Search returns memories | `/recall` returns evidence, `/answer` returns a grounded answer |
| Says it does not know | Your code decides | `abstained: true` on `/answer` |
| Cost visibility | Your model provider's bill | Reported per call in the response |

## How to choose

Both are reasonable choices and they are not built for the same job. The short version:

- **Choose mem0** if you want to own the whole memory in your own infrastructure, if your input is chat and your questions are about a user's stable preferences, or if an Apache 2.0 licence is a requirement.
- **Choose past.dev** if your input is history rather than chat, emails, transcripts, tickets and notes, if the answer you need changed over time, or if you need the evidence and the per-call cost in the response.
- **Neither is a framework.** Both leave your agent, your model and your prompts where they are.

## What this page does not claim

No head-to-head numbers. We run LoCoMo on the community-corrected answer keys, LongMemEval and BEAM, with full-context and plain-RAG baselines and several judges, and the method is published on [benchmarks](/benchmarks). A comparison against another product is only worth reading if the other product was configured by someone who wanted it to do well, and if the harness that produced it can be rerun. Until we publish that harness, this page compares designs, not scores. The numbers land here when they can be reproduced.

## Related

- [What is agent memory?](https://past.dev/what-is-agent-memory)
- [past.dev vs Zep](https://past.dev/vs/zep)
- [past.dev vs Letta](https://past.dev/vs/letta)
- [API reference](https://past.dev/docs/memory-api/api-reference)
- [How we measure memory](https://past.dev/benchmarks)