AI-LLM Memory & Reasoning Cheat Sheet

Updated 2026-05-28

Next Topic: AI-LLM Task Capabilities Cheat Sheet

🧠Study flashcards on this topic134 cards · spaced repetition→

AI memory and reasoning systems enable large language models and agents to retain information across interactions and solve complex problems through structured thought processes. Memory systems range from short-term conversation buffers to persistent knowledge graphs, while reasoning techniques guide models through step-by-step problem decomposition, verification, and refinement. In 2026, context engineering has emerged as the overarching discipline for managing what information lives in the context window at each step, and memory scaling — the property that agent performance improves as accumulated experience grows — has emerged as a new axis alongside parametric and inference-time scaling. Understanding the interplay between memory architecture, reasoning strategy, multi-agent coordination, and efficient context management is critical for building production agents that maintain context, reduce hallucinations, and execute multi-step workflows reliably.

What This Cheat Sheet Covers

This topic spans 17 focused tables and 134 indexed concepts, 134 flashcards. Below is a complete table-by-table outline of this topic, spanning foundational concepts through advanced details.

Table 1: Memory Types and ArchitectureTable 2: Memory Management FrameworksTable 3: Context Window ManagementTable 4: Reasoning Techniques — Chain-BasedTable 5: Reasoning Techniques — Tree and Graph-BasedTable 6: Reasoning Techniques — Reflection and RefinementTable 7: Reasoning Techniques — SpecializedTable 8: Inference-Time Compute ScalingTable 9: Retrieval-Augmented Generation (RAG) and MemoryTable 10: Memory Retrieval StrategiesTable 11: In-Context Learning and PromptingTable 12: Agent State and Session ManagementTable 13: Multi-Agent MemoryTable 14: Vector Databases for MemoryTable 15: Memory and Reasoning Trade-offsTable 16: Memory Evaluation BenchmarksTable 17: Model Architectures for Memory Efficiency

Quick IndexSubscribe to unlock

A jump-to index of every table row in this cheat sheet.

Mind MapSubscribe to unlock

An interactive map of every table and concept in this topic.

Table 1: Memory Types and Architecture

Memory in LLM agents draws directly from cognitive science: separating episodic, semantic, and procedural stores enables selective retrieval and prevents context overload. Choosing the right type — or the right combination — determines both how much an agent remembers and how cheaply it retrieves the right fact at query time.

Type	Example	Description
Short-Term (Working) Memory	`messages = [{"role": "user", "content": "Hi"},` `{"role": "assistant", "content": "Hello"}]`	• Stores recent conversation turns within the current session • limited by context window size and discarded when the session ends.
Long-Term Memory	`vector_db.store(embedding, metadata, user_id)`	• Persists knowledge across sessions using external storage • retrieved dynamically based on relevance rather than loaded wholesale.
Episodic Memory	`{"timestamp": "2026-04-01", "event": "user asked about X",` `"outcome": "provided Y"}`	• Records specific events and interactions with temporal context • allows the agent to recall what happened when and learn from past experiences.
Semantic Memory	`knowledge_graph.add_fact("Paris", "capital_of", "France")`	• Stores general facts and relationships independent of when they were learned • declarative knowledge without time markers.
Procedural Memory	`workflow = ["analyze_input", "generate_plan", "execute_steps",` `"verify_output"]`	• Encodes learned skills, workflows, and action sequences • guides how to perform tasks rather than storing facts, often implemented as tool patterns or code.
Observation Memory	`obs = synthesize(raw_facts, level="insight")` `store.add(obs, type="observation")`	• Higher-order synthesis of raw episodic and semantic memories into generalizable insights • improves multi-hop recall by giving retrieval access to richer, more abstract representations.
Vector Memory	`results = vector_db.search(query_embedding, top_k=5)`	• Embeds memories as vectors • enables semantic similarity search to retrieve contextually relevant information from large memory stores.
Graph Memory	`graph.add_edge("user_123", "prefers", "dark_mode")`	• Represents knowledge as entities and relationships in a graph structure • captures complex associations and multi-hop reasoning paths.
Mid-Term Memory	`# MemoryOS: short-term fills until FIFO threshold,` `# then promotes to mid-term as dialogue chains`	• Bridge tier between working memory and long-term storage (MemoryOS model) • manages promotion via FIFO dialogue-chain principle before further segmented-page compression to long-term.
Memory Distillation	`summary = llm.distill(episode_history,` `target="semantic_facts")` `archive.store(summary)`	• Compresses raw interaction history into actionable, low-footprint semantic or experiential memories • reduces token load while preserving critical knowledge across long-horizon tasks.
Buffer Memory	`memory = ConversationBufferMemory()`	• Stores the entire conversation history verbatim • simplest form but grows unbounded and consumes context rapidly.
Buffer Window Memory	`memory = ConversationBufferWindowMemory(k=5)`	• Maintains only the last $k$ conversation turns via a sliding window • balances recency with context limit constraints.
Summary Memory	`summary = llm.summarize(conversation_history)` `memory.store(summary)`	• Condenses conversation history into a running summary • trades detail for compression and is periodically regenerated to capture key points.
Hybrid Memory	`combine(vector_search(query), graph_traverse(entities))`	• Integrates multiple memory types (vector + graph, buffer + summary) • leverages strengths of each approach for robust retrieval.
Hierarchical Memory	`tiers = {"L1": working_context, "L2": session_cache,` `"L3": long_term_db}`	• Organizes memory in layered tiers from fast/small (working) to slow/large (persistent) • mimics human memory hierarchy for efficient access.

