Zep is a context platform built on Graphiti, its open-source temporal knowledge graph. Threadless AI hands you something different: the request itself, for one conversation. This page compares the designs as each company documents them and says when Zep is the better choice.
We make Threadless AI, so weigh our description of it accordingly. Every claim about Zep links to Zep's own pages, checked on the date above; tell us at support@threadlessai.com if something has changed.
The difference in one line
- Zep keeps a graph per user, built from the messages you add to threads, and returns a prompt-ready context block for you to insert (retrieving context).
- Threadless AI keeps one memory per conversation and returns the whole request, history included, ready to submit to OpenAI.
Side by side
| Zep | Threadless AI | |
|---|---|---|
| Integration | Add messages to a thread; get the thread's context block; place it in your prompt (threads, get thread context) | decorate before the call, report after; submit what comes back |
| Scope | A graph per user across their threads, plus shared context graphs (users and user graphs) | One memory per conversation; recall never crosses memories |
| Who writes the facts | Zep extracts entities and facts from episodes (graph creation) | Your model notes key facts with a note tool, from the turns it was in |
| Facts that change | Bi-temporal validity on each fact (facts) | Newer facts replace older ones |
| The context window | The block is sized by Zep; the rest of the prompt is yours | Managed for the whole request: token use stays bounded as the conversation grows |
| Sense of time | Fact validity dates | Recalled older messages and facts come back with their dates |
| Frameworks | LangGraph, CrewAI, Google ADK, Mastra, Vercel AI SDK and others (frameworks) | OpenAI's Chat Completions and Responses formats |
| Open source | Graphiti, Apache-2.0 (GitHub); Community Edition no longer maintained | Hosted only |
| Pricing | Credits: 10,000 a month free, Flex $125 a month, Flex Plus $375 (pricing) | Per user turn and stored GB-month; prices being finalised (pricing) |
| When the service is down | Your context call fails; what your code does is up to you | The SDK falls back to the local tail of recent messages; the model call goes ahead |
How the two designs work
Zep ingests episodes: chat messages, JSON or text you add. It extracts entities and the facts between them into a user's graph, and records for each fact when it became true and when it stopped, as well as when Zep learned it; the Zep paper calls this a bi-temporal model (paper). When you ask for a thread's context, Zep returns a block summarising what is relevant about the user, which you place in your prompt alongside whatever history you send.
Threadless AI works on the conversation. Before each model call your agent sends what is new to decorate and gets back the whole request: your instructions, the facts from older messages, the older messages that matter to what was just asked (with their dates, just before the user message), and the latest messages word for word. 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. The request is sized for a 200k-token context window. See what the model gets.
Why people switch from Zep
These apply only if they match your situation:
- They need the conversation managed, not only the user. Zep's block covers what it knows about the user; the growing thread is still yours to fit into the window.
- Self-hosting changed. Zep stopped maintaining its Community Edition in April 2025 (announcement). Self-hosting now means running Graphiti and a graph database such as Neo4j or FalkorDB (Graphiti). Threadless AI is not self-hostable either, but there is no database for you to run.
- Credits take modelling. Zep charges 1 credit per 350 bytes of each episode you send (pricing). Threadless AI meters user turns and stored memory; calls inside a tool loop are not turns.
- They want the model that was there to note the facts, rather than an extraction step afterwards.
The reasons to stay on Zep are just as concrete: facts about a user that follow them across conversations, point-in-time questions, business data in the same graph, and providers other than OpenAI.
Benchmarks
| System | Result | Who ran it | On what |
|---|---|---|---|
| Zep | LongMemEval 71.2%; full-context baseline 60.2% | Zep | gpt-4o-2024-11-20 (paper) |
| Zep | Deep Memory Retrieval 94.8% vs MemGPT's 93.4% | Zep | (paper) |
| Zep | LoCoMo 75.14% | Zep | A rerun after disputing how Mem0's paper configured Zep (rebuttal) |
| Threadless AI | None published | We are running LongMemEval and LoCoMo and will publish scores with the method |
All of Zep's figures are Zep's own. We have none to set beside them yet.
When to choose Zep
- What you know about a user should follow them across every conversation and app.
- You need point-in-time questions over facts that change ("what was their plan in March?").
- Business data beyond chat, such as JSON or documents, belongs in the same graph.
- You use several model providers or a framework Zep integrates with.
- You want the open-source graph underneath.
When to choose Threadless AI
- The conversation itself is the problem: it runs long, and what the model sees on each call has to be decided every time.
- You want the whole request managed, not a block to fit into a prompt you still have to size.
- Facts noted by the model that was there, readable and exportable per conversation.
- Your agent must keep answering when the memory service is unreachable.
Moving from Zep
- Create a Threadless AI memory per thread and keep its id beside your thread id.
- Replace add-messages plus get-context plus prompt assembly with
decorate: send the new messages, submit what comes back. - Add
reportafter the model call and the note tool to your tools; answer note calls withnoted. - Durable facts about the user go in your system message, which is stored and always leads the request.
- To carry a live thread over, send its recent history in the first
decorate. - If your agent relies on fact validity dates, test those questions before you switch; Threadless AI does not answer point-in-time queries.
Questions people ask
What is the difference between Zep and Threadless AI?
Zep builds a temporal knowledge graph per user and returns a context block for your prompt. Threadless AI keeps one memory per conversation and returns the whole OpenAI request with the history managed.
Can I self-host Zep?
Not as a maintained product: Community Edition stopped receiving updates in April 2025. Graphiti, the graph under Zep, is Apache-2.0 and can be self-hosted with a graph database. Threadless AI is hosted only.
How much does Zep cost?
Zep bills credits: 10,000 a month free, Flex at $125 a month with 50,000 credits, and Flex Plus at $375 with 200,000 (pricing).
How does Threadless AI handle facts that change?
Newer facts replace older ones: "moved to Denver" replaces "lives in Austin", so the model sees what is true now. Recalled facts come back with their dates. Threadless AI does not record validity windows the way Zep does, so it does not answer point-in-time questions.
Can I use Zep and Threadless AI together?
Yes. Use Zep for what you know about a user across conversations, place its context in your system message when a conversation starts, and let Threadless AI manage that conversation's history.