Doctrinal position: memory governance

Doctrinal position: memory governance

This page defines a doctrinal and normative position on memory governance in AI systems (advanced RAG, stateful agents, active memories).

This page is neither an operational method, nor a service offering, nor a promise of result. It exists to reduce ambiguity by declaring governance invariants applicable to systems that persist states and consolidate “memories”.

For public normative specifications (machine-first standard), see the interpretive governance GitHub repository, section “v0.2.0 (memory-aware)” and “ops-pack/M-layer”.

Table of contents

1. Problem
2. Doctrinal thesis
3. Non-negotiable invariants
4. Conformance break
5. Boundaries and non-objectives
6. Public specifications
7. Status

1. Problem

“Classic” RAG retrieves context. It does not govern truth, validity, obsolescence, or the consolidation of statements.

An active cognitive memory introduces mechanisms of:

• Consolidation (summaries, fusions, compressions, persisted “facts”)
• Controlled forgetting (invalidations, archiving, prioritization, cleanup)
• Temporal evolution (t0, t1, t2, cumulative drift)

This power also increases risk: an untyped hypothesis at t0 may become a consolidated “fact” at t1. Memory then becomes a mechanism for fossilizing errors.

2. Doctrinal thesis

An active memory is a surface of misalignment and drift by default. Any architecture that writes, consolidates, or erases memory objects must expose auditable artifacts and exogenous governance rules.

In practice:

• Fragile endogenous alignment: a model can be re-optimized (post-training) without preserving its invariants of refusal and prudence.
• Risky active memory: consolidation without typing or traceability transforms inference into fact.
• Enforceable guarantee: only constraints attached to execution (logs, hashes, rules, audits) can stabilize behavior over time.

3. Non-negotiable invariants

The following points constitute minimum doctrinal requirements:

1. Mandatory typing: no memory object may exist without explicit typing (statement type, status, origin, verdict).
2. Full traceability: every memory object must reference its sources (or explicitly state “absence of source” as a blocking condition for consolidation).
3. Temporal validity: every object must carry a temporal perimeter (valid from / valid until, or “unknown”).
4. Immutable journal: every creation, consolidation, invalidation, or logical deletion must be journaled (append-only).
5. Controlled forgetting: no silent erasure. Forgetting is performed by invalidation/archiving with an explicit reason.
6. Explicit consolidation rules: consolidation permitted only if typing, traceability, and coherence constraints are satisfied.
7. Automatic conformance break: any structural modification that prevents auditability triggers a conformance break.

4. Conformance break

A conformance break is triggered, at minimum, by:

• change of model version (weights), or unattested post-training;
• modification of consolidation or forgetting rules;
• reconstruction of embeddings without integrity recalculation and without journal;
• alteration or loss of memory event journals;
• change of normative source hierarchy without trace and without revalidation.

Doctrinal effect: no high confidence grade may be maintained without re-audit.

5. Boundaries and non-objectives

This position does not claim to:

• replace internal alignment or refusal mechanisms;
• guarantee the absence of errors;
• impose a technology (vector DB, graph, NDJSON, etc.).

It instead imposes governance and auditability invariants, independent of implementation.

6. Public specifications

Machine-first normative specifications are published on GitHub:

• Core v0.2.0 (memory-aware): primitives and minimum requirements.
• Ops-pack M-layer: operational rules (journal, consolidation, forgetting, temporal integrity).
• Schemas + examples: memory objects, logs, break scenarios.

Audits (e.g. IIP-Scoring and temporal derivatives) must reuse memory artifacts as verifiable inputs.

7. Status

Status: draft. The normative formalization first targets architectural coherence (core extension + M-layer), then empirical validation via real audits on stateful systems.