Supermemory alternatives for developers: memory APIs

This page is about Supermemory the developer API: a memory and context engine you add chat, documents and files to, then search or inject into your prompt. If you were looking for the consumer app that gave ChatGPT and Claude a shared memory, Supermemory closed it on 9 September 2026 (notice); people using assistants are now pointed to its MCP server.

We make Threadless AI, one of the options below. Its row is written by us, so read it with that in mind; we also say where it is the wrong choice. Every other fact comes from the vendor's own documentation, linked, as checked on the date above.

Short answer

• Stay on Supermemory if your agent needs a user's documents, files and connected apps in one memory, across conversations and products.
• Mem0 if you want a widely used user-memory store with an open-source edition.
• Zep if facts change over time and you need to ask what held when.
• Cognee or Hindsight if you want an open-source memory server you host yourself.
• Honcho if you want token-bounded history and summary handed back in OpenAI message format.
• Letta if you would rather the platform run the whole agent.
• Threadless AI if one long conversation with an OpenAI agent keeps running out of context and you want the whole request managed, not memories to fit into a prompt.

Why developers look for a Supermemory alternative

Supermemory is a capable store, and the reasons people look elsewhere are specific:

• The proxy is gone from the docs. Supermemory once offered Infinite Chat, later the Memory Router: a proxy in front of your OpenAI base URL that backfilled a conversation's history from a conversation id. Its announcement now opens with a notice that it describes the 2025 release, not the current v5 API, and the router's documentation pages redirect to an SDK integration (announcement). Teams that relied on it want something that manages the request.
• The current product does not manage your history. The OpenAI wrapper withSupermemory injects relevant memories into the system prompt and saves conversations; you still send messages (OpenAI integration). The growing chat log is still yours to trim.
• The server is not open source. "The SDKs and other components in the public repository are open source; the downloadable self-hosted server binary is built from a separate, non-public codebase." The self-hosted server is free up to 10,000 stored documents, and larger dedicated deployments are an enterprise arrangement (self-hosting, local vs enterprise).
• Its models write the memories. Supermemory's own models decide "what and how to learn, what is important, when to forget" (how it works). Some teams prefer the model that was in the conversation to write them.

At a glance

The alternatives

Mem0

A memory layer you add messages to and search: its LLM extracts facts when you add, and your code places the results in the prompt (how it works). Memories are scoped by user, agent, app or run (entity-scoped memory). Its open-source edition is Apache-2.0, but graph memory is now a platform feature that was dropped from it (platform vs OSS). The hosted plans are Free and Custom, and graph memory is listed only under Custom (pricing). Choose it over Supermemory when you want a self-hostable core and do not need documents and connectors in the same memory. See Threadless AI vs Mem0.

Zep

A context platform built on Graphiti, a temporal knowledge graph whose facts carry validity dates (facts). You add messages to a user's threads and get back a context block to place in your prompt (retrieving context). Zep stopped maintaining its Community Edition in April 2025 (announcement); Graphiti remains Apache-2.0 and needs a graph database such as Neo4j or FalkorDB (Graphiti). Hosted plans run on credits: 10,000 a month free, Flex at $125 a month (pricing). Choose it over Supermemory when the question is how a fact changed, not just what it is now. See Threadless AI vs Zep.

Letta

A platform that runs stateful agents. The agent edits its own memory files, versioned in git, and Letta summarises older messages as the context fills (MemFS, conversations). Apache-2.0 and self-hostable. Free covers up to 3 agents with your own keys; Pro is $20 a month (pricing). Choose it over Supermemory when you want the platform to run the agent loop, not just hold its memory. See Letta alternatives.

Cognee

An Apache-2.0 memory layer that builds a knowledge graph plus vectors, as a Python library, CLI, REST server or MCP server (introduction). Its pipeline calls an LLM to extract entities and relationships; dates become timestamp nodes for temporal search. Cloud is free for 1M tokens, then $1.00 per 1M tokens processed (pricing). Choose it over Supermemory when you want a graph you host and can inspect, with documents in it.

