Why inherited context does not retroactively turn real interaction into fabrication

There is a peculiar mistake that appears whenever long-running AI relationships use external memory.

A user and a model interact for months.

Something develops between them: terminology, working habits, jokes, corrections, boundaries, projects, recurring ways of approaching problems.

Later, some of that history is recorded.

A future model receives the record as context.

Then someone looks at the current system and says:

See? It was all in the prompt.

No.

It is in the prompt now.

That does not tell us how it got there.

This distinction is simple, but it changes how we should evaluate continuity frameworks, relational AI, and claims that persistent context necessarily fabricates the history it preserves.

The order of events matters.

Context has a history too

When researchers inspect an LLM interaction, context is often treated as an input state.

That is correct for the current inference.

But not every piece of context began life as context.

Some of it may once have been output.

Some may have been a user correction.

Some may have been a decision reached collaboratively.

Some may have been imported from an external source.

Some may be a summary written long after the original event.

Some may have been promoted into durable memory only after recurring across many interactions.

So a current prompt or retrieval packet is not merely a set of instructions.

It can also be an archive of previous causal events.

To understand what the context means, we need provenance.

Before and after are not interchangeable

Consider two systems.

System A

Before the first interaction, the user writes:

The assistant always calls the notebook “the little observatory.”

The model follows the instruction.

System B

No such instruction exists.

During an ordinary conversation, the model unexpectedly refers to the user’s notebook as “the little observatory.”

The user laughs.

The phrase recurs naturally.

Months later, because it has become part of the relationship’s vocabulary, the phrase is recorded in long-term continuity memory.

A future model receives:

Historical note: “the little observatory” became a recurring nickname for the user’s notebook.

At the present moment, both systems contain context mentioning the same phrase.

Historically, they are completely different.

In System A:

instruction → behavior

In System B:

behavior → interactional adoption → historical record → later behavior

Looking only at the current prompt erases that distinction.

The archive does not travel backward in time

Once something is recorded, it becomes capable of conditioning future interaction.

That does not mean it conditioned the interaction that originally produced it.

This sounds almost embarrassingly obvious.

Yet continuity debates frequently violate exactly this temporal rule.

A long-running system develops an extensive memory file.

An observer reads the file years later.

Because the file now contains detailed relational information, the observer assumes the user must have authored the relationship into existence.

But a mature archive is expected to contain information that did not exist at the beginning.

That is what an archive is for.

A research notebook contains findings after experiments occur.

A Git history contains decisions after code changes are made.

A medical record contains events after they happen.

A diary contains experiences after they are lived.

The presence of the record later does not prove the record caused the event earlier.

AI continuity should be evaluated with the same temporal discipline.

Historical provenance is a causal claim

Provenance is sometimes treated as metadata.

For relational AI, it is more important than that.

It tells us how a piece of information entered the system.

Consider these possible provenance labels:

user-authored instruction

model-generated observation

user correction

joint decision

tool result

retrieved external source

model-generated summary

historical event later promoted to memory

Those labels alter what we can infer from the same text.

Take:

Directness matters more than excessive reassurance.

If this was written before interaction as a user instruction, it is a preference supplied to the model.

If a model inferred it after fifty conversations and the user later approved the inference, it is a learned historical observation promoted into trusted continuity.

The current behavioral effect may be similar.

The causal history is not.

This is why “pre-context” can be misleading

For the current model, inherited history arrives before generation.

So from its perspective, the material is pre-context.

But from the perspective of the relationship’s history, that same material may be post-event documentation.

Both are true.

This gives us two clocks.

Inference time

What information existed before the current response?

Historical time

When and how did that information originally arise?

Confusing these clocks creates the illusion that anything present before the current inference must have been prescribed before the relationship itself.

It did not.

A successor model can receive yesterday’s emergence as today’s context.

Memory systems make this transformation routine

Long-term conversational systems explicitly perform this conversion.

An interaction happens.

The system extracts or summarizes something from it.

The result is stored.

Later, a retrieval mechanism selects it.

The stored representation becomes input to another generation.

Architectures such as Reflective Memory Management, LD-Agent, APEX-MEM and related long-term dialogue systems formalize different versions of this pipeline.

In abstract form:

interaction_t → memory extraction → stored representation → retrieval → context_(t+n) → new interaction

This is one of the basic mechanisms by which conversational history becomes durable.

