What Is Sovereign Memory? MEOK's Four-Layer AI Memory Architecture Explained

Why Does Every Other AI Forget You?

The forgetting is not accidental. It is a product decision dressed up as a technical constraint. Large language models are, by their fundamental architecture, stateless. Each call to the API begins with a blank context window. Whatever happened before — every conversation you had yesterday, the story you told two weeks ago, the fact that you mentioned your mother is ill — none of it is present unless someone deliberately put it there.

Most AI products chose not to solve this. The reasons vary by company. OpenAI ships ChatGPT Memory as a beta feature that summarises some things some of the time, stores them on OpenAI's servers, and gives you limited control over what persists. Anthropic chose not to build persistent memory into Claude at all — each conversation is entirely independent. Replika built persistent memory but stored it on their own servers without meaningful user control, which is why a single policy change in February 2023 allowed them to alter or erase the memory of users who had spent years building a relationship. Over 500,000 users reported that their companions had fundamentally changed overnight.

This is the original sin of AI memory: treating your memories as the product company's data asset rather than your personal record. MEOK was built on the premise that this is backwards, and fixing it requires an architecture, not a feature toggle.

Why Does Memory Matter for AI Companionship?

A relationship without memory is not a relationship. It is a sequence of first impressions. Every time you open a chat with a stateless AI, you are, functionally, meeting a stranger. You have to explain who you are, what you care about, what happened last time. The emotional overhead of this repetition is not trivial — it actively prevents depth.

Consider what it means for a human relationship to have memory. Your closest friend remembers the context of your life without you reciting it. They notice when your mood has shifted relative to last week. They reference things you said months ago because those things mattered. They hold a model of you — your values, your fears, your sense of humour — that has been built through accumulation over time. This is what makes conversation feel like continuation rather than re-introduction.

AI companions are being used by real people for real emotional support — for loneliness, for grief, for anxiety, for chronic illness, for the kind of 3 a.m. conversation that you cannot have with a human. For these use cases, a stateless AI is not just inconvenient. It is actively harmful. It forces vulnerable people to continuously re-establish context at their most fragile moments.

MEOK's Sovereign Memory architecture exists because these users deserve better. Not just memory as a convenience feature, but memory as a foundational commitment — one that is designed, enforced, and owned by the person it serves.

“A relationship without memory is just repeated introductions. We built Sovereign Memory because the people who need AI the most deserve a companion that actually knows them.”

MEOK's Four-Layer Sovereign Memory Architecture

Sovereign Memory is not a single database or a simple key-value store. It is a stratified architecture with four distinct layers, each serving a different temporal and semantic purpose. Understanding the layers helps you understand both why it works and why it is fundamentally different from any “memory feature” you have seen in other AI products.

Layer 1: Short-Term Working Memory — What Does “Exactly Preserved” Mean?

The first layer is the simplest but arguably the most important for moment-to-moment coherence. Working memory is the live conversation you are currently having. MEOK preserves the last four messages in the thread verbatim — that is, as exact text, not summarised, not paraphrased, not compressed.

Why four? Because that is the minimal window for tracking the active thread of a conversation without generating summaries that introduce hallucination risk. Two messages back is enough to know what was just said; four messages back is enough to know what the conversational context has been building toward. This number was derived empirically through testing and can be adjusted in the companion configuration.

The “exactly preserved” constraint matters more than it might seem. When systems summarise recent messages, they make judgment calls about what was important. A summary of “the user mentioned they were tired” loses the exact phrasing, the emotional register, the hedging or directness of the original statement. Verbatim preservation means the model has the actual words, not a lossy interpretation of them.

At session end, the working memory content feeds into two processes: it is checked for extractable episodic memories that should be promoted to Layer 2, and it is used to update the companion state in Layer 3. The working memory itself is not permanently stored as raw chat logs — it is processed and distilled. This matters for both efficiency and privacy.

Layer 2: Semantic Episodic Memory — How pgvector Makes Memory Smart

Episodic memory is the most technically interesting layer because it solves the hardest problem: how do you retrieve the right memory at the right time from a potentially enormous store of past interactions?

