Intelligent Schema Memory (ISM)

• Intelligent Schema Memory (ISM) is a schema-centric approach that stores reusable structured abstractions instead of raw episodes, ensuring verifiable and adaptable memory across tasks.
• ISM systems actively maintain memory through operations like self-audit, merge, and activation, replacing passive accumulation with structured, schema-aware updating.
• Empirical studies demonstrate that ISM reduces schema usage by up to 86% while enhancing accuracy, stability, and efficiency compared to traditional passive memory systems.

Searching arXiv for papers on Intelligent Schema Memory and closely related schema-memory architectures. Intelligent Schema Memory (ISM) denotes a schema-centric approach to persistent AI memory in which what persists is not only raw episodes or retrieved text, but reusable structured abstractions—such as strategy schemas, schema-grounded records, causal plan templates, ontology objects, or valid concept keys—that can be retrieved, adapted, validated, and operationalized across episodes. In its explicit recent formulation, ISM is a self-evolving memory-augmented system for continual mathematical reasoning with a frozen LLM under hard episodic resets (Dixit et al., 30 Jun 2026). In a broader interpretive sense, adjacent work treats schema-grounded memory as a system of record (Petrov et al., 30 Apr 2026), an ontological external memory layer (Salovskii et al., 22 Apr 2026), a causal schema memory for personalized agents (Raman et al., 8 Sep 2025), or a schema-constrained generative memory architecture (Zheng et al., 22 Apr 2026).

1. Definition and conceptual scope

In the explicit mathematical-reasoning formulation, ISM is defined by the per-episode computation

$\hat{u}_t = f_\theta(x_t, M_t),$

where $x_t$ is the current problem, $M_t$ is the external memory bank at episode $t$, $f_\theta$ is the frozen LLM with fixed parameters $\theta$, and $\hat{u}_t$ is the predicted answer. The central claim is that continual improvement can occur without parameter updates if the persistent component is an actively maintained external strategy memory rather than chat history or prompt residue (Dixit et al., 30 Jun 2026).

This definition is narrower than the broader family of schema-memory systems, but it isolates the core architectural thesis: memory should be bounded, reusable, verifiable, and adaptive. Related work sharpens that thesis from other directions. Schema-grounded memory argues that persistent AI memory must behave “less like search and more like a system of record,” because operations such as exact facts, current state, updates and deletions, aggregation, relations, negative queries, and explicit unknowns are not well served by unstructured recall (Petrov et al., 30 Apr 2026). SCG-MEM makes the complementary claim that valid recall should be a generative process performed within a dynamic Cognitive Schema, rather than dense retrieval or unconstrained key generation (Zheng et al., 22 Apr 2026). This suggests that ISM is best understood as an architectural stance in which schemas govern what may be stored, how it may be retrieved, and which transformations preserve memory validity.

A recurrent distinction across the literature is between passive accumulation and active maintenance. Passive memory stores examples, reflections, or prior traces, but does not consolidate duplicates, validate entries, or prune stale content. ISM-like systems instead emphasize abstraction over raw episodes, explicit access structure, and memory operations that remain meaningful under update, schema change, or task shift (Dixit et al., 30 Jun 2026).

2. Memory units and representational substrates

The canonical memory unit in the explicit ISM paper is the strategy schema. Each schema is split into a content section and a feature hook. The content section contains the schema name, natural-language description, solution template, and heuristics. The feature hook contains operator type, structural pattern, heuristic signature, quantity signature, embedding centroid, success rate, and usage count. This decomposition separates “what to do” from “when to use it,” allowing retrieval to adapt even when the strategy content remains unchanged (Dixit et al., 30 Jun 2026).

