--- title: "Cheapest Memory APIs for AI Agents (2026)" description: "Compare 2026 memory API pricing for production AI agents: past.dev, mem0, Zep, Honcho and others on cost per task, tokens per recall and billing." canonical: https://past.dev/blog/cheapest-memory-apis-for-ai-agents date: 2026-11-19 last-updated: 2026-11-19 category: Engineering authors: The past.dev team --- # Cheapest Memory APIs for AI Agents (2026) The cheapest memory API for a production AI agent is the one with the lowest cost per passed task at your traffic, because vendors meter different units: ingested bytes or tokens, retrievals, or active agents. past.dev publishes a measured cost per task. Codex memory v2 is an upgrade over v1, and with the past.dev plugin added to v2, each passed task cost 54% less and Codex read 41% fewer input tokens per task (600 DolphinBench tasks, run by past.dev). Zep and Honcho leave reads unmetered, which suits read-heavy agents. This comparison covers nine memory APIs on how each one bills, its entry price, the tokens each recall returns and any speed figure it publishes, with the date each price was checked. ## Why Production AI Agents Need a Low-Cost Memory API An agent without a memory layer resends its history on every call, so input tokens grow with the history. A memory layer ingests history once and returns only the evidence a call needs. Three other costs show up in production: - **Per-retrieval metering.** mem0's Free plan includes 1,000 retrieval requests (10,000 with your own LLM key), so an agent that recalls on every turn uses that allowance quickly. Beyond it, usage is billed with a monthly cap you set, or you move to a Custom plan. - **Ingestion delay.** Zep's documentation says ingestion can take a few minutes, and recent messages can be missing from the Context Block during that window. - **Input tokens per task.** Every token an agent sends to its model is billed at that model's input price, on every call. The size of each recall decides how much of that bill memory adds. To price tokens for your own model, use the [token cost calculator](/tools/token-cost-calculator). ## What to Look for in a Memory API for Production AI Agents We judged every entry, past.dev included, on five criteria. 1. **Pricing meter fit.** Some APIs bill mainly for ingest and others for retrieval. The cheaper one depends on whether your agents write more than they read. 2. **Tokens per recall.** An evidence budget is the maximum number of tokens one recall returns to your agent. A bounded budget keeps input tokens per task flat as history grows. 3. **Published speed and accuracy.** A useful figure states its metric, history size, date and who ran it. 4. **Freshness.** New data should be available for recall soon after it is written. 5. **Access scoping and deployment.** Recall should be scoped to the identity asking, and the data should live in a cloud account your rules allow. ## How AI Engineering Teams Lower Agent Cost per Task with a Memory Layer Teams lower cost per task in three steps. They ingest history once, with each record's original timestamp. They recall a capped page of evidence at each agent step instead of passing transcripts into the prompt. They choose the plan whose meter matches their read and write volume. On past.dev, `POST /api/v1/ingest/batch` accepts up to 1,000 data points per call. Recall takes an evidence budget from `low` (8,000 tokens, the default) to `extra-high` (32,000), capped by plan. The `usedEvidenceTokens` field reports what each page carried, so teams can log prompt size per agent step. See the [Memory API docs](/docs/memory-api/overview). ## Competitor Comparison: Memory APIs for Production AI Agents The table summarizes how each vendor bills and which speed figure it publishes. Prices change often, so check each vendor's pricing page before you commit. | Provider | How it bills | Entry and next tier | Published speed figure | Best fit | |---|---|---|---|---| | past.dev | Credits on ingest (1 credit = 350 bytes). Recall is 1 credit on Pay as you go and unlimited within fair use on Flex and Enterprise | Pay as you go $0 a month with starting credits; Flex $99 a month | No API latency figure. Median Codex task time 30 s with past.dev added to memory v2, against 40 s for v2 alone (run by past.dev) | Long histories where input tokens per task drive cost | | [mem0](https://docs.mem0.ai/) | Add and retrieval allowances | Free (10,000 adds in the first 30 days, 1,000 retrievals), then usage-based overages; Custom plans set to your volume | p50 0.148 s, p95 0.200 s (mem0 paper) | Getting started on a managed service | | [Zep](https://help.getzep.com/) | 1 credit per episode of up to 350 bytes; retrieval not metered | 10,000 credits a month on Free; Flex $125 a month | Context Block under 200 ms p95 (Zep docs) | High read volume | | Honcho | $2.00 per 1M ingested tokens; context reads not charged | $5 in starting credits | About 200 ms for context reads | Read-heavy agents | | [Cognee](https://docs.cognee.ai/getting-started/introduction) | $1.00 per 1M tokens processed, plus $5 per extra workspace a month | Free tier with 1M tokens | Not published | Processing documents into memory | | [Supermemory](https://supermemory.ai/docs/intro) | $5 per 1M plain-text tokens, $10 per 1M rich-content tokens | Free $0; Pro $19 a month | 187 ms median recall (pricing page) | Token-based ingest pricing | | [Hindsight](https://hindsight.vectorize.io/) | Token usage on Hindsight Cloud | Pay as you go, no monthly fee | Under 100 ms recall (Vectorize site) | Open-source code with a usage-billed cloud | | [Letta](https://docs.letta.com/guides/agents/memory-blocks) | Plan fee with model credits; server-side tool time at $0.00015 a second | Free $0 (3 stateful agents); Pro $20 a month with $20 of credits | Not published | Stateful agents on Letta's platform | | [LangMem](https://langchain-ai.github.io/langmem/) | No hosted fee; you pay for model calls and storage | $0 (MIT SDK) | Not published by LangMem | LangGraph teams running memory in their own stack | ## Cheapest Memory APIs for Production AI Agents in 2026 Each entry uses the same fields, with prices from vendor pages and the date each was checked. ### 1. past.dev past.dev is a memory layer API for AI agents. It returns what is true now, what it replaced and where it came from, scoped to the identity asking. - **How it runs:** managed service on every plan; Bring your own cloud (AWS, Google Cloud or Azure) on Enterprise. Commercial engine; the agent plugins and the benchmark harness are open source. - **Pricing (as of 18 November 2026):** Pay as you go is $0 a month with starting credits, more with a work email, no card required. Flex is $99 a month with 400,000 credits. Enterprise is custom. Storage and seats are never metered. See [pricing](/pricing). - **Tokens per recall:** at most 8,000 on Pay as you go and Flex, and up to 32,000 on Enterprise, whatever the size of the history. - **Published results:** with the past.dev plugin added to Codex memory v2 on GPT-6.1 Sol, Codex passed 85.8% of 600 tasks, read 41% fewer input tokens per task, each passed task cost 54% less ($0.055 against $0.119), and the median task was 25% faster ([Codex results](/blog/codex-memory-v2-past-dev), run by past.dev). With Claude Code on DolphinBench tasks (not an official score), 519 of 599 tasks were done right at $0.13 a task with past.dev, against 323 at $0.27 without. On BEAM, past.dev ranks first at every history size among published results, including 90.65% at 1M tokens and 85.03% at 10M; these results are self-reported, and the [harness is public](https://github.com/pastdotdev/benchmarks). - **Limits:** no published API latency figure. On DolphinBench with Hermes Agent, past.dev's self-administered run (absent from DolphinBench's leaderboard) cost $196.72 with a 51.6 s median, against $96.21 and 37.7 s for mem0's official run. - **Best for:** agents with long histories, where input tokens per task drive cost. ### 2. mem0 mem0 is a memory layer for agents, metered by add and retrieval requests on its managed platform. mem0 also created DolphinBench. - **How it runs:** managed platform, or the open-source library and server. Apache 2.0 licence. - **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 set to your volume. - **Published results:** retrieval p50 0.148 s and p95 0.200 s, from the mem0 paper. BEAM 64.1% at 1M. DolphinBench (Hermes Agent, GPT 5.6 Luna) 70.7% at $96.21 total cost. - **Best for:** teams that want to start on a managed service with a free allowance. ### 3. Zep Zep is a managed memory service built on Graphiti. It bills 1 credit per episode of up to 350 bytes, and agents read memory through a Context Block. - **How it runs:** managed service. Graphiti, the framework underneath, is Apache 2.0. - **Pricing (as of 18 November 2026):** 10,000 credits a month on Free. Flex $125 a month (50,000 credits, then $25 per 10,000). Flex Plus $375 a month (200,000 credits). Memory, retrieval, storage and users are not metered. - **Published results:** Context Block under 200 ms p95 (Zep docs), and 162 ms p95 on LongMemEval. Ingestion can take a few minutes before new messages appear. - **Best for:** read-heavy agents, since recall volume does not change the bill. ### 4. Honcho Honcho, from Plastic Labs, is a memory service priced on ingested tokens. It separates context reads from reasoning queries. - **How it runs:** your own infrastructure or Honcho Cloud. AGPL-3.0 licence. - **Pricing (as of 18 November 2026):** $2.00 per 1M ingested tokens. Context reads cost nothing. Reasoning queries cost $0.001 to $0.50 each. New accounts get $5 in credits. - **Published results:** about 200 ms for context reads. BEAM 63.1% at 1M (separately published run). DolphinBench 68.5%. - **Best for:** agents that read context far more often than they write it. ### 5. Cognee Cognee is an open-source engine that builds a knowledge graph with embeddings from supplied data. Cognee Cloud prices it on tokens processed, with workspaces as a second billing unit. - **How it runs:** the open-source engine on your own infrastructure, or Cognee Cloud, with bring your own cloud on Enterprise. Apache 2.0 licence. - **Pricing (as of 18 November 2026):** Free tier with 1M tokens and one workspace. Standard is $1.00 per 1M tokens plus $5 per extra workspace a month. - **Published results:** no published latency or accuracy figure. - **Best for:** teams processing documents into memory. Bi-temporal memory and per-answer provenance require Enterprise. ### 6. Supermemory Supermemory is a hosted context API that charges per million ingested tokens, with plan fees that include credits. - **How it runs:** hosted API. MIT-licensed repository. - **Pricing (as of 18 November 2026):** Free $0, Pro $19, Max $100 and Scale $399 a month, with $5, $20, $130 and $600 in included credits. Ingest costs $5 per 1M plain-text tokens and $10 per 1M rich-content tokens. - **Published results:** 187 ms median recall (pricing page). DolphinBench 59.2% (Mem0's run). - **Best for:** teams that want token-based ingest pricing. ### 7. Hindsight Hindsight, from Vectorize, is open-source agent memory with retain, recall and reflect. It reached version 1.0 in October 2026. - **How it runs:** your own infrastructure or Hindsight Cloud. MIT licence. - **Pricing (as of 18 November 2026):** Hindsight Cloud is pay as you go on token usage, with no monthly fee or seats. New accounts get $5 of credit. Per-token rates are on Hindsight's pricing page. - **Published results:** BEAM 79.1% at 1M (separately published run). DolphinBench 69.5%. Vectorize states that recall returns in under 100 ms. - **Best for:** teams that want open-source code with a usage-billed cloud option. ### 8. Letta Letta is a platform for stateful agents, with memory blocks the agent edits itself. - **How it runs:** Letta's platform, or the open-source code on your own infrastructure. Apache 2.0 licence. - **Pricing (as of 18 November 2026):** Free $0 with up to 3 stateful agents and your own API keys. Pro $20 a month with $20 of monthly model credits and up to 20 stateful agents. Server-side tool execution costs $0.00015 per second. - **Published results:** no published latency or accuracy figure. - **Best for:** teams building stateful agents on Letta, where cost scales with agent count and model usage. ### 9. LangMem LangMem is LangChain's SDK for extracting memories into a LangGraph store the application operates. - **How it runs:** inside your LangGraph application. MIT licence. - **Pricing:** no hosted fee. Model calls, storage and engineering time are separate costs. - **Published results:** LangMem publishes no latency or accuracy figure. - **Best for:** LangGraph teams running memory jobs in their own stack. ## Evaluation Rubric for Memory APIs for Production AI Agents Score each shortlisted API on the same measurable outcomes before you commit. The rubric carries no weights, so rank the rows against your own workload. | Category | Measurable outcome | |---|---| | Pricing meter fit | Cost per passed task at your expected ingest and recall volume | | Step-ups | Monthly cost at current volume and at about 10 times that volume | | Tokens per recall | Input tokens per task | | Latency | p50 and p95 retrieval latency, with the method (production API or open-source code) | | Freshness | Time until new data is available for recall | | Accuracy | Score at a stated history size, with the runner named | | Scoping and deployment | Whether recall is scoped to the identity asking, and which cloud account holds the data | Method note: figures come from each vendor's own pages, docs and papers, checked September to November 2026. Benchmark runs by different parties used different setups. ## Why past.dev Is the Best Memory API for Production AI Agents on Cost per Task past.dev makes its case on cost per passed task, the measure this comparison ranks on. Its evidence is the Codex test in the past.dev entry above. Codex memory v2 is itself an upgrade over v1: it passed 66.3% of the tasks, against 49.7% for v1. The past.dev plugin was added on top of v2 ([Codex results](/blog/codex-memory-v2-past-dev), run by past.dev; Mem0 has not run or checked these results). The billing model serves the same goal. Storage, memories, entities and seats are not metered on any plan, so the bill follows ingest volume and, on Pay as you go, recall count. Choose mem0 or Supermemory if a free starting allowance or a low monthly entry price matters most. Choose Zep or Honcho if reads dominate your traffic. Choose past.dev if input tokens per task drive your bill and each answer needs dated sources. [Get API key](https://sso.past.dev/sign-up) and measure cost per task on your own agent's history. ## Frequently Asked Questions ### What Is the Cheapest Memory API for Production AI Agents? The cheapest option is the one with the lowest cost per passed task at your volume. That depends on which unit each vendor meters (ingest, retrievals or agents) and on how often your agents write and read. Zep and Honcho do not meter reads, so read-heavy agents on those services pay mostly for ingest. past.dev publishes a measured cost per passed task in its [Codex results](/blog/codex-memory-v2-past-dev). ### Does a Memory API Make an Agent Faster? It can, by shrinking what the model reads on each call. With the past.dev plugin added to Codex memory v2, the median task took 30 s against 40 s for v2 alone (run by past.dev). For retrieval latency on its own, the mem0 paper reports 0.148 s p50 for mem0, Zep's docs state under 200 ms p95 for its Context Block, Supermemory states 187 ms median recall, and Vectorize states under 100 ms for Hindsight; past.dev publishes no API latency figure. ### How Does past.dev Keep Token Costs Bounded? Each recall returns one page of evidence. That page holds at most 8,000 tokens on Pay as you go and Flex, and up to 32,000 on Enterprise, whatever the size of the history behind it. The `usedEvidenceTokens` field reports what each page carried. ### Are past.dev's BEAM Results Independent? past.dev's BEAM results are self-reported, and the harness is public. Competitor rows come from separately published runs with different models, judges and configurations. See the [benchmarks page](/benchmarks).