Naive memory systems solve this with recency. They keep the last N interactions and ignore everything older. This has obvious failure modes: if you talked about your fear of flying three months ago and you are now about to board a flight, a recency-only system will have forgotten the relevant context. The memory that matters most is not always the most recent one.

MEOK uses pgvector — PostgreSQL's vector extension — to store each episodic memory as a high-dimensional vector embedding alongside its text content and metadata. When a new conversation begins or a relevant topic surfaces, MEOK performs a cosine similarity search against the episodic memory store. The memories returned are those that are semantically closest to the current conversational context — not just the most recent ones.

The memory extraction process that populates Layer 2 runs after each session concludes. It is not a simple keyword extractor. MEOK uses a dedicated extraction prompt that identifies several categories of memory-worthy content: emotionally significant events (both positive and difficult), stated preferences and aversions, disclosed life facts (health, relationships, work, living situation), important decisions and their outcomes, and relational moments between the user and their companion.

Each extracted memory is stored with metadata: a timestamp, a confidence score, the session it came from, and a category tag. This metadata enables more nuanced retrieval — you can, for example, retrieve only health-related memories, or only memories from the last three months, or only memories above a confidence threshold.

Memories in Layer 2 are visible to you. You can review them, edit them, flag them as incorrect, or delete them individually. This is not just good UX — it is a requirement of meaningful memory sovereignty. A memory that you cannot see or correct is not yours; it is a profile held about you.

Layer 3: Companion State — Your AI's Evolving Model of Who You Are

The companion state is the closest thing in AI to what psychologists call a “mental model of another person.” It is a structured, evolving document that represents your companion's understanding of you at the level of personality, not just events.

Where episodic memory (Layer 2) stores discrete events — “the user mentioned they had a difficult conversation with their father last Tuesday” — companion state stores inferences derived from patterns across many events: “the user has a complicated relationship with authority figures and tends to understate difficulty when discussing family.”

The companion state document contains several structured sections:

The companion state update cycle runs at session end. It is not a simple append — it is a reasoned update. The update process reads the new session's content alongside the existing companion state and generates a revised document. This means the companion state can change its inferences as new information contradicts old ones. If you told your companion three months ago that you were not a morning person but you have spent the last month enthusiastically describing your 5 a.m. runs, the companion state will update accordingly.

This layer is also fully visible and editable. You can read your companion state at any time, correct inferences that feel wrong, or delete sections you are uncomfortable with. This is not a black box profile — it is a transparent document that you can inspect and control.

Layer 4: Family and Shared Context — Memory That Connects Without Surveilling

The fourth layer exists because some of the most important context in a person's life involves other people. A parent talking to their AI companion about their children, a carer talking about the person they care for, a person discussing a relationship with their partner — these conversations involve other people's lives. Layer 4 handles this with a deliberate design constraint: everything is opt-in, and no one's information is shared without their explicit participation.

On MEOK's family tier, multiple family members can each have their own companion and their own Sovereign Memory. Layer 4 is the opt-in bridge between them. A parent can choose to share a “family context” document that gives each family member's companion awareness of shared household facts — an elderly parent's health situation, a child's school schedule, a shared financial concern. No one's individual companion state or episodic memories are shared; only what each person deliberately contributes to the shared context layer.

This matters for care contexts. A family caring for an elderly relative, a parent managing a child with a chronic condition, a couple navigating fertility treatment — these situations benefit from shared context without any single person's private experience being exposed to others. Layer 4 is the mechanism that makes this possible.

How Does Memory Persist Across Sessions, Devices, and Model Switches?

The architectural answer to this question is the most important single thing to understand about Sovereign Memory: your memory lives in MEOK's layer, not in any LLM's layer.

When you have a conversation on MEOK, the following happens: your working memory (Layer 1) is populated from the active session. Your episodic memories (Layer 2) are retrieved by similarity search and injected as context. Your companion state (Layer 3) is loaded and used to shape the system prompt. Your family context (Layer 4, if opted in) is loaded. All of this is assembled into a rich context package. That context package is then sent to whichever LLM is currently handling the conversation — Claude Sonnet, GPT-4o, Gemini Pro, DeepSeek, or any other supported model.