Table 2: Memory Management Frameworks

The memory framework market has consolidated around a few dominant patterns: universal memory layers, agent OS approaches, and graph-native stores. Choosing the right framework depends on whether you need cross-session persistence, structured entity extraction, or the ability to learn and evolve from both success and failure.

Tool	Example	Description
Mem0	`from mem0 import Memory` `memory = Memory()` `memory.add("User prefers Python", user_id="123")`	• Universal AI memory layer with entity extraction, graph storage, and adaptive retrieval • manages user, session, and agent memory independently; 21 frameworks and 20 vector stores integrated.

The rest of this section is part of the full cheat sheet

Table 3: Context Window Management

Context engineering in 2026 treats the context window as a constrained resource to curate, not just fill — selecting, ordering, and compressing information for maximum signal at every agent step. The discipline spans both token-level optimizations (caching, chunking) and higher-level architectural choices (which knowledge base to consult, what order context appears in).

Technique	Example	Description
Context Engineering	`context = select(history) + compress(docs)` `+ isolate(tool_outputs)`	The 2026 discipline of systematically curating the smallest high-signal set of tokens for the context window — selecting, compressing, and isolating information to maximize signal and minimize noise across every agent step.

The rest of this section is part of the full cheat sheet

Table 4: Reasoning Techniques — Chain-Based

Chain-based reasoning is the most broadly applicable prompting family: each variant produces a linear sequence of thought steps before the final answer. The key differentiators are whether those steps require examples, how verbose they are, and whether the chain decomposes top-down or bottom-up.

Technique	Example	Description
Chain-of-Thought (CoT)	`"Think step-by-step: 1) Identify the problem, 2) Break it down,` `3) Solve each part, 4) Combine results"`	• Prompts the model to show intermediate reasoning steps before the final answer • improves accuracy on complex tasks by exposing the thought process.

The rest of this section is part of the full cheat sheet

Table 1: Memory Types and Architecture

