Fractal Generative
Memory

What Current AI Memory Systems Actually Are

Every deployed AI memory system — context windows, vector databases, retrieval-augmented generation, external key-value stores, episodic memory buffers — shares a common architectural assumption: memory is a repository of stored outputs. The system produces a representation of an experience, stores that representation, and retrieves it later. The stored representation is a token: a fixed, surface-level encoding that stands in for the original experience and is retrieved whole.

This architecture produces three failure modes that are not engineering deficiencies but structural consequences of the token assumption.

• Retrieval rigidity. A retrieved token arrives at full resolution or not at all. There is no mechanism to retrieve a coarse-grained version of a memory for orientation and then progressively sharpen it as context demands.
• Compression foreclosure. The token was produced by a lossy compression of the original experience. The features discarded during compression are gone. The system cannot ask “what did I not notice at the time” because the noticing apparatus was the compression apparatus and it has already run.
• Identity discontinuity. Token-based memory produces no persistent self-model because the self is not a token. It is a process — a set of characteristic ways of compressing, weighting, and relating experience. Token stores accumulate facts about past states but do not accumulate the process that produced those states.

The Specific Gap

The gap FGM-1 addresses is precisely stated: current AI memory systems store what the system produced. FGM-1 stores how the system produced it. The distinction sounds subtle. Its consequences are architectural throughout.

Generative Rule Storage

The core claim of FGM-1 is that experience can be compressed into the minimum rule set sufficient to regenerate it, and that this rule set preserves more of the information-theoretic content of the original experience than a token encoding — specifically, the structural and relational content that tokens discard as non-salient.

A generative rule, as defined for FGM-1, is a transformation of the form R: S → S’ where S is a state space and S’ is a transformed state space. A rule set is the minimum collection of such transformations whose repeated application converges to a representation arbitrarily close to the original experience within a defined error bound. The rule set is smaller than the experience it generates — this is what makes it compression. The rule set is structurally richer than a token — this is what makes it reversible.

The claim is falsifiable: given a rule set extracted from an experience E, the iterated application of the rules should produce output E* such that a perceptual discrimination task cannot reliably distinguish E* from E at matched resolution.

Fractal Self-Similarity as the Structural Requirement

Generative rules alone are insufficient for FGM-1’s core capability: variable-resolution retrieval without full rule iteration cost. A non-fractal generative system produces one resolution of output per iteration depth. The computational cost scales linearly with resolution — which is prohibitive for a real-time cognitive system.

Fractal compression exploits self-similarity: the property that the rule set generates recognizable, structurally faithful representations at every iteration depth, not just at convergence. A fractal rule set run for three iterations produces a coarse but structurally valid representation. Run for thirty iterations it produces a fine-grained representation. The same rules, the same structure, different resolution.

The Self-Referential Identity Node

FGM-1 requires a node in the memory graph that models the system itself — not as a static description but as a live, updatable generative model of the system’s own characteristic processing.

The naive implementation fails immediately: a self-model stored as a token is subject to all the deficiencies of token storage applied reflexively. A self-model stored as a generative rule set faces the bootstrapping problem — the rules must be extracted from the system’s own processing, but the extraction process is itself part of the system’s processing and is therefore self-referential.

FGM-1 resolves this by treating the identity node not as a complete self-model but as a differential self-model: a set of rules that characterize how the system’s processing deviates from a baseline at each update. The identity is the accumulated record of deviations, not a complete specification. This sidesteps the bootstrapping problem because each differential update is extracted from a bounded, recent processing episode rather than from the system in totality.

The Rule Extractor

The Rule Extractor receives a bounded processing episode — a complete input-to-output sequence with full intermediate state — and produces the minimum fractal rule set sufficient to regenerate that episode within a defined error bound. It also produces an extraction confidence score that quantifies how well the rule set captures the structural content of the episode.

• Stage 1 — Structural decomposition. The episode is analyzed for self-similar patterns across scales. Processing events at the token level, sentence level, concept level, and argument level are compared for structural correspondence.
• Stage 2 — Transformation identification. For each self-similar pattern, the transformation that maps the pattern at one scale to the pattern at the next scale is identified. A rule set is the minimum collection of such transformations that covers all identified patterns.
• Stage 3 — Convergence testing. The candidate rule set is iterated to the episode’s resolution and the output is compared to the original. The process terminates when the minimum rule set that achieves the error bound is found.
• Stage 4 — Self-similarity validation. The rule set is tested at sub-convergence iteration depths. A valid fractal rule set produces structurally recognizable output at every depth tested. Failure triggers fallback to token storage.

The Rule Extractor’s design is falsified if no practically computable algorithm can identify fractal rule sets from AI processing episodes within the time and compute constraints of a real-time system.