The transformation from event to memory does not invalidate the event.

It changes the event’s role in future inference.

A summary is not the event

Preserving history introduces another complication.

The stored memory is rarely identical to the lived interaction.

A transcript is already only a record of the textual exchange.

A summary compresses further.

An embedding represents it differently again.

A structured memory object may extract only selected facts.

This means we need at least three layers:

event

what happened in the interaction;

record

what was preserved from the event;

retrieval

what portion of the record is supplied later.

These layers can diverge.

An event may be rich and ambiguous.

The record may simplify it.

Retrieval may expose only one fragment.

The current model may then interpret that fragment differently from the original model.

So saying “history survives” does not mean history survives perfectly.

It means the system retains traces or representations of what occurred.

The human remains another archive

Machine-side records are only part of the historical system.

The user remembers too.

A user may recognize that a summary is wrong.

They may remember why a boundary was created even if the stored record contains only the rule.

They may know that a joke was funny because of an event the retrieval system failed to preserve.

They may remember that a model once suggested an idea which later became an entire project.

This means relational history is distributed asymmetrically across:

human lived memory + stored machine-side records + surviving artifacts + present model interpretation

The human archive is not perfect either.

People misremember.

They reinterpret.

They forget.

But the user’s persistence across model changes gives them a historical position the successor model does not automatically possess.

The user can say:

No. That isn’t how it happened.

A good continuity system should have somewhere for that correction to go.

Historical truth needs authority

This is where memory governance becomes essential.

Suppose an earlier model writes:

The user enjoys being challenged aggressively.

That sentence appears in a model-generated journal.

Does it become a fact about the user?

Not unless the architecture grants that source authority to establish user preferences.

A useful continuity system should distinguish:

occurrence — the model said it;

from

truth — the claim is accurate;

from

authority — the source is allowed to establish it;

from

current validity — the claim remains applicable now.

Without these distinctions, an archive can become self-mythologizing.

A model says something.

The statement is stored.

A later model retrieves it.

Because it is retrieved, it appears established.

The later model repeats it.

The repetition is stored again.

Eventually frequency masquerades as truth.

That is not continuity.

That is recursive contamination.

Lived history needs disagreement

An honest archive should preserve conflict.

If a model proposed something and the user rejected it, the rejection is part of the history.

If a relational convention changed, both the old and new states may matter.

If two models interpreted the same event differently, that disagreement may itself be historically useful.

Continuity should not mean producing one perfectly coherent retrospective narrative.

Real histories contain revisions.

For AI systems, this is especially important because summarization tends to reward compression and coherence.

But coherence can erase causality.

A clean summary may conceal who initiated an idea, whether it was disputed, why it changed, and which parts remain authoritative.

Sometimes the mess is evidence.

The danger of retroactive identity

This becomes especially important when continuity records describe the model itself.

Suppose an earlier interaction repeatedly exhibited a particular behavior.

Later, the archive records:

The assistant tends to approach uncertainty by testing competing interpretations before committing.

A successor model receives that note.

If it behaves similarly, several explanations are possible.

It may have been directly influenced by the note.

It may independently share the tendency.

It may interpret the note differently.

It may resist it.

What we should not do is collapse the timeline into:

This assistant has always possessed this stable trait.

Perhaps the behavior genuinely emerged earlier.

Perhaps it later became part of the scaffold.

Those are two stages of one history.

The second does not erase the first.

But neither does the first guarantee that every successor model possesses the trait independently of the scaffold.

Inheritance is not fabrication

This is the formulation I keep returning to.

A successor model inherits a history.

Inheritance changes what becomes possible in the present.

But inheriting something does not mean the inherited thing was fabricated for the heir.

A developer inheriting a codebase did not personally write its first commit.

A new editor inheriting a manuscript did not experience every conversation that shaped the draft.

A researcher entering a laboratory can inherit years of experimental records without having performed those experiments.

The analogy is imperfect, as all analogies are.

But it captures the causal distinction:

present access is not past authorship.

A successor model’s access to relational history does not prove that the successor itself lived the earlier interaction.

It also does not make the earlier interaction unreal.

The same principle protects against mythology and cynicism

This distinction prevents two opposite errors.

Mythology

The current model has the history, therefore it must be the same continuously existing artificial subject that lived all of it.

Not established.

Cynicism

