Companion products already run a memory stack: a rolling summary, a vector store of past messages, and a table of extracted profile facts. Each layer loses something different, and the user reads the sum of those losses as the relationship resetting. A bounded field holds the whole history as resident context instead, at a footprint that does not move as the relationship grows. We have held one unbroken conversation to 9,359 turns, about a year of daily use, without the thread breaking.
A companion product in production runs three memory systems at once. A small model rewrites the relationship every N turns. pgvector or Pinecone holds the transcript and returns the chunks nearest the current turn. A Postgres table holds whatever an extraction pass was told to look for. Underneath all three, the context window carries the persona block, and prefix caching keeps it warm for as long as the user keeps typing.
Each layer fails in a way you can name. The summary compounds: it is a rewrite of a rewrite, and by the fortieth pass a detail from March survives as a category rather than a fact. Retrieval is a similarity match, so the callback a user phrases sideways, the joke rather than the subject of the joke, returns nothing. Extraction records only what its schema anticipated, which is never the detail that made the character feel real. And prefix caching, the one layer that loses nothing, is evicted the moment the user closes the app.
The cost curve then inverts against you. Your longest relationships generate the most summary passes, the largest embedding bills, and the deepest transcript stores, and they are the same cohort that pays. Memory is the retention driver and the margin driver at once, which is why a change to the memory layer moves both numbers in the same direction here and in almost no other workload. And the character itself — its voice, its boundaries, who it is to the user — lives in a prompt preamble that is re-tuned by hand, versioned nowhere, and drifts every time the base model changes underneath it.
SCOPE: schematic. Measured recall across a multi-month session comes out of the pilot, run against your own summarizer and retrieval configuration.
A year of daily conversation runs into the millions of tokens. The field carries that history at a footprint you fix before you deploy, on whatever model you serve.
SCOPE: measured on a single unbroken conversation of 1,900,000 tokens across 9,359 turns, 14.5× the base model's trained context, with the resident memory flat from 50,000 tokens through to the final turn, and total footprint ~1,370× at 1.9M tokens under a standard cache. The ratio grows with length and is only meaningful at a stated depth. Reproduced on 3 independent conversations. Your recall curve and the configuration that produced it come out of the pilot.
The character stops reconstructing the user from a paragraph and a search hit. The whole relationship is resident, so continuity is a property of the context rather than of the retrieval step firing correctly.
The character ships as a lens. Voice, boundaries, and backstory load as one versioned artifact instead of a hand-tuned preamble — so the same companion is the same companion across a patch, across users, and across a base-model change.
The character stops degrading on a schedule. Before we bounded the read, our own runs died at roughly 285,000 tokens: output collapsed to about a dozen tokens a turn and stopped. Nothing like that ceiling appears at any depth we have run since.
Cost per active companion stops tracking relationship length. The month-twelve user and the day-one user carry the same footprint, so margin stops inverting against your best cohort.
SCOPE: continuity behavior depends on your persona design and field budget. A paid pilot returns the footprint curve and recall deltas measured against your current summarizer and retrieval stack. Our published depth results were produced on a deliberately small research model, chosen to stress the memory rather than flatter the output. A larger model abuses it less. Treat them as a floor.
Months of conversation carried as one resident structure that keeps merging as it grows, not a paragraph rewritten nightly. What was said in the first week is read at the same resolution as what was said last night, and in our deepest run the model was measurably still attending to early-conversation content at the final turn.
The character's voice, boundaries, and backstory loaded as a versioned lens, held apart from the relationship it reacts to — so one character served to thousands of users is the same character in every one of them, and survives a base-model upgrade without a re-tune. What a pilot returns is how consistently that lens holds across a multi-month relationship, including under users actively trying to talk the character out of being the character.
The current session at full fidelity, kept literal over an instruction block the field cannot overwrite, so the live turn stays sharp without dropping the history behind it.
The footprint is a number you set before you deploy. Twelve months into a relationship it is the same number as day one, on the same model you already serve.
How consistently the character's lens holds — voice and boundaries — across a multi-month relationship and across a base-model change, if a model upgrade falls inside the pilot window.
Recall on references from months back, scored against your current summarizer and retrieval stack on the same conversations, at matched depth.
Footprint per active companion held flat across a multi-month session, next to your current per-user memory cost.
Time-to-first-token on a returning dormant user, against your current re-prefill path.
SCOPE: this page states direction, not magnitude. Measured numbers for your workload come out of the pilot, with the configuration that produced them.
Bounded memory on its own is not hard. A rolling window gets the same footprint number tomorrow by forgetting everything older than the window, and for a companion product, forgetting is the failure. What is hard is holding the footprint flat while the whole relationship stays available, and showing the model is still reading it a year in. That is the result we publish, reproduced across independent conversations, and it is what a pilot reproduces on your workload.
The field is held to a budget you fix before you deploy. It runs on the model you already serve, with no retraining and no recalibration. Patent pending; the implementation stays private.
A scoped four-week pilot: you bring one workload and a memory budget, we return a measured comparison against your current cache: footprint, recall, and the configuration that produced both.