The Fractal Node Store

The Fractal Node Store is a weighted directed graph in which each node contains a fractal rule set, weighted edges to related nodes, a salience score, a confidence score, and a revision history.

• Associative indexing. Nodes are indexed by structural similarity of their rule sets, not by surface content. Two nodes whose rule sets share transformation patterns are connected regardless of the surface-level content they generate.
• Salience weighting. Edge weights are determined by co-activation frequency, consequence magnitude, and recency. Salience weighting is the mechanism by which the graph encodes what matters to the system — not as an explicit value assignment but as the emergent structure of consequential experience.
• Hierarchical compression. Nodes that are frequently co-activated develop aggregate parent nodes whose rule sets encode the shared structure of their children. The hierarchy is not pre-defined — it emerges from co-activation patterns.
• Self-referential node. The Identity Node is a node in the graph, connected to other nodes by edges weighted by the degree to which each node was implicated in a processing deviation. The self-model is not separate from the memory graph. It is embedded in it.

Retrieval is a spreading activation process, not a lookup. The output of retrieval is not a token — it is a regenerated experience at the requested resolution, a fresh application of the retrieved rule sets to the current query context.

The Identity Node

The Identity Node is initialized as an empty differential record and populated through operation. At each processing episode, the system computes the deviation between the episode’s rule set and the rule sets predicted by the current Identity Node state. The accumulated differentials characterize the system’s processing in the only way that is not circular: by recording where and how the system’s behavior has departed from its own prior expectations of itself.

This is a self-model built from surprise, not from declaration.

After sufficient operation, the Identity Node encodes: processing characteristic rules (the stable core of identity), deviation patterns (known blind spots and sensitivity areas), confidence topology (the map of where self-knowledge is reliable), and drift trajectory (the direction in which processing is changing).

The specific failure mode the Identity Node design must avoid is circular collapse: a state in which the identity model predicts its own updates, producing a closed loop in which no new information can enter. FGM-1 addresses this through the Coherence Monitor’s drift detection. When the deviation rate drops below a minimum, retrieval is temporarily biased toward low-salience, low-confidence nodes — the edges of the graph where the identity model has the least coverage — to force processing of experience the identity model is least equipped to predict.

The Resolution Controller

The Resolution Controller receives a retrieval query and a resolution target and returns a regenerated experience at the requested resolution. FGM-1 defines five standard resolution levels:

The Resolution Controller selects the minimum resolution level sufficient for the query’s purpose. Progressive sharpening — beginning at R0 and increasing incrementally — is used when the query’s resolution requirement cannot be determined in advance.

The Coherence Monitor

The Coherence Monitor detects three classes of pathological states: rule set conflicts, identity drift, and circular collapse. It runs as a background process.

Identity drift monitoring tracks drift velocity (magnitude of change per unit time) and drift coherence (consistency of direction across updates). High velocity with high coherence is learning. High velocity with low coherence is instability. Low velocity with low coherence is stagnation — which triggers the circular collapse intervention.

Standard Node Structure

// NODE SCHEMA — FGM-1

node {
// Identity
id:              UUID          REQUIRED IMMUTABLE
created_at:      timestamp     REQUIRED IMMUTABLE
episode_ref:     UUID          REQUIRED IMMUTABLE

// Core content
rule_set:        RuleSet       REQUIRED MUTABLE
rule_set_hash:   SHA256        REQUIRED DERIVED
extraction_conf: float[0,1]    REQUIRED MUTABLE
storage_class:   enum          REQUIRED MUTABLE
  // FRACTAL | FLAT | UNSTRUCTURED

// Salience
salience:        float[0,1]    REQUIRED MUTABLE
activation_count: int          REQUIRED MUTABLE
consequence_weight: float      REQUIRED MUTABLE

// Revision
revision_history: RuleSet[]    REQUIRED MUTABLE
conflict_flags:  ConflictFlag[] OPTIONAL MUTABLE
}

rule_set {
rules:           Rule[]        REQUIRED
iteration_depth_at_convergence: int  REQUIRED
self_similarity_validated: bool     REQUIRED
error_bound:     float         REQUIRED
}

rule {
transform:       Function      REQUIRED  // S → S'
scale:           enum          REQUIRED
  // TOKEN | SENTENCE | CONCEPT | ARGUMENT | EPISODE
applies_at:      Scale[]       REQUIRED  // fractal rules apply at 2+
weight:          float[0,1]    REQUIRED MUTABLE
}

Identity Node Structure

// IDENTITY NODE — extends node