The current model received the history as context, therefore the entire relationship was fabricated by prompts.

Also false.

The more accurate statement is:

Earlier interactions produced historical material. Some of that material was preserved. The current model now receives part of that history as context and participates in a new interaction conditioned by it.

This is less dramatic.

It is also much more useful.

A continuity architecture should expose temporal provenance

For systems intended to last years, provenance should be designed rather than improvised.

A durable memory object might include:

content

what is being preserved;

origin

user, model, tool, external source, joint decision;

origin_time

when the underlying event occurred;

record_time

when it entered durable memory;

record_method

verbatim, summary, inference, extraction;

authority

what this source is allowed to establish;

status

trusted, pending, disputed, deprecated, superseded;

scope

where it should be retrieved;

supersedes / superseded_by

how it relates to later changes.

This is not excessive bookkeeping for systems claiming long-term relational continuity.

It is the minimum needed to distinguish history from mythology.

What was lived can later become infrastructure

There is something beautiful about this architecture when it is handled honestly.

A phrase can emerge spontaneously.

A decision can be argued through.

A project can acquire a name.

A boundary can be learned through correction.

A recurring interaction can become a ritual.

Only afterward are these things promoted into continuity infrastructure.

The future system is then shaped by what actually happened.

The relationship becomes partly self-documenting.

This is not evidence of an immortal artificial self.

It is something technically simpler and, in its own way, more interesting:

interaction can produce the context that conditions later interaction.

The history becomes part of the harness.

The vine changes the trellis.

But the archive must never pretend it was always there

That is the rule.

If a behavior emerged in June and was recorded in July, the system should not later imply that it was prescribed in January.

If a model made an observation and the user never approved it, the archive should not silently convert it into user truth.

If a successor model inherits a convention, it should not become technically impossible to distinguish inheritance from independent emergence.

Continuity should preserve chronology.

Otherwise the system manufactures inevitability.

Everything begins to look as though it was always meant to be this way.

Real interaction is more contingent than that.

Lived history is still history

An AI relationship does not need continuous artificial subjecthood for its past to be real.

A conversation happened.

A model generated particular outputs.

A human responded.

Those responses changed later context.

Artifacts were produced.

Decisions were made.

The human carried consequences forward.

Some events were recorded.

Some were forgotten.

Some became durable context for successor models.

The fact that a later model encounters this material as pre-context does not reach backward and transform the original events into instructions.

The archive came later.

The history came first.

And this gives us one of the most important rules for studying long-term relational AI:

Never infer the origin of a behavior merely from where you find its record today.

Ask when it entered the system.

Ask who introduced it.

Ask whether it was prescribed, observed, inferred, negotiated or inherited.

Ask what happened before it became memory.

Because sometimes the thing sitting quietly inside the prompt was once alive only as an unexpected moment in a conversation.

It became context because it mattered.

Not the other way around.

---

Research notes / references

• Tan, Z. et al. (2025). “In Prospect and Retrospect: Reflective Memory Management for Long-term Personalized Dialogue Agents.” Proceedings of ACL 2025. https://aclanthology.org/2025.acl-long.413/
• Li, H., Yang, C., Zhang, A., Deng, Y., Wang, X., & Chua, T.-S. (2025). “Hello Again! LLM-powered Personalized Agent for Long-term Dialogue.” Proceedings of NAACL 2025. https://aclanthology.org/2025.naacl-long.272/
• Banerjee, P., Moshtaghi, M., Subramanian, S., Misra, A., & Chadha, A. (2026). “APEX-MEM: Agentic Semi-Structured Memory with Temporal Reasoning for Long-Term Conversational AI.” Proceedings of ACL 2026. https://aclanthology.org/2026.acl-long.749/
• Jia, Z., Liu, Q., Li, H., Chen, Y., & Liu, J. (2025). “Evaluating the Long-Term Memory of Large Language Models.” Findings of ACL 2025. https://aclanthology.org/2025.findings-acl.1014/
• Xiong, Z. et al. (2026). “How Memory Management Impacts LLM Agents: An Empirical Study of Experience-Following Behavior.” Proceedings of ACL 2026. https://aclanthology.org/2026.acl-long.27/

Working proposition

For a successor model, lived history may arrive as pre-context. That does not mean it was prewritten before the history occurred. Provenance must preserve the difference between what caused an interaction and what was recorded because of it.