MemArchitect: Policy-Based Memory in AI

• MemArchitect is a memory architecture that uses policy-based governance to transform static memory into an active substrate for cognition and planning.
• It integrates dynamic components like front-end classifiers, retrieval auctions, and hygiene engines to ensure memory integrity while enforcing decay, privacy, and conflict resolution.
• Empirical benchmarks demonstrate significant performance gains on tasks such as multi-hop reasoning, underscoring its practical impact on autonomous intelligent systems.

MemArchitect is a general designation for memory architectures that prioritize policy-driven memory governance and representational minimality in autonomous intelligent systems. The term encompasses both contemporary memory governance layers for persistent LLM agents and foundational architectures for self-organizing memory in autonomous machines. The central objective is to transform memory from a passive log or storage facility into an actively managed, policy-enforced, and topologically interpretable substrate for cognition and planning, with formal guarantees relating to privacy, temporal decay, factual integrity, and learnability (Kumar et al., 18 Mar 2026, Guralnik et al., 2015).

1. Architectural Framework for Policy-Governed Memory

MemArchitect in the LLM context is instantiated as a governance layer interposed between an agent’s input/output operations and its underlying memory store. Memory is treated not as an inert database, but as a resource subjected to continual lifecycle adjudication according to explicit, rule-based policies. These policies operate across four principal feedback loops:

• Front-end Classifier: Performs intention detection to categorize inputs (e.g., Fact, Reasoning, Temporal, Open-Domain). Assigns decay weights ($\lambda$) and utility boosts ($\beta$) as metadata for subsequent retrieval and scoring pipelines.
• Retrieval Auction: Applies a vector retriever to produce a top-$K$ candidate set, followed by adaptive scoring that incorporates similarity, decay, and utility. A cross-encoder (relevance discriminator) excludes non-entailing candidates. Hebbian graph expansion augments recall using co-occurrence, while adaptive token budgeting defines the permissible LLM context window.
• Reflector: Tracks usage in model outputs for token or citation overlap, applying both Kalman filtering to trust/utility scores and Forgetting Curve (FSRS) updates to memory stability.
• Hygiene Engine: Executes continuous decay (FSRS-based), consolidates low-stability episodic logs, applies privacy controls, and runs background purging and noise compression.

This modular design decouples memory lifecycle management from model parameters, supporting dynamic enforcement of memory policies (Kumar et al., 18 Mar 2026).

2. Formal Policy Specification

Policies in MemArchitect are expressed as formal predicates and operational formulas implemented via a lightweight Policy DSL. The principal policy classes are:

• Memory Decay Schedule: The retrievability function is

$$D(t) \equiv R(t) = \left(1+\frac{19}{9}\cdot\frac{t}{S}\right)^{-1}$$

where $S$ is the memory’s stability and $t$ the time since last review. The decay threshold $R(t)=0.32$ when $t=S$.

• Conflict Resolution Operator $\mathcal{C}$: When two memories $m_i, m_j$ are contradictory,

$$\mathcal{C}(m_i, m_j) = \underset{m \in \{m_i, m_j\}}{\arg\max} [ \mathrm{SourceAuth}(m) \times \mathrm{Recency}(m)]$$

where $\mathrm{SourceAuth}$ denotes source credibility and $\mathrm{Recency}$ the timestamp.

• Privacy Control Constraint $P(m)$:

$$P(m) = (\neg \mathrm{ContainsToxicity}(m)) \land (\neg \mathrm{InGDPRDeletionList}(m))$$

This predicate filters insertions and retrievals.

Rule enforcement relies on runtime policy triggers across the memory lifecycle: on insertion, on retrieval, post-generation reflection, and during idle periods (Kumar et al., 18 Mar 2026).

3. Governance Enforcement and Algorithmic Workflow

MemArchitect’s enforcement routines are implemented via a rule-engine that compiles DSL policies into in-memory predicates and action callbacks. Key pseudocode mechanisms include:

• Memory Insertion (write-path privacy enforcement):

  def insert_memory(m): if not P(m): return m.stability = init_stability() m.utility = init_utility() store.add(m)

• Decay Enforcement:

def enforce_decay(): now = current_time() for m in store.all_memories(): R = D(now - m.last_review, m.stability) if R < 0.3: store.delete(m) elif R < 0.7: consolidate_to_semantic(m)

• Conflict Detection and Resolution:

def detect_and_resolve(new_mem): conflicts = store.find_contradictory(new_mem) for old_mem in conflicts: win = C(new_mem, old_mem) loser = old_mem if win==new_mem else new_mem store.delete(loser)

