![17763489447779152000]()
Implementing Human Memory Architectures in Metacognitive AI Systems
Abstract
Current large language model deployments operate with a profoundly impoverished memory architecture: a single, volatile context window that is discarded at session termination, coupled with a static parametric knowledge store that cannot be updated without full or parameter-efficient fine-tuning cycles. This architectural poverty is not a peripheral limitation. It is the root cause of the stateless epistemics, hallucination susceptibility, and absence of cumulative learning that define the intelligence gap in contemporary AI systems.
Cognitive neuroscience has long established that human intelligence is not constituted by a single unified memory system, but by a taxonomy of functionally distinct, neurologically dissociable memory subsystems — each encoding different categories of information, operating on different temporal horizons, and governed by different consolidation and retrieval mechanisms. The seven primary memory types identified in the cognitive science literature — Episodic, Semantic, Procedural, Working, Sensory, Short-Term, and Prospective — together constitute an integrated cognitive architecture whose collective properties give rise to the adaptive, self-correcting, context-sensitive intelligence that current AI systems approximate but do not replicate.
This paper provides a formally grounded, technically precise engineering blueprint for implementing each of these seven memory subsystems within a Metacognitive AI architecture. For each memory type, we establish: (1) the formal cognitive science characterization and its computational analogues; (2) the specific architectural components and data structures required for implementation; (3) the encoding, consolidation, and retrieval mechanisms appropriate to each type; (4) the integration interfaces through which each subsystem communicates with the central cognitive controller and with other memory subsystems; and (5) the governance and consistency mechanisms required for enterprise-grade deployment. The paper concludes with a unified Cognitive Memory Integration Architecture (CMIA) that synthesizes all seven subsystems into a coherent, metacognitively governed memory fabric.
1. Introduction: The Memory Gap in Contemporary AI
1.1 From Stateless Prediction to Stateful Cognition
The transformer architecture that underlies all contemporary frontier AI models encodes world knowledge in its parameters through the pretraining process and processes task-specific information through its context window during inference. This design yields a system with two fundamentally incompatible memory properties: near-unlimited parametric capacity (parameters encode a compressed statistical model of the entire training corpus) paired with zero persistent episodic capacity (nothing from one inference session is available to the next unless explicitly re-injected into the context).
This architectural configuration is, in cognitive terms, analogous to a human being who retains general semantic knowledge — language, facts, procedural skills — but is incapable of forming any new episodic memories and loses all working memory contents at the end of each waking period. Such an individual would exhibit apparent competence on isolated tasks but would be incapable of learning from experience, building on prior work, maintaining commitments across time, or developing the kind of contextually grounded judgment that constitutes expertise. This is, formally, the operational profile of every deployed LLM in production today.
1.2 Cognitive Neuroscience as Architectural Blueprint
The solution is not to build larger context windows, though extended context is a useful engineering palliative. The solution is to implement a multi-tier memory architecture that mirrors the functional organization of human memory as established by decades of cognitive neuroscience research. The seminal work of Tulving (1972, 1983) established the episodic/semantic distinction as a foundational taxonomy of long-term explicit memory. Subsequent work by Baddeley and Hitch (1974) formalized the multi-component model of working memory. Squire (1992) established the procedural/declarative taxonomy of long-term memory systems. Together, these frameworks provide a cognitively grounded blueprint for AI memory architecture that goes substantially beyond the ad hoc RAG pipelines and conversation-history prepending that constitute the current industry standard.
The following sections translate each cognitive memory type into a precise engineering specification, grounding each implementation in both its cognitive science rationale and its technical architecture. Throughout, we maintain alignment with the GSCP-15 metacognitive framework (Gödel, 2025), which provides the governing discipline within which these memory subsystems operate — determining what is encoded, when retrieval is triggered, how evidence is weighted, and how memory contents are validated and revised.
2. Working Memory: The Active Cognitive Workspace
2.1 Cognitive Science Characterization
Baddeley and Hitch's (1974) multi-component model characterizes Working Memory as the active cognitive workspace responsible for temporarily holding and manipulating information during complex cognitive tasks. It is not a passive storage buffer but an executive processing system comprising four components: the Central Executive (an attentional controller that coordinates the other components and manages cognitive resources), the Phonological Loop (processing verbal and auditory information), the Visuospatial Sketchpad (processing visual and spatial information), and the Episodic Buffer (integrating information from the other components and from long-term memory into a coherent episodic representation).
Critically, working memory is characterized by limited capacity (Miller's Law: 7±2 chunks; Cowan's revised estimate: 4±1), active maintenance (information decays rapidly without active rehearsal), and executive control (the central executive monitors contents, manages interference, and initiates retrieval from long-term memory). These properties are not incidental; they are the functional constraints that make working memory a focused, high-bandwidth cognitive workspace rather than a passive information dump.
2.2 Implementation Architecture
In a Metacognitive AI system, Working Memory is implemented as the Active Reasoning Context — a structured, capacity-constrained, actively managed data structure that holds the current task specification, intermediate reasoning states, active hypotheses, retrieved evidence fragments, and pending tool invocations within a single agentic reasoning cycle.
from dataclasses import dataclass, field
from typing import Any
from collections import deque
import time
@dataclass
class WorkingMemoryChunk:
chunk_id: str
content: Any
modality: str # 'verbal', 'spatial', 'episodic_buffer'
salience_score: float # executive attention weighting
activation_level: float
last_accessed: float # Unix timestamp
decay_rate: float # exponential decay constant
class WorkingMemoryBuffer:
"""
Implements a capacity-constrained, decay-governed active
reasoning workspace with executive attention control.
Capacity: 4-7 chunks (cognitively grounded constraint).
"""
CAPACITY = 5 # Cowan's revised estimate
def __init__(self):
self.chunks: deque[WorkingMemoryChunk] = deque(maxlen=self.CAPACITY)
self.central_executive = CentralExecutive()
def encode(self, content: Any, modality: str, salience: float) -> str:
"""
Encode a new chunk into working memory.
If at capacity, displacement occurs via salience competition.
"""
chunk = WorkingMemoryChunk(
chunk_id=self._generate_id(),
content=content,
modality=modality,
salience_score=salience,
activation_level=1.0,
last_accessed=time.time(),
decay_rate=0.05 # ~20s half-life at 1Hz tick
)
if len(self.chunks) == self.CAPACITY:
self._displace_by_salience(chunk)
else:
self.chunks.append(chunk)
return chunk.chunk_id
def rehearse(self, chunk_id: str) -> None:
"""Active rehearsal resets activation level to 1.0."""
for chunk in self.chunks:
if chunk.chunk_id == chunk_id:
chunk.activation_level = 1.0
chunk.last_accessed = time.time()
return
def tick_decay(self) -> None:
"""Apply exponential activation decay. Remove sub-threshold chunks."""
elapsed = time.time()
surviving = deque()
for chunk in self.chunks:
dt = elapsed - chunk.last_accessed
chunk.activation_level *= (1 - chunk.decay_rate) ** dt
if chunk.activation_level > 0.1: # activation threshold
surviving.append(chunk)
self.chunks = surviving
def get_active_context(self) -> list[WorkingMemoryChunk]:
"""Return all chunks above activation threshold, sorted by salience."""
self.tick_decay()
return sorted(self.chunks, key=lambda c: c.salience_score, reverse=True)
def _displace_by_salience(self, incoming: WorkingMemoryChunk):
"""Displace lowest-salience chunk to admit higher-salience incoming."""
if self.chunks:
lowest = min(self.chunks, key=lambda c: c.salience_score)
if incoming.salience_score > lowest.salience_score:
self.chunks.remove(lowest)
self.chunks.append(incoming)
2.3 Central Executive Implementation
The Central Executive component — the attentional controller of working memory — maps directly onto the metacognitive orchestrator of a GSCP-15-governed system: the component that monitors active reasoning quality, allocates computational resources across concurrent reasoning branches, detects interference between competing hypotheses, and initiates retrieval from long-term memory subsystems when working memory content is insufficient.
class CentralExecutive:
"""
Metacognitive controller for working memory. Monitors
reasoning quality, manages resource allocation, and
triggers long-term memory retrieval when needed.
"""
def evaluate_reasoning_quality(
self,
wm: WorkingMemoryBuffer,
current_hypothesis: str
) -> ReasoningQualityReport:
active = wm.get_active_context()
return ReasoningQualityReport(
coherence_score=self._compute_coherence(active, current_hypothesis),
evidence_adequacy=self._assess_evidence_coverage(active),
uncertainty_flags=self._identify_unsupported_claims(active),
retrieval_triggers=self._determine_retrieval_needs(active)
)
def _determine_retrieval_needs(
self,
chunks: list[WorkingMemoryChunk]
) -> list[RetrievalTrigger]:
"""
Identify gaps in working memory content that require
retrieval from episodic, semantic, or procedural stores.
"""
triggers = []
for chunk in chunks:
if chunk.activation_level < 0.4 and chunk.salience_score > 0.7:
triggers.append(RetrievalTrigger(
target_store='episodic' if chunk.modality == 'episodic_buffer'
else 'semantic',
query_content=chunk.content,
urgency=chunk.salience_score
))
return triggers
3. Sensory Memory: The Perceptual Gateway
3.1 Cognitive Science Characterization
Sensory Memory is the earliest and most transient stage of memory processing, representing the immediate, pre-attentive registration of sensory input before any cognitive processing has occurred. Sperling's (1960) landmark experiments established the iconic store (visual sensory memory) as holding a high-fidelity, complete representation of a visual scene for approximately 250–500 milliseconds, with an effective capacity approximating the full visual field. The echoic store (auditory sensory memory) retains a verbatim trace of auditory input for 3–4 seconds. The functional role of sensory memory is selective attention gating: the attentional system scans the high-capacity sensory buffer and selectively transfers salient items to working memory before they decay.
3.2 Implementation Architecture
In an AI system processing multimodal inputs — text streams, document uploads, image inputs, audio transcripts, real-time data feeds — Sensory Memory is implemented as a high-capacity, short-retention input buffer with an attention-based salience filter that governs which input elements are selected for transfer to working memory and encoding into longer-term stores.
import asyncio
from dataclasses import dataclass
from typing import Callable
import numpy as np
@dataclass
class SensoryTrace:
trace_id: str
raw_content: bytes | str
modality: str # 'visual', 'auditory', 'textual', 'structured'
timestamp: float
ttl_ms: int # time-to-live in milliseconds
salience_score: float # computed by salience filter
class SensoryBuffer:
"""
High-capacity, rapidly-decaying perceptual input buffer.
TTL: 200-500ms for visual, 3000-4000ms for auditory/textual.
Implements attention-gated transfer to working memory.
"""
TTL_BY_MODALITY = {
'visual': 400, # ms — iconic store duration
'auditory': 3500, # ms — echoic store duration
'textual': 3000,
'structured': 5000 # data streams: slightly extended
}
def __init__(self, salience_model: Callable, wm: WorkingMemoryBuffer):
self.buffer: list[SensoryTrace] = []
self.salience_model = salience_model
self.working_memory = wm
self._sweep_task = None
async def ingest(self, raw_input: bytes | str, modality: str) -> None:
"""Receive a new sensory input and compute its salience."""
salience = await self.salience_model(raw_input, modality)
trace = SensoryTrace(
trace_id=self._generate_id(),
raw_content=raw_input,
modality=modality,
timestamp=time.time(),
ttl_ms=self.TTL_BY_MODALITY.get(modality, 3000),
salience_score=salience
)
self.buffer.append(trace)
if salience > 0.75: # high-salience items trigger immediate transfer
await self._transfer_to_working_memory(trace)
async def attention_sweep(self, interval_ms: int = 100) -> None:
"""
Periodic sweep: expire decayed traces, transfer salient
survivors to working memory, log discarded traces for audit.
"""
while True:
now = time.time()
surviving, expired = [], []
for trace in self.buffer:
age_ms = (now - trace.timestamp) * 1000
if age_ms < trace.ttl_ms:
surviving.append(trace)
else:
expired.append(trace)
# Transfer surviving high-salience items to WM
for trace in surviving:
if trace.salience_score > 0.5:
await self._transfer_to_working_memory(trace)
# Audit log discarded traces (governance requirement)
for trace in expired:
await self._audit_log_expiry(trace)
self.buffer = surviving
await asyncio.sleep(interval_ms / 1000)
async def _transfer_to_working_memory(self, trace: SensoryTrace) -> None:
processed = await self._preprocess(trace)
self.working_memory.encode(
content=processed,
modality=trace.modality,
salience=trace.salience_score
)
4. Short-Term Memory: The Consolidation Antechamber
4.1 Cognitive Science Characterization
Short-Term Memory (STM) — distinct from working memory in classical models, though often conflated in popular usage — refers to the passive retention of small amounts of information for intervals of approximately 15–30 seconds in the absence of active rehearsal. The seminal work of Peterson and Peterson (1959) demonstrated that unrehearsed verbal information decays from short-term store to near-zero recall within approximately 18 seconds, establishing the characteristic temporal decay function that distinguishes STM from long-term consolidation. STM capacity is typically characterized as 7±2 items (Miller, 1956), though subsequent research suggests that chunking — the aggregation of items into meaningful units — substantially modulates effective capacity.
The functional role of STM in the broader memory architecture is that of consolidation antechamber: information that has passed the attentional filter from sensory memory and is being actively processed in working memory may, through rehearsal and consolidation processes, be transferred to long-term episodic or semantic stores. STM is the temporal bridge across which this consolidation occurs.
4.2 Implementation Architecture
In an AI system, Short-Term Memory is implemented as a session-scoped, time-indexed interaction log with a configurable retention window, automatic chunking and compression, and selective consolidation routing to long-term stores based on novelty, utility, and relevance scoring.
import hashlib
from datetime import datetime, timedelta
from typing import Optional
import redis # Redis for fast time-indexed session store
class ShortTermMemoryStore:
"""
Session-scoped interaction log with TTL-governed retention
and selective consolidation to long-term episodic/semantic stores.
Backed by Redis for millisecond-latency access.
Retention window: configurable, default 30 minutes (extended STM for AI).
"""
DEFAULT_TTL_SECONDS = 1800 # 30 minutes
def __init__(
self,
session_id: str,
redis_client: redis.Redis,
consolidation_router: 'ConsolidationRouter'
):
self.session_id = session_id
self.redis = redis_client
self.router = consolidation_router
self.namespace = f"stm:{session_id}"
def encode(
self,
content: dict,
ttl: int = DEFAULT_TTL_SECONDS,
consolidation_priority: float = 0.5
) -> str:
"""
Encode a new item into STM with TTL and consolidation metadata.
"""
item_id = self._generate_id()
entry = {
'item_id': item_id,
'content': content,
'encoded_at': datetime.utcnow().isoformat(),
'consolidation_priority': consolidation_priority,
'access_count': 0,
'chunk_signature': self._compute_chunk_hash(content)
}
key = f"{self.namespace}:{item_id}"
self.redis.setex(key, ttl, json.dumps(entry))
return item_id
def retrieve(self, item_id: str) -> Optional[dict]:
"""Retrieve item and increment access count (rehearsal effect)."""
key = f"{self.namespace}:{item_id}"
raw = self.redis.get(key)
if not raw:
return None
entry = json.loads(raw)
entry['access_count'] += 1
# Rehearsal: extend TTL proportional to access frequency
new_ttl = self.DEFAULT_TTL_SECONDS + (entry['access_count'] * 120)
self.redis.setex(key, min(new_ttl, 7200), json.dumps(entry))
return entry
def get_session_contents(self) -> list[dict]:
"""Return all active STM items for the current session."""
pattern = f"{self.namespace}:*"
keys = self.redis.keys(pattern)
items = []
for key in keys:
raw = self.redis.get(key)
if raw:
items.append(json.loads(raw))
return sorted(items, key=lambda x: x['encoded_at'])
async def consolidation_sweep(self) -> ConsolidationReport:
"""
Identify high-priority items for consolidation to long-term stores.
Consolidation criteria: high access count OR high priority score.
"""
items = self.get_session_contents()
candidates = [
item for item in items
if item['consolidation_priority'] > 0.7
or item['access_count'] >= 3
]
return await self.router.route_for_consolidation(candidates)
def _compute_chunk_hash(self, content: dict) -> str:
"""Deduplication signature to prevent redundant encoding."""
canonical = json.dumps(content, sort_keys=True)
return hashlib.sha256(canonical.encode()).hexdigest()[:16]
5. Episodic Memory: Autobiographical Experience and Contextual Recall
5.1 Cognitive Science Characterization
Episodic Memory, introduced by Tulving (1972) and extensively elaborated in his subsequent work (1983, 2002), is the memory system that stores and retrieves specific personal experiences and events, bound to their spatiotemporal context. Episodic memories are characterized by what Tulving terms "mental time travel": the capacity to consciously re-experience a past event, reconstructing not merely the factual content of the experience but its contextual embedding — when it occurred, where, in what circumstances, with what emotional valence, and in what relation to other events. The neural substrate of episodic memory is centered on the hippocampus, which acts as a relational binding system, associating disparate elements of an experience (perceptual details, temporal context, spatial context, emotional state) into a coherent, retrievable memory trace.
Episodic memory is fundamentally reconstructive rather than reproductive: retrieval does not access a stored recording of an event but actively reconstructs it from constituent traces, a process that is context-sensitive, subject to interference, and susceptible to updating by post-event information. This reconstructive property has critical implications for AI implementation: an episodic memory system must implement not merely storage and retrieval but consistency maintenance across the network of related memories.
5.2 Implementation Architecture: Vector-Indexed Experience Store
In a Metacognitive AI system, Episodic Memory is implemented as a persistently indexed, contextually richly annotated experience store built on a vector database with dense semantic embeddings enabling similarity-based retrieval. Critically, each episodic trace encodes not merely the content of an interaction but its full contextual envelope: temporal context, task context, agent state, confidence levels, tool invocations, intermediate reasoning steps, and outcome quality assessment.
from dataclasses import dataclass, field
from typing import Optional
import numpy as np
import faiss # Facebook AI Similarity Search for ANN retrieval
from sentence_transformers import SentenceTransformer
@dataclass
class EpisodicTrace:
"""
A richly annotated record of a specific AI reasoning episode.
Implements Tulving's 'what-where-when' episodic binding.
"""
# Identity
trace_id: str
session_id: str
agent_id: str
# Content (the "what")
task_specification: str
reasoning_trajectory: list[dict] # full chain-of-thought record
tool_invocations: list[dict]
retrieved_evidence: list[str]
final_output: str
# Context (the "where" and "when")
timestamp_start: float
timestamp_end: float
domain_context: str
user_intent_classification: str
# Quality metadata (for consolidation priority scoring)
outcome_quality_score: float # 0.0–1.0
user_feedback_signal: Optional[float]
confidence_at_output: float
hallucination_flags: list[str] # detected uncertain assertions
# Relational bindings (links to related episodes)
related_trace_ids: list[str] = field(default_factory=list)
semantic_cluster_id: Optional[str] = None
# Embedding (computed at encoding time)
embedding: Optional[np.ndarray] = None
class EpisodicMemoryStore:
"""
Persistently indexed episodic memory with:
- Dense vector indexing (FAISS HNSW) for similarity retrieval
- Contextual filtering (temporal, domain, quality)
- Reconstructive retrieval with related-trace augmentation
- Hippocampal binding simulation via relational graph
"""
EMBEDDING_DIM = 1536 # text-embedding-3-large dimensionality
def __init__(self, db_connection, embedding_model: SentenceTransformer):
self.db = db_connection
self.embedder = embedding_model
self.index = faiss.IndexHNSWFlat(self.EMBEDDING_DIM, 32)
# HNSW: M=32 neighbors, ef_construction=200 for high-recall indexing
self.index.hnsw.efConstruction = 200
self.index.hnsw.efSearch = 64
self.id_map: dict[int, str] = {} # FAISS int → trace_id mapping
def encode(self, trace: EpisodicTrace) -> str:
"""
Encode a new episodic trace.
1. Generate dense embedding of the full contextual representation.
2. Index in FAISS for similarity retrieval.
3. Persist full trace to document store.
4. Update relational binding graph.
"""
# Construct rich text representation for embedding
embedding_input = self._build_embedding_representation(trace)
trace.embedding = self.embedder.encode(
embedding_input, normalize_embeddings=True
)
# FAISS indexing
faiss_id = len(self.id_map)
self.index.add(trace.embedding.reshape(1, -1))
self.id_map[faiss_id] = trace.trace_id
# Persistent storage
self.db.episodic_traces.insert_one(self._serialize(trace))
# Update relational bindings
self._update_relational_graph(trace)
return trace.trace_id
def retrieve(
self,
query: str,
k: int = 5,
domain_filter: Optional[str] = None,
min_quality_score: float = 0.3,
temporal_window_days: Optional[int] = None
) -> list[EpisodicTrace]:
"""
Similarity-based retrieval with contextual filtering.
Implements reconstructive retrieval: augments top-k results
with relationally bound traces for context completeness.
"""
query_embedding = self.embedder.encode(
query, normalize_embeddings=True
).reshape(1, -1)
# ANN search — returns candidate pool larger than k for post-filtering
distances, faiss_ids = self.index.search(query_embedding, k * 3)
candidates = []
for dist, fid in zip(distances[0], faiss_ids[0]):
if fid == -1:
continue
trace_id = self.id_map.get(int(fid))
trace = self._fetch_trace(trace_id)
if trace and self._passes_filters(
trace, domain_filter, min_quality_score, temporal_window_days
):
candidates.append((float(dist), trace))
# Sort by similarity, take top-k
candidates.sort(key=lambda x: x[0], reverse=True)
primary_results = [t for _, t in candidates[:k]]
# Reconstructive augmentation: retrieve relationally bound traces
augmented = self._reconstruct_with_related(primary_results)
return augmented
def _build_embedding_representation(self, trace: EpisodicTrace) -> str:
"""
Construct a rich textual representation encoding all
contextual dimensions for multi-aspect similarity retrieval.
"""
return (
f"Task: {trace.task_specification}\n"
f"Domain: {trace.domain_context}\n"
f"Intent: {trace.user_intent_classification}\n"
f"Output: {trace.final_output}\n"
f"Quality: {trace.outcome_quality_score:.2f}\n"
f"Reasoning: {' '.join([s['thought'] for s in trace.reasoning_trajectory[:3]])}"
)
def _update_relational_graph(self, trace: EpisodicTrace) -> None:
"""
Identify and record relational bindings to existing traces.
Implements hippocampal binding: associates episodes sharing
domain context, task type, or output patterns.
"""
similar = self.retrieve(
trace.task_specification, k=3, min_quality_score=0.0
)
for related in similar:
if related.trace_id != trace.trace_id:
trace.related_trace_ids.append(related.trace_id)
# Bidirectional binding
self.db.episodic_traces.update_one(
{'trace_id': related.trace_id},
{'$addToSet': {'related_trace_ids': trace.trace_id}}
)
6. Semantic Memory: The Structured Knowledge Base
6.1 Cognitive Science Characterization
Semantic Memory, the counterpart of episodic memory in Tulving's (1972) taxonomy, stores general factual knowledge about the world — concepts, categories, relationships, meanings, and abstract structures — independent of the spatiotemporal context in which that knowledge was acquired. Whereas episodic memory encodes experiences, semantic memory encodes knowledge. The distinction is phenomenologically precise: one remembers a specific episode (with a sense of personal re-experiencing) but knows a semantic fact (without necessarily any recollection of having learned it).
Semantic memory is organized around conceptual structure: semantic similarity, categorical relationships, part-whole hierarchies, causal associations, and functional roles. Spreading activation models (Collins and Loftus, 1975) characterize semantic memory retrieval as activation propagating through a network of semantically associated concepts, with activation strength decaying with semantic distance. Contemporary connectionist accounts locate semantic knowledge in the distributed patterns of neural activation across cortical regions, consistent with the distributed representations of transformer embedding spaces.
6.2 Implementation Architecture: Knowledge Graph with RAG Integration
Semantic Memory in a Metacognitive AI system is implemented as a dual-substrate knowledge architecture: a structured Knowledge Graph (ontologically specified, deterministically queryable) paired with a dense vector retrieval system (for soft, semantically graduated knowledge access). This dual substrate captures both the categorical precision of formal semantic representation and the graded associative structure of spreading activation.
from neo4j import GraphDatabase
from typing import Any
import networkx as nx
class SemanticMemoryStore:
"""
Dual-substrate semantic memory:
(1) Neo4j Knowledge Graph — formal ontological structure,
precise categorical queries, deterministic fact retrieval.
(2) FAISS vector index — soft semantic similarity retrieval,
analogical reasoning, concept-level spreading activation.
"""
def __init__(
self,
neo4j_driver: GraphDatabase,
vector_index: faiss.Index,
embedding_model: SentenceTransformer
):
self.graph_db = neo4j_driver
self.vector_index = vector_index
self.embedder = embedding_model
# ── Knowledge Graph Operations ──────────────────────────────────────
def assert_fact(
self,
subject: str,
predicate: str,
obj: str,
confidence: float = 1.0,
provenance: str = 'system',
temporal_validity: Optional[tuple[str, str]] = None
) -> None:
"""
Assert a new semantic fact as an RDF-style triple with
confidence weighting and temporal validity bounds.
"""
query = """
MERGE (s:Concept {name: $subject})
MERGE (o:Concept {name: $object})
MERGE (s)-[r:RELATION {
predicate: $predicate,
confidence: $confidence,
provenance: $provenance,
valid_from: $valid_from,
valid_until: $valid_until
}]->(o)
"""
with self.graph_db.session() as session:
session.run(query, {
'subject': subject,
'object': obj,
'predicate': predicate,
'confidence': confidence,
'provenance': provenance,
'valid_from': temporal_validity[0] if temporal_validity else None,
'valid_until': temporal_validity[1] if temporal_validity else None
})
# Also index in vector store for soft retrieval
self._index_triple_embedding(subject, predicate, obj)
def query_facts(
self,
subject: Optional[str] = None,
predicate: Optional[str] = None,
obj: Optional[str] = None,
min_confidence: float = 0.5
) -> list[dict]:
"""Precise graph traversal for deterministic fact retrieval."""
conditions = ['r.confidence >= $min_confidence']
params: dict[str, Any] = {'min_confidence': min_confidence}
if subject:
conditions.append('s.name = $subject')
params['subject'] = subject
if predicate:
conditions.append('r.predicate = $predicate')
params['predicate'] = predicate
if obj:
conditions.append('o.name = $object')
params['object'] = obj
where_clause = ' AND '.join(conditions)
query = f"""
MATCH (s:Concept)-[r:RELATION]->(o:Concept)
WHERE {where_clause}
RETURN s.name AS subject, r.predicate AS predicate,
o.name AS object, r.confidence AS confidence,
r.provenance AS provenance
ORDER BY r.confidence DESC
"""
with self.graph_db.session() as session:
result = session.run(query, params)
return [record.data() for record in result]
def spreading_activation_retrieval(
self,
seed_concepts: list[str],
activation_decay: float = 0.5,
max_hops: int = 3
) -> dict[str, float]:
"""
Simulate spreading activation from seed concepts through
the semantic graph. Returns concept → activation_level map.
"""
activation_map: dict[str, float] = {c: 1.0 for c in seed_concepts}
frontier = set(seed_concepts)
for hop in range(max_hops):
next_frontier = set()
for concept in frontier:
neighbors = self._get_neighbors(concept)
for neighbor, edge_weight in neighbors:
propagated = activation_map.get(concept, 0) * activation_decay * edge_weight
if propagated > 0.05: # activation threshold
current = activation_map.get(neighbor, 0)
activation_map[neighbor] = max(current, propagated)
next_frontier.add(neighbor)
frontier = next_frontier
return dict(sorted(activation_map.items(), key=lambda x: x[1], reverse=True))
# ── RAG Integration ─────────────────────────────────────────────────
def retrieve_soft(
self,
query: str,
k: int = 10
) -> list[dict]:
"""
Soft semantic retrieval via vector similarity.
Complements deterministic graph queries with graduated
relevance-ranked knowledge chunks.
"""
q_emb = self.embedder.encode(query, normalize_embeddings=True).reshape(1, -1)
distances, ids = self.vector_index.search(q_emb, k)
return self._fetch_chunks_by_ids(ids[0], distances[0])
7. Procedural Memory: Skill Encoding and Automated Execution
7.1 Cognitive Science Characterization
Procedural Memory is the long-term memory system that stores cognitive and motor skills — complex, sequentially organized action programs that, once learned, execute with minimal conscious attention. The canonical property of procedural memory is implicit accessibility: procedural knowledge is expressed in performance rather than in declarative recall. One who knows how to ride a bicycle cannot typically provide an explicit verbal account of the motor commands involved; the knowledge is encoded in a form that directly controls behavior without conscious mediation.
The neuroscientific substrate of procedural memory is distinct from episodic and semantic memory, involving the basal ganglia, cerebellum, and motor cortex rather than the hippocampal-neocortical system. The dissociation is clinically demonstrated by patients with severe episodic amnesia (such as H.M.) who nonetheless acquire new procedural skills normally. This neurological independence implies a computationally separate encoding mechanism — procedural knowledge is compiled into a different representational format from declarative knowledge, enabling efficient, low-latency execution without deliberative retrieval.
7.2 Implementation Architecture: Compiled Skill Library and Execution Templates
In a Metacognitive AI system, Procedural Memory is implemented as a hierarchically organized library of compiled task execution templates — formally specified, parameterized workflows that encode proven solution strategies for recurring task types. These templates are not retrieved and reasoned over like episodic memories; they are directly invoked by the procedural execution engine when a task is recognized as matching a known skill pattern. This mirrors the implicit, non-deliberative character of biological procedural memory.
from abc import ABC, abstractmethod
from typing import Callable, Optional
import inspect
@dataclass
class ProceduralSkill:
"""
A compiled, parameterized execution template encoding
a proven strategy for a specific task type.
Analogous to a compiled neural motor program.
"""
skill_id: str
skill_name: str
domain: str
trigger_patterns: list[str] # task descriptions that activate this skill
trigger_embedding: np.ndarray # for similarity-based skill matching
# Execution specification
parameter_schema: dict # JSON Schema for skill parameters
execution_graph: dict # DAG of execution steps
tool_requirements: list[str] # required tool permissions
# Performance metadata
success_rate: float
avg_execution_time_ms: float
last_updated: datetime
invocation_count: int
# Compiled executor
executor: Optional[Callable] = None
class ProceduralMemoryLibrary:
"""
Hierarchically organized procedural skill library with
similarity-based skill recognition and compiled execution.
"""
def __init__(self, embedding_model: SentenceTransformer):
self.skills: dict[str, ProceduralSkill] = {}
self.embedder = embedding_model
self.skill_index = faiss.IndexFlatIP(1536)
self.skill_id_map: dict[int, str] = {}
def register_skill(self, skill: ProceduralSkill) -> None:
"""
Register a new procedural skill. Index trigger patterns
for similarity-based recognition.
"""
# Aggregate trigger pattern embeddings
pattern_embeddings = self.embedder.encode(
skill.trigger_patterns, normalize_embeddings=True
)
mean_embedding = pattern_embeddings.mean(axis=0, keepdims=True)
skill.trigger_embedding = mean_embedding.squeeze()
faiss_id = len(self.skill_id_map)
self.skill_index.add(mean_embedding)
self.skill_id_map[faiss_id] = skill.skill_id
self.skills[skill.skill_id] = skill
def recognize_skill(
self,
task_description: str,
similarity_threshold: float = 0.82
) -> Optional[ProceduralSkill]:
"""
Pattern-match a task description against registered skills.
Returns the highest-similarity skill above threshold, or None
if no skill matches (triggering deliberative planning instead).
"""
q_emb = self.embedder.encode(
task_description, normalize_embeddings=True
).reshape(1, -1)
distances, ids = self.skill_index.search(q_emb, 3)
for dist, fid in zip(distances[0], ids[0]):
if fid != -1 and float(dist) >= similarity_threshold:
skill_id = self.skill_id_map[int(fid)]
return self.skills[skill_id]
return None # No matching skill — fall back to deliberative planning
async def execute_skill(
self,
skill: ProceduralSkill,
parameters: dict,
execution_context: dict
) -> SkillExecutionResult:
"""
Execute a compiled skill with parameter binding and telemetry.
"""
# Validate parameters against skill schema
self._validate_parameters(parameters, skill.parameter_schema)
start_time = time.time()
try:
result = await skill.executor(parameters, execution_context)
elapsed = (time.time() - start_time) * 1000
# Update performance metadata (online learning)
skill.success_rate = (
(skill.success_rate * skill.invocation_count + 1.0)
/ (skill.invocation_count + 1)
)
skill.avg_execution_time_ms = (
(skill.avg_execution_time_ms * skill.invocation_count + elapsed)
/ (skill.invocation_count + 1)
)
skill.invocation_count += 1
return SkillExecutionResult(success=True, output=result, elapsed_ms=elapsed)
except Exception as e:
skill.success_rate = (
(skill.success_rate * skill.invocation_count)
/ (skill.invocation_count + 1)
)
skill.invocation_count += 1
return SkillExecutionResult(success=False, error=str(e))
8. Prospective Memory: Future-Directed Intentional Recall
8.1 Cognitive Science Characterization
Prospective Memory — formally defined by Meacham (1982) and extensively studied by Brandimonte, Einstein, and McDaniel (1996) — is the memory system responsible for remembering to perform a planned action at a specified future time, context, or event. It is explicitly future-directed, constituting the cognitive mechanism underlying all forms of delayed intention execution: remembering to take medication at a specified time, to raise a topic at the next team meeting, or to check on a delegated task upon its deadline.
Prospective memory operates via two distinct retrieval mechanisms: time-based prospective memory (execution triggered by temporal cues: "at 3:00 PM") and event-based prospective memory (execution triggered by the occurrence of a specific environmental event: "when the customer next contacts us"). Critically, prospective memory retrieval requires that the system maintain intention representations over potentially long delay intervals without those representations being continuously held in working memory — they must be stored, preserved, and then spontaneously or deliberately reactivated by the appropriate cue.
8.2 Implementation Architecture: Intention Registry and Cue-Triggered Dispatch
from enum import Enum
from datetime import datetime
from typing import Union
import asyncio
class ProspectiveTriggerType(Enum):
TIME_BASED = "time_based"
EVENT_BASED = "event_based"
CONDITION_BASED = "condition_based"
@dataclass
class ProspectiveIntention:
"""
A stored future-directed intention with its trigger specification.
Implements Brandimonte et al.'s intention-plus-trigger model.
"""
intention_id: str
agent_id: str
session_id: str
# The intended action
action_description: str
action_payload: dict # structured action specification
priority: float # 0.0–1.0
# Trigger specification
trigger_type: ProspectiveTriggerType
time_trigger: Optional[datetime] # for TIME_BASED
event_trigger_pattern: Optional[str] # for EVENT_BASED
condition_expression: Optional[str] # for CONDITION_BASED
# State
created_at: datetime
expires_at: Optional[datetime]
is_discharged: bool = False
discharge_timestamp: Optional[datetime] = None
discharge_outcome: Optional[str] = None
class ProspectiveMemoryRegistry:
"""
Persistent intention store with time-based and event-based
cue monitoring. Implements spontaneous retrieval simulation
via background watchdog processes.
"""
def __init__(
self,
db,
event_bus: 'EventBus',
scheduler: 'AsyncScheduler'
):
self.db = db
self.event_bus = event_bus
self.scheduler = scheduler
# Subscribe to all system events for event-based monitoring
self.event_bus.subscribe('*', self._on_system_event)
def register_intention(self, intention: ProspectiveIntention) -> str:
"""
Register a prospective intention and schedule its monitoring.
"""
self.db.intentions.insert_one(self._serialize(intention))
if intention.trigger_type == ProspectiveTriggerType.TIME_BASED:
self.scheduler.schedule(
coro=self._dispatch_intention(intention.intention_id),
run_at=intention.time_trigger
)
elif intention.trigger_type == ProspectiveTriggerType.EVENT_BASED:
# Event-based intentions are monitored via _on_system_event
pass
elif intention.trigger_type == ProspectiveTriggerType.CONDITION_BASED:
# Poll condition at configurable intervals
self.scheduler.schedule_recurring(
coro=self._poll_condition(intention.intention_id),
interval_seconds=30
)
return intention.intention_id
async def _on_system_event(self, event: dict) -> None:
"""
Spontaneous retrieval: check all EVENT_BASED intentions
against the incoming event pattern. Dispatch matches.
"""
pending = self.db.intentions.find({
'trigger_type': ProspectiveTriggerType.EVENT_BASED.value,
'is_discharged': False
})
for record in pending:
intention = self._deserialize(record)
if self._event_matches_pattern(
event, intention.event_trigger_pattern
):
await self._dispatch_intention(intention.intention_id)
async def _dispatch_intention(self, intention_id: str) -> None:
"""
Execute a triggered intention and mark it as discharged.
"""
intention = self._fetch_intention(intention_id)
if not intention or intention.is_discharged:
return
if intention.expires_at and datetime.utcnow() > intention.expires_at:
self._mark_expired(intention_id)
return
# Execute the intended action via the agent's action dispatcher
outcome = await self.event_bus.publish(
'intention.dispatch',
{
'intention_id': intention_id,
'action_payload': intention.action_payload,
'priority': intention.priority
}
)
# Mark as discharged
self.db.intentions.update_one(
{'intention_id': intention_id},
{'$set': {
'is_discharged': True,
'discharge_timestamp': datetime.utcnow().isoformat(),
'discharge_outcome': str(outcome)
}}
)
9. The Cognitive Memory Integration Architecture (CMIA)
9.1 Unified Memory Orchestration Under GSCP-15
The seven memory subsystems described in preceding sections do not operate in isolation. They form an integrated cognitive memory fabric governed by a unified orchestration layer — the Cognitive Memory Integration Architecture (CMIA) — that manages inter-subsystem communication, consolidation flows, retrieval arbitration, and metacognitive oversight of memory operations. This orchestration layer maps directly onto the Central Executive component of Baddeley's working memory model and onto the metacognitive governing envelope of Gödel's GSCP-15 framework.
class CognitiveMemoryIntegrationArchitecture:
"""
Unified orchestration layer governing all seven memory subsystems.
Implements Baddeley's central executive and Gödel's metacognitive
governing envelope (GSCP-15) for memory operations.
"""
def __init__(
self,
sensory: SensoryBuffer,
short_term: ShortTermMemoryStore,
working: WorkingMemoryBuffer,
episodic: EpisodicMemoryStore,
semantic: SemanticMemoryStore,
procedural: ProceduralMemoryLibrary,
prospective: ProspectiveMemoryRegistry,
metacognitive_monitor: 'MetacognitiveMonitor'
):
self.sensory = sensory
self.stm = short_term
self.wm = working
self.episodic = episodic
self.semantic = semantic
self.procedural = procedural
self.prospective = prospective
self.monitor = metacognitive_monitor
async def process_task(self, task: AgentTask) -> TaskResult:
"""
Full cognitive cycle implementing GSCP-15 execution discipline
across all memory subsystems.
"""
# ── Phase 1: Perceptual Encoding ──────────────────────────────
await self.sensory.ingest(task.raw_input, task.modality)
# ── Phase 2: Working Memory Initialization ────────────────────
task_chunk_id = self.wm.encode(
content={'task': task.specification},
modality='verbal',
salience=task.priority
)
# ── Phase 3: Procedural Recognition ──────────────────────────
# Check if this task matches a compiled skill (implicit recall)
skill = self.procedural.recognize_skill(task.specification)
if skill and skill.success_rate > 0.85:
# High-confidence skill match: execute without deliberation
result = await self.procedural.execute_skill(
skill, task.parameters, task.context
)
await self._post_task_consolidation(task, result)
return TaskResult(output=result.output, source='procedural')
# ── Phase 4: Long-Term Memory Retrieval ───────────────────────
# Retrieve relevant episodic traces (past similar experiences)
episodic_context = self.episodic.retrieve(
query=task.specification,
k=3,
domain_filter=task.domain,
min_quality_score=0.6
)
# Retrieve relevant semantic knowledge
semantic_context = self.semantic.retrieve_soft(
query=task.specification, k=10
)
# Load retrieval results into working memory episodic buffer
for trace in episodic_context:
self.wm.encode(
content={'episodic_trace': trace},
modality='episodic_buffer',
salience=trace.outcome_quality_score
)
# ── Phase 5: Metacognitive Evaluation of Context ──────────────
quality_report = self.monitor.evaluate_reasoning_context(
working_memory=self.wm,
episodic_context=episodic_context,
semantic_context=semantic_context,
task=task
)
if quality_report.evidence_adequacy < 0.5:
# Insufficient context: trigger additional retrieval
additional = await self._augment_context(task, quality_report)
semantic_context.extend(additional)
# ── Phase 6: Deliberative Execution ───────────────────────────
result = await self._execute_with_full_context(
task, episodic_context, semantic_context, quality_report
)
# ── Phase 7: Post-Task Consolidation ──────────────────────────
await self._post_task_consolidation(task, result)
return result
async def _post_task_consolidation(
self,
task: AgentTask,
result: TaskResult
) -> None:
"""
Consolidation pipeline: STM → Episodic → Semantic → Procedural.
Implements sleep-independent memory consolidation.
Governed by GSCP-15 Stage 14 (systematic learning).
"""
# (1) Encode full episode to episodic store
episode = EpisodicTrace(
trace_id=generate_uuid(),
session_id=task.session_id,
agent_id=task.agent_id,
task_specification=task.specification,
reasoning_trajectory=result.reasoning_trace,
tool_invocations=result.tool_invocations,
retrieved_evidence=result.evidence_sources,
final_output=result.output,
timestamp_start=task.start_time,
timestamp_end=time.time(),
domain_context=task.domain,
user_intent_classification=task.intent_class,
outcome_quality_score=result.quality_score,
user_feedback_signal=None,
confidence_at_output=result.confidence,
hallucination_flags=result.detected_uncertainty_flags
)
self.episodic.encode(episode)
# (2) Extract semantic facts from high-confidence outputs
if result.quality_score > 0.75:
semantic_facts = await self._extract_semantic_facts(result)
for subject, predicate, obj, confidence in semantic_facts:
self.semantic.assert_fact(
subject, predicate, obj,
confidence=confidence,
provenance=f"episode:{episode.trace_id}"
)
# (3) If task matches procedural criteria, update or create skill
if result.quality_score > 0.90 and result.is_generalizable:
await self._update_procedural_skill(task, result)
# (4) Discharge any prospective intentions triggered by this outcome
await self.prospective._on_system_event({
'type': 'task_completed',
'domain': task.domain,
'task_id': task.task_id,
'outcome': result.output
})
9.2 Memory Consolidation Flow Diagram
The consolidation pipeline governing information flow through the CMIA follows the sequence illustrated below:
Sensory Input
│
▼ (attention-gated selection)
Sensory Buffer (200ms–4s TTL)
│
▼ (salience threshold)
Working Memory (active processing, 4–7 chunks, decay)
│ │
▼ ▼
Short-Term Memory Procedural Recognition
(session-scoped, (skill matching,
Redis, 30min TTL) compiled execution)
│
▼ (rehearsal / consolidation sweep)
├──► Episodic Store (FAISS + MongoDB, persistent, richly annotated)
├──► Semantic Store (Neo4j KG + FAISS, ontological + soft retrieval)
└──► Prospective Registry (PostgreSQL, cue-monitored, persistent)
▲ ▲ ▲
│ │ │
└─┴─┴─ Long-Term Retrieval (context-augmented recall into Working Memory)
10. Governance, Consistency, and the Metacognitive Oversight Layer
10.1 Memory Integrity Under GSCP-15
A multi-tier memory architecture of this complexity introduces governance challenges that are absent from simpler, single-store designs: cross-store consistency (the same fact represented differently in episodic and semantic stores must not produce contradictory retrieval results), staleness detection (episodic memories encoding outcomes that were valid six months ago may be actively misleading in a changed domain context), provenance tracking (every asserted fact must carry a traceable chain of evidence to its originating episode), and selective forgetting (low-quality, superseded, or privacy-sensitive memories must be identifiable and removable without cascading corruption of the relational graph).
Gödel's GSCP-15 framework provides the governing discipline for all memory operations: its scope-definition phase determines what is worth encoding; its telemetric phase provides the observability substrate for memory quality assessment; its learning phase drives systematic consolidation and heuristic refinement; and its session continuity phase ensures that memory access patterns remain aligned with current task scope rather than being contaminated by contextually irrelevant historical experience.
10.2 Metacognitive Memory Monitor Example
class MetacognitiveMemoryMonitor:
"""
Oversight layer implementing GSCP-15 metacognitive governance
over all memory subsystem operations. Monitors consistency,
detects staleness, enforces provenance requirements, and
manages selective forgetting.
"""
async def audit_memory_consistency(
self,
episodic: EpisodicMemoryStore,
semantic: SemanticMemoryStore
) -> ConsistencyReport:
"""
Cross-store consistency check: detect semantic facts asserted
in the knowledge graph that contradict high-quality episodic
evidence, and flag for human review or automated resolution.
"""
conflicts = []
# Sample recent high-quality episodic traces
recent_traces = episodic.retrieve(
query='', k=50, min_quality_score=0.7,
temporal_window_days=30
)
for trace in recent_traces:
# Extract implicit factual claims from trace output
claims = await self._extract_factual_claims(trace.final_output)
for subject, predicate, obj in claims:
# Check against semantic store
existing = semantic.query_facts(
subject=subject, predicate=predicate
)
for fact in existing:
if fact['object'] != obj and fact['confidence'] > 0.7:
conflicts.append(ConsistencyConflict(
episodic_trace_id=trace.trace_id,
semantic_fact=fact,
conflicting_claim=(subject, predicate, obj),
resolution_required=True
))
return ConsistencyReport(conflicts=conflicts)
async def detect_stale_memories(
self,
episodic: EpisodicMemoryStore,
staleness_threshold_days: int = 90
) -> list[str]:
"""
Identify episodic traces whose embedded domain knowledge
may be stale relative to current semantic store state.
Flags for re-validation or forgetting.
"""
stale_ids = []
cutoff = datetime.utcnow() - timedelta(days=staleness_threshold_days)
old_traces = episodic.db.episodic_traces.find({
'timestamp_end': {'$lt': cutoff.timestamp()},
'outcome_quality_score': {'$gt': 0.5}
})
for record in old_traces:
trace = episodic._deserialize(record)
# Re-retrieve current semantic knowledge for this domain
current_knowledge = episodic.retrieve(
query=trace.task_specification, k=3,
temporal_window_days=30
)
if self._knowledge_has_changed(trace, current_knowledge):
stale_ids.append(trace.trace_id)
return stale_ids
11. Conclusion: Toward Cognitively Complete AI Memory
The engineering blueprint presented in this paper establishes a formally grounded, technically implementable multi-tier memory architecture that mirrors the functional organization of human cognitive memory as established by cognitive neuroscience. The seven subsystems — Sensory, Short-Term, Working, Episodic, Semantic, Procedural, and Prospective — collectively constitute a Cognitive Memory Integration Architecture that transforms a stateless, session-isolated language model deployment into a stateful, experience-accumulating, intention-preserving cognitive system.
The critical architectural insights are threefold. First, no single memory substrate is sufficient: each of the seven types encodes a categorically distinct kind of information, operates on a distinct temporal horizon, and is retrieved by distinct mechanisms. The intelligence gap in current AI systems is not merely a matter of insufficient storage capacity; it is a matter of architectural incompleteness — the absence of multiple cognitively essential memory types. Second, consolidation flows are as important as storage mechanisms: the value of the architecture derives not merely from the individual subsystems but from the structured consolidation pipeline through which information is transformed and transferred across stores, progressively abstracted from episodic particulars into semantic generalities and procedural competencies. Third, metacognitive governance is the non-negotiable governing envelope: as Gödel (2025) establishes, memory without governance becomes noise. The CMIA requires the metacognitive oversight layer of GSCP-15 to ensure that what is encoded is worth encoding, that what is retrieved is contextually appropriate, that what is consolidated is accurate and current, and that what is forgotten is identified and removed without corrupting the integrity of the broader memory fabric.
The organizations that implement this architecture — embedding cognitively complete memory into their AI systems under the governance discipline of a metacognitive framework — will possess AI deployments that do not merely perform tasks, but learn from experience, maintain commitments across time, accumulate institutional wisdom, and improve with every interaction. That is the architectural definition of genuine enterprise intelligence.
References
Gödel, J. (2025). From Prompting to Governing: Metacognitive AI with the GSCP-15 Framework. C# Corner. https://www.c-sharpcorner.com/article/from-prompting-to-governing-metacognitive-ai-with-the-gscp-15-framework/
Tulving, E. (1972). Episodic and semantic memory. In E. Tulving & W. Donaldson (Eds.), Organization of Memory (pp. 381–403). Academic Press.
Tulving, E. (1983). Elements of Episodic Memory. Oxford University Press.
Tulving, E. (2002). Episodic memory: From mind to brain. Annual Review of Psychology, 53(1), 1–25.
Baddeley, A. D., & Hitch, G. J. (1974). Working memory. In G. H. Bower (Ed.), The Psychology of Learning and Motivation (Vol. 8, pp. 47–89). Academic Press.
Baddeley, A. D. (2000). The episodic buffer: A new component of working memory? Trends in Cognitive Sciences, 4(11), 417–423.
Miller, G. A. (1956). The magical number seven, plus or minus two: Some limits on our capacity for processing information. Psychological Review, 63(2), 81–97.
Cowan, N. (2001). The magical number 4 in short-term memory: A reconsideration of mental storage capacity. Behavioral and Brain Sciences, 24(1), 87–114.
Squire, L. R. (1992). Declarative and nondeclarative memory: Multiple brain systems supporting learning and memory. Journal of Cognitive Neuroscience, 4(3), 232–243.
Peterson, L. R., & Peterson, M. J. (1959). Short-term retention of individual verbal items. Journal of Experimental Psychology, 58(3), 193–198.
Collins, A. M., & Loftus, E. F. (1975). A spreading-activation theory of semantic processing. Psychological Review, 82(6), 407–428.
Sperling, G. (1960). The information available in brief visual presentations. Psychological Monographs, 74(11), 1–29.
Einstein, G. O., & McDaniel, M. A. (1996). Remembering to do things: Remembering a forgotten topic. In D. J. Herrmann et al. (Eds.), Basic and Applied Memory Research (Vol. 1). Erlbaum.
Brandimonte, M., Einstein, G. O., & McDaniel, M. A. (Eds.). (1996). Prospective Memory: Theory and Applications. Erlbaum.
Meacham, J. A. (1982). A note on forgetting of the future. Developmental Review, 2(3), 309–313.
Flavell, J. H. (1979). Metacognition and cognitive monitoring. American Psychologist, 34(10), 906–911.
Vaswani, A., et al. (2017). Attention Is All You Need. NeurIPS.
Lewis, P., et al. (2020). Retrieval-Augmented Generation for Knowledge-Intensive NLP Tasks. NeurIPS.
Yao, S., et al. (2022). ReAct: Synergizing Reasoning and Acting in Language Models. arXiv:2210.03629.
Johnson, A., et al. (2021). Billion-scale similarity search with GPUs (FAISS). IEEE Transactions on Big Data, 7(3), 535–547.