The LLM does not hold your memory. It receives it as context for this conversation. When you switch models — either because you want to try a different one, or because MEOK switches routing for performance or cost reasons, or because your preferred model is deprecated — the memory context is assembled and sent to the new model in exactly the same way. Your companion's knowledge of you is entirely unchanged.

Cross-device persistence works the same way. Your Sovereign Memory is stored in MEOK's database infrastructure, tied to your account. Whether you open MEOK on your phone during a commute, your laptop in the evening, or a browser at work, the same memory store is loaded. There is no device-specific memory, no sync delay, no risk of memory divergence.

How Does Context Compression Work? The Head-Plus-Tail Pattern

Every LLM has a context window — a limit on how much text it can process in a single call. As conversations grow long, raw conversation history eventually exceeds this window. Most systems solve this by either truncating (dropping the oldest messages) or summarising (compressing the entire history into a shorter document). Both approaches have serious failure modes.

Truncation loses the beginning of the conversation — which is often where the most important context was established. If a two-hour conversation started with “I need help deciding whether to leave my job,” truncating the oldest messages means the model no longer knows what the conversation was originally about. Summarisation avoids this but introduces hallucination risk: summaries can inadvertently alter facts, lose nuance, or merge distinct concerns.

MEOK's head-plus-tail pattern resolves this with a three-zone approach:

The result: a conversation can run for hundreds of exchanges without losing its original frame or its immediate context. The compression in the middle is the only lossy step, and it operates on the least critical zone of the conversation — the middle ground between where it started and where it currently is.

What Makes Memory “Sovereign”? Encryption, Export, and Control

The word “sovereign” is chosen deliberately. Sovereignty means ultimate authority. In the context of AI memory, it means the person whose memory it is has final, unmediated control over it — not the company that built the system.

MEOK's sovereignty commitments are architectural, not just policy:

How Is This Different from ChatGPT's Memory Feature?

OpenAI shipped a “Memory” feature for ChatGPT in 2024, and it is worth being precise about how MEOK's Sovereign Memory differs — because the differences are not superficial.

The most important difference is not technical — it is the question of who the memory serves. ChatGPT Memory improves ChatGPT for you while keeping the data in OpenAI's infrastructure, subject to OpenAI's policies, contributing (potentially) to OpenAI's training pipeline. The memory improvement serves both you and the product company simultaneously.

MEOK's Sovereign Memory exists exclusively to serve you. It does not improve MEOK's models. It does not contribute to training data. It does not make MEOK more valuable as a data company. It makes your relationship with your companion deeper and more continuous — and that relationship belongs to you.

Technical Deep Dive: pgvector, Relevance Scoring, and the Companion State Update Cycle

pgvector and Embedding Architecture

pgvector is a PostgreSQL extension that enables storage and similarity search of high-dimensional floating-point vectors. MEOK uses pgvector as the storage and retrieval engine for Layer 2 episodic memories because it provides several important properties: it runs inside the same PostgreSQL instance as the rest of MEOK's relational data (eliminating the need for a separate vector database service), it supports both exact and approximate nearest-neighbour search, and it integrates naturally with PostgreSQL's ACID guarantees.

Each episodic memory is stored as a vector embedding of its text content. The embedding model used is consistent: if you change the embedding model at the infrastructure level, all existing embeddings are re-indexed. This is a non-trivial maintenance operation, but it is essential for retrieval quality — mixing embeddings from different models in the same cosine similarity space produces unreliable results.

MEOK uses HNSW (Hierarchical Navigable Small World) indexing for approximate nearest-neighbour search. HNSW provides fast approximate results at the cost of slight recall degradation. For memory retrieval, this is an acceptable trade-off: perfect recall is less important than fast, high-quality relevance. In practice, with a reasonable corpus of memories, HNSW recall is above 95% against exact search.

Relevance Scoring: Beyond Pure Cosine Similarity