Policy violations trigger either rejection on write, filtering on read, or consolidation/purging during background maintenance (Kumar et al., 18 Mar 2026).

4. Empirical Performance and Benchmarking

MemArchitect-based LLM agents were evaluated on the LoCoMo-10 benchmark emphasizing long-horizon QA, including Single-Hop, Multi-Hop, Temporal Reasoning, and Open-Domain tasks. Comparative baselines included MemOS (OS-style) and SimpleMem (compression + consolidation).

Model	Single-Hop	Multi-Hop	Temporal	Open-Dom	Average
SimpleMem→Qw3B	79.4%	66.7%	56.1%	67.1%	67.33%
MemArchitect→Qw3B	95.0% (+15.6)	95.8% (+29.1)	95.3% (+39.2)	93.1% (+26.0)	94.8% (+27.5)
MemOS→L3.1	74.0%	36.0%	72.0%	45.0%	56.8%
MemArchitect→L3.1	53.2% (−20.8)	40.1% (+4.1)	27.1% (−44.9)	56.3% (+11.3)	44.2% (+7.4)

On Qwen-3B, MemArchitect demonstrated a +27.5% accuracy increase over SimpleMem, evidencing the critical impact of policy adjudication over naive memory consolidation. On Llama-3.1-8B, MemArchitect yielded superior performance on multi-hop and open-domain, but its stricter decay and conflict policies led to performance trade-offs in temporal and single-hop domains (Kumar et al., 18 Mar 2026).

5. Data Structure Minimality and Topological Learning

In the more foundational formulation (Guralnik et al., 2015), MemArchitect is defined for Discrete Binary Agents operating on a sensorium $\Sigma$ of Boolean sensors. The architecture consists of:

• Snapshot $S_t$: Maintains a state vector $\sigma \subset \Sigma$ and a symmetric weight matrix $w:\Sigma \times \Sigma \to \mathbb{R}_{\geq0}$, with learning thresholds $\tau_{ab}$ for each pair.
• Weak Poc-Set $P_t$: Derived by orienting sensor pairs according to

$w_{a b^*} < \min\{w_{ab}, w_{a^*b}, w_{a^*b^*}\}$

followed by transitive closure. This structure encodes logical implications among sensed features.

• Cubical Complex $M_t$: The dual CAT(0) cubical complex Cube($P_t$), whose vertices are coherent $*$-selections. This object is provably minimal: any weaker poc-set yields a larger cubing, and any stricter poc-set omits valid sensory classes. Thus $M_t$ uniquely represents all observed sensory equivalence classes.

The cubical complex structure enables the use of geometric planning algorithms, exploiting convexity and Helly’s property for efficient policy-driven memory retrieval and action selection (Guralnik et al., 2015).

6. Learnability, Planning, and Customization

Learning in MemArchitect, for DBA systems, is supported by empirical and discounted snapshot rules. Empirical updates sum indicator counts of co-activation; discounted updates incorporate exponential decay. Both approaches guarantee convergence to an accurate poc-set, and thus global model-space, under persistent exploration.

In policy-governed LLM systems, customization is possible through:

• Tuning FSRS constants and decay schedules.
• Adjusting decay penalties $\lambda$ by task (e.g., $\lambda{=}0$ for persistent facts).
• Modifying cross-encoder entailment thresholds for coverage–precision trade-offs.
• Implementing domain-specific source authority weighting.
• Extending the privacy DSL to cover additional compliance regimes (e.g., personal identifiable information patterns, sector-specific legal hooks) (Kumar et al., 18 Mar 2026).

Signal-propagation algorithms (CAT(0) projection), used in the foundational paradigm, guarantee correct and efficient planning via nearest-point projection in the memory complex, without global search or backtracking (Guralnik et al., 2015).

7. Broader Significance and Research Trajectory

The policy-driven MemArchitect paradigm establishes a reproducible, enforceable, and theoretically principled approach to memory management in both LLM-based agentic systems and fully autonomous cognitive architectures. In LLM systems, explicit governance prevents factual contradiction, memory contamination, and compliance violations, and has been empirically shown to outperform passive or blind compressed retrieval schemes. In representational learning, CAT(0) cubical complexes afford topological guarantees on internal model minimality and learnability.

The abstraction of MemArchitect, applicable from symbolic weak-poc-set learning to dynamic cognitive governance in large-scale language agents, foregrounds memory as a first-class, policy-mediated, and actively managed resource central to the safe, reliable operation of autonomous and persistent AI systems (Kumar et al., 18 Mar 2026, Guralnik et al., 2015).