# Threadless AI vs Mem0: differences and when to choose each

> Mem0 is a memory store you add to and search; Threadless AI returns the whole OpenAI request with history managed. Design, pricing, benchmarks, migration.

Mem0 is one of the most widely used memory layers for AI apps, open source and hosted. Threadless AI solves a related problem a different way. This page compares the designs as each company documents them, and says plainly when Mem0 is the better choice.

We make Threadless AI, so weigh our description of it accordingly. Every claim about Mem0 links to Mem0's own pages, checked on the date above; tell us at support@threadlessai.com if something has changed.

## The difference in one line

- **Mem0** stores memories you add and returns the ones relevant to a query; your code places them in the prompt ([how it works](https://docs.mem0.ai/core-concepts/how-it-works)).
- **Threadless AI** returns the whole request, history included, ready to submit to OpenAI; we decide what the model sees on every call.

## Side by side

| | Mem0 | Threadless AI |
|---|---|---|
| Integration | `add` memories, `search` before a call, place results in your prompt ([memory operations](https://docs.mem0.ai/core-concepts/memory-operations/add)) | `decorate` before the call, `report` after; submit what comes back |
| Scope | Memories partitioned by user, agent, app or run ([entity-scoped memory](https://docs.mem0.ai/platform/features/entity-scoped-memory)) | One memory per conversation; recall never crosses memories |
| Who writes the memories | Mem0's LLM extracts facts when you add messages ([add](https://docs.mem0.ai/core-concepts/memory-operations/add)) | Your model writes facts with a note tool, from the turns it was in |
| The context window | Yours to manage | Managed: the latest messages word for word, facts from older messages in view, older messages that matter brought back; token use stays bounded |
| Sense of time | Opt-in ranking bias towards recently used memories, applied at search time ([changelog](https://docs.mem0.ai/changelog/platform.md)) | Older messages that come back carry their dates; newer facts replace older ones |
| Graph | Graph memory on the hosted Custom plan ([pricing](https://mem0.ai/pricing)); dropped from the open-source edition ([platform vs OSS](https://docs.mem0.ai/platform/platform-vs-oss)) | Not offered as a feature; newer facts replace older ones they contradict |
| Model providers | Many; integrations with LangChain, CrewAI, the OpenAI Agents SDK, Vercel AI SDK and more ([integrations](https://docs.mem0.ai/integrations)) | OpenAI's Chat Completions and Responses formats |
| Self-hosting | Open-source edition, Apache-2.0 ([GitHub](https://github.com/mem0ai/mem0)) | Hosted only |
| Pricing | Free plan with monthly limits; Custom plan, unpriced ([pricing](https://mem0.ai/pricing)) | Per user turn and stored GB-month; prices being finalised ([pricing](https://threadlessai.com/pricing)) |
| When the service is down | Your search call fails; what your code does is up to you | The SDK builds the request from a local tail; the model call goes ahead |
| MCP | Hosted MCP server ([Mem0 MCP](https://docs.mem0.ai/platform/mem0-mcp)) | No runtime MCP; memory is the context the agent runs in, not a tool it calls |

## How the two designs work

**Mem0** sits beside your agent. When a conversation produces something worth keeping, you call `add` with the messages and an id such as `user_id`; Mem0's model extracts memories and stores them. Before a model call, you call `search` with a query and the same id, and get back the memories most relevant to it. Building the prompt, deciding how much history to send, and trimming it as it grows are your code's job. That separation is a strength when you want full control of the prompt or memory about a user that spans many apps.

**Threadless AI** sits in front of the model call. Before each call your agent sends only what is new (the user's message, or the model's reply plus tool results) to `decorate`, and gets back the full request. Inside it are your instructions, the facts from older messages, the latest messages word for word, and the older messages that matter to the new message, with their dates, placed just before it. As the conversation grows, older messages stop being sent word for word; just before they do, your model notes their key facts with the note tool, and those facts stay in view. The request is sized for a 200k-token context window, so token use stays bounded. See [how it works](https://threadlessai.com/how-it-works#what-the-model-gets).

## Why people switch from Mem0

These are the reasons that bring Mem0 users to look at Threadless AI, and they only apply if they match your situation:

- **The conversation, not the user, is what outgrows the window.** Mem0 returns relevant memories, but the history you send alongside them keeps growing. Threadless AI manages the whole request.
- **They want the model that was there to write the facts.** Mem0's extraction model reads the messages afterwards; Threadless AI's note tool asks your agent's own model, just before those messages stop being sent word for word.
- **They want dates by default.** Mem0's recency bias is opt-in and off by default ([changelog](https://docs.mem0.ai/changelog/platform.md)). In Threadless AI older messages that come back always carry their dates, and newer facts replace older ones.
- **They want the agent to keep answering in an outage.** Threadless AI's SDK falls back to a local tail in your process; see [what happens when memory is down](https://threadlessai.com/guides/memory-that-fails-open).

And the reasons people move from Threadless AI to Mem0, or never leave: memory about a user across conversations, providers other than OpenAI, self-hosting, or memory as a tool over MCP.

## Benchmarks

| System | Result | Who ran it | On what |
|---|---|---|---|
| Mem0 | LoCoMo 92.5, LongMemEval 94.4 | Mem0 | Its managed platform; models not named on the page ([research](https://mem0.ai/research)) |
| Mem0 (2025 paper) | LoCoMo 66.88%; full-context baseline 72.90% | Mem0 | GPT-4o-mini, LLM-as-a-judge ([paper](https://arxiv.org/abs/2504.19413)) |
| Threadless AI | None published | | We are running LongMemEval and LoCoMo and will publish scores with the method |

Mem0's own repository says its scores "reflect Mem0's managed platform, which includes proprietary optimizations not available in the open-source SDK" ([GitHub](https://github.com/mem0ai/mem0)). Zep has disputed how Mem0's paper configured Zep ([rebuttal](https://www.getzep.com/blog/lies-damn-lies-statistics-is-mem0-really-sota-in-agent-memory/)). We have no numbers to set beside these yet.

## When to choose Mem0

- **Memory about a user across many conversations** is the core of your product: preferences, profile, history across sessions.
- **You are not on OpenAI**, or you use several providers.
- **You need to self-host**, or want an open-source core.
- **You want memory as a tool** an agent calls through MCP, for example in a coding assistant.
- **You want to control the prompt** and only need relevant snippets to place yourself.

## When to choose Threadless AI

- **Long conversations with one agent** that outgrow the context window, where what the model sees on each call is the hard part.
- **You want one call instead of a pipeline**: no prompt assembly, no deciding what fits, no summariser.
- **Facts written by the model that was there**, readable and exportable.
- **Your agent must keep answering** when the memory service is unreachable.

## Moving from Mem0

1. Create a Threadless AI memory per conversation and keep its id beside your conversation id.
2. Replace the search-then-build-the-prompt step with `decorate`: send the new messages, submit what comes back.
3. Add `report` after the model call and the note tool to your tools; answer note calls with `noted`.
4. To carry an ongoing conversation over, send its recent history, with any durable user facts in your system message, in the first `decorate`.
5. Keep Mem0 for anything that genuinely spans conversations, such as a user profile, and write it into your system message when a conversation starts.
6. Compare both on a sample of real conversations before you remove the old path.

```ts
// Before: search, then build the prompt yourself.
// After: one call returns the request.
const request = await memory.chat.decorate(memoryId, newMessages, { model: 'gpt-5', tools });
const reply = await openai.chat.completions.create(
  request as unknown as OpenAI.ChatCompletionCreateParamsNonStreaming,
);
memory.chat.report(memoryId, reply);
```

The [quickstart](https://threadlessai.com/docs/quickstart) has the full loop in TypeScript and Python.

## Questions people ask

### What is the difference between Mem0 and Threadless AI?

Mem0 is a store: you add memories and search them, then build the prompt. Threadless AI returns the whole OpenAI request for one conversation with the history managed, and your own model writes the facts.

### Can I use Mem0 and Threadless AI together?

Yes. Keep user-level facts in Mem0 and write the relevant ones into your system message when a conversation starts; Threadless AI stores the system message and always places it first, and manages the conversation's history.

### Is Mem0 free?

Mem0 has a Free plan with monthly limits on adds and retrievals, and a Custom plan with no published price ([pricing](https://mem0.ai/pricing)). The open-source edition is Apache-2.0.

### Does Mem0 manage the context window?

No. It returns relevant memories for you to place in the prompt; how much history you send, and trimming it, stays with your code.

### Does Threadless AI work with models other than OpenAI's?

It works with OpenAI's Chat Completions and Responses formats, with any model that API accepts. If you need other providers, Mem0 is the better fit.

### Has Threadless AI published benchmark scores?

Not yet. We are running LongMemEval and LoCoMo against the hosted service and will publish scores with the method.

## Related

- [Threadless AI vs Zep](https://threadlessai.com/guides/threadless-vs-zep)
- [Threadless AI vs Supermemory](https://threadlessai.com/guides/threadless-vs-supermemory)
- [Mem0 alternatives](https://threadlessai.com/guides/mem0-alternatives)
- [Mem0 vs Zep vs Letta](https://threadlessai.com/guides/mem0-vs-zep-vs-letta)
- [Memory per conversation, not per user](https://threadlessai.com/guides/memory-per-conversation)
- [Infinite context for OpenAI agents](https://threadlessai.com/guides/infinite-context)