Agentic Context Engineering: Evolving Contexts for Self-Improving Language Models

1. Problem Statement

The paper addresses the limitations of current Context Adaptation methods in Large Language Models (LLMs). While context adaptation (modifying inputs via instructions, strategies, or evidence rather than weight updates) is becoming a central paradigm for building self-improving AI systems, existing approaches suffer from two critical failure modes:

• Brevity Bias: Optimization methods often prioritize concise, generic instructions over comprehensive accumulation. This leads to the loss of crucial domain-specific heuristics, tool-use guidelines, and failure modes that are essential for complex tasks like multi-step reasoning or domain-specific programming.
• Context Collapse: Methods that rely on monolithic rewriting of accumulated context by an LLM tend to degrade over time. As the context grows, the model compresses it into shorter, less informative summaries, causing a sharp drop in performance and the erasure of detailed knowledge.

The authors argue that for agents and knowledge-intensive applications, contexts should function not as concise summaries, but as comprehensive, structured playbooks that preserve detailed insights and allow the model to distill relevance autonomously during inference.

2. Methodology: Agentic Context Engineering (ACE)

ACE is a framework designed to treat contexts as evolving playbooks that accumulate, refine, and organize strategies through a modular, agentic workflow. Instead of compressing knowledge, ACE uses a "grow-and-refine" principle with three specialized roles:

1. Generator: Produces reasoning trajectories (e.g., code, tool calls) for new queries. It identifies which existing context items (bullets) were helpful or misleading.
2. Reflector: Critiques the Generator's trajectories and execution feedback (success/failure signals, ground truth, or environment logs). It distills concrete insights, lessons, and root causes of errors into structured "delta" updates.
3. Curator: Integrates the Reflector's insights into the existing context. It performs incremental delta updates rather than full rewrites.

Key Technical Innovations

• Structured, Itemized Context (The Playbook): Context is represented as a collection of structured "bullets" (metadata + content) rather than a monolithic prompt. Each bullet tracks its utility (helpful/harmful counters) and content (strategies, domain concepts, failure modes).
• Incremental Delta Updates: Instead of regenerating the entire context, ACE produces compact "deltas" (new or modified bullets). These are merged deterministically into the playbook using lightweight, non-LLM logic. This prevents context collapse and reduces computational cost.
• Grow-and-Refine Mechanism:
  • Grow: New insights are appended as new bullets.
  • Refine: Periodic or lazy de-duplication (using semantic embeddings) and pruning of redundant or low-utility entries keep the context compact and relevant without losing critical details.
• Self-Improving Capability: ACE can operate without labeled supervision (ground truth). It leverages natural execution feedback (e.g., code execution success/failure, API return values) to guide the Reflector and Curator.

3. Key Contributions

• Framework Design: Introduction of ACE, a modular framework that separates generation, reflection, and curation to prevent the "brevity bias" and "context collapse" seen in prior methods like GEPA or Dynamic Cheatsheet.
• Incremental Adaptation: The proposal of delta-based updates as a scalable alternative to monolithic context rewriting, significantly reducing latency and token costs.
• Label-Free Adaptation: Demonstration that high-quality context adaptation is possible using only execution feedback, making the system applicable to real-world scenarios where ground truth labels are unavailable.
• Comprehensive Evaluation: Extensive benchmarking across agent tasks (AppWorld) and domain-specific reasoning (Finance, Medical, Text-to-SQL).

4. Results

ACE was evaluated on AppWorld (interactive coding agents) and domain-specific benchmarks (FiNER, Formula, DDXPlus, BIRD-SQL).

• Performance Gains:
  • Agents (AppWorld): ACE achieved an average improvement of +10.6% over strong baselines (including GEPA and Dynamic Cheatsheet).
  • Domain Knowledge (Finance): ACE showed an average gain of +8.6% on financial reasoning tasks.
  • State-of-the-Art Comparison: On the AppWorld leaderboard, ACE (using the open-source DeepSeek-V3.1 model) matched the top-ranked production agent (IBM-CUGA, powered by GPT-4.1) in overall average accuracy and surpassed it on the harder test-challenge split (+8.4% TGC).
• Efficiency:
  • Latency: ACE reduced adaptation latency by 86.9% on average compared to baselines.
  • Cost: It required significantly fewer rollouts and lower token costs (e.g., 83.6% reduction in token dollar costs on FiNER online adaptation compared to Dynamic Cheatsheet).
• Ablation Studies: Confirmed that the Reflector (for insight extraction), multi-epoch refinement, and incremental delta updates are the primary drivers of performance. Removing delta updates caused a massive performance drop, validating the "context collapse" hypothesis.

5. Significance and Implications

• Scalable Self-Improvement: ACE demonstrates that LLMs can continuously improve their performance over time by accumulating detailed, structured knowledge without retraining weights. This offers a more interpretable and cost-effective alternative to fine-tuning.
• Paradigm Shift: The paper challenges the prevailing "brevity" heuristic in prompt engineering, arguing that for complex, long-horizon tasks, comprehensive, detailed contexts are superior to distilled summaries.
• Practical Deployment: By leveraging KV cache reuse and incremental updates, ACE makes long-context adaptation feasible for production systems, reducing the barrier to entry for building self-improving agents.
• Robustness: The framework's ability to function without ground-truth labels makes it highly applicable to real-world agent deployments where feedback is often implicit (e.g., code execution errors) rather than explicit.

In conclusion, ACE establishes that treating context as a dynamic, evolving playbook—managed by specialized agentic roles—enables scalable, efficient, and self-improving LLM systems that outperform current state-of-the-art methods in both accuracy and cost-efficiency.