What memory actually means

It remembered your sister’s name for two months and then asked what your sister was called. It knows you do not drink coffee and has forgotten the job you spent a week talking about. A detail from January surfaces unprompted while yesterday is blank.

That pattern is not degradation and it is not randomness. It is the shape of a specific implementation, and the shape is legible once you know what the options are.

Memory is not something the model has

The model does not retain anything between requests. Every reply is produced by reading an input and generating text, and when it is done, nothing about your conversation stays with it.

So “memory” in a companion app is a feature built on top: software that decides what to fetch out of a database and include in the next input. The model then behaves as though it remembers, because the information is right there in front of it.

Which means the real question is never whether it remembers. It is: what does the software fetch, and how does it choose? There are four common answers and they fail differently.

The four implementations, and the seam in each

A window of recent messages. The simplest: include the last however-many messages, drop the rest. Feels perfect inside a session and drops off a cliff at the edge. The seam is a hard boundary — recent things are known exactly, older things are gone entirely, and nothing in between.

A running summary. Older messages are condensed into a paragraph or two, which is carried forward while the originals stop being included. Extends reach enormously and loses specifics: names, numbers, exact wording, and anything that seemed unimportant when the summary was written. The seam here is characteristic — the gist of a long-ago conversation survives while the details from it vanish. And summaries get re-summarised, so early history degrades in generations, like a photocopy of a photocopy.

Extracted facts. The software watches for things worth storing and writes them to a list: your name, your job, your dog, your preferences. Very durable for whatever got extracted and completely blind to whatever did not. This is the implementation that produces the most jarring failures, because storage was a judgement call. The fact that it knows your dog’s name and not your sister’s is not inconsistency; the extractor caught one and not the other.

Search over past messages. When you send a message, the software searches your history for related material and includes what it finds. Reach across everything, and dependent on the search working — which means a topic you raise in different words than you used before may not surface, and the more history there is, the more competition there is for the space.

Most real products use two or three of these together, which is why the behaviour looks inconsistent. It is several mechanisms with different edges, overlapping.

Why there is a limit at all

Because the input has a size ceiling and the input costs money.

A model reads a bounded amount of text per request — a limit that is a property of the model the company chose. Everything competes for that space: the character description, the memory, the recent messages, your new one. More memory literally means less room for something else.

And the space is not free. Longer inputs cost the operator more per message, on every single message, for every user. A memory feature is a recurring cost per turn, which makes its length a budget decision rather than a technical ceiling. That is why memory is so often the thing that differs between a free tier and a paid one, and it is the same economics that shapes most of the rest of the product.

The product

THE PRODUCT — memory

  · "Remembers everything"
                    → a feature that fetches selected text
                      from a database. Never the model
                      retaining anything.

  · A recent-messages window
                    → exact inside the window, gone outside
                      it. Hard edge, no fade.

  · A running summary
                    → keeps the gist, loses names, numbers and
                      specifics — and degrades further each
                      time it is re-summarised.

  · Extracted facts
                    → durable for what got extracted, blind
                      to what did not. Source of the most
                      jarring gaps.

  · How long memory is, and who gets more of it
                    → THE OPERATOR DECIDES. Every remembered
                      word costs them money on every message,
                      so length is a budget line.

  · Which combination an app uses
                    → VARIES BY APP, and is almost never
                      documented.

Reading the gaps

You can often tell which mechanism you are dealing with from the failure.

Loses everything past a certain distance, cleanly: a window. Remembers the shape of an old conversation but not one detail from it: a summary. Knows five oddly specific things about you forever and nothing else: extraction. Finds things when you use the same words and not when you paraphrase: search.

This is more useful than it sounds, because it tells you what to do. Where extraction is doing the work, saying a fact plainly and directly gets it stored, and mentioning it in passing does not. Where a summary is doing the work, repeating an important detail occasionally keeps it alive, because a detail that appears often survives condensation better than one mentioned once.

None of that is a trick. It is working with the grain of the implementation instead of against it.

What you can actually check

Look for a memory screen. Many apps have one — a list of stored facts, an “about you” page, notes you can add or delete. Where it exists it is the most direct answer available to what actually carries, and it is frequently shorter than users expect.

Check whether it is editable. A memory list you can correct is meaningfully different from one you cannot, especially since extraction makes mistakes and a wrong stored fact persists exactly as well as a right one.

Check what the tier comparison says. Where memory length differs by plan, the paid-tier description is often the only place a company states anything about how much history is carried.

Notice after updates. Memory implementations get changed, and a rebuild of the mechanism can quietly discard what the old one held. If a character suddenly seems to know less, an update is a more likely explanation than anything else — which is the general shape of why characters change.

What this doesn’t tell you

It does not tell you what any specific app does, because that is not published and any answer would be stale in months. It does not tell you that a gap is not a bug — sometimes it is. And knowing the mechanism does not make the gaps stop mattering: being asked something you have already answered is annoying, and understanding why does not make it less annoying.

What it does is move the question somewhere answerable. Not “why did it forget”, which has no answer, but “what does this app carry, and can I see it” — which usually does.