# Threadless AI vs Letta (MemGPT): when to choose each

> Letta runs your agent on its own server and manages its memory there; Threadless AI manages memory for the OpenAI agent you already run. How they differ.

Letta, founded by the creators of MemGPT ([about](https://letta.com/about-us)), is a platform for stateful agents: the agent lives on Letta's server, which runs its loop, calls the model and manages its memory. Threadless AI takes the opposite position: your agent stays in your code and calls OpenAI with your key, and Threadless AI returns what each request holds. This page compares the designs as each company documents them and says when Letta is the better choice.

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

## The difference in one line

- **Letta** runs the agent: you create an agent, send it messages, and get its reply ([agent SDK](https://docs.letta.com/agent-sdk/index.md)).
- **Threadless AI** runs no agent: you send what is new and get back the request for your own model call.

## Side by side

| | Letta | Threadless AI |
|---|---|---|
| Where the agent runs | On Letta's server (cloud or self-hosted), which calls the model | In your code; you call OpenAI with your key |
| Integration | Create an agent; send messages to its conversations ([conversations](https://docs.letta.com/concepts/conversations/index.md)) | `decorate` before the call, `report` after; submit what comes back |
| Scope | Memory per agent, shared across that agent's conversations ([stateful agents](https://docs.letta.com/concepts/stateful-agents/index.md)) | One memory per conversation; recall never crosses memories |
| Who writes the memory | The agent edits its own memory files, versioned in git, with background consolidation ([MemFS](https://docs.letta.com/concepts/memfs/index.md)) | Your model notes key facts with a note tool when older messages are about to stop being sent word for word |
| The context window | Managed: memory files in every prompt, older messages summarised near the limit | Managed: the latest messages word for word, facts from older messages in view, and older messages that matter recalled, in place of summaries |
| Sense of time | Not documented | Recalled older messages and facts come back with their dates; newer facts replace older ones |
| Model providers | Many, including local models ([models](https://docs.letta.com/configuration/models/index.md)) | OpenAI's Chat Completions and Responses formats |
| Open source | Apache-2.0, self-hostable ([GitHub](https://github.com/letta-ai/letta)) | Hosted only |
| When the service is down | The agent is unavailable | The SDK falls back to the local tail of recent messages; the model call goes ahead |
| Pricing | Free (up to 3 agents), Pro $20 a month, Teams Pro $20 a seat ([pricing](https://docs.letta.com/pricing/index.md)) | Per user turn and stored GB-month; prices being finalised ([pricing](https://threadlessai.com/pricing)) |

## How the two designs work

**Letta** grew out of MemGPT, which proposed managing a model's limited window the way an operating system pages memory between RAM and disk ([MemGPT paper](https://arxiv.org/abs/2310.08560)). Today a Letta agent keeps its memory as MemFS, a git repository of Markdown files that it reads, writes and reorganises; files at the root load into its system prompt on every turn, and background "dreaming" subagents consolidate lessons from recent conversations ([MemFS](https://docs.letta.com/concepts/memfs/index.md)). As a conversation approaches the context limit, Letta summarises older messages and keeps recent ones in view ([conversations](https://docs.letta.com/concepts/conversations/index.md)).

**Threadless AI** manages one conversation's request without running anything. Your agent sends what is new to `decorate` and submits the request it gets back to OpenAI; it calls `report` with the reply. The request holds the latest messages word for word and the facts from older messages. As the conversation grows, older messages stop being sent word for word; before they do, your model notes their key facts with the note tool, and those facts stay in view. When the conversation returns to something older, the older messages that matter come back, with their dates. Token use stays bounded. See [what the model gets](https://threadlessai.com/how-it-works#what-the-model-gets).

## Letta's 2026 direction

In March 2026 Letta said that Letta Code is its flagship and that it is "sunsetting a set of server-side features in favor of stronger client-side and runtime-native replacements", with memory moving to git-backed context repositories ([Letta's next phase](https://www.letta.com/blog/our-next-phase)). Its main repository now says the retired V1 API server lives on an archive branch and the current code is in `letta-code` ([GitHub](https://github.com/letta-ai/letta)). If you built on the older server API, check what you depend on against the current docs.

## Why people switch from Letta

Only if these match your situation:

- **They already have an agent loop.** Their tools, streaming, retries and model calls live in their own code, and moving the agent onto another server is more change than they want.
- **The server-side features they used are being retired** in favour of Letta Code and client-side replacements.
- **They want one memory per conversation**, not memory shared across everything an agent does.
- **They want the agent to keep answering in an outage.** With Letta, if the server is down the agent is down; Threadless AI's SDK falls back to a local tail.

## Benchmarks

| System | Result | Who ran it | On what |
|---|---|---|---|
| Letta | LoCoMo 74.0% | Letta | A simple agent with plain file tools and GPT-4o mini, August 2025 ([blog](https://www.letta.com/blog/benchmarking-ai-agent-memory)) |
| Threadless AI | None published | | We are running LongMemEval and LoCoMo and will publish scores with the method |

Letta also runs Context-Bench, which ranks language models on context engineering rather than comparing memory products ([leaderboard](https://leaderboard.letta.com)). We have no numbers of our own yet.

## When to choose Letta

- **You want the platform to run the agent**, its tools and its loop, not just its memory.
- **One agent should accumulate memory across all its conversations**, editing it deliberately over time.
- **You need open source and self-hosting**, or several model providers.

## When to choose Threadless AI

- **You already have an agent on OpenAI** and want it to stop running out of context without moving it onto another platform.
- **Your code owns the model call**: your key, your tools, your streaming, your retries.
- **Each conversation is its own memory**, with facts noted by the model that was there.
- **Your agent must keep answering** when the memory service is unreachable.

## Moving from Letta

1. **Export each agent** you depend on before changing anything; Letta's API has export endpoints for agents.
2. **Move the agent loop into your code**: the system prompt, the tools and the model call, using the OpenAI SDK with your own key.
3. **Create a Threadless AI memory per conversation** and keep its id beside your conversation id.
4. **Put durable memory in your system message.** What sat in the agent's root memory files, such as persona and user facts, belongs in instructions, which are stored and always lead the request.
5. **Wrap each model call** with `decorate` before and `report` after; add the note tool and answer its calls with `noted`.
6. **Seed live conversations** by sending their recent history in the first `decorate`.

## Questions people ask

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

Letta runs your agent on its server and manages its memory there. Threadless AI runs no agent: it returns the request for the OpenAI call your code already makes, with one conversation's history managed.

### Is Letta the same as MemGPT?

Letta was founded by the creators of MemGPT, and its open-source repository was formerly MemGPT ([GitHub](https://github.com/letta-ai/letta)). The current product describes memory as MemFS rather than MemGPT's main and external context.

### Is Letta open source?

Yes. `letta-ai/letta` and `letta-ai/letta-code` are Apache-2.0, and Letta can be self-hosted. Threadless AI is hosted only.

### Can I use Letta's memory without running agents in Letta?

Letta's memory belongs to its agents; you reach it by running an agent on Letta. If you want memory for an agent loop you already run, a memory layer such as Threadless AI, Mem0 or Zep fits better. See [Letta alternatives](https://threadlessai.com/guides/letta-alternatives).

### Does Letta work with OpenAI models?

Yes, among many providers. Threadless AI works only with OpenAI's Chat Completions and Responses formats.

## Related

- [Threadless AI vs Mem0](https://threadlessai.com/guides/threadless-vs-mem0)
- [Letta alternatives](https://threadlessai.com/guides/letta-alternatives)
- [Mem0 vs Zep vs Letta](https://threadlessai.com/guides/mem0-vs-zep-vs-letta)
- [Let the model write its own notes](https://threadlessai.com/guides/note-tool-pattern)
- [Agent memory glossary](https://threadlessai.com/guides/agent-memory-glossary)