Other ISM-adjacent systems instantiate different schema substrates. Schema-grounded memory stores records aligned to explicit schemas, with object detection, field detection, and field-value extraction defining the write path. Its organizing claim is that schemas define what must be remembered, what may be ignored, and which values must never be inferred (Petrov et al., 30 Apr 2026). Ontology-based external memory stores entities, relations, types, axioms, and constraints in an RDF/OWL graph, with SHACL and OWL acting as admission-control mechanisms for trusted memory (Salovskii et al., 22 Apr 2026). REMI stores a personal causal knowledge graph together with a library of plan schemas, where each schema is “an abstract sequence of steps for addressing a general issue” such as improving sleep quality, reducing stress, or fatigue reduction (Raman et al., 8 Sep 2025).

Some systems make the schema substrate more explicitly hybrid. “Second Me” organizes memory into L0: Raw Data Layer, L1: Natural Language Memory Layer, and L2: AI-Native Memory Layer, combining raw user data, summarized personal memory, and memories “learned and organized through model parameters” (Wei et al., 11 Mar 2025). AgentSM stores prior execution traces or synthesized curated ones as structured programs, segmented by exploration, execution, and validation phases, so that memory consists of schema-grounded reasoning trajectories rather than raw logs (Biswal et al., 22 Jan 2026).

Across these formulations, a common pattern emerges: memory is not a flat buffer. It is a typed or structured substrate that binds stored content to abstractions, operational roles, or schema-conditioned interfaces.

3. Retrieval, activation, and reasoning over schemas

ISM retrieval is typically schema-conditioned rather than example-only. In the mathematical-reasoning system, problems are mapped to structured features and retrieval occurs in two stages: an operator filter followed by soft scoring,

$$\text{score}(s, F_t) = \sum_{k \in K} w_k \cdot \text{sim}_k(s, F_t),$$

with $$K = \{\text{structural}, \text{heuristic}, \text{quantity}, \text{embedding}, \text{prior}\}$$ and weights $w = (0.15, 0.15, 0.05, 0.55, 0.10)$. Retrieval then falls into high, medium, or generic confidence buckets, determining whether the solver uses a specific schema, a schema plus fallback generic schema, or only a domain-level generic schema (Dixit et al., 30 Jun 2026).

Schema Activated In-Context Learning formalizes a related activation pattern in which memory consists of schemas $x_t$0, episodic traces $x_t$1, and association weights $x_t$2. A new problem $x_t$3 is mapped to an initial schema $x_t$4, the nearest prior schema $x_t$5 is retrieved, associated episodes are selected by thresholding $x_t$6, and an activated schema is computed as

$x_t$7

The paper’s ablations argue that abstraction alone is insufficient; explicit schema activation is the critical mechanism, and passive schema presence can lead to “schema dormancy” (Chen et al., 14 Oct 2025).

SCG-MEM pushes retrieval further by replacing dense retrieval with Schema-Constrained Generation. Its Cognitive Schema is a finite set of valid concept keys $x_t$8, stored in a Prefix Trie. Decoding is masked so that only valid next tokens remain available, yielding the structural guarantee

$x_t$9

under correct masking and terminal-node acceptance. Seed keys generated under trie constraints are then expanded over an Associative Graph for multi-hop recall (Zheng et al., 22 Apr 2026). The architectural implication is that recall can remain generative while still being bounded by a schema-defined ontology.

Ontology-backed systems implement an analogous constraint at the level of queryable structure. At inference time, the composite context is assembled as

$M_t$0

so retrieval over vectors, graph neighborhoods, tools, and user/session memory is explicitly fused rather than left to prompt concatenation alone (Salovskii et al., 22 Apr 2026). This suggests that ISM retrieval is often hybrid: schemas delimit admissible structure, while embeddings, tools, or execution traces select among valid candidates.

4. Update, validation, and memory evolution

A defining property of ISM is that memory changes under explicit maintenance rules rather than only appending new records. In the mathematical-reasoning system, maintenance includes Self-Audit, Self-Correct, Self-Merge, Self-Promote / Self-Demote, Self-Prune, Self-Reinforce, Self-Antipattern, and Conditional Schema Evolution. After a warmup of 10 episodes, schemas are scored as strong, neutral, weak, or unused; weak schemas may be rewritten; near-duplicate schemas with $M_t$1 may be merged; unused or persistently poor schemas may be pruned; and new schemas are synthesized only when at least three same-operator failures occur in the last 20 episodes. Crucially, every memory update is described as gated by symbolic verification (Dixit et al., 30 Jun 2026).

