Context Engineering Cheat Sheet

Updated 2026-05-25

Next Topic: CrewAI (Multi-Agent Framework) Cheat Sheet

🧠Study flashcards on this topic134 cards · spaced repetition→

Context engineering is the systematic discipline of designing, structuring, and managing the information fed to Large Language Models (LLMs) and AI agents to optimize their performance, accuracy, and efficiency. Unlike prompt engineering, which focuses on crafting individual queries, context engineering operates at a systems level—managing the full data environment including memory, external knowledge, tool definitions, conversation history, and environmental signals. In 2026, Gartner declared this "The Year of Context," and the field has formalized four core strategies: write (save context outside the window), select (pull relevant context in), compress (reduce tokens while preserving signal), and isolate (split context across agents and environments). As the challenge shifts from "what can we fit?" to "what should we include and how should we organize it?", context engineering applies information architecture, relevance ranking, dynamic adaptation, and governance to ensure AI systems receive the right information at the right time—without overwhelming their attention budget or incurring excessive costs.

What This Cheat Sheet Covers

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

Table 1: Core Context Engineering TechniquesTable 2: Context Window Management StrategiesTable 3: Retrieval & RAG Enhancement TechniquesTable 4: Context Structuring & FormattingTable 5: Memory & Session State ManagementTable 6: User Intent & Conversation ModelingTable 7: Context Compression & ReductionTable 8: Multimodal Context IntegrationTable 9: Context Relevance & Quality ControlTable 10: Cost & Performance OptimizationTable 11: Advanced Context Patterns for AI AgentsTable 12: Context Engineering Anti-Patterns & Failure ModesTable 13: Context Engineering Governance & EvaluationTable 14: Emerging & Specialized Techniques

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: Core Context Engineering Techniques

The foundational toolkit every context engineer uses—from dynamic retrieval to caching and compression—determines the quality and cost of every LLM interaction. Mastering these ten techniques before tuning advanced patterns yields the highest return on effort.

Technique	Example	Description
Retrieval-Augmented Generation (RAG)	`query = "What is RAG?"` `docs = retriever.get_relevant(query)` `context = f"Context: {docs}\nQuery: {query}"`	• Dynamically retrieves relevant documents from external knowledge bases and injects them into the context window • reduces hallucination and enables up-to-date information without retraining
Prompt Caching	`# Reuse prefix across requests` `cached_prefix = system_prompt + docs` `response = llm(cached_prefix + query)`	Stores frequently reused context (e.g., system prompts, static docs) in cache to reduce latency by up to 80% and input token costs by up to 90%.
Semantic Chunking	`chunks = semantic_splitter.split(` `text, max_size=512, overlap=50` `)`	• Divides documents into meaningful segments based on topic boundaries and semantic coherence rather than arbitrary character counts • improves retrieval precision
Contextual Retrieval	`chunk_with_context = f"` `{doc_summary}\n{chunk}"`	• Prepends each chunk with document-level context before embedding • reduces ambiguity and improves retrieval accuracy by up to 49%.
Reranking	`results = initial_retrieval(query)` `reranked = cross_encoder.rank(` `query, results` `)[:top_k]`	• Applies a second-stage neural model (cross-encoder) to reorder retrieved documents by true relevance • significantly boosts precision over vector similarity alone
Context Window Optimization	`used = count_tokens(context)` `if used > max_tokens:` `context = truncate(context)`	Manages the finite token budget by selecting, prioritizing, and structuring information to fit within model limits while preserving critical content.
Context Compression	`compressed = summarizer.compress(` `long_context, ratio=0.2` `)`	Uses summarization, keyphrase extraction, or semantic compression to reduce token count by 5–20× while retaining essential information.
Scratchpad	`scratchpad.write(plan)` `# Later in same session:` `plan = scratchpad.read()`	Saves intermediate reasoning, plans, or findings to external storage during a task so the agent can retrieve them without holding everything in the context window.
Sliding Window	`window = conversation[-10:]` `context = "\n".join(window)`	• Maintains a fixed-size moving window of recent conversation turns • oldest messages drop off as new ones arrive to stay within token limits
Adaptive Context Injection	`if task_complexity > threshold:` `context += detailed_examples` `else:` `context = minimal_prompt`	Dynamically adjusts the amount and type of context based on query difficulty, user expertise, or task requirements.
Lost-in-the-Middle Mitigation	`# Place critical info at start/end` `context = [key_facts] + middle + [summary]`	Strategically positions the most important information at the beginning or end of context, where LLMs demonstrate strongest attention and recall.
Context Isolation	`subagent_ctx = {task_slice_only}` `for agent in team:` `agent.run(subagent_ctx)`	• Splits context across sub-agents or sandboxed environments so each agent receives only what it needs • prevents context distraction and reduces token waste in multi-agent systems

Table 2: Context Window Management Strategies

Context windows have hard token limits and soft attention degradation well before those limits—both require active management. Knowing which truncation or budgeting strategy to apply prevents the most common causes of dropped instructions and runaway costs.