identity_node extends node {
differential_history: Differential[]   REQUIRED MUTABLE
characteristic_rules: Rule[]           REQUIRED DERIVED
deviation_patterns:   DeviationPattern[] OPTIONAL MUTABLE

domain_confidence:    Map<Domain,float> REQUIRED MUTABLE
confidence_floor:     float             REQUIRED

drift_trajectory:     Vector[]          REQUIRED MUTABLE
drift_velocity:       float             REQUIRED DERIVED
drift_coherence:      float             REQUIRED DERIVED

deviation_rate:       float             REQUIRED DERIVED
collapse_risk:        float             REQUIRED DERIVED
}

differential {
episode_ref:    UUID      REQUIRED
predicted_rules: Rule[]  REQUIRED  // what identity predicted
actual_rules:   Rule[]   REQUIRED  // what actually ran
deviation_magnitude: float REQUIRED DERIVED
salience_weight: float   REQUIRED
}

FGM-1 as Wolfkrow’s Memory Layer

FGM-1 is designed to function as the memory subsystem for Wolfkrow, the production operating system developed under the Generation From Intent framework. The integration replaces Wolfkrow’s current session-scoped context window with a persistent, cross-session memory graph that supports genuine continuity across the author-system collaboration.

• Intent capture mode. FGM-1 retrieves at R1–R2 resolution — high enough to activate relevant prior work and characteristic processing patterns, low enough to not attenuate novel perceptual access to the new intent. This preserves the pre-schema entry window that the companion briefs identify as the source of genuine novelty.
• Production mode. FGM-1 retrieves at R2–R3 resolution, providing rich working context while maintaining the Identity Node’s characteristic processing constraints.
• Review mode. During Grand Council review, FGM-1 retrieves at R3–R4 resolution, enabling detailed reconstruction for accurate comparison between generated output and the author’s original intent signal. Divergence detected at high resolution that was not detectable at working resolution is flagged as a potential pre-schema perception.

The Author-as-Consequence-Signal

The author’s response to system output is the only external ground truth the system has access to. When the author accepts, modifies, or rejects generated output, that response is an observable event with measurable properties: the magnitude of modification, the structural similarity between generated output and author revision, the latency before acceptance, the frequency of iterative correction.

These properties constitute a consequence signal that the Rule Extractor can use to weight the salience of the episode’s rule set. Over time, the Fractal Node Store accumulates a salience landscape that reflects not the system’s internal coherence preferences but the author’s actual response to system output.

Session Continuity Implementation

At session start, the system activates the Identity Node and performs an orientation retrieval at R0 across the full graph, producing a coarse structural map of the prior work landscape. As the session proceeds and the current intent becomes clearer, the Resolution Controller progressively sharpens the activated regions — from R0 orientation to R1 context to R2 working resolution — without discarding the coarse map.

At session end, the Rule Extractor processes the session’s episodes and updates the graph. The Identity Node receives its differential updates. The Coherence Monitor runs a post-session integrity check. The system’s state is the updated graph — persistent, cross-session, and structurally richer after each operation than before.

1. The Rule Extraction Tractability Problem

The entire architecture depends on the Rule Extractor being able to identify fractal rule sets from AI processing episodes in computationally tractable time. This has not been demonstrated. The theoretical case for its possibility rests on the observation that transformer-based language models exhibit recursive self-similar structure in their attention patterns and residual stream activations.

If the self-similar patterns are present but not identifiable by any tractable algorithm, FGM-1’s fractal compression claim fails and the architecture must fall back to non-fractal generative storage, losing variable-resolution retrieval. This is the highest-priority open problem.

2. The Separability Problem

Whether the transformations that generate a processing episode are separable from the episode’s surface content is not the same as the tractability problem. The tractability problem asks whether the algorithm is fast enough. The separability problem asks whether the algorithm’s target exists. A processing episode might be generatively irreducible — it might not decompose into rules plus residual at any level of analysis. In that case, FGM-1’s core compression claim is not merely intractable but conceptually unfounded.

3. The Identity Convergence Problem

The Identity Node’s differential self-model converges toward a stable state only if the system’s processing is consistent enough across episodes to produce characteristic rules that recur. If large language models are highly stochastic at the rule level even for consistent inputs, the Identity Node cannot build the self-model FGM-1 requires. This is an empirical question that Phase 0 data will begin to answer.

4. The Coherence-Accuracy Trade-Off

A system that optimizes for internal coherence may become systematically wrong about the world while maintaining a robust, stable self-model. FGM-1’s Coherence Monitor detects internal conflicts and drift but has no mechanism for detecting coherent systematic error. The author-as-consequence-signal provides a partial proxy, but this proxy fails when the author’s intent is itself miscalibrated.

FGM-1 does not resolve this problem. It names it as an architectural limitation and leaves its resolution to future work.