Replika's help center says it "retains everything since the beginning." Teardowns tell a different story: the model only sees roughly the last 25 messages, so everything older sits in your account where the AI cannot read it at inference time (thredly.io). The history is stored. It is not remembered. That gap is the whole problem.
If you have ever told a character your name, your backstory, the thing you decided together on day one, and watched it draw a blank fifty messages later, you have felt it. The chat log is right there on your screen. The model just is not looking at it.
Why AI characters forget
A language model does not have a running memory of your conversation the way you do. Each turn, it reads a fixed-size block of text called the context window, generates a reply, and forgets the act of reading. Whatever does not fit in that window on this turn might as well not exist.
As a chat grows past what the window holds, the oldest text gets pushed out to make room for the newest. Bigger windows buy you more room, but they cost more, add latency, and degrade in the middle: models reliably lose track of information buried between the start and end of a long prompt, the "lost in the middle" effect (Atlan, bitfern). So forgetting is not a bug a patch will fix. It is the default behavior of the architecture. Everything below is an attempt to work around it.
The ways an AI can "remember" (and how each one fails)
Every memory system is a strategy for getting the right old text back into that fixed window at the right moment. Each one trades recall against cost, latency, and a failure mode of its own.
Rolling summarization. An LLM compresses old turns into a running summary that rides along in the prompt. It is cheap and compact, and it is lossy by design: each pass throws away detail to stay short. A rare day-one fact survives the first compression, gets thinned by the second, and is gone by the third. You do not notice until the character contradicts something you both established a week ago (mem0, Recursively Summarizing, arXiv).
Lorebooks / World Info. You write entries by hand, and each one is injected only when its trigger keyword appears in the text (SillyTavern docs). When it fires, it is precise. The catch is that the AI is deliberately blind to its own lorebook until a keyword wakes it: paraphrase the trigger, misspell it, or refer to the thing sideways, and the entry silently never loads. The knowledge exists and stays invisible.
Vector / RAG retrieval. Every message gets embedded as a vector and stored. Each turn, the system retrieves the snippets most similar to what you just said and pastes them in (freeCodeCamp). This scales to enormous histories, which is its real strength. It also surfaces the wrong snippet when "most similar" is not "most relevant," and a confidently retrieved wrong memory is worse than none: it hands the model a false premise to build on.
Multi-layer / structured memory. Instead of dumping raw text, an LLM extracts salient facts and issues add, update, and delete operations, or scores memories by recency, importance, and relevance the way the Generative Agents work did (arXiv survey, Generative Agents). This is closer to how remembering should feel. It also adds a step that can fail: the HaluMem benchmark shows memory systems fabricate and lose information at the extraction, update, and retrieval stages (HaluMem, arXiv). Memory hallucinates. It does not only forget.
Knowledge graphs. Entities become nodes and relationships become edges, with temporal edges that track when something happened versus when it was learned (Zep / Graphiti paper). It is the most structured option and the most work to build and keep clean as a story branches.
Two things fall out of this. First, the tradeoff is real and unavoidable: recall versus cost versus latency versus the risk of fabricated memories. Second, a bigger context window is not a memory system. Past a point, old information actively blocks recall of newer information ("proactive interference"), and at high interference, retrieval collapses into fabrication rather than degrading gracefully (proactive interference study, arXiv). More tokens is more haystack, not a better needle.
How the platforms handle it
Short version of who does what, and where each one cracks. Cells are kept tight on purpose.
| Platform | How it remembers | Where it breaks |
|---|---|---|
| Character.AI | Pinned messages plus a forgetting window between sessions | Forgetting and context rot rank as the top user complaints (404 Media) |
| AI Dungeon | Editable Story Summary plus a Memory Bank RAG layer and keyword Story Cards (Latitude, help) | Memory slots are tier-capped with least-used eviction; the AI is blind to a Story Card until an exact keyword loads it (help) |
| SillyTavern | You stack World Info, Author's Note, Summarize, and Vector Storage by hand (World Info, Summarize) | Entirely manual; keyed entries miss off-keyword phrasing; the Summarize docs warn output "drift and hallucinate" |
| Kindroid | Always-in-context backstory plus retrievable long-term memory and a keyphrase journal (docs) | Docs admit long-term memory is "potentially unreliable"; deepest tier is paid; journal keyphrases must match verbatim |
| Nomi | A Mind Map that builds up over a long history (Nomi) | Map only materializes after ~500 messages, reliable recall pegged to 1,000+; the Identity Core is not viewable or editable |
| Replika | Account claims to retain everything from the beginning (thredly) | Model only sees ~25 recent messages; the rest is stored but invisible at inference |
| Saga | Holds across a long story; you set the lore | In preview, library still small |
A few of these deserve a sentence. SpicyChat gates lorebooks behind paid tiers and caps free-tier context at 4,096 tokens, so memory there is short before any technique applies (SpicyChat docs). NovelAI's lorebook activates entries on keyword triggers (NovelAI docs), the same precise but brittle pattern as everyone else's.
So what does "memory that works" actually mean?
Notice what the table does not contain: a platform that "never forgets." Anyone promising that is selling you the marketing version of Replika's "retains everything." The useful question is narrower. Does the character still recall what matters as the story gets long, in exactly the place where pinned and persistent memory elsewhere visibly break?
That is the bar Saga is built to clear. What matters is the experience: characters remember what happened across a long story, call back to it, and shift because of it, and you set the lore that anchors a world so the AI works from your canon instead of guessing at it. Shorter, casual scenes fit just as well.
There is a test you can run yourself. Establish a fact, play 200 messages past it, then reference it sideways and see whether the character still has it. That is the moment summarization drops detail and a keyword lorebook stays silent, and that is the case Saga is built for. Around the memory, the rest holds its shape: Saga routes across models through OpenRouter, so you are not locked to one provider if its quality slips. Creators set the content boundaries, with one hard line that does not move: nothing involving minors. Conversations are encrypted in transit and stored securely, never sold and never used to train models. It runs on credits, with free credits to start and a bring-your-own-key option planned, and it is in preview on a waitlist.
If you are mapping the wider field, our guide to Character.AI alternatives covers the platforms above on price, content policy, and who each one is for.
Frequently asked questions
Why does Character.AI forget everything? Its model reads a fixed context window each turn, and once a chat outgrows that window the oldest text gets trimmed. Long chats simply exceed what the model can hold at once, and forgetting and context rot are among the most common complaints (404 Media). The history is still stored on your account; the model just cannot see all of it at once.
Which AI roleplay has the best memory? It depends on what you are doing. For one companion you return to daily, Kindroid's multi-layer system is strong, though its docs concede long-term recall is "potentially unreliable" (Kindroid). For a long story where the thread has to hold across a whole arc, that is the case Saga is built for. Treat any "remembers everything" claim with suspicion and test it yourself.
Can an AI chatbot remember everything? Not literally, and you should distrust anyone who says it can. Beyond the context window, memory systems themselves fabricate and lose information at the extraction, update, and retrieval stages (HaluMem). A good system recalls what matters reliably; it does not store an infinite, perfect transcript the model can read at will.
What is a lorebook? A lorebook (also called World Info) is a set of entries you write about your world, each tied to a trigger keyword that injects the entry only when that word appears in the chat (SillyTavern). It is precise when it fires and silent when it does not: paraphrase or misspell the trigger and the entry never loads. In Saga you set the lore that anchors a world, so canon is something you define rather than hope the model infers.
Does a bigger context window mean better memory? No. A larger window helps up to a point, then runs into "lost in the middle," where models drop information buried in the body of a long prompt, and into proactive interference, where old text blocks recall of newer text until retrieval collapses into fabrication (Atlan, arXiv). More tokens is a bigger haystack. Memory is about finding the right needle.
Saga is in preview right now, so you can get in early and help shape what the memory feels like in practice.
Questions, or want to swap roleplay ideas? Come hang out on Discord. Platform details above reflect publicly reported information as of mid-2026; systems change fast, so check the source links for the latest.