--- title: "Best Memory APIs for LLM Agents 2026: 7 Compared" description: "Compare 7 memory APIs for LLM agents in 2026: past.dev, mem0, Zep, Letta, Supermemory, Hindsight and Cognee, with features, pricing and BEAM results." canonical: https://past.dev/blog/best-memory-apis-for-llm-agents date: 2026-11-19 last-updated: 2026-11-19 category: Engineering authors: The past.dev team --- # Best Memory APIs for LLM Agents 2026: 7 Compared The best memory API for an LLM agent returns the current value of each fact, the value it replaced and the dated source behind it, scoped to the user or agent asking. On those requirements, past.dev ranks first: it scores highest on BEAM, the largest public memory benchmark, at every history size among published results (92.08% at 100K tokens to 85.03% at 10M; self-reported, and the harness is public). mem0, Zep, Letta, Supermemory, Hindsight and Cognee each fit narrower setups, covered below. This comparison is for engineers and technical leads choosing a memory API for agents in production. Every entry, past.dev included, uses the same format: what the tool is, how it runs, its licence, its published results, its pricing as of November 2026, and when to choose it. ## Why Do LLM Agents Need a Memory API for Long-Term Memory? Agent memory is the record an agent keeps about users, decisions and facts so it can act on them in later sessions. Retrieval-augmented generation (RAG) retrieves similar text for one task; a memory API keeps facts current across many sessions and tasks. The difference is covered in more depth in [vector database vs memory](/vector-database-vs-memory). ### The Problems Agents Hit Without a Dedicated Memory Layer - **Stale facts.** A vector store finds relevant past text but cannot tell that a fact was replaced. The agent can receive an outdated fact and act on it as if it were current. - **No dates or sources.** Without a record of when a fact was true and where it came from, the agent has no evidence to weigh conflicting facts, and engineers cannot trace a wrong answer back to its input. - **Recall that ignores who is asking.** If recall returns every matching fact regardless of the caller, one user's data can reach another user's session. - **No clean way to remove a source.** Deleting a document from an index does not remove the facts derived from it, so those facts can keep appearing in later answers. A memory API is a service that agents call to ingest information and recall what is relevant, with change, provenance, permissions and deletion handled behind the API. See [what is agent memory](/what-is-agent-memory) for a longer definition. ## Memory API vs RAG, Vector Databases and Markdown Files Most agents start with one of three approaches before they adopt a memory API: retrieval-augmented generation over a vector database, a Markdown file the agent reads and edits, or the full history sent again on every call. Each works at small scale, and each has a documented limit once facts change. | Approach | What it does well | Where it falls short as agent memory | |---|---|---| | RAG over a vector database | Retrieves text similar to the query from a static corpus, with predictable write cost and exact control of search settings | Treats a timestamp as one more metadata field, so it can return a replaced fact beside the current one | | Markdown memory files (such as CLAUDE.md or MEMORY.md) | Simple to read and edit; suited to standing instructions and stable preferences | When the agent rewrites a line, the earlier value and its date are lost; every agent that loads the file reads all of it; a large file gets summarized or searched without dates | | Sending the full history on every call | Needs no extra system for a short, single-session tool | Input tokens and cost grow with the history on every call | | Memory API | Returns the current value, the value it replaced and the dated source, scoped to the identity asking | Adds a service to call; a static, read-only corpus is served well by a plain vector index | The approaches combine. A team can keep standing instructions in a Markdown file, keep a vector index for a static document corpus, and send changing facts from email, tickets and transcripts to a memory API. A single-session tool whose context fits in the window needs no memory system, and a prototype with a handful of users can send its history again and defer the decision. past.dev's guide to [choosing a memory system](/guides/choose-memory-system) suggests five tests to run on your own data before reading any vendor's numbers: 1. A changed fact returns its current value and its prior value, both dated. 2. Backfilled history keeps its original timestamps. 3. One person's email, transcript and chat identities link to one subject. 4. The system abstains when the data cannot answer the question. 5. The cost holds at your real write and read volume. ## What Should You Look for in a Memory API for LLM Agents? The problems above point to five requirements. Each provider below is measured against them, along with its published accuracy results. - **Changing facts.** The API keeps the current value and the one it replaced. In past.dev, add `queryTimestamp` to a recall to read memory as it stood on a past date, or use `occurredFrom` and `occurredTo` to cover a period. - **Dated evidence in recall.** Each result carries content and dated source evidence, so a model can cite what it uses and abstain when the evidence is insufficient. past.dev's `/recall` response includes `asOf`, `usedEvidenceTokens` and `results`. - **Identity and audience scoping.** Each data point can name an audience, and each read names an identity. In past.dev, recall has no metadata filter; scoping comes from identity and audience. - **Ingest of existing data.** Emails, transcripts, tickets and documents go in as they are, with their original dates. `POST /api/v1/ingest/batch` accepts an ordered batch of up to 1,000 data points per call. - **Source-level deletion.** Deleting a source removes the memory derived only from it. The [Memory API docs](/docs/memory-api/overview) cover each of these in detail. ## How Do AI Startup Teams Give Agents Long-Term Memory with a Memory API? Engineering teams at AI startups and scale-ups often have a small group of engineers, an agent in production or close to it, and records spread across support tickets, chat logs, account notes and internal documents. The steps below show how such a team uses past.dev as the memory layer, with the endpoint behind each step. 1. **Ingest existing records as they are.** `POST /api/v1/ingest` accepts timestamped source text, source metadata, an audience and an author identity. Each record becomes a data point with its origin attached. 2. **Backfill history with original timestamps.** Ingest can be backdated, and `POST /api/v1/ingest/batch` takes up to 1,000 data points per call, so recall can use last quarter's records from the first day. 3. **Keep changing facts current.** When a customer moves to a new plan or a project gets a new owner, past.dev tracks the current value and the values it replaced, each with its date and source. 4. **Scope recall to each identity.** `POST /api/v1/recall` requires a `query` and an `identity`, and returns only what that identity can read. Audiences list identities or use rules over their traits ([access control](/docs/memory-api/access-control)). 5. **Ground answers in dated evidence.** The evidence budget sets how much recall returns: `low` 8,000 tokens (default), `medium` 16,000, `high` 24,000 and `extra-high` 32,000. The ceiling is 8,000 tokens on Pay as you go and Flex, and 32,000 on Enterprise. 6. **Honor deletion requests at the source.** `DELETE /api/v1/data-points/{sourceId}` removes one data point and every memory that rests only on it, and `DELETE /api/v1/ingest/{ingestionId}` removes everything accepted in one ingest call. A fact that other sources also support stays, backed by those remaining sources. With past.dev, the application decides which records enter memory. In Letta, the agent decides what to write. The two can be combined by calling past.dev from a Letta tool. ### Connecting past.dev to an Existing Stack past.dev adds memory to the agent stack a team already runs. Published integrations cover Zapier, n8n, the Vercel AI SDK, CrewAI, LlamaIndex and Dify, each with ingest and recall steps or tools, and in every one the application or workflow sets the identity ([integrations announcement](/blog/memory-integrations)). The [MCP server](/docs/mcp/overview) gives AI assistants access through OAuth, and open-source [plugins](/docs/plugins/overview) add recall to coding agents such as Claude Code, Codex and Cursor. All of them call the same Memory API. ## Competitor Comparison: Memory APIs for LLM Agents The table gives a side-by-side view of the seven memory APIs. Competitor descriptions come from each vendor's own docs, linked in the entries below, and prices carry the date they were checked. Prices change often, so check each vendor's pricing page before you commit. | Provider | How it handles long-term memory | Best fit | Deployment and entry pricing | |---|---|---|---| | past.dev | The application ingests emails, transcripts, tickets and documents with their dates. Recall returns what is true now, the value it replaced and dated source evidence, scoped to the identity asking | Agent teams that need current values with provenance and per-identity scoping | Managed, or Bring your own cloud on Enterprise. Pay as you go $0 a month with 50,000 starting credits (200,000 with a work email); Flex $99 a month (as of 18 November 2026) | | [mem0](https://docs.mem0.ai/) | An LLM extracts facts from messages on each add call and stores them additively, without overwriting or deleting earlier memories; search ranks the most relevant. Memory is keyed to `user_id`, `agent_id` and `run_id` | Per-user personalization with Python and TypeScript SDKs | Managed, or the Apache 2.0 open-source library and server. Free plan with 10,000 adds in the first 30 days and 1,000 retrievals, then usage-based overages with a cap you set; Custom plans set to your volume (as of 18 November 2026) | | [Zep](https://help.getzep.com/) | Facts in a temporal knowledge graph (Graphiti) with validity windows linked to source episodes | Teams that need to track when a fact was valid | Managed or VPC. 10,000 credits a month on Free; Flex $125 a month with 50,000 credits (as of 18 November 2026) | | [Letta](https://docs.letta.com/guides/agents/memory-blocks) | A stateful agent runtime: memory blocks in the prompt, an archival store, and tools the agent uses to rewrite its own memory | Teams that want memory and the agent runtime in one platform | Apache 2.0, or hosted. Free for up to 3 stateful agents; Pro $20 a month with $20 of credits and up to 20 agents (as of 18 November 2026) | | [Supermemory](https://supermemory.ai/docs/intro) | Turns chats and documents into versioned facts per user, plus a user profile and document retrieval | Assistant apps that need per-user facts and profiles | MIT-licensed repository; hosted API. Free $0 with $5 of monthly usage; Pro $19 a month with $20 of usage (as of 18 November 2026) | | [Hindsight](https://hindsight.vectorize.io/) | Retain, recall and reflect, over world facts, experiences, observations, mental models and knowledge pages | Teams that want agents to reflect on past experience and run memory themselves | MIT; Docker image or Hindsight Cloud, billed on token usage with no monthly fee | | [Cognee](https://docs.cognee.ai/getting-started/introduction) | Builds a knowledge graph with embeddings from supplied data; remember, recall, improve and forget since version 1.0 | Knowledge graphs over documents and data | Apache 2.0 engine, or Cognee Cloud: 1M tokens free, then $1 per 1M tokens processed | ## Best Memory APIs for LLM Agents in 2026 ### 1. past.dev past.dev is a memory layer API for LLM agents. Your application ingests data points, and each recall returns what is true now, what it replaced and the dated sources behind it, scoped to the identity asking. - **How it runs:** managed service, or Bring your own cloud (AWS, Google Cloud or Azure) on Enterprise. Self-hosting is not offered. Commercial engine; the agent plugins and the benchmark harness are open source. - **Published results:** first on BEAM at every history size among published results, in a run of 29 September 2026: 92.08% at 100K tokens, 89.63% at 500K, 90.65% at 1M and 85.03% at 10M. The results are self-reported, and the [harness is public](https://github.com/pastdotdev/benchmarks); competitor figures come from separately published runs, so setups differ. On DolphinBench, past.dev's self-administered run with Hermes Agent passed 490 of 600 tasks (81.7%), against 424 (70.7%) for Mem0's official run; DolphinBench has not run or verified past.dev's result. Full results are on the [benchmarks page](/benchmarks). - **Pricing (as of 18 November 2026):** Pay as you go is $0 a month and starts with 50,000 credits (200,000 with a work email), no card required. One credit buys 350 bytes of ingested payload, and a recall costs 1 credit. Flex is $99 a month with 400,000 credits and unlimited recall within fair use. Enterprise is custom. Storage, entities and seats are not metered. Eligible early-stage startups can apply for six months of Flex at no charge. See [pricing](/pricing). - **Pros:** current and previous values with dates and sources; recall scoped by identity and audience; backdated batch ingest; deletion that removes derived memory; SOC 2 Type II audited, ISO 27001 and ISO 27701 certified, and no customer data used to train models. - **Cons:** no agent runtime, so teams that want a managed agent loop pair it with a runtime such as Letta; no self-hosting; recall has no metadata filter. past.dev has no published LongMemEval result. Choose past.dev if your agent must answer from the current value of changing facts, cite a dated source for each answer and keep each user's memory separate. ### 2. mem0 [mem0](https://docs.mem0.ai/) is a memory layer with Python and TypeScript SDKs. On each add call, an LLM extracts facts from messages and stores them additively, without overwriting or deleting earlier memories; search then ranks the most relevant. Memory is keyed to `user_id`, `agent_id` and `run_id`. - **How it runs:** managed platform, or the open-source library and server on your own infrastructure. Apache 2.0 licence. - **Published results:** BEAM 64.1% at 1M tokens and 48.6% at 10M, with no figure at 100K or 500K. LoCoMo 92.5 (mem0 does not name the answer key used, so comparisons with other LoCoMo figures are indicative). DolphinBench, which mem0 created: 424 of 600 tasks (70.7%) with Hermes Agent. - **Pricing (as of 18 November 2026):** Free includes 10,000 add requests in the first 30 days (50,000 with your own LLM key) and 1,000 retrieval requests (10,000 with your own LLM key). Beyond those limits, usage is billed with a monthly cap you set, or you move to a Custom plan. - **Pros:** widely used, with SDKs in two languages and several deployment paths. - **Cons:** BEAM results fall from 64.1% at 1M tokens to 48.6% at 10M; new memories are added alongside older ones rather than replacing them, so retrieval has to rank the current fact; self-hosted installs need a vector store the team configures. Choose mem0 if you want per-user personalization from conversations and a free allowance to start on a managed service. ### 3. Zep [Zep](https://help.getzep.com/) is a managed memory service built on Graphiti, a temporal knowledge graph in which each fact carries a validity window and a link to its source episode. Graphiti is also available as a separate Apache 2.0 framework that a team runs on its own graph database. - **How it runs:** managed service or VPC. Zep's README says Zep Community Edition is no longer supported. - **Published results:** Zep publishes no BEAM or DolphinBench result. - **Pricing (as of 18 November 2026):** 10,000 credits a month on Free, Flex $125 a month with 50,000 credits, Flex Plus $375 a month with 200,000 credits, and custom Enterprise. A credit covers an episode of up to 350 bytes, and retrieval is not metered. - **Pros:** a time-aware fact model in the core product; unmetered retrieval suits read-heavy agents. - **Cons:** Graphiti on its own means operating a graph database; credit allowances step up in large increments between tiers. Choose Zep if you want a managed temporal graph and expect reads to far outnumber writes. ### 4. Letta [Letta](https://docs.letta.com/guides/agents/memory-blocks), formerly MemGPT, is a platform for stateful agents. A Letta agent keeps memory blocks in its prompt, an archival store it can query, and tools that let it rewrite its own memory. Letta also runs the agent loop, tool execution and state. - **How it runs:** hosted plans, or the open-source code on your own infrastructure. Apache 2.0 licence. - **Published results:** none published. - **Pricing (as of 18 November 2026):** Free for up to 3 stateful agents with your own API keys. Pro is $20 a month with $20 of monthly model credits and up to 20 stateful agents. Server-side tool execution costs $0.00015 per second. - **Pros:** agent runtime and memory in one system. - **Cons:** memory quality depends on the agent's own edits to its blocks, and adopting Letta's memory means adopting its runtime. Choose Letta if the agent runtime should own memory. It can also call past.dev from a Letta tool. ### 5. Supermemory [Supermemory](https://supermemory.ai/docs/intro) is context infrastructure for agents. It turns chats, documents and other content into versioned facts per user, with a user profile and document retrieval, and offers connectors for sources such as Google Drive, Gmail, Notion, OneDrive, GitHub and Granola. It has no Slack connector. - **How it runs:** hosted API. MIT-licensed repository. - **Published results:** DolphinBench 355 of 600 tasks (59.2%) with Hermes Agent, in Mem0's run. No BEAM figure is published. - **Pricing (as of 18 November 2026):** Free $0 with $5 of monthly usage, Pro $19 a month with $20 of usage, Max $100 a month, Scale $399 a month, and custom Enterprise. - **Pros:** built-in source connectors and per-user profiles. - **Cons:** the Gmail connector comes with the Max plan ($100 a month); usage-based tiers need monitoring as volume grows. Choose Supermemory if you want built-in source connectors and per-user profiles from one hosted API. ### 6. Hindsight [Hindsight](https://hindsight.vectorize.io/) is Vectorize's agent memory system. It exposes retain, recall and reflect, and organizes memory into world facts, experiences, observations, mental models and knowledge pages. Reflect generates a response from memory. Each query runs semantic, keyword, graph and temporal retrieval, then fuses and reranks the results. - **How it runs:** a Docker image, a Python server or an embedded library on your own infrastructure, or Hindsight Cloud. MIT licence. - **Published results:** BEAM 86.2% at 100K tokens, 80.1% at 500K, 79.1% at 1M and 64.1% at 10M, from agentmemorybenchmark.ai. DolphinBench 417 of 600 tasks (69.5%). - **Pricing:** free to run on your own infrastructure. Hindsight Cloud is pay as you go on token usage, with no monthly fee. - **Pros:** the second-highest published BEAM results at 100K and 500K tokens; several deployment shapes. - **Cons:** running it yourself means operating PostgreSQL with pgvector or Oracle; five memory types add concepts to learn. Choose Hindsight if you want open-source memory you run yourself, with an agent that reflects on its own experience. ### 7. Cognee [Cognee](https://docs.cognee.ai/getting-started/introduction) is an open-source engine that builds a knowledge graph with embeddings from supplied data. Version 1.0 (26 June 2026) added a simpler API with remember, recall, improve and forget alongside the lower-level pipeline. - **How it runs:** the open-source engine in infrastructure you operate, or Cognee Cloud, with Enterprise delivered in your own cloud. Apache 2.0 licence. - **Published results:** none cited here. - **Pricing:** Cognee Cloud includes 1M tokens a month at no charge, then $1 per 1M tokens processed, with extra workspaces at $5 a month. Enterprise is custom. - **Pros:** knowledge graph on every tier, including the free engine. - **Cons:** bi-temporal memory and per-answer provenance are on the Enterprise tier; billing depends on ingest volume. Choose Cognee if you want to build and query a knowledge graph over your documents in infrastructure you control. ## Evaluation Rubric for Memory APIs for LLM Agents Score every memory API on the same categories, each tied to a failure that shows up in production: wrong answers at long history, stale facts, unexplained results, leaks across users and data that survives deletion. | Category | High performance use case | Measurable outcome | |---|---|---| | Accuracy at long history | The agent answers correctly after months of conversations and documents | BEAM score at each history size, from 100K to 10M tokens, with the run date and who ran it | | Changing facts | A user changes plan, address or owner, and the agent uses the new value | Recall returns the current value and the value it replaced; as-of reads return what was true on a given date | | Evidence and provenance | An engineer can trace why the agent said something | Share of recall results with a dated source attached | | Access scoping | Several users or teams share one agent without seeing each other's data | A test query from one identity returns no data points owned by another | | Deletion | A customer asks for their data to be removed | A recall after deleting a source returns no memory derived only from it | | Ingest of existing data | A team loads its history on day one | Backdated ingest supported (yes or no); items per batch call | | Integration | The memory layer fits the agent runtime already in use | SDK languages, MCP server (yes or no), documented frameworks | | Pricing and data use | Costs stay predictable and data stays out of model training | Metering unit, unmetered dimensions and the training policy for the plan you will run | When you read a published benchmark, check four things: the history size, the date of the run, whether the harness is public, and whether a difference is stated in percentage points or relative percent. Most memory results across vendors are self-reported, including past.dev's, whose BEAM harness is public in the pastdotdev GitHub organization. ## How to Read Memory Benchmark Results Four benchmarks appear most often in memory API comparisons. They test different things, so a score on one says little about another. | Benchmark | What it tests | Scale | past.dev's published result | |---|---|---|---| | BEAM | Ten memory abilities, including temporal reasoning, contradiction resolution and multi-session reasoning | 2,000 questions over 100 conversations, at 100K, 500K, 1M and 10M tokens of history | 92.08% (100K), 89.63% (500K), 90.65% (1M), 85.03% (10M); self-reported, harness public | | LoCoMo | Recall over long multi-session dialogues | About 1,540 questions over 10 conversations of about 9K tokens each | 93.12% on the community-corrected answer keys (run of 16 September 2026) | | LongMemEval | Recall, knowledge updates and abstention over chat history | 500 questions over about 1.5M tokens | None published | | DolphinBench | Whether an agent takes the right action, using memory, across simulated work histories | 600 tasks across three personas | 490 of 600 with Hermes Agent (self-administered and absent from DolphinBench's leaderboard) | BEAM is the largest public memory benchmark: its conversations reach 10M tokens, against about 1.5M for LongMemEval and about 9K per conversation for LoCoMo. LoCoMo scores sit close together near the top. mem0 reports 92.5, and its page does not name the answer key used, so LoCoMo comparisons are indicative. DolphinBench is Mem0's benchmark. On its official Hermes Agent configuration, Mem0's own memory has the best official result, 424 of 600 tasks. On its official Claude Code configuration with Claude Sonnet 5, Honcho leads at 35.8%, and past.dev has not run that configuration ([DolphinBench results](/benchmarks/dolphinbench)). Published results also show where each system is weaker. past.dev's lowest BEAM ability is multi-session reasoning: 68.95% at 100K tokens and 28.17% at 10M. Contradiction resolution scores between 73.13% and 78.57% across the four sizes, and information extraction is 68.75% at 10M. Six abilities stay above 90% at every size: abstention, event ordering, instruction following, preference following, summarization and temporal reasoning. The per-ability breakdown is on the [benchmarks page](/benchmarks). ## Which Memory API Fits Your Use Case? The right memory API depends on who writes memory, who reads it and how often facts change. The table maps common agent types to the tools in this list. | Use case | What the memory layer must do | Tools to evaluate first | |---|---|---| | Customer support assistant | Join tickets, calls, email and billing events for one customer; return the current plan with its date | past.dev, Zep | | Company brain or internal agent | Ingest email, meetings, tickets and chat at their real dates; scope each read to what an employee may see | past.dev, Zep | | Personalized assistant app | Keep facts and preferences per user from conversations | mem0, Supermemory, past.dev | | Agent that manages its own memory | Let the agent decide what to write and rewrite | Letta | | Open-source memory you operate | Run the engine on your own infrastructure | Hindsight, Cognee, mem0's open-source server, Graphiti | | Coding agents | Carry project decisions across sessions, machines and tools | past.dev plugins, claude-mem for one machine | ### Customer Support Assistants A support assistant answers from tickets, calls, email and billing, which usually carry different identifiers for the same customer. With past.dev, the application sends each record to `POST /api/v1/ingest` with its original date, calls `POST /api/v1/recall` when a conversation opens, and adds the returned evidence to the prompt. When a plan changes in June, recall returns the June entitlement with its date and keeps the May entitlement as history. Restricted material gets an `audience`, so recall leaves it out for identities outside that audience. See [memory for customer support agents](/use-cases/customer-support). ### Company Brains and Internal Agents A company brain is shared memory over an organization's own records. past.dev's [company brain guide](/guides/build-a-company-brain) lists four properties it needs: ingestion from real sources at their real times, one identity per person and project, changed facts that supersede earlier ones, and answers with dated evidence that abstain when the records cannot answer. The guide recommends starting with meetings and email, which carry the densest decision history, and scoping recall to audiences at the memory layer rather than in prompt instructions. ### Personalized Assistants mem0 and Supermemory extract facts from conversations and keep them per user, which suits assistants that adapt to one person's preferences. past.dev fits when those preferences change and the assistant needs the current value with the date it changed, or when several people share one assistant and each read must stay scoped to the person asking. ### Agents That Write Their Own Memory A Letta agent edits its own memory blocks and searches an archival store with tools, so the agent decides what to keep. Teams that want the application to decide what enters memory can call past.dev from a Letta tool, and the two run together. ### Open-Source Memory You Operate Hindsight (MIT), Cognee (Apache 2.0), mem0's open-source library and server (Apache 2.0) and Graphiti (Apache 2.0) can all run on your own infrastructure. That means operating the database and the engine, and usually supplying a model provider key. past.dev runs as a managed service, or on an Enterprise agreement in your own AWS, Google Cloud or Azure account. Self-hosting is not offered. ### Coding Agents For Claude Code, Codex, Cursor and other coding agents, past.dev offers open-source plugins that send sessions to a project and recall memory into prompts, plus a remote MCP server. Claude Code and Codex also have built-in memory: CLAUDE.md files and auto memory in Claude Code, and memory v2 in Codex. claude-mem keeps one developer's session memory on one machine. ## Why past.dev Is the Best Memory API for LLM Agents The seven tools take different approaches. mem0 and Supermemory extract facts per user. Zep and Cognee build knowledge graphs. Letta is an agent runtime. Hindsight combines several retrieval strategies that you can run yourself. past.dev combines superseded-value tracking, dated source evidence, identity and audience scoping, backdated ingest and source-level deletion behind four core endpoints, and it ranks first on BEAM at every history size among published results, including 85.03% at 10M tokens against mem0's 48.6% (both self-reported; past.dev's harness is public). past.dev is SOC 2 Type II audited, ISO 27001 and ISO 27701 certified, and GDPR compliant, and it does not use customer data to train models. [Get API key](https://sso.past.dev/sign-up) to test recall on your own data. ## FAQs About Memory APIs for LLM Agents ### What Is the Best Memory API for LLM Agents in 2026? past.dev ranks first on BEAM, the largest public memory benchmark, at every history size among published results: 92.08% at 100K tokens, 89.63% at 500K, 90.65% at 1M and 85.03% at 10M (run of 29 September 2026). The results are self-reported, and the harness is public. Its recall returns the current value of each fact, the value it replaced and the dated source, scoped to the identity asking. ### How Is a Memory API Different from RAG or a Vector Database? A vector database finds text similar to a query, and a timestamp is only metadata, so it can return a fact that was later replaced. A memory API keeps facts current across sessions: past.dev returns what is true now, what it replaced and where it came from. Vector databases remain a good fit for predictable write cost and exact control of search settings. ### How Should I Read Self-Reported Memory Benchmark Results like BEAM? Compare results at the same history size, and check the run date, who ran it and whether the harness is public. mem0 publishes BEAM results only at 1M (64.1%) and 10M (48.6%), and Zep publishes none. past.dev's BEAM results are self-reported with a public harness, so anyone can rerun them. ### How Does past.dev Handle Facts That Change over Time? past.dev keeps the current value of a fact and the previous values it replaced, each with its date and source. Add `queryTimestamp` to a recall to read memory as it stood on a past date, or use `occurredFrom` and `occurredTo` to cover a period. ### How Do I Delete Data from an AI Agent's Long-Term Memory for GDPR Requests? In past.dev, call `DELETE /api/v1/data-points/{sourceId}` for each data point linked to the person, using the source ids you sent at ingest. This removes those data points and every memory that rests only on them, while facts that other sources support keep their remaining evidence. Use `DELETE /api/v1/ingest/{ingestionId}` only when everything in one ingest call should go, since a batch can hold up to 1,000 data points. past.dev is GDPR compliant. ### How Much Do Memory APIs for AI Agents Cost in 2026? As of 18 November 2026, past.dev's Pay as you go plan is $0 a month with 50,000 starting credits (200,000 with a work email), and Flex is $99 a month. Elsewhere, Zep Flex is $125 a month, Letta Pro and Supermemory Pro are $20 and $19 a month, mem0 has a free plan and custom pricing, and Cognee Cloud charges $1 per 1M tokens after 1M free tokens a month. ### I'm a Startup Building AI Agents. Which Memory API Should We Use? Start with the requirement your agent fails without. If facts change, several users share the agent, or answers need a dated source, test past.dev: Pay as you go is $0 a month and starts with credits (more with a work email, no card required), and eligible early-stage startups can apply for six months of Flex at no charge ([startup program](/startup-program)). For per-user personalization on a managed service, test mem0 or Supermemory. If you must run the engine yourself, test Hindsight or Cognee. ### Which Memory Layer Should I Use for My AI App? Choose by who writes memory and who reads it. If your application decides what to ingest and many users read it, a memory API such as past.dev scopes each recall to the identity asking and returns dated sources. If one user's preferences drive the app, a per-user fact store such as mem0 or Supermemory fits. If the agent itself should decide what to remember, Letta's agent runtime does that. ### Does past.dev Work with My Existing Agent Framework? Yes. Published integrations cover the Vercel AI SDK, CrewAI, LlamaIndex, Zapier, n8n and Dify, and any stack can call `POST /api/v1/ingest` and `POST /api/v1/recall` directly. In each integration the application sets the identity, so recall returns only what that identity can read. Coding agents connect through plugins or the remote MCP server. ### Is past.dev Open Source? The past.dev engine is commercial. Self-hosting is not offered. The agent plugins, the integration packages and the benchmark harness are open source. past.dev runs as a managed service or, on an Enterprise agreement, in your own AWS, Google Cloud or Azure account.