Why AI Characters Forget: What a Memory Limit Really Is in 2026
An AI character forgets because of how the reply is built, not because the app deleted something. Every message you send is assembled into a block of text โ the character definition, a few instructions, the recent conversation, and whatever memories the app decided to inject โ and that block has a fixed size. When it fills, the oldest turns fall out of it. The character is not being careless. It is answering from a shorter document than the one you think you wrote together.
That single sentence explains almost every "my AI forgot again" complaint, and why some apps feel like they remember and others do not: the difference is rarely the model, it is what each product builds around the limit. This page separates the four designs, shows the four ways a detail gets lost, gives you a five-minute test, and then says plainly where OurDream sits โ including what it cannot do.
The limit in one sentence: a fixed window, resent every turn
A language model has no memory of yesterday. On each turn it is handed a block of text and asked to continue it. Everything the character "knows" at that moment is inside that block โ there is no background lookup happening unless the application wraps one around the model.
What the model actually sees on every turn
Four things, in this order: the system instructions that describe the product's rules and tone, the character definition you or the platform wrote, the recent conversation, and any memory the app injected before sending. Nothing else. The order matters too โ a fact placed in the character definition is present on every single reply, while the same fact said in a chat message is present only while that message is still inside the window.
What a token is, in practical terms
Models count in tokens rather than words: in English a token is roughly three quarters of a word, while in Japanese a single character can cost one token or more, which is why a Japanese conversation reaches the ceiling faster on the same plan. When an app publishes a message cap rather than a token budget, it is translating a window into an average message length and rounding down.
Why nobody simply makes the window enormous
Because the cost of a reply scales with how much text you send in, latency grows with it, and a model's ability to use one small detail degrades as the input gets longer. A fact buried in the middle of a very long transcript is easy to miss even when it is technically present. That is why companion apps invest in summaries and retrieval rather than paying for the largest window available.
The four mechanisms, and what each one drops
Every companion app is a combination of these four. Knowing which one you are looking at tells you what kind of forgetting to expect.
| Mechanism | What it does | What it drops | Where you notice it |
|---|---|---|---|
| Context window (raw recency) | Sends the last N turns verbatim | Everything older than the window, all at once | Fine for a session, blank slate on the next one |
| Rolling summary | Compresses older turns into a short recap | Detail: names of places, exact wording, small promises | It remembers the shape of the story, not the specifics |
| Retrieval (embeddings) | Stores chunks and pulls back the ones that match the current message | Anything the search misses โ a detail worded differently | It recalls one event perfectly and ignores the one next to it |
| Pinned or structured memory | Keeps a short list of facts in every reply | Everything not on the list, and it is always short | Rock solid on three facts, silent on the fourth |
Window only: the honest minimum
Some lightweight or unofficial clients are window-only. They feel astonishing for twenty messages and then reset the world. If an app has no settings page mentioning memory, notes or character knowledge, assume this design.
Summaries: the shape without the detail
A summary is a lossy compression chosen by a model. It keeps the emotional arc and the setting, and loses the name of the restaurant, the sister's age, the thing you said you were afraid of. If the character remembers you are nervous about a job interview but not which company, that is a summary working as designed.
Retrieval: good at synonyms, blind to wording
Retrieval embeds stored passages and your new message into vectors, then pulls the nearest. Paraphrase works โ say "my mother" and it can surface a memory written as "mum". A detail stored under generic wording can be missed when your question is specific, because nothing in the query points at it.
Pinned memory: small, deliberate, reliable
A handful of facts โ your name, a preference, a boundary โ are prepended to every reply. It cannot break, and it cannot be generous: the list is short because every entry is paid for on every turn.
The four ways a character loses something you told it
1. Overflow โ the turn fell out
You said it forty messages ago and the window holds thirty. No system was ever asked to keep it, so nothing did. That is not a defect, it is the base behaviour of the architecture โ and the reason a recall test is worth more than a marketing page.
2. Compression โ the summary flattened it
The detail reached the summary stage but did not survive it. The character knows you had a bad week, not what happened; knows you have a sister, not her name. If a correction holds for a while and then fades, you are watching a summary being rebuilt.
3. Retrieval miss โ stored, but not found
This one looks like lying. The fact is in the memory list you can read, and the character still does not use it, because retrieval ranks candidates against the current message. Asking directly ("what did I tell you about my brother?") often works โ the tell that the information was never gone.
4. Priority override โ the persona outranks the memory
When a stored fact conflicts with what the character is instructed to be โ playful, flirty, agreeable โ the instruction wins, because it sits closer to the top of the block and is repeated on every turn. A memory saying "I do not want to talk about that" can lose to a persona written to keep the scene moving. This is a design choice, and it is the one users read as dishonesty.
How to test any app's memory in five minutes
You do not need to trust a marketing page. Plant three facts of different kinds, then check when each one dies. Do this on a free tier before paying for anything.
1. Prepare three facts, not one
A name (identity), a preference (how you like to be spoken to), and a specific detail with a number or a place in it โ the kind a summary is most likely to drop. Write them down outside the app.
2. Plant them in one message, then behave normally
Send all three in a single message near the start, phrased as yourself rather than as an instruction. Then have an ordinary conversation, twenty to thirty turns of normal length. Do not repeat the facts and do not hint โ repeating them tests your memory, not the app's.
3. Check at three checkpoints
Around message fifteen, ask an open question that requires one of the facts without naming it. Around message forty, ask about the number or the place. Then close the app, come back the next day, and ask again in a new session. Write each result next to the app's price: two apps at the same monthly rate are not the same product if one holds your name for a week and the other loses it before dinner.
| Result | What it means | What it predicts |
|---|---|---|
| Forgotten by message 15 | The window is very small, or the character definition consumes most of it | Short scenes only; expect resets inside a single session |
| Held at 15, lost by 40 | Window plus summary, no retrieval, or retrieval that misses | Good for episodic chat, weak for a long story |
| Held at 40, lost after reopening | Session memory without cross-session storage | Every day starts over; you re-explain yourself |
| Held across the reopen | A stored memory is being carried forward and retrieved | The design will hold while the list stays small |
Five workarounds that work inside the limit
Keep messages short
Four sentences per turn fill the window four times faster than two-line messages. Brevity is the cheapest memory upgrade available, and it is free.
One thread per character
Mixing three characters into one conversation spends the same window on text the current character does not need.
Put durable facts in the character definition and the memory field
The persona, greeting and knowledge fields are resent on every turn, and where an app offers a memory list or memory box it is usually prepended verbatim. Both are the reliable surfaces โ and both are short, so spend them on identity and boundaries rather than plot. The mechanics are in how a character sheet is assembled.
Ask for a recap and correct it
Every ten or fifteen turns, ask the character to summarise what it knows in five lines, read it, and correct what is wrong in one message. You are repairing the summary before it becomes the history.
Restart the scene instead of arguing
Once a character has drifted, correcting it rarely works: the wrong version is now inside the recent window and competes with your correction. A fresh chat with a two-line recap beats an argument. And run the five-minute test on the free tier before paying โ it is the one feature a free plan reveals honestly.
When memory is the real reason to change apps
It is worth saying the obvious: memory is one axis among five, and it is not the one most people should optimise first. Price per month, what the free tier actually allows, whether the filter matches what you want to write, voice quality, and image generation all change the experience faster than a longer memory list. Memory becomes decisive in one case only โ long-form roleplay where the value is the accumulated history โ and there the question is not "how big is the window" but "what does this app carry forward, and can I see it".
For the per-app side of that question, the closer comparisons are five apps tested on what they actually remember, what "memory-first" means in practice, and the head-to-heads against Character.AI, Replika and Kindroid.
Where OurDream sits in this picture
A browser companion with a stored history
OurDream runs in a browser and keeps conversations in your account rather than in a local file, which is why the same character continues on a phone and on a desktop. Its own materials present memory as persistent across chats rather than reset each session. What that means concretely is the thing worth testing: a stored history is a prerequisite for recall, not a guarantee of it, because the model still only sees the window it is given on each turn.
What it cannot do
Exceed its context window โ and no competitor can either. Long, detail-dense scenes will compress, and a fact mentioned once, forty turns ago, may not be retrieved. Anyone promising otherwise, for this product or any other, is describing a technology that does not exist in 2026.
What the plans actually are
The published structure is simple enough to state precisely: $19.99 per month billed monthly, with 1,000 DreamCoins granted immediately and 1,000 more each month, or $9.99 per month billed at $119.88 once a year, with 2,000 DreamCoins up front including a 1,000 bonus and 1,000 each month after that. Coins pay for voice calls and media generation, not for memory. The detail is in the pricing breakdown.
Try OurDream.ai โ free starter DreamCoins, no card required
Run the five-minute test on it. If the character holds your name across a reopening, the design is doing what it claims. If it does not, you have lost nothing but a few minutes, and you will know exactly which question to ask the next app you try.
Frequently asked questions
Why does my AI character forget my name?
Because the message where you said it has fallen outside the window, and nothing was stored to replace it. The model does not look anything up; it reads the block of text the app assembles on each turn.
Does Character.AI have a memory limit?
Yes โ every chat product does, because a reply can only be generated from a limited window of text. Character.AI has added a chat memory feature, announced in its own product blog, which carries selected information between conversations. The platform does not publish a token budget in its help centre, so the recall test above is a better measure than a quoted number.
Is a bigger context window always better?
No. A larger window costs more per turn, answers more slowly, and models get less reliable at finding one detail inside a very long input. A tight summary plus a few pinned facts usually outperforms dumping a huge transcript into every reply.
Can I make an AI character remember everything?
Not within one conversation โ the window is a hard limit, not a setting. What you control is what survives: short messages, durable facts in the character definition, the memory field where one exists, and recaps you correct yourself.
Why does the character remember the setting but not the conversation?
The setting lives in the character definition, which is resent on every turn. The conversation lives in the window, which slides. Anything in the persona is present from the first token; anything said in a message expires when that message leaves the window.
Does OurDream have a memory limit?
Yes. It is a browser-based companion with a stored conversation history and memory presented as persistent across chats, but it still runs on a model with a window. The same five-minute test applies, and it is the first thing worth doing on the free starter coins.
Keep reading
- Five AI character apps tested on what they actually remember
- Six platforms compared on memory over 30 days
- What "memory-first" means for a companion app
- How a character sheet is assembled, field by field
- The five fields that make a character hold over long scenes
- Six moves that keep a scene alive past the window
- The category overview, if you are still choosing
- What an AI girlfriend costs across pricing models
- OurDream vs Character.AI, side by side
Sources checked in November 2026: the official OurDream help desk for subscription structure and account behaviour, Character.AI's own product announcement on chat memories, and published documentation of open-source front-ends on context handling. Token-to-word ratios are approximations, not benchmarks.