Type	Example	Description
Short-Term (Working) Memory	`messages = [{"role": "user", "content": "Hi"},` `{"role": "assistant", "content": "Hello"}]`	• Stores recent conversation turns within the current session • limited by context window size and discarded when the session ends.
Long-Term Memory	`vector_db.store(embedding, metadata, user_id)`	• Persists knowledge across sessions using external storage • retrieved dynamically based on relevance rather than loaded wholesale.
Episodic Memory	`{"timestamp": "2026-04-01", "event": "user asked about X",` `"outcome": "provided Y"}`	• Records specific events and interactions with temporal context • allows the agent to recall what happened when and learn from past experiences.
Semantic Memory	`knowledge_graph.add_fact("Paris", "capital_of", "France")`	• Stores general facts and relationships independent of when they were learned • declarative knowledge without time markers.
Procedural Memory	`workflow = ["analyze_input", "generate_plan", "execute_steps",` `"verify_output"]`	• Encodes learned skills, workflows, and action sequences • guides how to perform tasks rather than storing facts, often implemented as tool patterns or code.
Observation Memory	`obs = synthesize(raw_facts, level="insight")` `store.add(obs, type="observation")`	• Higher-order synthesis of raw episodic and semantic memories into generalizable insights • improves multi-hop recall by giving retrieval access to richer, more abstract representations.
Vector Memory	`results = vector_db.search(query_embedding, top_k=5)`	• Embeds memories as vectors • enables semantic similarity search to retrieve contextually relevant information from large memory stores.
Graph Memory	`graph.add_edge("user_123", "prefers", "dark_mode")`	• Represents knowledge as entities and relationships in a graph structure • captures complex associations and multi-hop reasoning paths.
Mid-Term Memory	`# MemoryOS: short-term fills until FIFO threshold,` `# then promotes to mid-term as dialogue chains`	• Bridge tier between working memory and long-term storage (MemoryOS model) • manages promotion via FIFO dialogue-chain principle before further segmented-page compression to long-term.
Memory Distillation	`summary = llm.distill(episode_history,` `target="semantic_facts")` `archive.store(summary)`	• Compresses raw interaction history into actionable, low-footprint semantic or experiential memories • reduces token load while preserving critical knowledge across long-horizon tasks.
Buffer Memory	`memory = ConversationBufferMemory()`	• Stores the entire conversation history verbatim • simplest form but grows unbounded and consumes context rapidly.
Buffer Window Memory	`memory = ConversationBufferWindowMemory(k=5)`	• Maintains only the last $k$ conversation turns via a sliding window • balances recency with context limit constraints.
Summary Memory	`summary = llm.summarize(conversation_history)` `memory.store(summary)`	• Condenses conversation history into a running summary • trades detail for compression and is periodically regenerated to capture key points.
Hybrid Memory	`combine(vector_search(query), graph_traverse(entities))`	• Integrates multiple memory types (vector + graph, buffer + summary) • leverages strengths of each approach for robust retrieval.
Hierarchical Memory	`tiers = {"L1": working_context, "L2": session_cache,` `"L3": long_term_db}`	• Organizes memory in layered tiers from fast/small (working) to slow/large (persistent) • mimics human memory hierarchy for efficient access.

Table 2: Memory Management Frameworks

Tool	Example	Description
Mem0	`from mem0 import Memory` `memory = Memory()` `memory.add("User prefers Python", user_id="123")`	• Universal AI memory layer with entity extraction, graph storage, and adaptive retrieval • manages user, session, and agent memory independently; 21 frameworks and 20 vector stores integrated.

Table 3: Context Window Management

Technique	Example	Description
Context Engineering	`context = select(history) + compress(docs)` `+ isolate(tool_outputs)`	The 2026 discipline of systematically curating the smallest high-signal set of tokens for the context window — selecting, compressing, and isolating information to maximize signal and minimize noise across every agent step.

Table 4: Reasoning Techniques — Chain-Based

Technique	Example	Description
Chain-of-Thought (CoT)	`"Think step-by-step: 1) Identify the problem, 2) Break it down,` `3) Solve each part, 4) Combine results"`	• Prompts the model to show intermediate reasoning steps before the final answer • improves accuracy on complex tasks by exposing the thought process.

AI/LLM Memory & Reasoning Cheat Sheet

Table 1: Memory Types and Architecture

Table 2: Memory Management Frameworks

Table 3: Context Window Management

Table 4: Reasoning Techniques — Chain-Based

AI/LLM Memory & Reasoning Cheat Sheet

Table 1: Memory Types and Architecture

Table 2: Memory Management Frameworks

Table 3: Context Window Management

Table 4: Reasoning Techniques — Chain-Based