Skip to content

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

🕒 Published (v1): 2026-01-01 · Source: ICLR · Venue: ICLR 2026 · link

Why this paper was selected

Evolving context adaptation for self-improving LLM agents without weight updates

Ask a follow-up

Open an assistant pre-loaded with this paper's context.

💬 Ask ChatGPT✦ Ask Claude

TL;DR

ACE (Agentic Context Engineering) is a framework that treats LLM contexts as evolving, structured playbooks rather than compressed summaries, using a three-role agentic pipeline (Generator, Reflector, Curator) to accumulate and refine strategies incrementally. It addresses two failure modes of prior context adaptation—brevity bias and context collapse—achieving +10.6% on agent benchmarks and +8.6% on financial reasoning, while cutting adaptation latency by 86.9%. On AppWorld, ACE with an open-source model matches or surpasses a production GPT-4.1-based top-ranked agent.

Problem

Context adaptation methods (prompt optimization, memory systems) suffer from two pathologies: (1) brevity bias, where iterative optimization converges to short, generic prompts that discard domain-specific heuristics and failure modes; and (2) context collapse, where monolithic LLM rewriting of accumulated context compresses it catastrophically—e.g., a 18,282-token context collapsing to 122 tokens in one step, dropping accuracy from 66.7 to 57.1. Both pathologies erode the detailed, task-specific knowledge needed by long-horizon agents and knowledge-intensive domains.

Method

ACE separates context adaptation into three specialized roles: - Generator: executes the task and produces reasoning trajectories, flagging which stored bullets were helpful or harmful. - Reflector: critiques trajectories to extract concrete lessons and corrective insights, optionally refined across multiple iterations. - Curator: synthesizes lessons into compact delta context items (structured bullets with metadata: unique ID, helpfulness/harmfulness counters) and merges them into the playbook via deterministic, non-LLM logic.

Two key mechanisms prevent collapse: 1. Incremental delta updates: contexts are collections of itemized bullets; only relevant bullets are added or modified locally, never fully rewritten. Multiple deltas can be merged in parallel. 2. Grow-and-refine: bullets are appended with new IDs or updated in-place; a semantic-embedding-based deduplication step prunes redundancy either proactively (after each delta) or lazily (when context window is exceeded).

ACE supports both offline adaptation (optimizing a system prompt on a training split) and online adaptation (updating memory sequentially on test instances without labeled supervision, using execution signals like code success/failure).

Key Contributions

  • Identification and empirical characterization of two context adaptation failure modes: brevity bias and context collapse.
  • ACE framework with modular Generator–Reflector–Curator architecture and incremental delta update design.
  • Grow-and-refine mechanism that balances context expansion with deduplication, enabling scalable long-horizon context accumulation.
  • Demonstration that ACE works without ground-truth labels in agent settings by leveraging execution feedback.
  • State-of-the-art results on AppWorld leaderboard using DeepSeek-V3.1 (open-source) matching/surpassing IBM CUGA (GPT-4.1-based production agent).
  • 86.9% reduction in adaptation latency versus monolithic rewriting methods.

Results

  • AppWorld (agent benchmark, offline): ReAct + ACE achieves +12.3% over ICL and +11.9% over GEPA on average (TGC+SGC across normal/challenge splits), using DeepSeek-V3.1-671B.
  • AppWorld (online, no GT labels): +14.8% average improvement over ReAct baseline; +7.6% over Dynamic Cheatsheet.
  • AppWorld leaderboard: 59.4% average (vs. IBM CUGA's 60.3%); on test-challenge, ACE surpasses IBM CUGA by 8.4% TGC and 0.7% SGC.
  • Financial reasoning (offline, GT labels): ACE reaches +7.6% on FiNER and +18.0% on Formula vs. base LLM; beats GEPA by an average of 10.9%.
  • Financial reasoning (online, GT labels): ACE (+7.5% avg) outperforms DC by 6.2%.
  • Adaptation latency: 86.9% reduction on average vs. full-rewrite methods.
  • Consistent gains also reported on DDXPlus (medical reasoning) and BIRD-SQL (text-to-SQL) via StreamBench.
  • Without reliable feedback signals, both ACE and DC can degrade on financial online adaptation (ACE no-GT: −3.4% on FiNER, +11.0% on Formula).

Limitations

  • Effectiveness is critically dependent on feedback signal quality; without reliable execution outcomes or ground-truth labels, the Reflector and Curator can incorporate spurious or misleading insights, degrading context quality.
  • Grow-and-refine deduplication relies on semantic embeddings, adding overhead and potential fragility when bullet semantics are subtle or domain-specialized.
  • All experiments use DeepSeek-V3.1 as the backbone; generalization to significantly weaker or differently-aligned models is not fully characterized (appendix results mentioned but not detailed in the main text).
  • Online adaptation performance depends on test-set ordering (a single shuffled split is used); variance across orderings is not reported.
  • The leaderboard comparison to IBM CUGA is not a controlled head-to-head (different agent architectures, underlying infrastructure), limiting direct claims.

Relevance to Agentic AI / LLM Agents

ACE directly advances the paradigm of test-time self-improvement without weight updates, a central challenge in agentic systems where labeled data is scarce and environments provide only execution signals. The grow-and-refine playbook design is a concrete, deployable alternative to both prompt optimization (brittle to brevity collapse) and monolithic memory rewriting (vulnerable to context collapse), making it directly applicable to long-horizon agent loops. The demonstrated ability to match a production GPT-4.1 system using an open-source model through structured context engineering reinforces that context quality is a first-class lever—alongside model scale and RLHF—for capable agents. For researchers in this space, ACE offers an empirically validated blueprint for structured, incremental memory/context management in multi-episode agent deployments.