Schema-grounded memory relocates intelligence from the read path to the write path. Its single-pass record-correctness model is

$M_t$2

and local retries improve field reliability to

$M_t$3

The architecture therefore decomposes ingestion into object detection, field detection, and field-value extraction, with validation gates, local retries, and stateful prompt control. The result is a memory system in which writes are schema-aware and reads become constrained queries over verified records (Petrov et al., 30 Apr 2026).

Compound Schema Registry extends the same principle to data systems. It treats schema registries as more than version stores by inferring and preserving schema mappings, field correspondences, rename relationships, type casts, defaults, and value transformations. Its Schema Transformation Language (STL) introduces commands such as MATCH, COPY, CAST, RENAME, DEFAULT, MISSING, SCALE, [SHIFT](https://www.emergentmind.com/topics/shift), LINK, GEN, and APPLY, which the registry prompts an LLM to generate and an assembler compiles into deterministic dataflow operations (Fu et al., 2024). This is not labeled ISM in the paper, but it operationalizes a form of schema-version memory plus transformation memory.

SCG-MEM provides a different update model through assimilation and accommodation. If new input can be grounded in the current schema through constrained generation, the system assimilates it into existing concept keys and strengthens graph relations. If constrained generation fails or yields high uncertainty, accommodation relaxes constraints, generates novel concepts, inserts them into the trie, and expands future recall space (Zheng et al., 22 Apr 2026). A plausible implication is that ISM systems require not only storage and retrieval, but explicit policies for novelty detection, schema expansion, and post-update coherence.

5. Representative formulations and neighboring traditions

The label “Intelligent Schema Memory” is recent and not uniformly adopted, but several systems instantiate closely related designs.

Formulation	Memory substrate	Salient role
ISM for continual mathematical reasoning (Dixit et al., 30 Jun 2026)	Compact bank of strategy schemas	Verified continual improvement under hard episodic reset
Compound Schema Registry (Fu et al., 2024)	Stored schemas, reusable mappings, executable transformations	Generalized schema evolution across versions
REMI / Causal Schema Memory (Raman et al., 8 Sep 2025)	Personal causal graph plus plan-schema library	Personalized recommendation with causal explanation
AgentSM (Biswal et al., 22 Jan 2026)	Structured execution traces as semantic memory	Reuse of schema-grounded reasoning paths in Text-to-SQL
SCG-MEM (Zheng et al., 22 Apr 2026)	Dynamic Cognitive Schema plus Associative Graph	Schema-constrained generative recall
“Second Me” (Wei et al., 11 Mar 2025)	L0/L1/L2 hybrid personal memory	Persistent personalized context provider

The intellectual lineage is broader than these explicit formulations. Universal Schema with Memory Networks unifies KB facts and textual facts in a shared memory, showing that heterogeneous relational evidence can be jointly addressed and attended over rather than fused only after separate retrieval (Das et al., 2017). “Topological Schemas of Memory Spaces” models memory space as a finite topological space induced by neuronal coactivity, with consolidation represented as reduction to an irreducible core; Morris’ schemas are identified with such cores (Babichev et al., 2017). “Defining Image Memorability using the Visual Memory Schema” operationalizes a shared visual memory schema as a probability map over memorable image regions, and distinguishes true from false VMS, thereby treating schemas as retrieval-relevant organization rather than mere saliency (Akagunduz et al., 2019).

Other neighboring systems show how ISM-like ideas migrate into specific modalities. A declarative-memory structure for text organizes text observations into episodic graphs with temporal links, WordNet-assisted semantic links, forgetting, and consolidation, though without strong schema induction (Pushp et al., 2020). A category-theoretic SBL framework formalizes memory subsystems as

$M_t$4

with $M_t$5 and $M_t$6, thereby making schema-indexed memory, typed read/write interfaces, and schema-change coherence explicit (Riscos et al., 12 Apr 2026). This suggests that ISM spans both concrete engineering systems and formal attempts to make schema memory compositional, typed, and semantically grounded.

6. Empirical status, limitations, and open problems

The explicit ISM paper provides the most direct quantitative evidence. On MATH-Hard, ISM reports Accuracy 80.67, Plasticity 76.67, Stability 84.67, Forgetting 0.07, and BWT -0.05, while using 17 schemas versus 47 for Passive Schema Memory; on OlympiadBench, it reports Accuracy 61.67, Plasticity 59.33, Stability 64.00, Forgetting 0.03, and BWT +0.03, while using 13 schemas versus 91 for Passive Schema Memory. The paper summarizes this as using 64% fewer schemas on MATH-Hard and 86% fewer schemas on OlympiadBench than the strongest passive baseline (Dixit et al., 30 Jun 2026).

Schema-grounded record memory reports strong evidence that write-path architecture matters for factual memory workloads. In its extraction benchmark, the judge-in-the-loop configuration reaches 90.42% object-level accuracy and 62.67% output accuracy; on the end-to-end memory benchmark, xmemory reaches 97.10% F1, compared with 80.16%–87.24% across third-party baselines; and on the Splitwise application task, xmemory reaches 95.2% accuracy (Petrov et al., 30 Apr 2026). SCG-MEM reports substantial gains on LoCoMo across Single-Hop, Multi-Hop, Temporal, and Adversarial categories; on Qwen2.5 3B, average F1 rises to 41.48 from 21.33 for A-MEM, with +126.6% in Multi-Hop F1 (Zheng et al., 22 Apr 2026). AgentSM reports a state-of-the-art execution accuracy of 44.8% on Spider 2.0 Lite and states that average token usage and trajectory length are reduced by 25% and 35%, respectively, on Spider 2.0 (Biswal et al., 22 Jan 2026).

In more specialized settings, REMI reports PSS = 0.92 and CRA = 0.60 on a detailed afternoon-fatigue scenario, with broader ranges of 0.85–0.92 for PSS and 0.4–0.8 for CRA; its memory-only baseline has 0.0 CRA across prompts (Raman et al., 8 Sep 2025). Compound Schema Registry reports that STL improves average F1 from 78% to 94% on example IoT schema mappings (Fu et al., 2024). These results support a recurring empirical pattern: structured, schema-aware memory often improves correctness, continuity, or efficiency when compared with passive retrieval, raw trajectory reuse, or direct end-to-end generation.

The limitations are equally recurrent. Many systems evaluate on specialized or narrow benchmarks, rely on small-scale or scenario-based settings, or do not provide per-mechanism ablations. The mathematical ISM system does not isolate the contribution of each maintenance mechanism (Dixit et al., 30 Jun 2026). REMI’s evaluation is scenario-based over 28 different scenarios and does not provide a large public benchmark (Raman et al., 8 Sep 2025). Compound Schema Registry is an extended abstract with limited evaluation and no formal semantics for STL (Fu et al., 2024). Ontology-backed external memory offers only descriptive evidence on planning tasks such as Tower of Hanoi and a qualitative Fact Analyzer example, while leaving prompt details, statistical aggregation, and temporal/versioned ontology management unspecified (Salovskii et al., 22 Apr 2026). Across the literature, open problems therefore include canonical schema induction from repeated episodes, schema versioning and conflict resolution, uncertainty and provenance management, multi-hop reasoning over large schema spaces, memory compression and rewriting, and robust handling of schema drift under long-term deployment.

A plausible synthesis is that ISM has already emerged as a recognizable design family, but not yet as a settled standard architecture. What is stable across formulations is the claim that memory should be schema-bearing, operationally reusable, and actively maintained. What remains unstable is the choice of schema substrate—strategy templates, records, ontologies, causal plans, constrained key spaces, topological cores, or typed categorical interfaces—and the degree to which those schemas are explicit, learned, verifiable, and compositional.