Strategy	Example	Description
Token Budget Allocation	`budget = {` `"system": 1000,` `"history": 8000,` `"docs": 4000` `}`	• Assigns explicit token quotas to each context component (system prompt, history, retrieved docs) and enforces compliance • prevents any single component from crowding out others

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

Table 3: Retrieval & RAG Enhancement Techniques

Basic vector search is rarely enough for production—retrieval quality is the single largest determinant of RAG output quality. These techniques target every failure mode: vocabulary mismatch, flat ranking, poor chunking structure, missing relationships, and single-query brittleness.

Technique	Example	Description
Hybrid Search	`vector_results = vec_search(query)` `keyword_results = bm25(query)` `combined = merge(vector_results, keyword_results)`	• Combines dense vector search (semantic) with sparse keyword search (BM25) to capture both conceptual similarity and exact term matches • one of the highest-ROI RAG upgrades

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

Table 4: Context Structuring & Formatting

How context is formatted shapes whether the model can parse it reliably—structured delimiters, semantic tags, and hierarchical sections reduce ambiguity and help LLMs locate the right information within large inputs.

Approach	Example	Description
Role-Based Segmentation	`messages = [` `{"role": "system", "content": ...},` `{"role": "user", "content": ...}` `]`	• Separates context by speaker role (system, user, assistant, tool) • clarifies information source and authority to the model

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

Table 1: Core Context Engineering Techniques

Technique	Example	Description
Retrieval-Augmented Generation (RAG)	`query = "What is RAG?"` `docs = retriever.get_relevant(query)` `context = f"Context: {docs}\nQuery: {query}"`	• Dynamically retrieves relevant documents from external knowledge bases and injects them into the context window • reduces hallucination and enables up-to-date information without retraining
Prompt Caching	`# Reuse prefix across requests` `cached_prefix = system_prompt + docs` `response = llm(cached_prefix + query)`	Stores frequently reused context (e.g., system prompts, static docs) in cache to reduce latency by up to 80% and input token costs by up to 90%.
Semantic Chunking	`chunks = semantic_splitter.split(` `text, max_size=512, overlap=50` `)`	• Divides documents into meaningful segments based on topic boundaries and semantic coherence rather than arbitrary character counts • improves retrieval precision
Contextual Retrieval	`chunk_with_context = f"` `{doc_summary}\n{chunk}"`	• Prepends each chunk with document-level context before embedding • reduces ambiguity and improves retrieval accuracy by up to 49%.
Reranking	`results = initial_retrieval(query)` `reranked = cross_encoder.rank(` `query, results` `)[:top_k]`	• Applies a second-stage neural model (cross-encoder) to reorder retrieved documents by true relevance • significantly boosts precision over vector similarity alone
Context Window Optimization	`used = count_tokens(context)` `if used > max_tokens:` `context = truncate(context)`	Manages the finite token budget by selecting, prioritizing, and structuring information to fit within model limits while preserving critical content.
Context Compression	`compressed = summarizer.compress(` `long_context, ratio=0.2` `)`	Uses summarization, keyphrase extraction, or semantic compression to reduce token count by 5–20× while retaining essential information.
Scratchpad	`scratchpad.write(plan)` `# Later in same session:` `plan = scratchpad.read()`	Saves intermediate reasoning, plans, or findings to external storage during a task so the agent can retrieve them without holding everything in the context window.
Sliding Window	`window = conversation[-10:]` `context = "\n".join(window)`	• Maintains a fixed-size moving window of recent conversation turns • oldest messages drop off as new ones arrive to stay within token limits
Adaptive Context Injection	`if task_complexity > threshold:` `context += detailed_examples` `else:` `context = minimal_prompt`	Dynamically adjusts the amount and type of context based on query difficulty, user expertise, or task requirements.
Lost-in-the-Middle Mitigation	`# Place critical info at start/end` `context = [key_facts] + middle + [summary]`	Strategically positions the most important information at the beginning or end of context, where LLMs demonstrate strongest attention and recall.
Context Isolation	`subagent_ctx = {task_slice_only}` `for agent in team:` `agent.run(subagent_ctx)`	• Splits context across sub-agents or sandboxed environments so each agent receives only what it needs • prevents context distraction and reduces token waste in multi-agent systems

Table 2: Context Window Management Strategies

Strategy	Example	Description
Token Budget Allocation	`budget = {` `"system": 1000,` `"history": 8000,` `"docs": 4000` `}`	• Assigns explicit token quotas to each context component (system prompt, history, retrieved docs) and enforces compliance • prevents any single component from crowding out others

Table 3: Retrieval & RAG Enhancement Techniques

Technique	Example	Description
Hybrid Search	`vector_results = vec_search(query)` `keyword_results = bm25(query)` `combined = merge(vector_results, keyword_results)`	• Combines dense vector search (semantic) with sparse keyword search (BM25) to capture both conceptual similarity and exact term matches • one of the highest-ROI RAG upgrades

Table 4: Context Structuring & Formatting

Approach	Example	Description
Role-Based Segmentation	`messages = [` `{"role": "system", "content": ...},` `{"role": "user", "content": ...}` `]`	• Separates context by speaker role (system, user, assistant, tool) • clarifies information source and authority to the model