---
title: "past.dev vs Letta"
description: "Compare Letta and past.dev by agent runtime, memory control, ingestion model, deployment, and recall output. The products can also be used together."
canonical: https://past.dev/vs/letta
last-updated: 2026-10-09
---
# past.dev vs Letta

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

Letta is a platform for stateful agents. Agents edit memory blocks in their context window and search an archival store through tools. past.dev provides memory through an API and does not include an agent runtime. Applications can also use the products together by calling past.dev from a Letta tool.

## What Letta is

[Letta](https://docs.letta.com), formerly MemGPT, is an Apache 2.0 platform for stateful agents. Memory blocks remain in the context window across interactions. Archival memory remains outside the window and is searched on demand. The agent uses tools to read, write and reorganize memory. Letta can run self-hosted or as Letta Cloud and includes a memory inspection interface.

## What past.dev is

past.dev provides a JSON memory API and does not provide an agent loop, tool-calling runtime or state machine. Applications send timestamped text, wait until ingestion completes, and later query it. `/recall` returns ranked documents with dated source excerpts.

In Letta, the agent decides what to write to memory. With past.dev, the application decides which source records to submit through the ingest API.

## 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 |
| Who writes memory | The agent, through tools | The application, through ingest requests |
| 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 | Recall documents requested per question |
| Time | A property of what the agent wrote | Timestamped ingestion and optional recall perspective |
| Sources | Whatever the agent recorded | Documents include dated source excerpts |
| Fits with | Building on Letta's agents | Any framework, or none |

## How to choose

Choose based on the requirements below.

- **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 need to add memory, or if the history you need to query is in emails, transcripts and tickets rather than only in the agent's 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

This page contains no head-to-head scores. Our evaluation uses BEAM and LoCoMo with community-corrected answer keys, with full-context and plain-RAG baselines and several judges. The method is published on [benchmarks](/benchmarks). We will publish product comparisons after documenting a reproducible configuration for the other product.

## 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)