---
title: "past.dev vs Letta"
description: "Letta is an agent runtime whose agents edit their own memory. past.dev is a memory API with no runtime. Where the two differ, and why they are more often combined than compared."
canonical: https://past.dev/vs/letta
last-updated: 2026-08-26
---
# past.dev vs Letta

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

Letta is a platform for stateful agents: the agent owns its memory and edits it with tools, keeping memory blocks in its context window and an archival store it searches on demand. past.dev is a memory API with no agent runtime at all, which you call from whatever framework you already use. They compete only if you are choosing between building on an agent platform and adding memory to your own agent, and they compose more often than they compete.

## What Letta is

[Letta](https://docs.letta.com), formerly MemGPT, is an Apache 2.0 platform for stateful agents. Its memory model has two halves: memory blocks, which live inside the agent's context window and persist across interactions, and archival memory, which sits outside the window and is searched on demand. The distinguishing idea is that the agent manages its own memory: it calls tools to read, write and reorganise the blocks, rather than having a pipeline decide for it. Letta runs self-hosted or as Letta Cloud, with an environment for inspecting and editing an agent's memory directly.

## What past.dev is

A memory API, and nothing above it. No agent loop, no tool calling, no state machine: five endpoints over a temporal graph. You send text and a timestamp, and later ask a question. `/recall` returns evidence, `/answer` returns a grounded answer with its cost and an explicit abstention. Your agent framework, model and prompts are untouched.

The write path is the other difference. In Letta the agent decides what is worth remembering. In past.dev everything ingested is extracted and resolved into the graph, so nothing depends on an agent choosing to write at the right moment.

## Architecture differences

|  | Letta | past.dev |
| --- | --- | --- |
| What it is | An agent runtime with memory built in | A memory API with no runtime |
| Licence | Apache 2.0 | Commercial, with a self-host image |
| Who writes memory | The agent, through tools | The ingestion pipeline, on everything you send |
| In-context memory | Memory blocks, always present in the window | None; you choose what to put in the window from `/recall` |
| Out-of-context memory | Archival memory, searched on demand | The graph, queried per question |
| Time | A property of what the agent wrote | A validity window on every fact, with backdated ingestion |
| Sources | Whatever the agent recorded | Evidence carries the source and its date |
| Fits with | Building on Letta's agents | Any framework, or none |

## How to choose

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

- **Choose Letta** if you want the agent itself to be the product's unit, if self-editing memory blocks match how you think about state, or if you want an open-source runtime you can host.
- **Choose past.dev** if you already have an agent and the missing piece is what it knows, or if the history you need to answer from lives in emails, transcripts and tickets rather than in the agent's own conversations.
- **Use both** by giving a Letta agent a tool that calls `/recall`. The agent keeps its working state in its blocks and asks past.dev the questions whose answers changed.

## 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)
- [Context engineering for AI agents](https://past.dev/context-engineering)
- [past.dev vs mem0](https://past.dev/vs/mem0)
- [MCP server](https://past.dev/docs/mcp/overview)
- [How we measure memory](https://past.dev/benchmarks)