🤖 machine learning

MemArchitect: A Policy Driven Memory Governance Layer

MemArchitect introduces a policy-driven governance layer that decouples memory lifecycle management from model weights to enforce rules on decay, conflict resolution, and privacy, thereby preventing context contamination and improving the reliability of persistent LLM agents.

Original authors: Lingavasan Suresh Kumar, Yang Ba, Rong Pan

Published 2026-03-20

📖 5 min read🧠 Deep dive

CC BY 4.0

Original authors: Lingavasan Suresh Kumar, Yang Ba, Rong Pan

Original paper licensed under CC BY 4.0 (http://creativecommons.org/licenses/by/4.0/). ✨ This is an AI-generated explanation of the paper below. It is not written or endorsed by the authors. For technical accuracy, refer to the original paper. Read full disclaimer

Imagine you have a brilliant, super-smart assistant who remembers everything you've ever told them. Sounds great, right? But here's the problem: if you tell this assistant, "I'm single," in 2024, and then "I'm married" in 2025, a standard AI might get confused. It might pull up both facts at the same time, get overwhelmed, and start hallucinating (making things up) or giving you contradictory advice. It's like having a library where books are just thrown on the floor; eventually, you can't find the right one, or you grab a book that says the sky is green.

This paper introduces MemArchitect, a new "manager" for AI memory that fixes this chaos. Instead of just letting the AI hoard every single fact forever, MemArchitect acts like a strict but helpful librarian who actively curates what the AI remembers.

Here is how it works, broken down into simple concepts:

1. The Problem: The "Zombie Memory"

Current AI systems treat memory like a giant, passive bucket. You dump information in, and the AI tries to pull it out later.

The Issue: Over time, this bucket gets full of "zombie memories"—outdated facts, contradictions, and noise. If you ask the AI a question, it might grab a fact from three years ago that is no longer true, leading to confusion.
The Analogy: Imagine trying to cook a meal using a pantry where old, expired ingredients are mixed in with fresh ones. You might accidentally use the expired milk, ruining the dish.

2. The Solution: MemArchitect (The Active Librarian)

MemArchitect sits between the user and the AI. It doesn't just store data; it governs it. It decides what stays, what goes, and what gets highlighted based on rules (policies).

Think of MemArchitect as a Triage Nurse or a Talent Scout for information. Every piece of information has to "audition" to get into the AI's short-term attention span (the context window).

3. How the Librarian Works (The 4 Rules)

The paper outlines four main "jobs" this librarian does:

A. The "Forgetting" Engine (Lifecycle & Hygiene)

What it does: It mimics how human brains work. We forget things we don't use often, and we remember things we use a lot.
The Analogy: Imagine a garden. If you don't water a plant (use a memory), it withers and dies. MemArchitect uses a special schedule (called FSRS) to water the important plants and let the weeds die.
The Result: Old, useless facts (like "I bought a coffee on Tuesday") are automatically deleted or compressed into a simple summary ("I like coffee"). This keeps the garden tidy.

B. The "Truth" Engine (Consistency & Utility)

What it does: It checks if a memory is actually useful and true.
The Analogy: Imagine a Security Guard at a club. Even if a person looks like they belong (they are similar to what you asked), the guard checks their ID. If they are lying or irrelevant, they get kicked out.
The Result: If the AI tries to remember a fact that contradicts reality, the system lowers its "Trust Score" and stops using it. It prevents the AI from believing its own hallucinations.

C. The "Auction" Engine (Adaptive Retrieval)

What it does: It decides which memories are most important right now.
The Analogy: Imagine a Talent Show. Every memory is a contestant. If you ask a complex question, the system holds an auction. The most relevant, high-quality memories "win" the bid to enter the AI's brain. Less important memories are left out.
The Result: The AI focuses on the right facts for the specific task, rather than getting distracted by irrelevant history.

D. The "Budget" Engine (Efficiency)

What it does: It manages the AI's "brain space" (token limit).
The Analogy: Think of it like a wallet. If you are doing a hard math problem, the system saves more "money" (space) for thinking. If you are just looking up a simple fact, it spends less.
The Result: The AI doesn't run out of space, and it uses its brain power efficiently.

4. The Results: Why It Matters

The researchers tested MemArchitect against other AI memory systems.

The Winner: MemArchitect was much better at solving complex, multi-step problems and reasoning over long periods.
The Trade-off: It is worse at remembering every single tiny detail (like a specific timestamp from a year ago) because it aggressively deletes "one-time" facts.
The Takeaway: This is actually a good thing. It's better to have an AI that is smart, consistent, and doesn't get confused by old news, than an AI that remembers everything but is constantly hallucinating.

Summary

MemArchitect changes AI memory from a passive storage closet (where everything piles up and gets messy) into an active, smart manager. It actively cleans, verifies, and prioritizes information, ensuring the AI stays reliable, truthful, and focused on the task at hand. It's the difference between a chaotic attic and a well-organized, high-tech command center.

1. Problem Statement: The "Governance Gap"

As Large Language Models (LLMs) evolve from stateless chatbots into autonomous agents, they face a critical failure mode known as Memory Hallucination. Unlike standard hallucinations, this occurs when an agent retrieves conflicting, outdated, or contradictory facts from its own history (e.g., remembering a user is both single and married).

Current architectural paradigms (Operating Systems like MemGPT, efficient streaming like SimpleMem, and structured retention like MemoryBank) suffer from a "Governance Gap." They treat memory as a passive, append-only log or a static storage bucket. Consequently, they lack mechanisms to:

Resolve state contradictions.
Enforce privacy (e.g., "Right-to-be-Forgotten").
Actively prune obsolete data ("zombie memories").
Manage context pollution caused by expanding context windows.

2. Methodology: The MemArchitect Framework

MemArchitect introduces a governance middleware layer that decouples memory lifecycle management from model weights. Instead of passive retrieval, it implements an active "Triage & Bid" economy where information must compete for the context window based on explicit, rule-based policies.

The system operates via a Governance Engine anchored in four foundational pillars:

A. Lifecycle & Hygiene (The "Forgetting" Engine)

FSRS Decay: Replaces simple exponential decay with the Free Spaced Repetition Scheduler (FSRS v4). Memory retrievability ( $R$ ) is calculated based on stability ( $S$ ) and time ( $t$ ), mimicking biological forgetting curves.
Entropy-Triggered Consolidation: A background process monitors information density. High redundancy triggers a cleanup cycle where:
- Fading episodic memories ( $0.3 \le R \le 0.7$ ) are compressed into stable semantic facts.
- "Forgettable" noise ( $R < 0.3$ ) is physically pruned.

B. Consistency & Truth (The "Utility" Engine)

Kalman Filter Loop: Tracks a "Trust Score" ( $U$ ) for every memory. Useful memories gain inertia, while hallucinations are mathematically down-weighted based on usage feedback.
Relevance Discriminator (Veto Gate): A secondary Cross-Encoder acts as a strict gatekeeper. Even if a memory passes vector search, it is discarded if it fails a strict entailment threshold (e.g., $< 0.1$ ), preventing semantically similar but irrelevant noise from polluting the context.

C. Adaptive Retrieval (The "Auction" Engine)

Multi-Hop Decomposition: Complex queries are broken into atomic sub-questions to retrieve disjointed facts.
Adaptive Scoring: Queries are classified (Fact, Temporal, Reasoning) to tune retrieval weights. For example, old memories are penalized for immediate reasoning tasks ( $\lambda = 1.0$ ) but treated as timeless for facts ( $\lambda = 0$ ).
Hebbian Graph Expansion: Implements associative learning ("memories that fire together are wired together"). If Memory A and B are frequently co-retrieved ( $P(B|A) > 0.7$ ), retrieving A automatically pulls B into context.

D. Efficiency (The "Budget" Engine)

Adaptive Token Budgeting: The system dynamically allocates the context window. High-confidence retrieval reserves tokens for reasoning (30%), while low-confidence retrieval maximizes the "Recall Reserve" (10%) to search for facts.

Execution Workflow:

Read Path: Queries are classified, decomposed, and candidates are ranked via an auction, filtered by the veto gate, and expanded via Hebbian links.
Reflect Path: Post-generation, the system analyzes which memories contributed to the answer, updating the Kalman Utility and FSRS Stability scores.
Background Path: During idle time, the hygiene engine deletes low-retrievability noise and consolidates fading memories.

3. Key Contributions

Paradigm Shift: Moves memory management from passive retrieval to active adjudication.
Policy-Driven Governance: Introduces a unified protocol covering lifecycle, consistency, provenance, and efficiency, ensuring the agent's context is proactively managed.
Model Agnosticism: Unlike frameworks like MemOS that modify model parameters or require OS-level integration, MemArchitect operates as an external layer without altering model weights, making it lightweight and compatible with various LLMs.
Mathematical Rigor: Integrates established theories (FSRS, Kalman Filters, Hebbian Learning) into a cohesive memory architecture.

4. Experimental Results

The system was evaluated on the LoCoMo-10 benchmark (long-horizon conversational memory) using Qwen-3B and Llama-3.1-8B.

Comparison with SimpleMem (Algorithmic Efficiency Baseline):
- MemArchitect achieved a dominant sweep, improving accuracy by +27.5% in subgroup analysis.
- Temporal Reasoning: +39.2% improvement (SimpleMem failed due to indiscriminate compression of temporal markers; MemArchitect prioritized them via FSRS).
- Multi-Hop Reasoning: +29.1% improvement.
- Conclusion: Policy-driven adjudication preserves context fidelity better than semantic compression.
Comparison with MemOS (System-Level Governance Baseline):
- Trade-off: MemOS (which retains all logs) outperformed MemArchitect in raw recall tasks like Single-Hop and Temporal reasoning because it does not prune data. MemArchitect saw a -44.9% drop in Temporal recall due to aggressive pruning of "one-shot" facts.
- Advantage: MemArchitect significantly outperformed MemOS in Open Domain (+11.3%) and Multi-Hop (+4.1%) tasks.
- Significance: MemArchitect shifts the failure mode from dangerous "Context Pollution" (hallucinations) to tunable "Over-Pruning," which is a manageable parameter rather than a structural flaw.
Aggregate Performance: MemArchitect showed a +7.45% average accuracy improvement across all tasks compared to baselines.

5. Significance and Future Work

MemArchitect demonstrates that governance is essential for autonomous agentic environments. By treating memory as a governed resource rather than a static database, it prevents "context collapse" and ensures long-horizon coherence.

Future Directions:

Evaluation on LongMemEval for significantly longer interaction turns.
Validation on persona-centric benchmarks (e.g., PreFEval, PersonaMem) to ensure stable identity preservation.
Calibration of FSRS for low-frequency fact retention and implementation of planned safety policies (e.g., "Right-to-be-Forgotten" cascades and toxic memory filters).

In summary, MemArchitect provides a robust framework for transforming LLMs from stateless chatbots into reliable, self-correcting agents capable of managing their own memory lifecycles through policy-driven governance.