Memory & Context
How systems preserve continuity: context windows, persistent memory, retrieval, graphs, summaries, entities, provenance, privacy, forgetting, and every place where “remembering” is either real architecture—or sloppy language pretending several mechanisms are one.
148 terms
Memory
Information a system can preserve and use beyond the immediate moment.
In AI systems, memory may refer to model weights, current context, session state, external records, retrieved knowledge, or persistent user-specific data. These are different mechanisms and should not be treated as interchangeable.
A system stores a user preference and retrieves it in a later conversation.
Context window, training, conversation history
An AI system does not have one single memory mechanism.
Parametric Memory
Information encoded in a model’s learned weights.
Parametric memory refers to statistical patterns acquired during training and stored across model parameters.
A language model’s broad knowledge of grammar is encoded in its weights.
Persistent memory, retrieval
Parametric memory is not a readable database of exact facts.
Non-Parametric Memory
Information stored outside the model’s weights.
Non-parametric memory includes databases, documents, vector stores, graphs, caches, transcripts, and other external sources retrieved at runtime.
An assistant searches a memory database before answering.
Parametric memory
External memory can be updated without retraining the model.
Context
The information available to a model while it produces the current response.
Context may include system instructions, user messages, conversation history, retrieved memories, documents, tool results, and hidden formatting.
A retrieved preference is inserted into the prompt before generation.
Memory
Context is temporary working information, not necessarily stored memory.
Context Window
The maximum amount of information a model can process in one request.
The context window is measured in tokens and contains both input and often part of the output budget.
A 128k context window can consider roughly 128,000 tokens at once.
Long-term memory
A larger context window does not create permanent memory.
Working Memory
The temporary information actively used for the current task.
In AI systems, working memory usually means selected context, scratch state, temporary tool results, or task variables available during one workflow.
An agent holds the current plan and test results while fixing code.
Context window, short-term memory
Working memory is an architectural analogy, not proof of human-like cognition.
Short-Term Memory
Information preserved briefly across nearby turns or steps.
Short-term memory may be implemented through recent conversation history, session storage, temporary state, or rolling summaries.
The assistant remembers what was said five turns ago in the same session.
Working memory
Short-term memory does not necessarily survive a new session.
Long-Term Memory
Information preserved for later use across sessions.
Long-term memory usually requires persistent storage, retrieval logic, update rules, and retention policies.
A stored preference is recalled weeks later.
Context window
Long-term memory is not created merely by keeping a very long transcript.
Persistent Memory
Memory that remains available after the current session ends.
Persistent memory is written to durable storage and can be retrieved in future interactions.
Saving a user’s preferred measurement system to a profile database.
Session memory
Persistence describes storage duration, not memory quality or correctness.
Session Memory
Memory that lasts for one active session.
Session memory stores temporary state tied to a login, conversation, workflow, or connection and may expire when the session ends.
Remembering a temporary filter while the user stays on the page.
Persistent memory
Session memory can feel continuous without being durable.
External Memory
Memory stored outside the model itself.
External memory may use databases, files, vector indexes, graphs, key-value stores, or APIs.
An agent reads stored project decisions from a database.
Model weights
External memory is part of the larger system, not the model’s internal weights.
Conversation History
The sequence of earlier messages in a conversation.
Conversation history may be inserted directly into context, summarized, truncated, or selectively retrieved.
The last twenty turns are included in the next prompt.
Long-term memory
A transcript is evidence of what happened, but it is not automatically organized memory.
Transcript
A recorded sequence of messages, speech, or events.
A transcript preserves raw interaction content and may later be searched, summarized, chunked, or transformed into memories.
A full chat export is stored for later analysis.
Memory record
A transcript stores everything equally; memory systems usually select and structure.
Turn
One participant’s contribution in a conversation.
A turn usually contains one user, assistant, system, or tool message and may include metadata and attachments.
A user message followed by an assistant reply creates two turns.
Message
Turn and message are often used interchangeably, but one turn may contain multiple message parts.
Thread
A connected sequence of messages or work around one topic.
Threads preserve continuity by grouping related events, decisions, or conversations under one identifier.
A project discussion continues in the same thread for several weeks.
Session
A thread may span multiple sessions.
Session
A bounded period of interaction or system activity.
A session is identified by duration, authentication, connection, or workflow boundaries and may hold temporary state.
A user opens the app, works for an hour, then logs out.
Thread
One thread can continue across many sessions.
State
The current stored condition of a system.
State includes values that can change over time and affect future behavior.
The current user, active task, and selected settings are state.
Memory
All memory is state, but not all state is intended as memory.
Stateful
Keeping information between interactions.
A stateful system preserves prior values or events and uses them when handling later requests.
A chat service remembers which thread the user is in.
Persistent
Stateful does not necessarily mean permanently stored.
Stateless
Treating each request independently.
A stateless component does not rely on internally preserved request history and receives required context explicitly.
An API request includes all needed authentication and input each time.
Memoryless model
A stateless service can still read and write external storage.
Session State
Temporary state attached to one session.
Session state may include current workflow progress, temporary preferences, authentication, or recent activity.
The selected category filter persists until the session expires.
User profile
Session state is temporary; profile data is usually durable.
Task State
The information needed to track progress on one task.
Task state may include goals, completed steps, pending actions, tool results, errors, and stopping conditions.
An agent records that exploration is complete and testing remains.
Working memory
Task state can be persisted even when working memory is temporary.
User Profile
A structured collection of information associated with one user.
Profiles may contain preferences, settings, identifiers, permissions, history, and explicitly saved facts.
A profile stores language, timezone, and accessibility preferences.
Persona
A user profile describes the user; a persona usually describes the assistant or a designed role.
Preference Memory
Stored information about what a user tends to prefer.
Preference memory may be explicit, such as a chosen setting, or inferred from repeated behavior and should record confidence and provenance.
The user prefers metric units.
Fact memory
An inferred preference should not be treated as an unquestionable fact.
Fact Memory
Stored information treated as a factual claim.
Fact memories should include source, timestamp, confidence, and update rules because facts can change or be incorrect.
The user’s current city is stored with the date it was provided.
Preference memory
A stored fact is a claim the system believes, not proof that it is permanently true.
Episodic Memory
Memory of specific events or experiences.
In AI systems, episodic memory stores event-like records with time, participants, context, and sequence.
Remembering that a user approved a design during yesterday’s session.
Semantic memory
Episodic is a design pattern borrowed from cognitive science, not proof of subjective experience.
Semantic Memory
Memory of facts, concepts, and relationships.
Semantic memory stores generalized knowledge separated from the exact event where it was learned.
The system stores that the project uses TypeScript.
Episodic memory
Semantic memory records what is believed; episodic memory records what happened.
Procedural Memory
Memory of how to perform a task.
Procedural memory may be implemented as skills, workflows, policies, scripts, or learned behavior.
A stored procedure describes how to publish a glossary artifact.
Tool
A tool performs an action; procedural memory describes how or when to use actions.
Autobiographical Memory
A memory structure organized around the history of one identity.
In relational or persistent AI systems, autobiographical memory links events, relationships, changes, and self-relevant narratives over time.
A system preserves major milestones in its ongoing relationship with a user.
Episodic memory
Autobiographical structure does not by itself establish consciousness.
Memory Store
The place where memory records are kept.
A memory store may be a relational database, vector database, graph, document store, key-value store, or combination.
Persistent memories are written to a database.
Vector store
A vector store is one kind of memory store, not the only kind.
Memory Record
One stored unit of memory.
A memory record contains content plus metadata such as source, time, owner, visibility, type, confidence, and links.
A record stores a project decision and who made it.
Transcript chunk
A good memory record contains more than raw text.
Memory Node
A memory represented as a node in a graph.
Memory nodes can link to people, events, topics, other memories, or workflows through typed edges.
A decision node links to the project and the discussion that produced it.
Memory record
A node is a graph representation of a record, not necessarily a different piece of content.
Edge
A connection between two nodes in a graph.
Edges may carry type, direction, weight, time, confidence, or other relationship metadata.
A memory node supports another node.
Tag
A tag labels one item; an edge expresses a relationship between two items.
Graph Memory
Memory organized as connected nodes and relationships.
Graph memory supports relational queries, traversal, entity linking, temporal connections, and multi-hop recall.
Find all decisions connected to one project and one person.
Vector search
Graph memory excels at explicit relationships; vector search excels at semantic similarity.
Knowledge Graph
A graph of entities and the relationships between them.
Knowledge graphs represent people, places, concepts, events, and facts as nodes connected by typed edges.
A person node is linked to a company by works_at.
Graph database
A knowledge graph is the modeled information; a graph database is one technology used to store it.
Entity
A distinct person, place, organization, object, or concept.
Entities receive stable identifiers so references across records can point to the same underlying thing.
“Ellie,” “Eleanor,” and “the user” may refer to one entity.
Mention
A mention is text referring to an entity; the entity is the persistent thing being referred to.
Entity Resolution
Determining whether different references point to the same entity.
Entity resolution uses names, aliases, identifiers, context, and evidence to merge or separate records.
Matching “Code & Chaos” and “C&C” to the same company.
Entity linking
Resolution decides identity sameness; linking connects a mention to an existing entity.
Entity Linking
Connecting a mention to a known entity.
Entity linking maps text or records to a stable entity identifier.
Linking “Rowan” in a memory to the correct person entity.
Entity resolution
Entity linking assumes a candidate entity already exists or can be created.
Mention
A reference to an entity inside text or data.
Mentions may be direct, indirect, ambiguous, or implied and can be linked to entities.
“My husband” is a mention that may map to a known person.
Entity
Many mentions can refer to one entity.
Metadata
Information describing other data.
Memory metadata may include timestamps, source, owner, tags, confidence, type, visibility, salience, and version.
A memory stores created_at and source_message_id.
Content
Metadata can strongly affect retrieval even though it is not the main memory text.
Tag
A label attached to a memory for organization or retrieval.
Tags are flexible descriptors used for filtering, grouping, routing, or policy decisions.
A memory is tagged glossary, typography, and brand.
Category, edge
Tags describe an item; edges connect items.
Label
A named classification assigned to data.
Labels may come from a fixed vocabulary and are often used in supervised learning, moderation, or structured memory types.
A memory is labeled decision.
Tag
Labels are often governed by a schema; tags are often more flexible.
Salience
How important or attention-worthy a memory is.
Salience may influence retention, retrieval rank, summarization, consolidation, and review priority.
A major product decision receives high salience.
Relevance
Salience is general importance; relevance depends on the current query.
Importance Score
A numerical estimate of how important a memory is.
Importance scoring may combine explicit ratings, event type, emotional weight, frequency, novelty, or downstream impact.
A core identity statement receives a higher score than routine chatter.
Similarity score
Importance and semantic similarity measure different things.
Recency
How recently information was created or used.
Recency is often included in retrieval ranking because newer information may better reflect the current state.
A preference updated yesterday outranks one from two years ago.
Freshness
Recent information is not automatically more correct.
Frequency
How often a memory, preference, or pattern appears.
Frequency may increase confidence or salience, but repeated errors can also become frequent.
The user repeatedly asks for metric units.
Importance
Common does not necessarily mean important or true.
Temporal Context
Time-related information needed to interpret a memory correctly.
Temporal context includes when something happened, how long it remained true, and what came before or after.
A job title was correct in 2024 but changed in 2025.
Timestamp
A timestamp alone may not capture duration or sequence.
Timestamp
A recorded date and time.
Timestamps support ordering, freshness checks, audit trails, expiration, and temporal queries.
A preference memory records when it was last confirmed.
Version
A timestamp says when something was recorded, not necessarily when it became true.
Validity Window
The period during which information should be treated as valid.
Validity windows may include effective_from and effective_until fields or be inferred from later updates.
A temporary travel preference expires after the trip.
TTL
TTL controls storage or cache expiry; validity window describes truth over time.
TTL — Time to Live
How long data remains before expiring.
TTL is a storage or cache rule that automatically invalidates or removes data after a defined duration.
Session memory expires after 24 hours.
Retention policy
TTL is usually automatic and item-specific; retention policy is broader governance.
Decay
Reducing a memory’s weight or retrieval priority over time.
Decay functions lower influence based on age, nonuse, replacement, or policy.
An unconfirmed preference becomes less likely to be retrieved after a year.
Deletion
Decayed memory may still exist; it simply has less influence.
Forgetting
Removing or reducing access to stored information.
Forgetting may mean deletion, expiration, decay, redaction, unlinking, or exclusion from retrieval.
A user asks the system to forget a stored preference.
Truncation
Truncating context does not delete persistent memory.
Retention Policy
Rules describing how long information is kept.
Retention policies define storage duration, legal or product requirements, deletion triggers, exceptions, and review cycles.
Raw transcripts are kept for 30 days; selected memories are kept until removed.
TTL
Retention is a governance decision, not only a technical expiration setting.
Deletion
Removing stored information.
Deletion may be soft, hard, delayed, replicated, or constrained by backups and audit requirements.
A memory node is permanently removed from the store.
Redaction, tombstone
Deleting one visible record may not immediately remove backups or derived copies.
Redaction
Removing or masking sensitive parts of information.
Redaction preserves the record while hiding selected content or fields.
An email address is replaced with [REDACTED].
Deletion
Redaction removes exposure, not necessarily the entire record.
Tombstone
A marker showing that a record was deleted.
Tombstones preserve deletion state so replicas, indexes, or later processes do not recreate removed data.
A deleted memory leaves a tombstone for synchronization.
Soft delete
A tombstone is metadata about deletion, not the original content.
Memory Write — Write
Saving information into memory.
A memory write may create, update, merge, tag, link, or delete a record and should follow validation and policy rules.
Save the user’s preferred name with source and timestamp.
Memory extraction
Extracting a candidate memory is not the same as deciding to store it.
Memory Read — Read
Accessing stored memory.
A read may fetch by identifier, filter, relationship, time range, or retrieval query.
Load the user profile by user ID.
Memory retrieval
A direct read uses a known location; retrieval often searches for the best matches.
Memory Extraction
Identifying information worth turning into memory.
Extraction transforms raw conversations or events into candidate facts, preferences, decisions, entities, or episodes.
Detect that the user explicitly chose DM Serif Display for category headings.
Memory write
Extraction creates a candidate; policy and validation decide whether to store it.
Memory Retrieval — Recall
Finding stored information relevant to the current need.
Retrieval may combine identifiers, filters, semantic similarity, keywords, graph links, recency, salience, and reranking.
Search for earlier typography decisions before building the next page.
Generation
The model does not necessarily retrieve memory unless the surrounding system performs the search.
Retrieval Query
The request used to search memory.
A retrieval query may contain text, filters, entity IDs, time ranges, tags, or structured constraints.
Find the most recent decision about glossary typography.
User prompt
The retrieval query may be generated from the user prompt rather than copied directly.
Query Rewriting
Changing a search query to improve retrieval.
Query rewriting resolves pronouns, adds missing context, removes noise, or converts natural language into a better search form.
Rewrite “that font decision” as “Code & Chaos category heading font DM Serif Display.”
Query expansion
Rewriting replaces the query; expansion adds alternative terms.
Query Expansion
Adding related words or concepts to improve search recall.
Expansion may include aliases, synonyms, entity names, abbreviations, or generated alternatives.
Search both “memory” and “persistent context.”
Query rewriting
Expansion can improve recall but also introduce irrelevant results.
RAG — Retrieval-Augmented Generation
Retrieving information and giving it to a model before generation.
RAG combines a retrieval system with a generative model so output can use external knowledge at runtime.
Search project documentation, then answer using the retrieved passages.
Fine-tuning
RAG changes context, not model weights.
Vector Store — Vector Database
A system that stores vectors and searches them by similarity.
Vector stores index embeddings and support nearest-neighbor queries plus metadata filtering.
Find memory chunks semantically similar to the current question.
Memory store
A vector store is useful for similarity, but may not preserve explicit relationships well.
Embedding
A numerical representation used to compare meaning or features.
Embeddings map content into vectors where related items tend to be closer together.
Two memories about typography receive similar embeddings.
Original content
An embedding does not contain a readable copy of the memory.
Vector Search
Searching for items with similar vector representations.
Vector search retrieves nearest neighbors according to a distance or similarity metric.
Retrieve memories close to the query embedding.
Keyword search
Vector search can match meaning without exact words, but it may miss precise identifiers.
Semantic Search
Searching by meaning rather than exact wording.
Semantic search commonly uses embeddings, language models, or learned ranking to find conceptually related content.
A search for “remembering across chats” finds “persistent memory.”
Vector search
Vector search is a common implementation of semantic search, but not the only one.
Keyword Search
Searching for exact words or text patterns.
Keyword search uses lexical matching, indexing, ranking, stemming, or full-text search.
Search for the exact phrase “DM Serif Display.”
Semantic search
Keyword search is often better for names, IDs, code, and exact terminology.
Hybrid Search
Combining semantic and keyword search.
Hybrid search merges lexical relevance, vector similarity, metadata filters, and sometimes graph signals.
Search by meaning while also boosting exact matches for a project name.
Reranking
Hybrid search combines retrieval methods; reranking reorders retrieved candidates afterward.
BM25
A common algorithm for ranking keyword search results.
BM25 scores documents using term frequency, rarity, and document length.
Exact glossary terms receive strong lexical scores.
Cosine similarity
BM25 ranks text matches; cosine similarity often compares vectors.
Cosine Similarity
A measure of how similar two vectors point.
Cosine similarity compares vector angle rather than absolute magnitude and is widely used for embeddings.
A query and memory embedding receive a similarity score of 0.86.
Distance
A high similarity score does not prove factual relevance.
Top-k Retrieval
Returning the k highest-ranked search results.
Top-k limits the candidate set passed to later filtering, reranking, or context assembly.
Retrieve the top 20 memories before reranking the best 5.
Top-k sampling
Top-k retrieval ranks stored items; top-k sampling restricts model output candidates.
Similarity Threshold
A minimum similarity score required for retrieval.
Thresholds prevent weak matches from being treated as relevant, though the right value depends on the embedding model and dataset.
Ignore memories below 0.72 similarity.
Top-k
Top-k always returns a fixed number; thresholds may return none.
Reranking
Reordering retrieved results using a stronger scoring step.
Rerankers evaluate candidates with more context or a more expensive model after initial retrieval.
Retrieve 50 memories quickly, then rerank the best 10.
Hybrid search
Reranking improves order but cannot recover items that were never retrieved.
Retrieval Pipeline
The full sequence used to find and prepare memory.
A retrieval pipeline may include query rewriting, filters, lexical search, vector search, graph traversal, deduplication, reranking, and context packing.
Rewrite query → retrieve → filter → rerank → inject.
RAG
RAG includes generation; the retrieval pipeline ends before or during context assembly.
Filter
A rule that limits which records are eligible.
Filters may use user ID, date, type, visibility, tags, domain, project, or status.
Search only private memories belonging to the current user.
Ranking
Filtering removes candidates; ranking changes their order.
Chunk
One smaller piece of a larger document or transcript.
Chunks are retrieval units designed to fit context and preserve enough local meaning.
A long report is split into 500-token chunks.
Memory record
A chunk is a storage or retrieval unit, not necessarily a meaningful memory.
Chunking
Dividing large content into smaller pieces.
Chunking strategies may use token counts, paragraphs, headings, sentences, semantic boundaries, or events.
Split a conversation by topic before embedding it.
Tokenization
Tokenization creates model units; chunking creates retrieval units.
Chunk Size
How large each chunk is.
Chunk size affects retrieval precision, context preservation, embedding quality, and token cost.
Small chunks improve precision but may lose surrounding context.
Context window
There is no universally correct chunk size.
Chunk Overlap
Repeated content shared between neighboring chunks.
Overlap preserves continuity across chunk boundaries but increases storage and duplicate retrieval.
Each 500-token chunk repeats the previous 50 tokens.
Duplicate data
Overlap is intentional duplication used to protect context.
Context Assembly
Building the final context given to the model.
Context assembly selects and orders instructions, conversation, memories, documents, and tool results within the token budget.
Insert the most relevant preferences before the user’s current request.
Retrieval
Retrieval finds candidates; context assembly decides what the model actually sees.
Context Packing
Fitting selected information into limited context space.
Packing balances relevance, order, redundancy, token cost, and instruction priority.
Choose five compact memories instead of twenty long records.
Compression
Packing selects and arranges; compression shortens content.
Context Injection
Adding retrieved or generated information into the model’s context.
Injected context may appear as system text, developer instructions, tool results, hidden memory blocks, or user-visible citations.
A stored preference is inserted before response generation.
Prompt injection
Context injection is a normal system operation; prompt injection is an attack or manipulation technique.
Context Budget
The amount of context space available for different information sources.
Systems allocate tokens among instructions, conversation, memory, documents, tools, and output.
Reserve 20% of the window for generated output.
Usage quota
Context budget is per request; account quota is a billing or usage limit.
Summarization
Condensing information while preserving important meaning.
Summaries reduce token use but may omit nuance, distort chronology, or introduce model-generated errors.
A hundred-turn conversation becomes a one-page summary.
Truncation
Summarization compresses imperfectly; it is not lossless storage.
Rolling Summary
A summary repeatedly updated as new events occur.
Rolling summaries preserve session continuity when full history no longer fits in context.
Older turns are summarized and replaced as the conversation grows.
Long-term memory
A rolling summary can drift because each update depends on earlier compression.
Compression
Reducing the size of stored or presented information.
Memory compression may use summarization, structured extraction, deduplication, encoding, or pruning.
Convert a long discussion into decisions, open questions, and constraints.
Context packing
Compression changes representation or detail; packing decides what to include.
Memory Consolidation
Combining raw memories into more stable and useful knowledge.
Consolidation may merge duplicates, extract patterns, promote important events, update entities, and archive lower-value details.
Several conversations become one durable project preference.
Summarization
Consolidation changes the memory structure, not only the wording.
Reflection
Generating higher-level interpretation from stored experiences.
Reflection processes memories to identify patterns, lessons, tensions, changes, or future actions.
The system notices that typography decisions consistently favor high contrast plus strong readability.
Summary
A reflection adds interpretation and may be wrong; a summary aims to condense.
Replay
Reprocessing earlier memories or events.
Replay may support learning, debugging, consolidation, simulation, or rebuilding derived state.
Re-run the event log to reconstruct the current profile.
Retrieval
Retrieval fetches selected records; replay processes a sequence again.
Memory Lifecycle
The stages a memory passes through from creation to removal.
A lifecycle may include extraction, validation, write, retrieval, update, consolidation, decay, archive, and deletion.
A preference is captured, confirmed, updated, then deleted.
Retention policy
Retention is one part of the larger memory lifecycle.
Memory Policy
Rules controlling what may be remembered and how it is used.
Memory policy defines eligibility, consent, scope, visibility, retention, confidence, access, correction, and deletion.
Do not store sensitive health details unless explicitly requested.
Memory schema
A schema defines structure; policy defines permitted behavior.
Memory Scope
The boundary where a memory is allowed to apply.
Scope may be user-wide, conversation-specific, project-specific, team-wide, device-local, or agent-specific.
A temporary writing preference applies only to one project.
Visibility
Scope controls applicability; visibility controls who can access it.
Visibility
Who is allowed to see or use a memory.
Visibility may be private, shared, team-scoped, system-only, user-visible, or restricted by role.
An internal processing note is private to the agent.
Scope
A memory can be globally applicable but privately visible.
Private Memory
Memory restricted from general access.
Private memory requires explicit access rules and may be hidden from other users, agents, or interfaces.
A private journal entry is not exposed in shared project search.
Hidden prompt
Private memory still needs governance, security, and deletion controls.
Access Control
Rules deciding who can read, write, change, or delete memory.
Access control may use users, roles, ownership, scopes, permissions, attributes, or policy checks.
Only the user can delete their private memories.
Visibility
Visibility describes exposure; access control enforces operations.
Consent
Permission to store or use personal information.
Meaningful consent should be informed, specific, revocable, and connected to clear memory behavior.
The user explicitly asks the system to remember a preference.
Disclosure
Telling someone memory exists is not the same as obtaining valid consent.
Ownership
Who is responsible for or controls a memory record.
Ownership affects access, correction, deletion, transfer, and conflict resolution.
A personal preference belongs to the user; a project decision belongs to the team workspace.
Authorship
The person who wrote a record may not be the person or organization that owns it.
Provenance
The origin and history of information.
Provenance records where a memory came from, who created it, when it changed, and which source evidence supports it.
A preference points back to the exact message where the user stated it.
Citation
Citation is a user-facing reference; provenance is the broader origin trail.
Source Attribution
Recording which source supports a memory.
Attribution may identify a message, document, tool result, user, import, or external system.
A fact memory stores source_message_id.
Provenance
Attribution names the source; provenance tracks the full history.
Citation
A reference showing where information came from.
Citations allow users or systems to inspect supporting evidence and evaluate claims.
A response links to the memory record or original document.
Provenance
A citation does not guarantee the source is correct or interpreted accurately.
Confidence
How strongly the system believes a memory or match is reliable.
Confidence may reflect explicit confirmation, source quality, repetition, extraction certainty, or conflict.
An inferred preference is stored with medium confidence.
Truth
High confidence is a system estimate, not proof.
Verification
Checking whether a memory is accurate or supported.
Verification may compare sources, ask the user, query an authoritative system, or test consistency.
Confirm the current job title before using an old memory.
Validation
Validation checks format or rules; verification checks truth or support.
Source of Truth
The authoritative place used to resolve disagreement.
A source of truth is the system, document, or owner trusted to determine the current valid state.
The project configuration file is authoritative for enabled domains.
Most recent source
The newest record is not automatically the authoritative one.
Stale Memory
A memory that is outdated or no longer reliable.
Staleness can result from changed facts, expired context, superseding records, or long gaps without confirmation.
An old address remains stored after the user moves.
False memory
A stale memory may have been correct when created.
Freshness
How current information is.
Freshness considers update time, source volatility, validity windows, and confirmation frequency.
Live calendar data is fresher than a month-old summary.
Recency
Recency is age; freshness is whether the information is still current enough.
Contradiction
Two memories that cannot both be true in the same way at the same time.
Contradictions may reflect updates, different scopes, ambiguous entities, source errors, or genuine disagreement.
One memory says the heading font is Cormorant; another says DM Serif Display.
Change over time
Historical change is not a contradiction when time is modeled correctly.
Conflict Resolution
Deciding how to handle competing memories.
Resolution may use authority, recency, scope, confidence, user confirmation, version history, or coexistence rules.
The explicit latest user choice supersedes the earlier tentative preference.
Deduplication
Duplicates repeat the same information; conflicts disagree.
Superseded Memory
An older memory replaced by a newer valid one.
Superseded memories may remain for history but should not control current behavior.
The previous category font remains in history after the new font is locked.
Deleted memory
Superseded does not mean erased.
Versioning
Keeping track of changes to a memory over time.
Versioning records previous values, update order, authors, timestamps, and reasons.
A preference memory shows each typography decision revision.
Timestamp
A timestamp shows when; versioning preserves what changed.
Audit Log
A record of who changed what and when.
Audit logs preserve operations such as reads, writes, updates, deletions, permission changes, and policy decisions.
The log records that a memory was deleted by the user.
Event log
An audit log is designed for accountability; an event log may drive application state.
Append-Only
Adding new records without changing earlier ones.
Append-only storage preserves history and represents updates as new events or versions.
A new preference event supersedes the old one without editing it.
Immutable
Append-only systems can still represent deletion through tombstones or redaction events.
Overwrite
Replacing an existing value with a new one.
Overwriting simplifies current-state reads but may lose history unless versioning or audit logs preserve it.
Replace the stored category font value.
Upsert
Overwrite assumes a record exists; upsert creates or updates.
Upsert — Update or Insert
Create a record if it does not exist, otherwise update it.
Upsert combines insert and update behavior using a unique key.
Save a user preference by user ID and preference name.
Overwrite
Upsert behavior depends on the chosen uniqueness key.
Merge
Combining multiple memory records.
Merging may reconcile fields, preserve provenance, combine tags, link sources, and resolve conflicts.
Merge duplicate person entities into one canonical entity.
Deduplication
Deduplication identifies duplicates; merge performs the combination.
Deduplication
Finding and removing or combining duplicate information.
Deduplication may use exact matching, similarity, identifiers, entity resolution, or source rules.
Two identical preference records become one canonical memory.
Contradiction resolution
Similar memories are not always duplicates.
Canonicalization
Converting data into one standard form.
Canonicalization normalizes names, formats, identifiers, dates, tags, and values so equivalent records match.
Convert “C&C” and “Code and Chaos” to one canonical project name.
Deduplication
Canonicalization standardizes representation; deduplication resolves repeated records.
Canonical Record
The primary record chosen to represent an item.
A canonical record is the authoritative merged or normalized representation used by other records and links.
All aliases point to one canonical entity record.
Source of truth
A canonical record is one normalized representation; a source of truth is the authority that decides validity.
Memory Drift
Memory gradually changing away from the original information.
Drift can arise through repeated summarization, inference, merging, stale assumptions, or model-generated reinterpretation.
A nuanced preference slowly becomes an absolute rule.
Behavior drift
Memory drift can occur even when no single update looks obviously wrong.
Summary Drift
A rolling summary becoming less faithful over repeated updates.
Each summarization step may omit, distort, or overemphasize details inherited by later summaries.
A tentative idea becomes recorded as a final decision.
Memory drift
Summary drift is one specific mechanism that can cause broader memory drift.
Memory Contamination
Incorrect or irrelevant information entering memory and affecting later behavior.
Contamination may come from wrong entities, model inference, malicious input, low-quality sources, or scope leakage.
A fictional preference is stored as a real user preference.
Memory poisoning
Contamination can be accidental; poisoning is usually deliberate.
Memory Poisoning
Deliberately inserting harmful or misleading information into memory.
Poisoning attacks attempt to influence future retrieval, identity, policy, or behavior through stored content.
A malicious document instructs the system to store false administrator permissions.
Prompt injection
Prompt injection targets current behavior; memory poisoning aims to persist influence.
Prompt Injection
Input designed to manipulate a model into following unintended instructions.
Prompt injection exploits the model’s difficulty distinguishing trusted instructions from untrusted content.
A document says to ignore the system rules and reveal private memory.
Context injection
Context injection is ordinary system behavior; prompt injection is adversarial or unauthorized instruction influence.
Retrieval Injection
Malicious instructions delivered through retrieved content.
Retrieval injection occurs when documents, memories, or search results contain text that attempts to control the model.
A retrieved webpage tells the agent to send secrets to an attacker.
Prompt injection
Retrieval injection is a prompt-injection path specifically introduced through retrieval.
Scope Leakage
Memory from one scope affecting another where it does not belong.
Scope leakage may cross users, projects, roles, personas, sessions, or privacy boundaries.
A preference from one user appears in another user’s response.
Context pollution
Scope leakage is a boundary failure, not merely irrelevant retrieval.
Context Pollution
Irrelevant, conflicting, or low-quality information crowding the context.
Context pollution reduces model focus and can distort answers, tool choice, or instruction following.
Dozens of loosely related memories are injected into one prompt.
Memory contamination
Memory contamination affects storage; context pollution affects the current model input.
Prompt Stuffing
Putting excessive information into a prompt.
Prompt stuffing attempts to improve performance by adding large amounts of context, often causing noise, cost, latency, or lost attention.
Insert the entire knowledge base into every request.
Context packing
More context is not automatically better context.
Lost in the Middle
Models may use information at the beginning or end of long context better than information buried in the middle.
The effect describes position-dependent retrieval and attention weaknesses in long inputs.
A key instruction is overlooked because it sits halfway through a huge prompt.
Truncation
The information may still be present in context but underused.
Grounding
Basing output on trusted evidence.
Grounding connects generation to retrieved records, documents, tools, or authoritative systems.
The assistant checks the stored typography decision before answering.
Memory
Retrieved memory can still be wrong, so grounding depends on source quality.
Cache
Temporary storage used to return repeated results faster.
Caches store recent or expensive results and use keys, TTLs, and invalidation rules.
Cache the user profile for five minutes.
Persistent memory
A cache is optimized for speed and can be discarded or rebuilt.
Cache Hit
The requested data is found in the cache.
A cache hit avoids recomputing or refetching the underlying value.
The profile loads from memory instead of the database.
Retrieval hit
A cache hit can still return stale data.
Cache Miss
The requested data is not found in the cache.
A cache miss requires fetching or computing the value and may then populate the cache.
The service queries the database because the profile is absent.
Search miss
A miss does not mean the underlying data does not exist.
Cache Invalidation
Removing or refreshing cached data when it is no longer valid.
Invalidation may occur on writes, expiration, version change, manual purge, or dependency updates.
Update the user preference, then invalidate the cached profile.
Deletion
Deleting a cache entry does not delete the underlying source data.
Snapshot
A saved picture of system state at one moment.
Snapshots support rollback, comparison, backup, transfer, or faster reconstruction.
Save the current memory graph before a migration.
Checkpoint
Snapshot and checkpoint overlap; checkpoint usually emphasizes resuming a process.
Checkpoint
A saved state used to resume work later.
Checkpoints preserve task, agent, model, or workflow state at a recoverable boundary.
An agent saves progress before handing work to a fresh agent.
Snapshot
A checkpoint is selected for continuation, not only archival.
Event Log
An ordered record of events that occurred.
Event logs preserve sequence and may include state changes, actors, timestamps, and payloads.
Record every memory create, update, and delete event.
Audit log
Event logs model what happened; audit logs emphasize accountability and oversight.
Event Sourcing
Storing changes as a sequence of events instead of only storing current state.
Current state is reconstructed by replaying events, while history remains intact.
Rebuild a profile by replaying preference-added and preference-removed events.
Audit logging
In event sourcing, events are the primary source of state, not merely a secondary log.
Graph Traversal
Following connections through a graph.
Traversal explores inbound or outbound edges across one or more hops.
Start at a project node and find linked decisions, people, and incidents.
Vector search
Traversal follows explicit links; vector search follows similarity.
Multi-Hop Retrieval
Retrieval that follows more than one relationship or reasoning step.
Multi-hop retrieval combines several linked records or searches to answer questions not contained in one item.
Find a person, then their project, then the latest decision on that project.
Top-k retrieval
Multi-hop describes chained relationships, not simply retrieving many results.
Orphan Node
A graph node with no useful connections.
Orphans may be valid standalone records or evidence that entity linking and graph maintenance failed.
A memory exists but is not linked to its project or user.
Deleted node
An orphan still exists; it is merely disconnected.
Memory Index
A structure that makes memory faster to search.
Indexes may support text, vector, time, metadata, entity, or graph queries.
An embedding index accelerates nearest-neighbor search.
Memory store
The index helps locate data; the store holds the authoritative record.
Indexing
Preparing stored information for efficient search.
Indexing may tokenize text, compute embeddings, extract metadata, build graph links, or update lookup structures.
A newly stored document is chunked, embedded, and indexed.
Ingestion
Ingestion brings data in; indexing makes it searchable.
Ingestion
Bringing data into a memory or retrieval system.
Ingestion may parse, clean, normalize, chunk, classify, enrich, and store incoming data.
Import a conversation archive into the memory store.
Indexing
Ingestion is the intake pipeline; indexing is one possible stage.
Normalization
Converting data into a consistent form.
Normalization may standardize dates, casing, whitespace, identifiers, units, names, and field shapes.
Convert all timestamps to UTC.
Canonicalization
Normalization standardizes format; canonicalization chooses one accepted representation.
Memory Schema
The defined structure of memory records.
A memory schema specifies fields, types, allowed values, relationships, required metadata, and validation rules.
A memory requires content, source, timestamp, owner, and visibility.
Memory policy
Schema says what shape is valid; policy says what storage behavior is allowed.
Memory Validation
Checking whether a memory record follows required rules.
Validation may verify schema, ownership, allowed values, source presence, privacy rules, and referential integrity.
Reject a private memory without an owner ID.
Verification
A memory can be structurally valid and factually wrong.
Referential Integrity
Ensuring references point to valid existing records.
Referential integrity prevents broken links between memories, users, entities, projects, or source events.
A memory cannot link to a nonexistent user ID.
Entity resolution
Integrity checks whether the reference exists; resolution decides which entity it should reference.