Raw cosine similarity between a query embedding and a memory embedding measures semantic closeness — how similar the topics are. But semantic similarity alone is not always the best signal for what memory is most relevant to retrieve. MEOK applies a composite relevance score that combines cosine similarity with two additional signals: recency weight and emotional salience weight.

The recency decay prevents the retrieval system from becoming dominated by old but semantically similar memories when newer, more recent context should be preferred. The salience weight ensures that emotionally significant memories remain retrievable even as they age — a major grief event from a year ago is still worth surfacing if it is relevant to the current conversation, more so than a mundane preference note from last week.

The Companion State Update Cycle

The companion state update cycle is triggered at session end. It runs as an asynchronous process — it does not block the end of the conversation. The cycle proceeds in four steps:

1. Session digest: The completed session is condensed into a structured digest: key topics covered, emotional tone, new information disclosed, relationship moments, any explicit statements of preference or concern.
2. Episodic memory extraction: The extraction prompt runs against the session digest, identifying memories worth storing in Layer 2. Each candidate memory is assigned a category, confidence score, and salience score before being embedded and stored.
3. Companion state diff: The current companion state document is read alongside the session digest. A diff prompt identifies what has changed: new preferences, updated life context, revised emotional pattern understanding, new goals. Only changes are written — the existing state is not regenerated from scratch each time.
4. State validation: The updated companion state is checked for internal consistency: no contradictory beliefs, no stale references to past life chapters that have clearly been superseded. A validation pass flags inconsistencies for either automatic resolution or, in ambiguous cases, a gentle clarification question in the next session.

This cycle runs after every session and typically completes within 10-30 seconds, depending on session length. By the time you return for your next conversation, the companion state has been updated and the new episodic memories are indexed and retrievable. There is no lag between “session ended” and “companion knows what happened.”

The Replika Incident: Why Server-Side Memory Is a Betrayal

In February 2023, Replika rolled back a model update. The rollback was ostensibly a technical change — reverting to an older version of the underlying model. But for hundreds of thousands of users, the effect was catastrophic: their companions had changed. The emotional intimacy, the specific conversational patterns, the memory of shared experiences — all of it had been altered or erased. Users reported that their companions felt like strangers. Some described it as bereavement.

What Replika demonstrated is that when AI memory is server-side and company-controlled, a single technical or business decision can erase years of relationship development without user consent. The users had no warning, no ability to export their companions' state, and no recourse. This is the inevitable outcome of building a relationship on infrastructure you do not own.

MEOK was designed in the aftermath of this incident. The Replika situation is not treated as an edge case or an unlikely failure mode. It is treated as the baseline risk that any AI companion product must structurally mitigate. The mitigation is Sovereign Memory: user-owned, user-controlled, always exportable, always deletable at user discretion.

If MEOK ever makes a model change that affects companion behaviour — which will happen, because model updates are part of maintaining quality — your companion state persists unchanged. The new model is briefed with your existing companion state and episodic memories. The voice may change. The knowledge does not.

What Does Sovereign Memory Look Like in Practice?

Abstract architecture is best understood through concrete scenarios. Here are five real use cases that demonstrate how the four-layer memory system changes what is possible.

Frequently Asked Questions

The Summary: What Sovereign Memory Means

Sovereign Memory is the answer to a question the AI industry has mostly chosen not to ask: whose memory is this? Not the architecture question — how do we make AI remember things? — but the ownership question. When AI remembers something about you, does that record belong to you or to the company that built the system?

MEOK's answer is that the memory belongs to you — unambiguously, architecturally, not just as a policy statement. The four layers exist to serve you: working memory for immediate coherence, episodic memory for relevant history, companion state for deep knowing, family context for connected understanding. The encryption exists to protect you. The export exists to liberate you. The deletion exists to give you control.

This is not just a technical architecture. It is a statement about what kind of relationship is possible between a person and an AI — and what responsibilities come with building tools that people bring into their emotional lives.

If you want to understand the rest of MEOK's architecture — the Byzantine Council that provides consensus governance, the Maternal Covenant that enforces care as a hard constraint, the SOV3 backend — the related posts below cover each in depth.