A peer-reviewed study running 9,649 experiments concluded that the quality of context you feed a model matters more than the quality of your prompts. That finding is reshaping how production AI teams work. Prompt engineering optimizes what you ask. Context engineering optimizes what the model sees. And for AI agents running multi-step workflows in production, what the model sees at each step determines whether it succeeds or fails.
Context engineering is the systematic practice of curating, structuring, and delivering information to LLMs through their context windows. It is one of the three pillars of harness engineering, the discipline that makes AI agents reliable in production. Martin Fowler identifies it alongside architectural constraints and entropy management as the foundation of agent infrastructure.
This guide covers what context engineering is, why it has replaced prompt engineering as the critical skill, the six techniques that production teams use, and how to implement them in your agent systems.
Interactive Concept Map
Click any node to expand or collapse. Use the controls to zoom, fit to view, or go fullscreen.
What Is Context Engineering?
Bharani Subramaniam offers the most concise definition: “Context engineering is curating what the model sees so that you get a better result.”
Prompt engineering focuses on how you ask the question. Context engineering focuses on everything that surrounds the question: the system prompts, retrieved documents, conversation history, tool results, file contents, and structured data that fill the context window before the model generates a single token.
For single-turn tasks like text generation or classification, prompt engineering is often sufficient. The input goes in, the output comes out, and the prompt determines quality. For multi-step agent workflows where the model makes dozens of decisions across multiple context windows, context engineering becomes the dominant challenge.
Context Engineering vs Prompt Engineering
| Dimension | Prompt Engineering | Context Engineering |
|---|---|---|
| Focus | How you ask | What the model sees |
| Scope | Single interaction | Entire agent lifecycle |
| Optimizes | Instruction quality | Information architecture |
| Controls | Phrasing, examples, format | Retrieval, memory, tool results |
| Scale | One context window | Multiple context windows over time |
| Skills required | Writing, domain knowledge | Software engineering, systems design |
The distinction matters practically. A team that spends three weeks refining a prompt can move task completion from 85% to 88%. A team that redesigns the context pipeline, ensuring the model sees the right information at the right time, can move task completion from 83% to 96%. Both are valuable. But as tasks grow more complex, context engineering delivers outsized returns.
Why Context Engineering Matters Now
Three forces have made context engineering the critical skill for 2026.
Agents changed the game. Single-turn LLM applications can often get by with good prompts. Agents that plan, reason, and act across multiple steps need carefully engineered context at every step. The model that decided which tool to call needs different context than the model evaluating whether the tool call succeeded.
Bigger windows did not solve the problem. Model providers now offer million-token context windows. Research shows that performance drops around 32,000 tokens even in million-token windows because of context distraction and confusion. More room for context means more opportunity to fill it with the wrong information.
Context rot emerged as a failure mode. As agents run multi-step workflows, the context window accumulates tool outputs, intermediate results, and conversation history. Without active curation, irrelevant information crowds out important context. The model’s attention diffuses. Quality degrades. This is context rot, and it is one of the primary reasons production agents fail on complex tasks.
For organizations running agents at scale, hallucinations and output consistency are the biggest quality challenges. Both are context engineering problems. A model hallucinates when it lacks sufficient context to answer accurately. Outputs become inconsistent when the context varies unpredictably between runs.
The Six Core Techniques
The Manus team, builders of one of the most widely deployed AI agent platforms, published their context engineering techniques from production. Combined with research from Martin Fowler and industry practitioners, these six techniques form the foundation of production context engineering.
1. Context Window Architecture
Design what fills the context window deliberately, not by accumulation.
Every context window has three zones: the system prompt (stable instructions), dynamic context (retrieved documents, tool results, conversation history), and the current query. Production teams allocate explicit token budgets to each zone.
The constraint: Agents have roughly 100:1 input-to-output token ratios. For every token the model generates, it processes 100 tokens of context. This means context costs dominate your API bill. Wasted context is wasted money.
The technique: Treat context window allocation like memory management. Define maximum token budgets per component. Monitor actual consumption. Alert when any component exceeds its budget. This prevents context overflow, where excessive information overwhelms the model’s ability to identify which parts matter.
2. KV-Cache Optimization
This is the single most important cost optimization for production agents, according to the Manus team.
Large language models cache the key-value computations for previously processed tokens. When a new request shares the same prefix as a previous one, the model reuses cached computations instead of reprocessing everything. With Claude, cached tokens cost $0.30 per million versus $3.00 per million uncached: a 10x cost difference.
The technique: Maintain stable prompt prefixes across agent steps. Use append-only context structures so the prefix remains consistent. Mark explicit cache breakpoints in your context. Avoid modifying tool definitions between steps, as this invalidates the cache.
The Manus team found that cache optimization is the single most impactful production technique because of the 100:1 input-to-output ratio. Small improvements in cache hit rate translate to large cost savings at scale.
3. Memory Externalization
Instead of trying to fit everything into the context window, use the file system as extended memory.
Agents working on complex tasks generate far more information than fits in a single context window. The traditional approach is to compress or summarize this information aggressively. The better approach: write intermediate results to files and retrieve them when needed.
The technique: The Manus team treats the file system as unlimited, restorable context. Observations can be dropped from the context window if their source (URLs, file paths) remains available for later retrieval. This preserves both efficiency (smaller context windows) and information completeness (nothing is permanently lost).
For cross-session state management, create progress files that document completed work, decisions made, and current status. When a new session begins, the agent reads the progress file to reconstruct context without reprocessing the entire task history.
4. Attention Manipulation Through Recitation
Long agent workflows suffer from the “lost-in-the-middle” problem: the model pays less attention to information in the middle of the context window than to information at the beginning or end. After 50 steps of tool calls and observations, the original goal can drift out of the model’s effective attention.
The technique: Have the agent periodically create and update a todo.md file that recites its objectives and current progress. This moves goal-relevant information into the recent context window, where the model’s attention is strongest. The Manus team found this technique essential for maintaining goal alignment during typical 50-step tasks.
This is also a debugging tool. When an agent veers off track, the todo file shows exactly when and where the divergence occurred.
5. Retrieval Strategy Design
RAG (Retrieval-Augmented Generation) is a context engineering technique, not a standalone solution. Its effectiveness depends entirely on how you integrate it into the context pipeline.
Three critical decisions:
When to retrieve: Pre-retrieval loads context before the agent starts. Just-in-time retrieval loads context when the agent needs it. Pre-retrieval is faster but risks context overflow. Just-in-time retrieval is slower but keeps the window focused. Production agents typically use a hybrid: essential baseline context upfront, with further retrieval as needed.
How much to retrieve: Experiments show that irrelevant or repetitive passages crowd the window, push critical information out of focus, and increase hallucination rates even when using RAG. Retrieve less, higher-quality context rather than more, lower-quality context.
Where to place retrieved content: Position matters. Information placed near the end of the context window (closest to the query) receives the most attention. Place the most critical retrieved context close to the query, not at the beginning of a long context window.
6. Error Preservation
The instinct is to hide failed attempts from the model. Do not do this.
The technique: Keep erroneous actions and their results visible in the context. When a tool call fails, when a reasoning step produces a wrong answer, when an approach does not work, preserve this evidence. The model uses it for implicit belief updates and avoids repeating the same mistakes.
The Manus team argues that error recovery is a key indicator of genuine agentic behavior. Agents that can see their own failures and adjust course produce dramatically better outcomes than agents whose failure history is scrubbed from context.
Building a Context Engineering Pipeline
Context engineering is not a one-time optimization. It is infrastructure that requires ongoing management.
The Context Pipeline
| Stage | Purpose | Techniques Used |
|---|---|---|
| Pre-processing | Prepare input for the model | Query augmentation, intent classification |
| Retrieval | Gather relevant external knowledge | RAG, file system access, tool results |
| Assembly | Combine components into context window | Token budgeting, priority ordering, cache optimization |
| Monitoring | Track context quality in production | Token usage, cache hit rates, retrieval relevance |
| Iteration | Improve based on production data | Golden dataset updates, retrieval tuning |
Context Engineering as Harness Engineering
Context engineering is one component of the broader harness engineering discipline. It works alongside:
- Verification loops that validate agent outputs
- Cost controls that prevent runaway spending
- Observability that traces agent decisions
- Graceful degradation that handles failures
Martin Fowler identifies three categories within harness engineering: context engineering (enhanced knowledge bases and dynamic data access), architectural constraints (deterministic linters and structural tests), and entropy management (periodic agents detecting inconsistencies). Context engineering is the first pillar, and for many teams it is the highest-impact investment.
Common Context Engineering Mistakes
Stuffing the Context Window
More context is not better context. Research shows performance drops when context windows exceed roughly 32,000 tokens of relevant information, even in models with million-token capacities. Carefully curated 10,000 tokens outperform carelessly assembled 100,000 tokens.
Ignoring Cache Economics
Failing to optimize KV-cache hit rates wastes 10x on token costs. For agents with 100:1 input-to-output ratios, this is the single largest cost optimization available. Restructuring your context for cache stability is worth doing before any other optimization.
Static Context for Dynamic Tasks
Using the same system prompt and context for every agent step, regardless of what the agent is doing, wastes tokens and reduces quality. The context an agent needs when planning is different from what it needs when executing, which is different from what it needs when evaluating results.
Neglecting Context Monitoring
If you do not measure what fills your context windows in production, you cannot improve it. Track token consumption per component, cache hit rates, retrieval relevance scores, and context utilization efficiency. Teams that instrument context usage consistently discover that 40-70% of their tokens provide minimal value.
Frequently Asked Questions
Is context engineering replacing prompt engineering?
Context engineering builds on prompt engineering, it does not replace it. You still need well-crafted prompts. But as tasks move from single-turn interactions to multi-step agent workflows, the context surrounding the prompt has more impact on quality than the prompt itself. Context engineering is becoming the primary skill; prompt engineering is becoming a prerequisite.
Do I need to learn context engineering for simple LLM applications?
For single-turn applications (chatbots, text generation, classification), prompt engineering is often sufficient. Context engineering becomes critical when you build agents that use tools, maintain state across steps, or operate over multiple context windows. If your application is growing in complexity, context engineering is worth learning now.
What tools support context engineering?
LlamaIndex specializes in data structuring and retrieval pipelines. LangChain and LangGraph handle agent orchestration with context management. Weaviate and other vector databases support semantic retrieval. MCP (Model Context Protocol) is becoming the universal standard for connecting agents to enterprise data, with 97M+ monthly SDK downloads.
How does context engineering relate to RAG?
RAG is one technique within context engineering. RAG addresses the specific problem of retrieving relevant documents when the corpus exceeds the context window. Context engineering is the broader discipline that determines what to retrieve, how much to retrieve, where to place it in the context window, and how to manage context across multiple agent steps.
Starting Your Context Engineering Practice
Context engineering is the highest-leverage skill for AI developers building agent systems. The quality of what your model sees determines the quality of what your model produces. No amount of prompt refinement compensates for poorly curated context.
Three steps to start this week:
- Audit your context windows. Add instrumentation to log what fills your context windows in production. Identify which components consume the most tokens and which contribute the least value.
- Optimize your KV-cache hit rates. Restructure your prompts and context assembly to maximize cache reuse. This is the fastest path to both cost reduction and quality improvement.
- Subscribe to the newsletter for weekly context engineering techniques, production patterns, and case studies from teams managing context at scale.
The agents that work reliably are the agents that see the right context. Everything else follows from that.