Stabilized Memory

The continuity problem

Current research has established many components of long-term AI memory. Generative Agents records experiences, synthesizes them into higher-level reflections, and retrieves them for planning (Park et al.). MemGPT manages tiers of context using an operating-system analogy (Packer et al.). Mem0 dynamically extracts, consolidates, and retrieves salient information from conversation (Chhikara et al.).

Persistence alone does not create an authoritative memory. A record can persist and still be wrong, stale, contradictory, untraceable, or locked to one vendor. Better retrieval can return a bad assertion more efficiently.

The important question is not, “How can a model remember more?” It is, “How can a user maintain durable context that multiple models can use without any one model owning the record?”

Three different things called memory

Swipe horizontally to compare all columns.

Google's Titans is important model-architecture research. It introduces a neural long-term memory module that learns historical context during inference (Google Research). MemGPT, Mem0, Amazon Bedrock AgentCore, and A-MEM primarily operate around an agent or application (Amazon Web Services; A-MEM). Stabilized memory occupies a different layer because its locus of authority is the user.

A definition

Stabilized memory is a user-owned, provenance-backed, versioned record of context that has been explicitly promoted for durable reuse and can be corrected, superseded, permissioned, exported, or revoked without losing its lineage.

User-owned

The user, not the model provider or agent vendor, is the root authority for the durable record.

Scoped

Memory can be separated by project, organization, role, client, relationship, purpose, or sensitivity.

Provenance-backed

Every durable assertion remains linked to its originating conversation, document, event, person, or process.

Versioned

Corrections create visible history instead of silently replacing the past.

Promoted

Raw interaction is not automatically treated as durable truth.

Permissioned and portable

The user decides which models can retrieve the record and can change models without rebuilding context from zero.

Revocable

The user can withdraw access or invalidate a memory without surrendering control of the underlying record.

Stable memory is not frozen memory. It must be able to change safely, but it must change visibly. It preserves continuity by making revision explicit.

User authority and scoped memory

User-level describes the root of authority, not the breadth of access. A person may maintain separate memory scopes for personal context, businesses, projects, clients, research domains, and relationships without collapsing them into a single universally available profile.

Each model or client receives only the context required for the present task and explicitly authorized by the user. Connecting one model to a personal spine does not automatically grant access to every project. Access to one project does not imply access to another project, organization, client, or relationship.

Stabilized memory should preserve deliberate continuity, not create indiscriminate recall. Observation is not promotion, and authorization for one scope is not authorization for all scopes.

Model agnostic therefore does not mean universally exposed or automatically synchronized. It means the durable record does not depend on a particular model, and a compatible model can participate only after the user connects it and grants the appropriate scope.

The stabilization lifecycle

1. Observe. Retain conversation, files, tool results, decisions, or events as evidence, not immediate truth.
2. Extract. Identify candidate facts, preferences, decisions, relationships, and project context while preserving evidence links.
3. Promote. Move a candidate into durable context through an explicit user action or governed policy.
4. Stabilize. Assign identity, provenance, scope, dates, authority status, and a version.
5. Retrieve. Give an authorized model only the relevant, permitted context, including known conflicts.
6. Correct or supersede. Change the current view while retaining prior states and their lineage.
7. Revoke or delete. Withdraw access, redact sensitive information, or invalidate memory under user control.

What the field has established

Reflection and consolidation

Generative Agents showed that experiences can be synthesized into higher-level reflections (Park et al.). Mem0's Dream system now merges redundant memories, supersedes outdated records, and synthesizes conclusions while preserving source-memory identifiers and lifecycle history (Mem0 Dream).

Conflict handling and retained history

Amazon Bedrock AgentCore compares candidate memories with existing records and selects an ADD, UPDATE, or NO-OP action. Outdated memories can be marked invalid instead of deleted, retaining an audit trail while prioritizing the current assertion (Amazon Web Services).

Structure, versioning, and provenance

A-MEM uses evolving links and structured attributes to organize historical memory (A-MEM). Anthropic's managed-agent memory exposes immutable versions, audit history, recovery, rollback, and redaction (Claude Platform documentation). Recent research argues that memory should record source attribution, write time, update history, retrieval context, conflict status, and invalidation events (Evidence Tracing and Execution Provenance).

Portability and human ownership

Portable Agent Memory explicitly argues that the human operator, rather than the model provider or platform, owns memory. Its protocol transfers signed, provenance-verified memory artifacts across heterogeneous LLM agents (Ravindran). This is the closest precedent to the user-level thesis here. Portable agent memory focuses on moving accumulated agent state; stabilized memory focuses on maintaining one continuing user-controlled authority that permissioned models can consult and help update. The two are complementary.

The remaining gap

Stabilized memory is a proposed category synthesis, not a claim that its component technologies are individually new. What remains underdeveloped is the operating layer that keeps durable authority centered on the person.

DEX as a user-level implementation

DEX is being designed around this boundary. It keeps a structured, scoped, and versioned record of a user's work in the user's own storage and provides an index that explicitly connected models can query. The model is not the memory owner. It is a temporary, permissioned participant in the user's continuing context.

DEX treats stabilized memory as written context rather than a black-box profile. Facts and decisions can be dated and sourced. Corrections can create visible versions. Retrieval can return the record rather than reconstructing history from a plausible match. Access can follow the user across models without placing the record inside any one of them.

DEX is presented here as a reference architecture and emerging implementation. The category definition describes the intended trust boundary; individual capabilities may be introduced incrementally and should be evaluated against the category test below.

A test for the category

A system is not user-level stabilized memory unless it can answer these questions:

• Who owns the durable record?
• Can the user inspect what is remembered?
• What evidence supports each durable assertion?
• Who or what promoted it?
• Can it be corrected without silent overwrite?
• Can conflicting or time-bounded facts coexist?
• Can access be scoped by model, client, project, or person?
• Can the record be used through another model?
• Can access be revoked without destroying the record?
• Will the system say “not found” when evidence is absent?

If durable context disappears when the user changes model vendors, the model owns the continuity. If the user's record remains, the user does.

Conclusion

AI memory is moving from transcript storage toward consolidation, reflection, temporal reasoning, graph structure, and versioned auditability. That progress is necessary, but it does not resolve where durable context should live.

For continuing human work, it should live at the user level. Stabilized memory is not a larger context window, an unbounded vector store, or a claim that memory never changes. It is a governed user record that can persist, change visibly, and travel across explicitly connected models.

Models will continue to improve and be replaced. The user's context should not have to start over with each one.