📌 TL;DR
The world of AI is rapidly advancing, with AI agents emerging as powerful tools that independently accomplish multi-step tasks on behalf of users. Yet, many organizations struggle to move beyond basic chatbots to "magical" production-grade agents. The core challenge isn't the intelligence of the LLM models, which are "extremely intelligent" by 2025, but rather the quality and management of the information fed to them. This critical discipline, now dubbed context engineering, is becoming "effectively the #1 job of engineers building AI agents". It's about designing dynamic systems that provide the "right information and tools, in the right format, at the right time". Despite the appeal of multi-agent systems, experience shows they are often "fragile" in 2025 due to inherent difficulties in sharing context and managing dispersed decision-making, frequently leading to "compounding errors". Instead, prioritizing single-threaded agents that maintain continuous context and implementing robust guardrails are foundational for reliability and safety. Ultimately, successful agent deployment is about treating them as integral software products that multiply the quality of existing system designs, rather than magic solutions.
📚 Sources
Don’t Build Multi-Agents by Walden Yan
Context Engineering by LangChain
Context Engineering for Agents by Lance Martin
Context Engineering by Simon Willison
The New Skill in AI is Not Prompting, It's Context Engineering by Philipp Schmid
The Rise of Context Engineering by LangChain
What Can Agents Actually Do? by Will Larson
A Practical Guide to Building Agents by OpenAI
🧩 Key Terms
AI agent: A system that independently performs complex, multi-step tasks on a user's behalf. It uses a Large Language Model (LLM) for reasoning and decision-making, and accesses various tools to gather information and take actions.
Context engineering: The precise art and science of dynamically curating and delivering the most relevant information to an LLM's context window at each step of an agent's operation, enabling it to effectively accomplish a task. It's about building intelligent information delivery systems.
Context window: The limited "working memory" of a Large Language Model (LLM), akin to a computer's RAM, where all information relevant to the current task is held.
LLM (Large Language Model): The foundational AI model that drives an agent's ability to reason, make decisions, and generate text or code.
Tools: External functions or APIs that an agent can access and use to interact with other systems, retrieve data, or perform actions (e.g., search the web, query a database, send an email). The agent recommends tool use, but a separate program executes the call.
Multi-agent system: An architecture where multiple, often specialized, AI agents coordinate or hand off tasks to one another to achieve a larger goal. While tempting, these systems currently face significant challenges with coordination and context sharing, often leading to "fragile systems".
Single-agent system: An agent architecture where a single LLM, equipped with a comprehensive set of tools and instructions, handles an entire workflow in a continuous loop, maintaining a unified context. This is often the more reliable and simpler approach for agent building.
Guardrails: Layered defense mechanisms implemented to ensure AI agents operate safely, predictably, and within defined boundaries, preventing issues like data leaks, harmful outputs, or unintended actions. They can include rules-based checks, safety classifiers, and PII filters.
Context poisoning: A specific problem in agent design where a hallucination (false or fabricated information) from the LLM or a tool makes its way into the agent's context, leading to further erroneous actions.
Retrieval Augmented Generation (RAG): A technique where relevant external information (e.g., documents, databases, web search results) is retrieved and dynamically inserted into an LLM's context window to provide up-to-date and specific knowledge. It helps agents answer questions beyond their training data.
💡 Key Insights
Context is the core competency: The most significant factor determining an AI agent's success is the quality of the context it receives, making context engineering the paramount skill for agent builders. This evolution from "prompt engineering" reflects a broader, more systematic approach to providing LLMs with all necessary information.
Multi-agent architectures are currently fragile: Despite their conceptual appeal, multi-agent systems are, as of 2025, often fragile in real-world production. They frequently suffer from compounding errors, miscommunication, and inconsistent outputs because decision-making is too dispersed and context cannot be shared thoroughly enough between agents. Humans communicate efficiently due to "non-trivial intelligence," which agents currently lack for complex cross-agent discourse.
Reliability hinges on context sharing and decision alignment: To ensure reliable, long-running agents, two principles are critical: share full agent traces and context (not just individual messages) and recognize that actions inherently carry implicit decisions, thus conflicting decisions lead to poor results. Violating these principles is rarely advisable.
Simplicity leads to robustness: For most applications, a single-threaded linear agent is the simplest and most effective way to adhere to context engineering principles, providing continuous context and enabling agents to get "very far". When context windows overflow for truly long-duration tasks, a dedicated LLM model can compress action history into key details, events, and decisions, though this is "hard to get right" and may require fine-tuning.
Four pillars of context management: Effective context engineering relies on four strategic approaches: writing (saving information outside the context window, e.g., scratchpads, memories), selecting (pulling relevant information into the context window, e.g., RAG, tool selection), compressing (retaining only essential tokens, e.g., summarization, trimming), and isolating (splitting context across components, e.g., sandboxes, state objects).
Tools amplify capabilities (with nuance): Tools are vital for agents to interact with external systems for both information retrieval and action-taking. Crucially, the LLM recommends tool usage, but the broader software program (the agent) executes the tool call and feeds the output back into the LLM's context. Strategic tool selection, possibly through RAG, can improve accuracy by 3-fold.
Human intervention is a non-negotiable safeguard: Especially in early deployments, human-in-the-loop intervention is paramount for identifying failures, uncovering edge cases, and establishing a robust evaluation cycle. Agents must be designed to gracefully transfer control to humans when exceeding failure thresholds or attempting high-risk actions.
Agents as system multipliers: AI agents are sophisticated software programs that can manage workflow control, build memory, and initiate processes. They act as a "multiplier on the quality of your system design". Well-designed systems become significantly more effective, but poorly designed ones will see their problems amplified.
Optimize models for performance and cost: When selecting models, first establish a performance baseline with the most capable LLM for every task. Then, strategically swap in smaller, faster models where they still achieve acceptable results to optimize for cost and latency without prematurely limiting agent capabilities.
Implicit decisions drive outcomes: Every action an agent takes is based on decisions, both explicit and implicit. When different parts of an agent's system make conflicting implicit decisions due to incomplete context or lack of coordination, it leads to "bad results" and failures, as seen in multi-agent or multi-model "edit apply" systems.
🚀 Use Cases
Automated customer support agent
Context: Businesses face escalating customer service demands with varied, complex inquiries.
Motivation: To streamline and automate the first tier of customer service, handling common issues that involve nuanced judgment or unstructured conversational data.
How it works: An AI agent receives tickets or chats, equipped with tools to retrieve user information (account history, previous tickets) and perform actions like escalating to a human, initiating refunds, or closing accounts. It uses customer support guidelines as part of its context.
Challenges: Ensuring the agent handles exceptions gracefully, avoids incorrect actions (e.g., unauthorized refunds), and provides consistent, high-quality responses.
How to avoid: Implement robust flow control rules (both rules-based and statistics-based) that trigger human approval for high-value transactions or escalate interactions after a set number of turns or errors. Continuously review agent-customer interactions and performance metrics (e.g., resolution time).
Implementation: Requires building a comprehensive software pipeline, a dedicated engineering team, and customer support leadership acting as product managers, necessitating ongoing operational refinement.
Intelligent incident and bug report triaging
Context: Organizations need rapid and accurate assessment of incoming incidents and bug reports to determine severity and appropriate routing.
Motivation: To quickly triage issues, ensuring immediate investigation for severe problems while routing less urgent ones to appropriate channels.
How it works: The agent ingests all created incidents and tickets. It uses tools to access production metrics, deployment logs, feature flag changes, and can even toggle "known-safe" feature flags. It identifies and proposes merging duplicates, assesses impact, proposes potential causes, and drafts initial incident reports.
Challenges: Ensuring the agent functions even if primary LLM providers are unavailable. Preventing unintended actions, especially with tools like feature flag toggles.
How to avoid: Employ redundant LLM providers for critical workflows with fallback mechanisms. Maintain a strict "allow list" of "known-safe" feature flags the agent can manipulate. The agent should defer to humans for final remediation. Continuously review incident statistics, like mean-time-to-resolution (MTTR), to validate agent effectiveness.
Implementation: This use case necessitates treating the agent as a core software product, with engineering as the product owner, and requires "immense care" in constraining changes to prevent unsafe behavior.
Intra-agent information summarization
Context: Long-running agent conversations or investigative work can lead to context window overflow, limiting performance and increasing cost.
Motivation: To reduce the token load in the main agent's history and allow for longer task traces without losing crucial information.
How it works: As seen with Claude Code, a subagent or a dedicated summarization model "auto-compacts" or summarizes the full trajectory of user-agent interactions or specific tool call outputs once a context window threshold is reached (e.g., 95% full). Cognition uses a fine-tuned model for this.
Challenges: Ensuring that summarization accurately captures "specific events or decisions" and doesn't lose critical nuance.
How to avoid: Invest in developing or fine-tuning a model specifically for context compression, ensuring it can reliably distill key details and decisions. Strategically apply summarization at specific points in the agent's design, like after token-heavy tool calls or at agent-agent boundaries.
Implementation: This requires significant "investment into figuring out what ends up being the key information" for a given domain. It moves beyond simple heuristic trimming to intelligent, LLM-driven compression.
Code editing with single-model responsibility
Context: In 2024, many LLM models struggled with direct, accurate code editing, leading to complex multi-model "edit apply" systems.
Motivation: To achieve more reliable and less faulty code modifications compared to error-prone multi-model hand-offs.
How it works: Instead of a large model explaining changes in markdown to a small model for execution, a single, more capable model now handles both the "edit decision-making and applying" in one action.
Challenges: Prior systems failed due to "slight ambiguities" in instructions, leading to misinterpretations by the smaller model and incorrect edits. This reflects the "actions carry implicit decisions" principle.
How to avoid: Consolidate responsibilities within a single model when the task demands high fidelity and precision, especially when intermediate communication could introduce ambiguity.
Implementation: Requires using models capable of handling both the reasoning and direct execution of code changes, and a system design that prioritizes a unified operational flow for critical tasks.
🛠️ Now / Next / Later
Now
Conduct a "context audit": Systematically review your existing LLM applications and agent prototypes. Identify points where context is implicitly handled, omitted, or poorly formatted, recognizing that "most agent failures are not model failures anymore, they are context failures".
Prioritize single-agent architectures: For all new agent development, default to a single-threaded linear agent model. Maximize its capabilities with well-defined tools and continuous context flow, embracing simplicity for initial reliability.
Implement foundational guardrails: Immediately integrate essential input and output guardrails across your agent systems. Focus on relevance classification, safety classification (to prevent prompt injections or jailbreaks), and PII filtering to ensure secure and appropriate interactions from the outset.
Next
Master context engineering strategies: Systematically apply the "write, select, compress, and isolate" techniques. For long-running tasks, begin investing in advanced summarization (potentially fine-tuned models) or intelligent retrieval (RAG) to manage growing context windows effectively.
Develop a robust tool ecosystem: Define, document, and thoroughly test reusable tools with clear names, parameters, and descriptions. Prioritize tools that enable both information retrieval and action-taking, ensuring they present information in a maximally digestible format for LLMs to improve selection accuracy.
Design for Human-in-the-Loop (HITL): Establish clear triggers and protocols for human intervention, especially for high-risk actions (e.g., large refunds) or when agents exceed defined failure thresholds (e.g., multiple attempts to understand user intent). Ensure seamless handoff mechanisms and robust feedback loops to improve agent performance over time.
Later
Strategically explore multi-agent patterns: If single-agent systems genuinely reach their limits, cautiously investigate "Manager" or "Decentralized" multi-agent patterns. Focus efforts on solving the "difficult cross-agent context-passing problem" before scaling, as parallelism unlocks efficiency only with robust communication.
Embed "system design as context engineering": Cultivate an organizational mindset where engineers see their primary role as designing the dynamic systems that curate and present optimal context to LLMs. Recognize that agents are a "multiplier" that amplifies the quality of your underlying software and system architecture.
Implement continuous evaluation and refinement: Leverage advanced observability and evaluation platforms (e.g., LangSmith) to trace agent calls, monitor exact LLM inputs/outputs, and track token usage. Use these insights to continuously refine your context engineering strategies, measure improvements, and ensure agents deliver sustained business value.
Share this post