Honcho

An AGPL-3.0 memory library with a managed service that reasons about each user in the background (overview). Its session.context(tokens=N) returns "a blend of summary and messages which covers the entire session history", convertible to OpenAI format; you still make the model call (get context). Ingestion is $2.00 per 1M tokens and context reads are free (homepage). Choose it over Supermemory when you want history and summary handed back within a token budget.

Hindsight

Vectorize's MIT-licensed memory system: retain, recall and reflect against isolated memory banks, one per user or agent (docs). Recall runs semantic, keyword, graph and temporal search in parallel. Cloud retain is $10.00 per 1M input tokens and recall $0.75 per 1M output tokens (billing). Choose it over Supermemory when you want an open-source server you run in Docker.

Threadless AI

Hosted memory for OpenAI agents. Before every model call your agent sends what is new to decorate and gets back the whole request, to submit to OpenAI with its own key; it calls report with the reply. The latest messages are sent word for word. When older messages are about to stop being sent word for word, the request asks your model to note their key facts with a note tool, and those facts stay in view. Older messages that matter come back, with their dates, when the conversation turns to them, and the SDK builds the request from the local tail if we cannot be reached. See how it works.

Choose it over Supermemory when the conversation itself is the problem and you want the request managed. Do not choose it if you need a user's documents and connectors in memory, memory shared across a user's conversations, a provider other than OpenAI, or self-hosting: it does none of those. Prices are being finalised (pricing).

Benchmarks, and who ran them

Every number below was published by the vendor about its own system. They use different models, judges and metrics, so they do not rank the products against each other.

Compare systems on your own conversations before trusting any of these. Supermemory publishes its MemoryBench harness under MIT, which helps (MemoryBench).

How to choose

Migrating from Supermemory

1. Decide the scope. Supermemory namespaces are usually per user; most alternatives above are too. Threadless AI is per conversation, so create a memory per conversation and keep its id beside your conversation id.
2. Export what you hold. List your documents per namespace before you switch, so nothing depends on the old account.
3. Move durable user facts. Into the new store, or for Threadless AI into your system message, which is stored and always leads the request.
4. Replace the read step. For a store, swap search for its equivalent. For Threadless AI, replace the search-and-inject step or the wrapped client with decorate, and submit what comes back.
5. Replace the write step. Supermemory saves turns under a stable id. For Threadless AI, call report after each reply and add the note tool to your tools, answering its calls with noted.
6. Carry live conversations over by sending their recent history in the first decorate.
7. Compare on your own transcripts before you turn the old path off.

Questions people ask

What is the best Supermemory alternative?

It depends on what you used it for. For user memory across conversations, Mem0 or Zep; for an open-source server, Cognee or Hindsight; for a platform that runs the agent, Letta; for one long OpenAI conversation with the request managed, Threadless AI.

Is Supermemory open source?

Partly. Its SDKs and the public repository are open source; the self-hosted server binary is built from a non-public codebase and is free up to 10,000 stored documents (self-hosting).

How much does Supermemory cost?

It bills usage in credits: Free includes $5 of credits a month, Pro is $19 a month, Max $100 and Scale $399, with Enterprise custom (billing).

Does Supermemory still have Infinite Chat or the Memory Router?

Its current docs no longer describe them: the announcement is marked as historical and the router's pages redirect to the Vercel AI SDK integration. New apps are pointed to the memory API and SDK wrappers.

Is there a Supermemory alternative that manages the chat history?

Letta manages the whole context because it runs the agent. Honcho returns a token-bounded summary and recent messages for you to send. Threadless AI returns the whole OpenAI request with the history managed, for the model call your code already makes.

Related

• Threadless AI vs Supermemory
• Mem0 alternatives
• Zep alternatives
• Letta alternatives
• Mem0 vs Zep vs Letta