Agentic Context Engineering: Evolving Contexts for Self-Improving Language Models
Authors: Qizheng Zhang
Changran Hu
Shubhangi Upasani
Boyuan Ma
Fenglu Hong
Vamsidhar Kamanuru
Jay Rainton
Chen Wu
Mengmeng Ji
Hanchen Li
Urmish Thakker
James Zou
Kunle Olukotun
Venue: ICLR 2026 Poster (2026)
Keywords: LLM Agents
Context Engineering
Continual Learning
Agent Memory
Test-Time Scaling
Self-Improving LLMs
Primary area: foundation or frontier models, including LLMs

Abstract: Large language model (LLM) applications such as agents and domain-specific reasoning increasingly rely on *context adaptation*: modifying inputs with instructions, strategies, or evidence, rather than weight updates. 
Prior approaches improve usability but often suffer from brevity bias, which drops domain insights for concise summaries, and from context collapse, where iterative rewriting erodes details over time. 
We introduce ACE (**A**gentic **C**ontext **E**ngineering), a framework that treats contexts as evolving playbooks that accumulate, refine, and organize strategies through a modular process of generation, reflection, and curation. 
ACE prevents collapse with structured, incremental updates that preserve detailed knowledge and scale with long-context models.
Across agent and domain-specific benchmarks, ACE optimizes contexts both offline (e.g., system prompts) and online (e.g., agent memory), consistently outperforming strong baselines: +10.6\% on agents and +8.6\% on finance, while significantly reducing adaptation latency and rollout cost. 
Notably, ACE could adapt effectively without labeled supervision and instead by leveraging natural execution feedback. 
On the AppWorld leaderboard, ACE matches the top-ranked production-level agent on the overall average and surpasses it on the harder test-challenge split, despite using a smaller open-source model.
These results show that comprehensive, evolving contexts enable scalable, efficient, and self-improving LLM systems with low overhead.

Published as a conference paper at ICLR 2026
AGENTIC CONTEXT ENGINEERING: EVOLVING CON- TEXTS FOR SELF-IMPROVING LANGUAGE MODELS
Qizheng Zhang Changran "un"",hhubhang Upasani", Boyuan Ma², Fenglu Hong",
Vamsidhar Kamanuru", Jay Rainton', Chen Wu², Mengmeng, Ji², Hanchen Li", Urmish Thakker', James Zou', Kunle Olukotun
"ttanford University SSmbbaNova Systems, Inc.
UC Berkeley
{qi zhengz, kunle) esttan ford.edd changran_ Shangran_huuberke www.hhkkweeeee....e . edu
agent//ce ace wwwaraggntggthhhhe io
"Equal contribution.
ABSTRACT
Large language model (LLM) applications such as agents and domain-specific reasoning increasingly rely on context adaptation: modifying inputs with instruc- tions, strategies, or evidence, rather than weight updates. Prior approaches im- prove usability but often suffer from brevity bias, which drops domain insights for concise summaries, and from context collapse, where iterative rewriting erodes details time. We introduce ACE (Agentic Context Engineering), framee- work that treats contexts as evolving playbooks that accumulate, refine, and orga- nize strategies through modular process of generation, reflection, and curation. ACE prevents collapse with structured, incremental updates that preserve detailed knowledge and scale with long-context models. Across agent and domain-specific benchmarks, ACE optimizes contexts both offline (e.g., system prompts) and on- line (e.g., agent memory), consistently outperforming strong baselines: +10.6% on agents and +8.6% on finance, while significantly reducing adaptation latency and rollout cost. Notably, ACE could adapt effectively without labeled supervision and instead by leveraging natural execution feedback. On the AppWorld leader- board, ACE matches top-ranked production-level agent on the overall average and surpasses it the harder test-challenge split, despite using smaller open- source model. These results show that comprchensive, evolving contexts enable scalable, efficient, and self-improving LLM systems with low overhead.
INTRODUCTION
Agent: AppWorld
Domain Knowledge: FINER
Numerical Reasoning: Formula
59.5%
82.5
80
80.0
76.5%
Accuracy
77.5
75
73.5% 74.5%74.2% 74.2%
50
46.0%% 46.0%
70
70.7%
67.5%67.0%
42.4%
70.0
40
65
Base LLM
ICL
GEPA
DC
ACE
Base LLM
ICL
GEPA
DC
ACE
Base LLM
GEPA
DC
ACE
Figure I: Overall Performance Results, Our proposed framework, ACE, consistently outperforms
strong baselines across agent and domain-specific tasks.
Modern Al applications based on large language models (LLMs),, such as LLM agents (Yao et al., 2023; Yang al., 2024) and compound AI systems (Zaharia et al., 2024), increasingly depend context adaptation. Instead of modifying model weights, context adaptation improves performance after model training by incorporating clarified instructions, structured reasoning steps, domain-

---

Published as a conference paper at ICLR 2026
specific input formats directly into the model's inputs. Contexts underpin many Al system compo- nents, including system prompts that guide downstream tasks (Opsahl-Ong et al., 2024; Agrawal et al., 2025), memory that carries past facts and experiences (Suzgun et al., 2025; Xu et al., 2025), and factual evidence that reduces hallucination and supplements knowledge (Asai et al., 2024).
Adapting through contexts rather than weights offers several key advantages. Contexts inter- pretable and explainable for users and developers (Wei et al., 2022; Wang et al., 2023), allow rapid integration of new knowledge at runtime (Lewis al., 2020; Borgeaud et al., 2022), and can be shared across models or modules in a compound system (Khot et al., 2023). Meanwhile, advances in long-context LLMs (Peng et al., 2024) and context-efficient inference such as KV cache reuse (Gim et al.. 2024; Yao et al., 2025) are making cantext-based approaches increasingly practical for de- ployment. As a result, context adaptation is emerging as a central paradigm for building capable, scalable, and self- reff-improving Al systems.
Despite this progress, existing approaches to context adaptation face two limitations. First, brevity bias: many prompt optimizers prioritize concise applicable instructions over comprehensive accu- mulation. For example, GEPA (Agrawal et al., 2025) highlights brevity as a strength, but such abstraction can omit domain-specifie heuristics, tool-use guidelines, or common failure modes that matter in practice (Gao et al., 2025). This objective aligns with validation metrics in some settings, but often fails to capture the detailed strategies required by agents and wwwllede-inttnsiin applica- tions. Second, context collapse: methods that rely on monolithic rewriting by an L.LM often degrade into shorter, less informative summaries over time, causing sharp performance declines (Figure 2). In domains such as interactive agents (Trivedi et al., 2024; Patil et al., 2024; Zhang et al., 2024), domain-specific programming (Ye et al., 2023; Zhang al., 2025a;b; Mang et al., 2025), and finan- cial or legal analysis (Loukas et al., 2022; Guha et al., 2023; Wang et al., 2025a), strong performance depends on retaining detailed, task-specific knowledge rather than compressing it away.
As applications like agents and knowledge-intesivve reasoning demand greater reliability, recent work has shifted toward saturating contexts with abundant, potentially useful information (Jiang et al,, 2025; Chung et al., 2025; Chen et al., 2025), enabled by advances in long-conter LLMs (Peng et al., 2024; Mao et al., 2024). We argue that contexts should function not as concise summaries, but as comprehensive, structured playbooks that are detailed, inclusive, and rich with domain insights. Unlike humans, who often benefit from concise generalization, LLMs are more effective when provided with long, detailed contexts and can distill relevance autonomously (Jiang et al., 2025; Liu et al., 2025b; Suzgun et al., 2025). Thus, instead of compressing away domain-speciife heuristics and tactics, contexts should preserve them, allowing the model to decide what matters during inference time.
To address these limitations, we introduce ACE (Agentic Context Engineering), framework for comprehensive context adaptation in both offline settings (e.g., system prompt optimization) and online settings (e.g., test-time memory adaptation). Rather than compressing contexts into distilled summaries, ACE treats them as evolving playbooks that accumulate and organize strategies over time. By design, ACE incorporates modular workflow of generation, reflection, and curation, while adding structured, incremental updates guided by grow-and-rehee principle. This design preserves detailed, domain-specífie knowledge, prevents context collapse, and yields contexts that remain comprehensive and scalable throughout adaptation.
We evaluate ACE on two categories of LLM applications that most benefit from comprehensive, evolving contexts: (1) agents (Trivedi et al., 2024), which require multi-turn reasoning, tool use, and enviromment interaction, where accumulated strategies can be reused across episodes; and (2) domain-specific benchmarks, which demand specialized tactics and knowledge, like financial anal- ysis (Loukas et al., 2022: Wang et al., 2025a). Our key findings are:
ACE consistently outperforms strong baselines, yielding average gains of 10.6% on agents and 8.6% on domain-specific benchmarks, across both offline and online adaptation settings.
ACE is able to construct effective contexts without labeled supervision, instead leveraging execu- tion feedback and environment signals, key ingredients for self-improving LLMs and agents.
On the AprWorld benchmark leaderboard (AppWorld), ACE surpasses the top- 1-rnked production-leve agent IBM-CUGA (Marreed et al., 2025) (powered by GPT-4.1) while using an open-source model (DeepSeck-V3..
2

---

Published as a conference paper at ICLR 2026
ACE requires significantly fewer rollouts and achieves lower adaptation latency than existing adaptive methods, demonstrating that scalable self ieplooeprove can be achieved with both higher accuracy and lower cost.
BACKGROUND AND MOTIVATION
2.1 CONTEXT ADAPTATION
Context adaptation (or context engineering) refers to methods that improve model behavior by con- structing or modifying inputs to an LLM, rather than altering its weights. The current state of the art leverages natural language feedback (Shinn et al., 2023; Yuksekgonul et al., 2025; Agrawal al., 2025). In this paradigm, a language model inspects the current context along with signals such as execution traces, reasoning steps, validation results, and generates natural language feedback on how the context should be revised. This feedback is then incorporated into the context, enabling it- erative adaptation. Representative methods include Reflexion (Shinn al., 2023), which reflects on failures to improve agent planning: TextGrad (Yuksekgonul et al., 2025), which optimizes prompts gradient-like textual feedback; GEPA (Agrawal al., 2025), which refines prompts iteratively based on execution traces and achieves strong performance, even surpassing reinforcement learning approaches in some settings; and Dynamic Cheatsheet (Krause al., 2019), which constructs an external memory that accumulates strategies and lessons from past successes and failures during inference. These natural language feedback methods represent a major advance, offering flexible and interpretable signals for improving LLM systems beyond weight updates.
2.2 LIMITATIONS OF EXISTING CONTEXT ADAPTATION METHODS
Brevity Bias A recurring limitation of context adaptation methods is brevity bias: the tendency of optimization to collapse toward short, generic prompts. Gao et al. (Gao et al., 2025) document this effect in prompt optimization for test generation, where iterative methods repeatedly produced near- identical instructions (e.g.. "Create unit tests to ensure methods behave as expected"), sacrificing diversity and omitting domain-specific detail. This convergence only narrows the search space but also propagates recurring eтrоrs across iterations, since optimized prompts often inherit the same faults their seeds. More broadly, such bias undermines performance in domains that demand de- tailed, context-rich guidance such as multi-step agents, program synthesis, or knowledge-intenss reasoning where success hinges on accumulating rather than compressing task specisie insights.
20,000
# tokens context
Accuracy: 66.7
15,000
10,000
5,000
Tokens:
0
Accuracy w/o context: 63.7
Accuracy: 57.1
10 20
30
40
50
60
70
80
# adaptation steps
Figure 2: Context Collapse. Monolithic rewriting of context by LLM can collapse into shorter, less informative summaries, leading to sharp performance drops.
Context Collapse In case study on the AppWorld benchmark (Trivedi et al., 2024), we observe a phenomenon we call context collapse, which arises when an LLM tasked with fully rewriting the accumulated context each adaptation step. As the context grows large, the model tends to compress into much shorter, less informative summaries, causing a dramatic loss of information. For instance, at step 60 the context contained 18,282 tokens and achieved accuracy of 66.7, but at the very next step it collapsed to just 122 tokens, with accuracy dropping to 57.1-worse than the baseline accuracy of 63.7 without adaptation. While highlight this through Dynamic Cheat-
3

---

Published as a conference paper at ICLR 2026
sheet (Suzgun et al., 2025), the issue is not specific to that method; rather, it reflects fundamental risk of end-to-end context rewriting with LLMs, where accumulated knowledge can be abruptly erased instead of preserved.
The Generated ACE Playbook AppWorld
STRATEGIES AND HARD RULES
[br-00009]
When processing lime-seniiivee transactions involving specific relationships: always resolve identities the correct app (phone contacts), use proper datetime range comparisans instead of string matching, and verify all filtering criteria (relationship time) are met before processing items. This ensures accurate identification processing right transactions.
USEFUL CODE SNIPPETS AND TEMPLATES
mroda-00133)
For efficient artist aggregation when processing songs, use defaultdict(Iist) to map song titles to artist
Eron col collections inport, dedaul idiet. artiat, map defaul add (1 isti for song in snnga:
("Licle") extend [astist naamm") foz artist in ("attisaa"])
TROUBLESHOOTING PITFALLS
[ta-00003]
authentication fails, troubleshact systematically: try phone number credentials from supervisor, check API documentation for correct parameters etc. Do not proceed with workarounds.
as username, clean
Figure 3: Example ACE-Generated Context the Aorlo Benchmark (partially shown). ACE-generated contexts contain detailed, domain-specific insights along with tools and code that readily usable, serving comprehensive playbook for LLM applications.
3 AGENTIC CONTEXT ENGINEERING (ACE)
We present ACE (Agentic Context Engineering). a framework for scalable and efficient context adaptation in both offline (e.g., system prompt optimization) and online (e.g., test-time memory adaptation) scenarios. Instead of condensing knowledge into terse summaries or static instructions, ACE treats contexts evolving playbooks that continuously accumulate, refine, and organize strate- gies over time. Inspired by the agentic design of Dynamic Cheatsheet (Suzgun et al., 2025), ACE introduces structured division of labor across three roles (Figure 4): the Generator, which pro- duces reasoning trajectories; the Reflector, which distills concrete insights from successes and er- rors; and the Curator, which integrates these insights into structured context updates. This mirrors how humans learn: experimenting, reflecting, and consolidating, while avoiding the bottleneck of overloading single model with all responsibilities.
To address the limitations of prior methods discussed in $2.2 (notably brevity bias and context col- lapse) ACE introduces three key innovations: (1) dedicated Reflector that separates evaluation and insight extraction from curation, improving context quality and downstream performance ($4.6); (2) incremental delta updates ($3.1) that replace costly monolithic rewrites with localized edits, reduc- ing both latency and compute cost ($4.7); and (3) a grow-and-refine mechanism ($3.2) that balances steady context expansion with redundancy control.
As shown in Figure 4, the workflow begins with the Generator producing reasoning trajectories for new queries, which surface both effective strategies and recurring pitfalls. The Reflector critiques these traces to extract lessons, optionally refining them across multiple iterations. The Curator then synthesizes these lessons into compact delta entries, which are merged deterministically into the existing context by lightweight, non-LLM logic. Because updates are itemized and localized, multiple deltas can be merged in parallel, enabling batched adaptation at scale. ACE further supports multi-epoch adaptation, where the same queries are revisited progressively strengthen the context.
4

---

Published as a conference paper at ICLR 2026
Iterative Refinement
Query
R delpo LLM Generator
Trajectory
Fapa LLM Reflector
Insights
sapaa LLM Curator
Context Playbook
Update
Delta Context Items
Figure 4: The ACE Framework. Inspired by Dynamic Cheatsheet, ACE adopts an agentic archi- tecture with three specialized components: a Generator, Reflector, and Curator.
3.1 INCREMENTAL DELTA UPDATES
A core design principle of ACE is represent context collection of structured, itemized bullets, rather than single monolithic prompt. The concept of a bullet is similar to the concept of a memory entry in LLM memory frameworks like Dynamic Cheatsheet (Suzgun al., 2025) and A-MEM (Xu et al., 2025), but builds on top of that and consists of (1) metadata. including unique identifier and counters tracking how often was marked helpful or harmful; and (2) content, capturing small unit such as reusable strategy, domain concept. or common failure mode. When solving new problems, the Generator highlights which bullets were useful or misleading, providing feedback that guides the Reflector in proposing corrective updates.
This itemized design enables three properties: (1) localization, so only the relevant bullets are up- dated; (2) fine-grainne retrieval, the Generator can focus on the most pertinent knowledge; and (3) incremental udaptation, allowing efficient merging, pruning, de-duplication during inference.
Rather than regenerating contexts in full, ACE incrementally produces compact delta contexts: small sets of candidate bullets distilled by the Reflector and integrated by the Curator. This avoids the computational cost and latency of full rewrites, while ensuring that past knowledge is preserved and new insights are steadily appended. As contexts grow, this approach provides the scalability needed for long-hon nonghorizon inttnin-ntensiiv applications.
3.2
BHOW-AND-REFING
Beyond incremental growth, ACE ensures that contexts remain compact and relevant through peri- odic or lazy refinement. In grow-and-refine, bullets with new identifiers are appended, while existing bullets are updated in place (e.g.. incrementing counters). A de-duplication step then prunes redun- dancy by comparing bullets via semantic embeddings. This refinement can be performed proactively (after each delta) or lazily (only when the context window is exceeded), depending application requirements for latency and accuracy.
Together, incremental updates and grow-and-refine maintain contexts that expand adaptively. remain interpretable, and avoid the potential variance introduced by monolithic context rewriting.
RESULTS
Our evaluation of ACE shows that:
Enabling High-Performance, Self-Improving Agents. ACE enables agents to self-improve by dynamically refining their input context. both in offline and online settings. It boosts accuracy the World benchmark by up to 17.1% by learning to engineer better contexts from exccution feedback alone, without needing ground-truth labels. ($4.3)
Large Gains Domain-Specifte Benchmarks. On complex financial reasoning benchmarks, ACE delivers an average performance gain of 8.6% over strong baselines by constructing com- prehensive playbooks with domain-specific concepts and insights. (54.4)

---

Published as a conference paper at ICLR 2026
Effective by Design. Ablation studies confirm design choices are key to success, with compo- nents like the Reflector, multi-epoch refinement, and incremental delta update each contributing substantial performance gains. ($4.6)
Lower Cost and Adaptation Latency. ACE achieves these gains efficiently, reducing adaptation latency by 86.9% on average, while requiring fewer rollouts and lower token dollar costs. ($4.7)
4.1 TASKS AND DATASETS
We evaluate ACE on two categories of LLM applications that benefit most from evolving contexts: (1) LLM agent, which require multi-turn reasoning, tool use, and environment interaction; with ACE, agents accumulate and reuse strategies across episodes and environments; and (2) domain- specific reasoning, which demand mastery of specialized concepts and tactics; we focus on financial analysis as main case study, and show additional results on medical reasoning and text-to-SQI..
LLM Agent: AprWorld (Trivedi et al., 2024) is a suite of autonomous agent tasks involving API understanding, code generation, and environment interaction. It provides realistic execution en- vironment with common applications and APIs (e.g., email, file system) and tasks of two difficulty levels (normal and challenge). public leaderboard (AppWorld) tracks performance, where, at the time of submission, the best system achieved only 60.3% average accuracy, highlighting the benchmark's s difficulty and realism.
SSpecfi Reasoning: Financial, Medical, and Text-to-SQI. Benchmarks We use fi- nance as main case study in $4.4. For financial analysis, we focus on FiNER (Loukas et al., 2022) and Formula (Wang et al., 2025a), which test LLMs on financial reasoning tasks that rely on the eXtensible Business Reporting Language (XBRL). FINER requires labeling tokens in XBRL financial documents with one of 139 fine-grained entity types, a key step for financial information extraction in regulated domains. Formula focuses on applying financial concepts and performing computations to answer queries, i.e., numerical reasoning. Beyond finance, we evaluate on two additional domain tasks from StreamBench (Wu et al., 2024): DDXPlus (Fansi Tchango al., 2022) (medical reasoning) and BIRD-SQL (Li et al., 2023) (text-to-SQL).
Evaluation Metries For AppWorld, we follow the official benchmark protocol and report Task Goal Completion (TGC) and Scenario Goal Completion (SGC) on both the test-normal and test- challenge splits. For FiNER, Formula and DDXPlus, we follow the original setup and report curacy, measured as the proportion of predicted answers that exactly match the ground truth. For BIRD-SQL, we use GPT-4o-mini (OpenAI, 2024) under LLM-as-a-judge (Zheng et al., 2023).
All datasets follow the original train/validation/eest splits. For offfine context adaptation, methods optimized the training split and evaluated the test split with pass @ 1 accuracy. For online context adaptation, methods are evaluated sequentially on the test split: for each sample, the model first predicts with the current context, then updates its context based that sample. The same shuffled test split is used across all methods.
4.2 BASELINES AND METHODS
The base model is evaluated directly each benchmark without any context engineer- ing, using the default prompts provided by dataset authors. For AppWorld, we follow the official ReAct (Yao al., 2023) implementation released by the benchmark authors, and build all other baselines and methods on top of this framework.
Base LLM
In-Context Learning (ICL) (Agarwal et al., 2024) ICL provides the model with task demonstra- tions in the input prompt (few-shot or many-shot). This allows the model infer the task format and desired output without weight updates. We supply all training samples when they fit within the model's s context window; otherwise, we fill the window with as many demonstrations as possible.
MIPROv2 (Opsahl-Ong et al., 2024) MIPROv2 is a popular prompt optimizer for LLM applications that works by jointly optimizing system instructions and in-context demonstra- tions via bayesian optimization. We use the official DSPy implementation (DSPy, b), setting auto="heavy" to maximize optimization performance.

---

Published as a conference paper at ICLR 2026
GEPA (Agrawal et al., 2025) GEPA (Genetic-Pareto) is sample-efficien prompt optimizer based on reflective prompt evolution. collects execution traces (reasoning, tool calls, interme- diate outputs) and applies natural-languee reflection to diagnose errors, assign credit, and propose prompt updates. A genetic Pareto search maintains a frontier of high-performing prompts, mitigat- ing local optima. Empirically, GEPA outperforms reinforcement learning methods such GRPO and prompt optimizers like MIPROv2, achieving up to 10-20% higher accuracy with as much as 35x fewer rollouts. We use the official DSPy implementation (DSPy, a), setting aut auto="hevv"" to maximize optimization performance.
Dynamic Cheatsheet (DC) (Suzgun et al., 2025) DC is a test-time learning approach that intro- duces an adaptive external memory of reusable strategies and code snippets. By continuously up- dating this memory with newly encountered inputs and outputs, DC enables models to accumulate knowledge and reuse it across tasks, often leading to substantial improvements over static prompt- ing methods. A key advantage DC is that it does not require ground-trum -ruth labels: the model can curate its own memory from its generations, making the method highly flexible and broadly appli- cable. We use the official implementation released by the authors (Suzgun et al.) and set it to use the cumul ative ve mode (DC-CU).
ACE (ours) ACE optimizes LLM contexts for both offline and online adaptation through an agen- tic context engineering framework. To ensure fairness, we use the same LLM for the Generator, Reflector, and Curator (non-thing inon-thinking mode of DeepSeek-Va3 V (Liu et al., 2024a)), preventing knowl- edge transfer from a stronger Reflector or Curator to a weaker Generator. This isolates the benefit of context construction itself. We additionally evaluate ACE with other backbone LLMs in the ap- pendix, where we observe consistent gains. We adopt a batch size of (constructing delta context from each sample). We set the maximum number of Reflector refinement rounds and the maximum number of epoch in offline adaptation to 5.
4.3
RESULTS ON AGENT BENCHMARK
Test-Normal
Test-Challenge
Method
GT Labels
Average
TGC1
SGCt
TGC1
SGC1
DeepSeek -V3 V3. 1- as Base T.L.M
ReAct
63.7
42.9
41.5
21.6
42.4
offline Adaptation
ReAct ICL
64.3 g..6
46.4
16.5
27.3
46.0
ReAct + GEPA
V
64.9
44.6
46.0
30.2
46.4
ReAct ACE
V
76.2+12.5
64.3
57.3
39.6418.0
59.4+17.0
ReAc: + ACE
X
75.0+11.3
64.34221.4
54.4+12.9
35.2413.6
57.2+14.8
Online
Adaptation
ReAct + DC (CU)
X
65.5
58 58.9416.0
52.3
30.8 +9.2
51.9
ReAc: + ACE
X
69.6
53.6
66.0
48 48.9.,7..
5975
Table Results on the World Agent Benchmark (DeepSeek- -3..5eeek--311-67777 V3.1-671B as the Base LLM). "GT labels" indicates whether ground-truth labels are available to the Reflector during adaptation. We evaluate the ACE framework against multiple baselines on top of the official ReAct implemen- tation, both for offline and online context adaptation. ReAct ACE outperforms selected baselines by an average of 10.6%, and could achieve good performance even without access to GT labels.
Analysis: Aorlorld As shown Table ACE consistently improves over strong baselines on AppWorld. In the offline setting, ReAct ACE outperforms both ReAct + ICL and ReAct GEPA by significant margins (12.3% and 11.9%, respectively), demonstrating that structured, evolving, and detailed contexts enable more effective agent learning than fixed demonstrations or single optimized instruction prompts. These gains extend to the online setting, where ACE continues to outperform prior adaptive methods such Dynamic Cheatsheet by average of 7.6%.
In the agent use case, ACE remains effective even without access to ground-truth labels during adaptation: ReAct ACE achieves average improvement of 14.8% over the ReAct baseline

---

Published as a conference paper at ICLR 2026
in this setting. This robustness arises because ACE leverages signals naturally available during execution (egg, code execution success or failure) to guide the Reflector and Curator in forming structured lessons of successes and failures. Together, these results establish ACE as strong and versatile framework for building self-improving agents that adapt reliably both with and without labeled supervision.
Notably, on the latest World leaderboard (as of September 20, 2025; Figure 5), ReAct + ACE (59,4% average) matches the o-p-l-rnned IBM CUGA (60.3%) production-level GPT-441-based agent (Marreed et al., 2025), despite using the much smaller open-source model DeepSeek-V3. V3.11 With online adaptation, ReAct ACE even surpasses IBM CUGA by 8.4% in TGC and 0.7% in SGC on test-challenge, underscoring the effectiveness of ACE in building comprehensive and self-evolving contexts for agents.
4.4 RESULTS DOMAIN- SPECIFCC BENCHMARK
Method
GT Labels
FiNER (Acet)
Formula (Acct)
Average
DeepSeek -otbeekk-33111 v3.1 70.7
Base LLM
Base
LLM
67.5
69.1
Offline Adaptation
ICL
72.3
67.0-o.s
69.6+0.5
MIPROv2
72.4+1.7
69.542.0
70.9
GEPA
V
73.5
71,544.0
72.543.4
ACE
78.3
85.5
81.9
ACE
X
71.1
83.0
77.148.0
Online Adaptation
DC (CU)
74.2+3.5
69.5
71.842.7
DC (CU)
X
68.3-2.4
62.5-s.0
65.4-s.7
ACE
76.7
76.5.9.0
76.6
ACE
67.3
78.5
72.9
Table 2: Results Financial Analysis Benchmark PreepSeek-V3.1-6777 as the Base LLM). "GT labels" indicates whether ground-truth labels are available to the Reflector during adaptation. With GT labels, ACE achieves consistent improvements both offline and online settings, high- lighting the advantage of structured and evolving contexts for domain-specific reasoning. However, we also observe that in the absence of reliable feedback signals (e.g., ground-trute truth labels or execu- tion outcomes), both ACE and other adaptive methods such as Dynamic Cheatsheet may degrade, suggesting that context adaptation depends critically on feedback quality.
Analysis: Finance Benchmark As shown in Table 2, ACE delivers strong improvements on fi- nancial analysis benchmarks. In the offline setting, when provided with ground-trutt answers from the training split, ACE surpasses ICL, MIPROv2, and GEPA by clear margins (an average of 10.9%), showing that structured and evolving contexts are particularly effective when tasks require precise domain knowledge (e.g., financial concepts, XBRL rules) that goes beyond fixed demonstrations or monolithic optimized prompts. the online setting, ACE continues to exceed prior adaptive meth- ods such as DC by average of 6.2%, further confirming the benefit of agentic context engineering for accumulating reusable insights across specialized domains.
Moreover, we also observe that when ground-truth supervision or reliable execution signals are absent, both ACE and DC may degrade in performance. such cases, the constructed context can be polluted by spurious misleading signals, highlighting potential limitation of inference-time adaptation without reliable feedback. This suggests that while ACE is robust under rich feedback (e.g., g., code execution results formula correctness in agent tasks), its effectiveness depends on the
'We mention IBM CUGA as a rough contextual reference to show that ACE operates in a similar perfor- mance range on the AppWorld leaderboard. It is not used as a methodological baseline, and we do not make direct comparisons. CUGA's internal design differs from ACE's context-adaptation focus, and all baselines evaluated under identical setups isolate methodological effects rather than agent-engincering choices.
8

---

Published as a conference paper at ICLR 2026
availability of signals that allow the Reflector and Curator to make sound judgments. We return to this limitation $5.
Analysis: Medical and Text-to-SQL Benchmark While this subsection focuses finance as a detailed case study, ACE is not finance-specific: we also see consistent gains on other domain- specific tasks, including medical reasoning and text-to-SQL, suggesting that the same playbook- style context adaptation transfers across domains. Full results are reported in Appendix $A.2.
4.5 GENERALIZATION ACROSS LLMS
Table and Table 2
default backbone (DeepSeek-V33) V3.11, but ACE is not specific to this model. We can swap in other LLMs without changing the algorithm or prompts, and still see con- sistent gains on AppWorld and Finance benchmarks. Appendix $A.1 reports full results on GPT- OSS-120B: GPT-5.1, and Llama-3.3-70B. 24-70B-Innttrct where ACE improves over the corresponding base agents or models. These results suggest ACE generalizable method for test-time context evolution across LLM families.
4.6 ABLATION STUDY AND SENSITIVITY ANALYSIS
Ablation Study Table reports ablation studies on AppWorld, analyzing how individual design choices of ACE contribute to effective context adaptation. We examine three factors: (1) the Reflec- tor with iterative refinement, our addition to the agentic framework beyond Dynamic Cheatsheet, (2) multi-epoch adaptation, which refines contexts training samples multiple times, and (3) offline warmup, which initializes the context through offline adaptation before online adaptation be- gins. Additionally, study the effect of incremental context update and why it is key enabler for ACE's performance gain in Appendix $A.5.
Test-Normal
Test-Challenge
Method
Labels
Average
TGC1
SGC1
TGC1
SGC1
DeepSeek-V3.
Base LLM
ReAct
63.7
42.9
41.5
21.6
42.4
orrlise AdapLacion
ReAct + ACE w/o Reflector or multi-epoch
70.8 72.0 60.7417.5
55.4+12.5
55.9
38.1 38.1
55.1 1
ReAct ACE w/o multi-epoch
54.9
39.6, 18.0
56.8,144
ReAct
76.2.12.6
64.3
57.3
30.6,18.0
50.4.17.0
On Online Adaptation
ReAct ACE
67.9-42
51.8489
61.4.185
13.2421.6
56. +11.7
ReAct ACE offline warmup
69.6
53.6
66.0.
48.94
59.5+17.1
Table 3: Ablation Studies AppWorld We study how particular design choices of ACE (iterative refinement, multi-epoch adaptation, and offline warmup) could help high-quality context adaptation.
Robustness to Reflection Quality ACE is robust to reflection quality: it remains effective with a much weaker Reflector and shows only modest additional gains from stronger reflectors, and degrades gracefully under noisy/harmful reflections, staying above the base model except under fully adversarial updates every iteration. Full experiment results are Appendix $A.4.
Sensitivity to Hyperparameter Choice ACE's gains are stable across a wide range of reasonable hyperparameter settings (e.g., Reflector refinement rounds, number adaptation epochs, and grow- and-refine thresholds): performance changes modest, and ACE consistently remains above the corresponding baselines. Full discussion and detailed results are reported in Appendix $A.6..
4.7 COST AND SPEED ANALYSIS
Due to its support for incremental, "delta" context updates and hon-LLL-bassed context merging and de-duplication, ACE demonstrates particular advantages reducing the cost (in terms of the number of rollouts or the amount of dollar cost for token ingestion/generatioo)) and latency of adaptation.
As examples, on the offline adaptation of AppWorld, ACE achieves 82.3% reduction in adaptation latency and 75.1 1 % reduction in the number of rollouts as compared to GEPA (Table 4(a)). On

---

Published as a conference paper at ICLR 2026
the online adaptation of FINER, ACE achieves 91.5% reduction in adaptation latency and 83.6% reduction in token dollar cost for token ingestion/generation as compared to DC (Table 4(b)).
Method
Latency (8)
Rollouts
Method
Latency (8)
Token Cost ($)
ReAct + GEPA
53898
1434
DC (CU)
65104
17.7
ReAct + ACE
9517(82239)
357((75.19)
ACE
5503
2.9.83.6%)
(a) Offline (AppWorld).
(b) Online (FiNER).
Table 4: Cost and Speed Analysis. We measure the context adaptation latency, number of rollouts, and dollar costs of ACE against GEPA (offline) and DC (online).
Fine-Grained Cost Analysis We conduct a fine- neeegraieed cost analysis of ACE and GEPA (as a rep- resentative baseline). On AppWorld, ACE is substantially cheaper during offline adaptation, reduc- ing input/output token usage by 80.8%/83.6 % vs. GEPA: ACE avoids GEPA's prompt-validation loop and replaces repeated full rewrites with localized delta updates. At evaluation time, while ACE may use more raw input tokens due to richer playbook, this does not necessarily translate to higher billed serving cost because large fraction of the context reused by KV caching; we quantify this effect in the next paragraph. Full results, including a component-wiss token breakdown for both methods, are in Appendix $A.3.
KV Cache Reuse: Longer Context * Higher Serving Cost Although ACE produces longer contexts than methods such GEPA, this does not translate to linearly higher inference cost or GPU memory usage. Modern serving infrastructures are increasingly optimized for long-context work- loads through techniques such as the reuse (Gim al., 2024; Yao et al., 2025), compression (Liu et al., 2024c;b), and offload (Lee et al., 2024; Li et al., 2025) of KV cache. These mechanisms allow frequently reused context segments be cached locally or remotely, avoiding repetitive and expensive prefill operations. Ongoing advances in ML systems suggest that the amortized cost of handling long contexts likely to decrease, making context-rich approaches like ACE increasingly practical in deployment. In our prompt- grompt-caching study with the OpenAI API (GPT-5.1), we find that ACE achieves high cache reuse: 91.8% % of input tokens are served from cache during evaluation stage, which reduces billed input-token cost by 82.6 % relative to counting context tokens.
5 DISCUSSION
Implications for Online and Continual Learning Online and continual learning are key research directions in machine learning for addressing issues like distribution shifts (Koh et al., 2021; Gul- rajani & Lopez-Paz, 2021) and limited training data (Pan & Yang, 2010; Hutchinson et al., 2017; Zhuang et al., 2019). ACE offers flexible and efficient alternative to conventional model fine- tuning, as adapting contexts is generally cheaper than updating model weights (Brown et al., 2020; Lester et al., 2021; Li & Liang. 2021; Hu et al., 2022). Moreover, because contexts are human- interpretable, ACE enables selective unlearning (Cao & Yang, 2015; Bourtoule et al., 2021; Liu et al., 2025a), whether due to privacy or legal constraints (gdp, 2016; ocp, 2018), or when outdated incorrect information is identified by domain experts. These promising directions for future work, where ACE could play a central role in advancing continuous and responsible learning.
Limitations and Challenges A limitation of ACE is its reliance on a reasonably strong Reflector: if the Reflector fails to extract meaningful insights from generated traces or outcomes, the con- structed context may become noisy or even harmful. In domain-specific tasks where no model can extract useful insights, the resulting context will naturally lack them. This dependency is similar to Dynamic Cheatsheet (Suzgun et al., 2025), where the quality of adaptation hinges on the underlying model's ability to curate memory. We also note that not all applications require rich or detailed contexts. Tasks like HotPoiQA (Yang et al., 2018) often benefit more from concise, high-level in- structions (e.g., how to retrieve and synthesize evidence) than from long contexts. Similarly, games with fixed strategies such as Game of 24 (Suzgun et al., 2025) may only need a single reusable rule, rendering additional context redundant. Overall, ACE is most beneficial in settings that demand de- strategies that go beyond what
tailed domain knowledge, complex tool use, or anvironment-speciin is already embedded in model weights or simple system instructions.
10

---

Published as a conference paper at ICLR 2026
ACKNOWLEDGEMENT
We thank the amonymous reviewers and area chair for their constructive feedback, which improved this paper. Qizheng Zhang is supported by NSF award CNS-221 1384 and DARPA award TFAWI- PRR0012520038. We also thank Lakshya A Agrawal, Xuekai Zhu, Yuhan Liu, Junchen Jiang, and Azalia Mirhoseini helpful discussions.
ETHICS STATEMENT
This work does not raise specific ethical concerns. Our contributions focus on developing algorithms and system frameworks for effective context adaptation in large language models (LL.Ms). All experiments are conducted on publicly available benchmarks with open-source models, without involving human subjects, sensitive data, or privacy-related information. No potential conflicts of interest are present.
REPRODUCIBILITY STATEMENT
Our code is available gi thub. com/ aern/ace-agsee aace-aaeet/ccc. We provide detailed descriptions of our experimental setup, including datasets, benchmarks, evaluation metrics, baselines, and hyper- parameter choices. Additional details, such as prompts for large language models and extended experimental settings, included in the appendix. With this information, readers with reasonable computational resources should able to reproduce our results.
REFERENCES
General Data Protection Regulation (GDPR) Article 17: Right to Erasure. BU Regulation 2016/679, 2016.
California Consumer Privacy Act, Civil Code $1798. 105: Right to Delete. State of California Civil Code, 2018.
Rishabh Agarwal, Avi Singh, Lei Zhang, Bernd Bohnet, Luis Rosias, Stephanie Chan, Biao Zhang, Ankesh Anand, Zaheer Abbas, Azade Nova, et al. Many-Shot In-Context Learning, Advances in Neural Information Processing Systems (NeurIPS), 37:76930-76966, 2024.
Lakshya A Agrawal, Shangyin Tan, Dilara Soylu, Noah Ziems, Rishi Khare, Krista Opsahl-Ong Arnav Singhvi, Herumb Shandilya, Michael Ryan, Meng Jiang, GEPA: Reflective Prompt Evolution Can Outperform Reinforcement Learning, arXiv preprint arXiv:2507.19455) 2025.
AppWorld. Leaderboard. https: https://appworld. /aapaaapwoord... hew.::/dd.de/eeaeerbbbo..... Accessed: 09/2025.
Akari Asai, Zeqiu Wu, Yizhong Wang, Avirup Sil, and Hannaneh Hajishirzi. Self-RAG: Learning to Retrieve, Generate, and Critique through Self-Reflection. The Twelfth International Conference Learning Representations (ICLR), 2024.
Sebastian Borgeaud, Arthur Mensch, Jordan Hoffmann, Trevor Cai, Eliza Rutherford, Katie Milli- can, George Bm Van Den Driessche, -ran-stptiste Lespiau, Bogdan Damoc, Aidan Clark, et al. Improving Language Models by Retrieving from Trillions of Tokens. In International Conference on Machine Learning (ICML), pp. 2206 2206-2240. PMLR, 2022.
Lucas Bourtoule, Varun Chandrasekaran, Christopher Choquette Choo, Hengrui Jia, Adelin Travers, Baiwu Zhang, David Lie, and Nicolas Papernot. Machine Unlearning. In IEEE Symposium on Security and Privacy (IEEE S&P), 2021.
Tom Brown, Benjamin Mann, Nick Ryder, Melanie Subbiah, Jared D Kaplan, Prafulla Dhariwal, Arvind Neelakantan, Pranav Shyam, Girish Sastry, Amanda Askell, et al. Language Models are Few-Shot Learners. Advances in Neural Information Processing Systems (NeurlPS), 33:1877- 1901, 2020.
11

---

Published as a conference paper at ICLR 2026
Yinzhi Cao and Junfeng Yang. Towards Making Systems Forget with Machine Unlearning. In IEEE Symposium on Security and Privacy (IEEE S&P), 2015.
Tianxiang Chen, Zhentao Tan, Xiaofan Bo, Yue Wu, Tao Gong, Qi Chu, Jieping Ye, and Neng- hai Yu. Flora: Effortless Context Construction Arbitrary Length and Scale. arXiv preprint 1rXiv:2507.19780 2025.
Yeounoh Chung, Gaurav T Kakkar, Yu Gan, Brenton Milne, and Fatma Özcan. Is Long Context All You Need? Leveraging LLM's Extended Context for NL2SQL. Proceedings of the VLDB Endowment, (86))2773-27747 2025.
DSPy, dsPy:GEPA: Reflective Prompt Optimizer. httr:s://app...aaap////ttt GEPA/overview/ Accessed: 09/2025.
DSPy, dspy.MIPROv2: Multiprompt Instruction PRoposal Optimizer Version 2. htttps://dspp b. Accessed: 09/2025.
Arsene Fansi Tchango, Rishab Goel, Zhi Wen, Julien Martel, and Joumana Ghosn. DDXPlus:
A New Dataset For Automatic Medical Diagnosis. Advances in neural information processing systems (NeurIPS), 2022.
Shuzheng Gao, Chaozheng Wang, Cuiyun Gao, Xiaoqian Jiao, Chun Yong Chong, Shan Gao, and Michael Lyu. The Prompt Alchemist: Automated LLM--rillred Prompt Optimization for Test Case Generation. arXiv preprint arXiv:2501.01322 2025.
In Gim, Guojun Chen, Seung-seob Lee, Nikhil Sarda, Anurag Khandelwal, and Lin Zhong. Prompt Cache: Modular Attention Reuse for Low-Latency Inference. Proceedings of Machine Learning and Systems (MLSys), 6:325-338, 2024.
Neel Guha, Julian Nyarko, Daniel Ho, Christopher Ré, Adam Chilton, Alex Mhohlas-Wook Austin Peters, Brandon Waldon, Daniel Rockmore, Diego Zambrano, et al. LegalBench: Collabora- tively Built Benchmark for Measuring Legal Reasoning in Large Language Models. Advances in neural information processing systems (NeurIPS), 2023.
Ishaan Gulrajani and David Lopez-Paz. In Search of Lost Domain Generalization. In International Conference on Learning Representations (ICLR), 2021.
Edward J. Hu, Yelong Shen, Phillip Wallis, Zeyuan Allen-Zhu, Yuanzhi Li, Shean Wang, Lu Wang, and Weizhu Chen. LoRA: Low-Rank Adaptation of Large Language Models. In The Tenth International Conference on Learning Representations (ICLR), 2022.
Maxwell L Hutchinson, Erin Antono, Brenna M Gibbons, Sean Paradiso. Julia Ling, and Bryee Meredig. Overcoming Data Scarcity with Transfer Learning. arXiv preprint 2017.
Mingjian Jiang, Yangjun Ruan, Luis Lastras, Pavan Kapanipathi, and Tatsunori Hashimoto. Putting It All into Context: Simplifying Agents with LCLMs. arXiv preprint arXiv:2505.08. 2025.
Tushar Khot, Harsh Trivedi, Matthew Finlayson. Yao Fu, Kyle Richardson, Peter Clark, and Ashish Sabharwal. Decomposed Prompting: A Modular Approach for Solving Complex Tasks. In Inter- national Conference Learning Representations (ICLR), 2023.
Pang Wei Koh, Shiori Sagawa, Henrik Marklund, Sang Michael Xie, Marvin Zhang, Akshay Bal- subramani, Weihua Hu, Michihiro Yasunaga, Richard Lanas Phillips, Irena Gao, al. WILDS: A Benchmark of -n-lh--Wild Distribution Shifts. International conference on machine learning (ICML), 2021.
Ben Krause, Emmanuel Kahembwe, lain Murray, and Steve Renals. Dynamic Evaluation of Trans- former Language Models. arXiv preprint arXiv:1904.0883 083788 2019.
Wonbeom Lee, Jungi Lee, Junghwan Seo, and Jaewoong Sim. InfiniGen: Efficient Generative Inference of Large Language Models with Dynamic KV Cache Management. In 18th USENIX Symposium Operating Systems Design and Implementation (OSDI 24), pp. 155-172, 2024.
12

---

Published as a conference paper at ICLR 2026
Brian Lester, Rami Al-Rfou, and Noah Constant. The Power of Scale for Grrameter-Efficiiee Prompt Tuning. In Proceedings of the 2021 conference on empirical methods in natural language pro- cessing (EMNLP), pp. 3045-3059) 2021.
Patrick Lewis, Ethan Perez, Aleksandra Piktus, Fabio Petroni, Vladimir Karpukhin, Naman Goyal, Heinrich Küttler, Mike Lewis, Wen-tau Yih, Tim Rocktäschel, et al. Retrieval-Augmented Gen- cration for Hewwledge-Intessiig NLP Tasks. Advances in neural information processing systems (NeurIPS), 2020.
Hanchen Li, Qiuyang Mang, Runyuan He, Qizheng Zhang, Huanzhi Mao, Xiaokun Chen, Hangrui Zhou, Alvin Cheung. Joseph Gonzalez, and Ion Stoica. Continuum: Efficient and Robust Multi- Turn L.M Agent Scheduling with KV Cache Time-to-Live. arXiv preprint 1rxxi:25/1.022..50 2025.
Jinyang Li, Binyuan Hui, Ge Qu, Jiaxi Yang, Binhua Li, Bowen Li, Bailin Wang, Bowen Qin, Ruiying Geng, Nan Huo, et al. Can LLM Already Serve as A Database Interface? A Blg Bench for Large-Scale Database Grounded Text-to-SQLs. Advances in Neural Information Processing Systems (NeurIPS), 2023.
Xiang Lisa Li and Percy Liang. Prefix-Tuning Optimizing Continuous Prompts for Generation. In Proceedings of the 59th Annual Meeting of the Association for Computational Linguistics and the 11th International Joint Conference on Natural Language Processing (Volume 1: Long Papers),
pp. 4582 4597, 2021.
Aixin Liu, Bei Feng, Bing Xue, Bingxuan Wang, Bochao Wu, Chengda Lu, Chenggang Zhao, Chengqi Deng, Chenyu Zhang, Chong Ruan, et al. DeepSeek-V V3 Technical Report. arXiv preprint arXiv:2412.19437. 2024a.
Sijia Liu, Yuanshun Yao, Jinghan Jia, Stephen Casper, Nathalie Baracaldo, Peter Hase, Yuguang Yao, Chris Yuhao Liu, Xiaojun Xu, Hang Li, et al. Rethinking Machine Unlearning for Large Language Models. Nature Machine Intelligence 7(2):181-194 2025a.
Yuhan Liu, Hanchen Li, Yihua Cheng, Siddhant Ray, Yuyang Huang, Qizheng Zhang, Kuntai Du, Jiayi Yao, Shan Lu, Ganesh Ananthanarayanan, et al. CacheGen: KV Cache Compression and Streaming for Fast Large Language Model Serving. In Proceedings of the ACM SIGCOMM 2024 Conference, pp. 38-56, 2024b.
Zhining Liu, Rana Ali Amjad, Ravinarayana Adkathimar, Tianxin Wei, and Hanghang Tong. Self- Elicit: Your Language Model Secretly Knows Where is the Relevant Evidence. In Proceedings of the 63rd Annual Meeting of the Association for Computational Linguistics (Volume 1: Long Papers), pp. 1153-9173, 2025b.
Zirui Liu, Jiayi Yuan, Hongye Jin, Shaochen Zhong, Zhaozhuo Xu, Vladimir Braverman, Beidi Chen, and Xia Hu. KIVI: A Tuning-Free Asymmetric 2bit Quantization for KV Cache In International Conference Machine Learning (ICML), 2024c.
Lefteris Loukas, Manos Fergadiotis, Ilias Chalkidis, Eirini Spyropoulou, Prodromos Malakasiotis, Ion Androutsopoulos, and Georgios Paliouras. FiNER: Financial Numeric Entity Recognition for XBRL Tagging. Proceedings of the 60th Annual Meeting of the Association for Computational Linguistics (Volume 1: Long Papers), pp. 4419-4431, 2022.
Qiuyang Mang, Wenhao Chai, Zhifei Li, Huanzhi Mao, Shang Zhou, Alexander Du, Hanchen Li, Shu Liu, Edwin Chen, Yichuan Wang, et al. FrontierCS: Evolving Challenges for Evolving Intel- ligence. arXiv preprint arXiv:2512.15699, 2025.
Yansheng Mao, Jiaqi Li, Fanxu Meng, Jing Xiong, Zilong Zheng, and Muhan Zhang LIFT: Improving Long Context Understanding Through Long Input Fine-Tuning. arXiv preprint arXiv:2412.13626. 2024.
Sami Marreed, Alon Oved, Avi Yaeli, Segev Shlomov, Ido Levy, Offer Akrabi, Aviad Sela, Asaf Adi, and Nir Mashkif. Towards Enterprise-Resd Reedy Computer Using Generalist Agent. arXiv preprint 2xXi:2250.00186 2025.
13

---

Published as a conference paper at ICLR 2026
OpenAL. GPT-4o mini: Advancing Cost-Efficient Intelligence. https://openal: com/ Andex/gpt-4o-ne
2024.
Krista Opsahl-Ong. Michael Ryan, Josh Purtell, David Broman, Christopher Potts, Matei Zaharia, and Omar Khattab. Optimizing Instructions and Demonstrations for Multi- Language Model Programs. In Proceedings of the 2024 Conference on Empirical Methods in Natural Language Processing (EMNLP), pp. 9340-9366, 2024.
Sinno Jialin Pan and Qiang Yang. A Survey on Transfer Learning. IEEE Transactions on Knowledge and Data Engineering. 22(10):1345-1339 2010.
Shishir G Patil, Tianjun Zhang, Xin Wang, and Joseph E Gonzalez. Gorilla: Large Language Model Connected with Massive APIs. Advances in Neural Information Processing Systems (NeurIPS), 2024.
Bowen Peng, Jeffrey Quesnelle, Honglu Fan, and Enrico Shippole. YaRN: Efficient Context Window Extension of Large Language Models. In The Twelfth International Conference Learning Representations (ICLR), 2024.
Noah Shinn, Federico Cassano, Ashwin Gopinath, Karthik Narasimhan, and Shunyu Yao. Reflex- ion: Language Agents with Verbal Reinforcement Learning. Advances in Neural Information Processing Systems (NeurIPS), 2023.
Mirac Suzgun, Mert Yuksekgonul, Federico Bianchi, Dan Jurafsky, and James Zou. Dy- namic Cheatsheet: Test-Time Learning with Adaptive Memory. https::/gitte com/ muzzuuniirac/dynaniic-oo sheat. Accessed: 09/2025.
Mirac Suzgun, Mert Yuksekgonul, Federico Bianchi, Dan Jurafsky, and James Zou. Dynamic Cheat- sheet: Test-Time Learning with Adaptive Memory. arXiv preprint arXiv:2504.07952, 2025.
Harsh Trivedi, Tushar Khot, Mareike Hartmann, Ruskin Manku, Vinty Dong, Edward Li, Shashank Gupta, Ashish Sabharwal, and Niranjan Balasubramanian. AppWorld: A Controllable World of Apps and People for Benchmarking Interactive Coding Agents. In Proceedings of the 62nd Annual Meeting of the Association for Computational Linguistics (Volume Long Papers), pp. 16022-16076, 2024.
Dannong Wang, Jaisal Patel, Daochen Zha, Steve Y Yang. and Xiao-Yang Yang Liu. FinLoRA: Benchmarking LoRA Methods for Fine-Tuning LLMs on Financial Datasets. arXiv preprint arXiv:2505.19879, 2025a.
Xuezhi Wang, Jason Wei, Dale Schuurmans, Quoe Le, Ed Chi, Sharan Narang, Aakanksha Chowd- hery, and Denny Zhou. Self-Consistency Improves Chain of Thought Reasoning in Language Models. In The Eleventh International Conference on Learning Representations (ICLR), 2023.
Zora Zhiruo Wang. Jiayuan Mao, Daniel Fried, and Graham Neubig. Agent Workflow Memory. In Forty-second International Conference on Machine Learning (ICML), 2025b.
Jason Wei, Xuezhi Wang, Dale Schuurmans, Maarten Bosma, Fei Xia, Ed Chi, Quoe V Le, Denny Zhou, et al. Chain-of-Thouue Prompting Elicits Reasoning in Large Language Models. Advances in neural information processing systems (NeurIPS), 35:24824-24877, 2022.
Cheng- Kuang Wu, Zhi R Tam, Chieh- Chieh-Yen Lin, Yun-Nung Chen, and Hung-yi Lee. StreamBench: Towards Benchmarking Continuous Improvement of Language Agents, Advances in Neural In- formation Processing Systems (NeurIPS), 2024.
Wujiang Xu, Kai Mei, Hang Gao, Juntao Tan, Zujie Liang. and Yongfeng Zhang. A-Mem: Agentic Memory for LLM Agents. Advances in neural information processing systems (NeurIPS), 2025.
John Yang. Carlos E Jimenez, Alexander Wettig, Kilian Lieret, Shunyu Yao. Karthik Narasimhan, and Ofir Press. SWE-agent: Agent-Compucte Interfaces Enable Automated Software Engineer- ing. Advances in Neural Information Processing Systems (NeurIPS), 2024.
14

---

Published as a conference paper at ICLR 2026
Zhilin Yang. Peng Qi, Saizheng Zhang, Yoshua Bengio, William Cohen, Ruslan Salakhutdinov, and Christopher D Manning. HotpotQA: A Dataset for Diverse, Explainable Multi-hop Question Answering. In Proceedings of the 2018 conference empirical methods in natural language processing (EMNLP), pp. 2369-2388 2018.
Jiayi Yao, Hanchen Li, Yuhan Liu, Siddhant Ray, Yihua Cheng, Qizheng Zhang, Kuntai Du Shan Lu, and Junchen Jiang. CacheBlend: Fast Large Language Model Serving for RAG with Cached Knowledge Fusion. In Proceedings of the Twentieth European Conference on Computer Systems (FuroSys). pp. 909 2025.
Shunyu Yao, Jeffrey Zhao, Dian Yu, Nan Du, Izhak Shafran, Karthik Narasimhan, and Yuan Cao. ReAct: Synergizing Reasoning and Acting in Language Models. In International Conference Learning Representations (ICLR), 2023.
Jiacheng Ye, Chengzu Li, Lingpeng Kong, and Tao Yu. Generating Data for Symbolic Language with Large Language Models. In Proceedings of the 2023 conference on empirical methods in natural language processing (EMNLP), pp. 8418-8445 2023.
Mert Yuksekgonul, Federico Bianchi, Joseph Boen, Sheng Liu, Pan Lu, Zhi Huang, Carlos Guestrin, and James Zou. Optimizing Generative Al by Backpropagating Language Model Feedback. Na- lure, 639(8055)6699-61 2025.
Matei Zaharia, Omar Khattab, Lingjiao Chen, Jared Quincy Davis, Heather Miller, Chris Potts, James Zou, Michael Carbin, Jonathan Frankle, Naveen Rao, and Ali Ghodsi. The Shift from Models to Compound AI Systems. https: //bairr//r.r... wtw..eeee....ebebllooo////aa http///oo//o////////2//// 18/ compound- ai atsppuudddi-sssstssss//ssssss 2024.
Genghan Zhang, Weixin Liang, Olivia Hsu, and Kunle Olukotun. Adaptive Self-Improvement LLM Agentic System for ML Library Development. In forty-secone International Conference on Ma- chine Learning (ICML), 2025a.
Genghan Zhang, Shaowei Zhu, Anjiang Wei, Zhenyu Song, Allen Nie, Zhen Jia, Nandita Vijayku- mar, Yida Wang, and Kunle Olukotun. AccelOpt: A Self-Impooving LLM Agentic System for AI Accelerator Kernel Optimization. arXiv preprint arXiv:2511. 2025b.
Qizheng Zhang, Ali Imran, Enkeleda Bardhi, Tushar Swamy, Nathan Zhang, Muhammad Shahbaz, and Kunle Olukotun. Caravan: Practical Online Learning of In-Network ML Models with La- beling Agents. In 18th USENIX Symposium on Operating Systems Design and Implementation (OSDI), pp. 325-345, 2024.
Qizheng Zhang, Michael Wornow, and Kunle Olukotun. Agentic Plan Caching: Test-Time Mem- ory for Fast and Cost-Efficient LLM Agents. In The Thirty-ninth Annual Conference on Neural Information Processing Systems (NeurIPS), 2025c.
Lianmin Zheng, Wei-Lin Chiang, Ying Sheng, Siyuan Zhuang, Zhanghao Wu, Yonghao Zhuang, Zi Lin, Zhuohan Li, Dacheng Li, Eric Xing, et al. Judging LLM-as-a-JJudg with MT-Beech and Chatbot Arena. Advances in neural information processing systems (NeurIPS), 36:46595-46623, 2023.
Huichi Zhou, Yihang Chen, Siyuan Guo, Xue Yan, Kin Hei Lee, Zihan Wang, Ka Yiu Lee, Guchun Zhang, Kun Shao, Linyi Yang. et al. AgentFly: Fine-tuning LLM Agents without Fine-tuning LLMs. arXiv preprint S..V::2008.6153. 2025.
Yujun Zhou, Yufei Han, Haomin Zhuang, Kehan Guo, Zhenwen Liang, Hongyan Bao, and Xian- gliang Zhang. Defending Jailbreak Prompts via In-Context Adversarial Game. In Proceedings of the 2024 Conference Empirical Methods in Natural Language Processing (EMNLP), pp- 20084-20105, 2024.
Fuzhen Zhuang, Zhiyuan Qi, Keyu Duan, Dongbo Xi, Yongchun Zhu, Hengshu Zhu, Hui Xiong, and Qing He. A Comprehensive Survey on Transfer Learning. /9/ 1.06685, 2019.
15

---

Published as a conference paper at ICLR 2026
A
EXTENDED RESULTS
A.1 GENERALIZATION ACROSS DIFFERENT LLMS
ACE is a model-agnostic framework that operates on execution traces and contextual deltas, and does not rely any architectural or training-specific features of DeepSeek-V3.J (the default back- bone we use in the main text). We evaluated ACE with three additional models of varying size, cost, and capability: GPT-OSS- 120B (Table 5 and 7), GPT-5.1 (Table 6 and 8), and Llama-3.3-70B. Instruct (Table 9). In each case, the Generator, Reflector, and Curator were all switched to the new model without changes the algorithm.
Analysis Across all four LLM families we tested (DeepSeek- V3.1, GPT-OSS-120B. GPT-5.1, and Samma-3.3770--nnstruse ACE consistently improves performance over both the base LLM/agent, GEPA, and other baselines, often by 5 to 12 points depending on the task and supervision setting. The relative gains ACE remain stable even when switching to models that differ significantly in size, cost, and training recipe, and ACE delivers benefits with without ground-truth lahels, validating the robustness of its context adaptation mechanism. The online variant reliably achieves the strongest performance across all models.
We note that the magnitude of improvement can vary across model families: for example, Llama- 3.3-70B-Instruc shows smaller gains compared GPT-5.1 GPT-OSS-120B. This is expected since ACE relies on the quality of intermediate reflections and calibrations, and smaller or weaker models naturally generate noisier feedback. Even in these cases, however, ACE remains beneficial, demonstrating that the framework is broadly applicable while still reflecting the inherent capability limits of the underlying LLM,, as we discussed in the "Limitations and Challenges" paragraph in $5.
Test-Normal
Test-Challenge
Method
GT Labels
Average
TGC1
SGCt
TGC1
SGCt
G GPT-OSS-120B
Base
LLM
ReAct
54.8
33.9
34.5
15.1
34.6
Offline Adaptation
ReAct GEPA
56.0
33.9
40.1 45.6
20.9
37.7 43.1
ReAct + ACE
V
61.3
39.3
40.3 48.8
20.9 28.9.8.8
40.5 4-8.9
ReAct ACE
X
58.343.5
41.147.2
39.645.1
18. 73.6
39.444.55
Online Adaptation
ReAct + DC (CU)
X
49.4 5.4
33.9 +0.0
30.8
3.7
18.2
33.1 1.5
ReAct ACE
X
60.7
44.6
43.2 88.7
20.1
+5.0
42.2 17.6
Table 5: Results the Aor Agent Benchmark (GPT-OSS-120B as the Base LLM). "GT labels" indicates whether ground-trum -tuth labels are available to the Reflector during adaptation. We evaluate the ACE framework against multiple baselines top of the official ReAct implementa- tion, both for offline and online context adaptation.
A.2 BEYOND FINANCE: ADDITIONAL DOMAIN TASKS
We evaluate ACE two additional domain tasks from StreamBench (Wu al., 2024) under the non-streaming setting (i.e., offline adaptation): DDXPlus (Fansi Tchango et al., 2022) for medical reasoning (Table 10) and BIRD-SQL (Li et al., 2023) for Text-to-SQL generation (Table 11). For ACE, we perform offline adaptation using 1000 randomly sampled training examples. For GEPA, use the same 1000 examples for training, and reserve separate validation set of 500 examples for BIRD-SQL or 372 examples for DDXPlus (StreamBench provides 1372 train/val examples for DDXPlus in total). All other settings follow the main-text configuration unless stated otherwise.
Analysis On DDXPlus, ACE substantially improves the base LLM, rising from 75.2 to 90.2 accuracy (+15.0). contrast, GEPA yields much smaller gain (76.4, +1.2). This suggests that ACE's test-time evolving context transfers well multi-step, domain diagnostic reasoning.
16

---

Published as a conference paper at ICLR 2026
Test-Normal
Method
GT Labels
Average
TGC1
SGCT
GPT-5.1 as Base
ReAct
61.9
46.4
54.2
Offline AdapLation
ReAct + GEPA
64.3 22.4
48.2
56.2 +2.0
ReAct ACE
66. 66.7+188
53.647.2
60.2+6.0
ReAct + ACE
67.3 55.4
61.3 47.1
Onl ine AdapLation
ReAct + DC (CU)
X
62.5
55.4
58.9
ReAct ACE
10.7
58.9 12.55
65.8 11.66
Table 6: Results on the Wprl Agent Benchmark (GPT-5.1 as the Base LLM). "GT labels" indicates whether ground-truth labels are available to the Reflector during adaptation. We evaluate the ACE framework against multiple baselines on top of the official ReAct implementation, both offline and online context adaptation.
Method
GT Labels
FiNER (Acet)
Formula (Acct)
Average
GPT-OSS-122
Base L.M
Base LLM
66.6
71.5
69.1
Off ine Adaptati on
GEPA
67.9
71.540.0
69.740.6
ACE
73.8 69.7
88.5
81.2
ACE
X
84.0
76.9
Onl ine Adaptation
DC
X
55.8-10.8 10.8
55.8
66.0 5.5
60.9 8.2
ACE
X
70.5
85.0
77.8
Table 7: Results on Financial Analysis Benchmark (GPT-OSS-1201) as the Base LLM). "GT labels" indicates whether ground-truth labels are available to the Reflector during adaptation.
Method
GT Labels
FiNER (Acct)
Formula (Acet)
Average
CPT-5.1 as Base LLM
Base
LLM
73.5
73.0
73.3
Offline ine Adaptation
GEPA
74.5
73.0
73.8 0.5
ACE
/
81.0 78.2
82.8 49.5
ACE
X
76.5
77.4
On in Adaptation
DC
X
70.0 335
69.0
69.5 3.8
ACE
X
75.2
79.0
77.1
Table 8: Results Financial Analysis Benchmark (GPT-5.1 as the Base LLM). "GT labels" indicates whether ground-truth labels are available to the Reflector during adaptation.
On BIRD-SQL, ACE also improves consistently over the base model on all splits, achieving better overall average (52.9, +5.1). The gains are driven mainly by the Simple subset (53.5, +7.1). While GEPA yields larger gains on Moderate and Challenging, ACE still improves over the base model on both splits. Overall, these results indicate that ACE generalizes beyond finance to both knowledge- intensive reasoning and structured code generation tasks.
17

---

Published as a conference paper at ICLR 2026
Method
GT Labels
FiNER (Acct)
Llama-3 3. 3-70B-Instrrnn as Base LLM
Base LLM
62.5
Offline Adaptat ion
GEPA
59.41 -9.41-3.00 3.09
ACE
64.9 42.4
ACE
64.2+1..7
On ine Adaptat
DC
X
59.0 -35
ACE
63.6
Table 9: Results on Financial Analysis Benchmark (Llama-3.3-70B-Insstt as the Base LLM).
"GT labels" indicates whether ground-truth labels are available to the Reflector during adaptation.
Method
Accuracy (t)
DeepSeek-vas V3.1 Base LLM
Base LIM
75.2
Offline Adaptation
GEPA
76,4+12
ACE
90.2 15.0
Table 10: Results on Medical Reasoning Benchmark (DeepSeek- V3.1-6676 as the Base LLM). We use DDXPlus from StreamBench.
Method
Simple (f)
Moderate (t)
Challenging (t)
Average
DeepSeek-V3.
Base L.M.M
Base LLM
46.4
48.2
55.1
47.8
Offline Adaptation
GEPA
51.6+5.2 53.5 17.1
51.9
57 27.242.1
52.2++14
ACE
50.7
56.6 1.5
52.9 5.1
Table 11: Results on Text-to-SQL Benchmark (DeepSSeck.V3.1-67) as the Base LLM). We use BIRD-SQL from StreamBench.
A.3 FINE-GRAINED COST ANALYSIS
We perform fine-grained cost analysis of ACE and GEPA for both the adaptation and evaluation stages (offline adaptation setting), using AppWorld as a representative application. For ACE, we run offline adaptation with epoch and reflector refinement round. While increasing the number of epochs or refinement rounds will increase cost, the qualitative trends below should remain: ACE avoids expensive validation-tine re-evaluation and performs localized updates rather than repeated full rewrites. For GEPA, we use the official DSPy implementation (DSPy, b) with auto= "heov=""""""" maximize optimization strength.
Across adaptation (Table 12 and Table 13), ACE reduces input-token usage by 80.8% relative to GEPA (204. 1M + 39.3M) and output-toker usage by 83.6% (1.87M - 0.31M). This gap primarily driven by (1) GEPA's prompt-validation loop, which repeatedly evaluates candidate prompts on a held-out validation set (57 queries), incurring substantial additional LLM calls and validation tokens, and (2) ACE's incremental context updates, which replace full prompt rewrites with localized Generator- Senerator-Reflecttrr-ee Reflector-Crratoo updates.
Adaptation Stage
Evaluation Stage At evaluation time (Table 14 and Table 15), ACE uses more raw input tokens per query than GEPA due to its richer, more actionable playbook. However, output-token usage
18

---

Published as a conference paper at ICLR 2026
is similar (115.0 101.8), and the number of rollouts is comparable across methods. Moreover, under modern Procci/K- infrastructures, the additional input tokens can be largely amor- tized: using OpenAl's ss default prompt caching, 91.8% of ACE's input tokens are served from cache, resulting in an 82.6% reduction in billed input-token cost (see $4.7).
Method
Total # input tokens
Total # output tokens
Total # rollouts
Total # queries
GEPA (prompt generation)
65,005, 192
1,266,090
429
90
GEPA (prompt validation)
139.070,904
604,098
1,026
57
GEPA (total)
204.076,096
1,870.188
1,455
147
ACE (Generator)
31,012,122
198, 198,847
1,790
90
ACE (Reflector)
4,685,840
70,487
161
ACE (Curator)
3.552,963
37.794
ACE (total)
39,250,925 (-80.8%)
307, (-83.6%)
2,075 (+42.66%
90 (-38.8%)
Table 12: Adaptation-Stage Aggregate Cost Statistics on Apr The percentages compare ACE (total) against GEPA (total).
Arg luput rollout
Avg output rallout
Arg lnpput query
Aug output/ query
quertes
GEPA (pcompt generation)
151.60014
2,951.4
722.279.9
14,067.7
429
90
GEPA (prmjt validation)
135,560
$89 2.
840.
10,600.0
1,026
57
GEPA (wral)
140,291,8
1,285.4
1.387_538.4
12,721.7
1,455
147
ACE (Genentee)
17. 67.326.6
111.1
344,579.1
2,209.4
1,700
90
ACE (Reflector)
29, 29.112.4
457.3
$2,064,9
753.2
161
90
(Cuunooe)
420.0
90
ACE
148
(68.6%)
3,412.5
(-38.89)
Table 13: Adaptation-Stage Average Cost Statistics on World. The percentages compare
ACE (total) against GEPA (total).
Method
Total input tokens
Total # output tokens
Total # rollouts
Total eval queries
Base ReAct.
27.460,411
289,802
2,430
GEPA
26,960,675
251, $41,442
2,470
160
ACE
58,623,267 (+117.4%)
270.652 (+7.6%)
2.354 (-4.7%)
160 (+0.0%)
Table 14: Evaluation-Stage Aggregate Cost Statistics on Apr The percentages compare ACE against GEPA.
Method
Avg input
Avg output/
Avg query query
Arg output query
queries
Rose ReAct
11,208.5
119.3
171.627.6
1.811.3
2,430
160
GEPA
10,918.5
101.8
168.504.2
1,571.5
2,470
160
ACE
249124
115.0 (+13006)) 366,3954 (x117.44%)
(.9915(+7.66)
2,354 (-4.7%)
(+0.0%
Table 15: Evaluation-Stage Average Cost Statistics on AppWorld. The percentages compare ACE against GEPA.
A.4 ROBUSTNESS TO REFLECTION QUALITY
We conduct analyses evaluate ACE's sensitivity reflection quality. Unless otherwise noted, experiments are run on FiNER with ACE offline adaptation.
Using Weaker Reflector Models To test whether ACE requires strong reflector, we vary the Reflector across three models with substantially different capability: GPT-OSS-120B, DeepSeek- V3.1-671B, B, and GPT-5.1 (Table 16). Across all choices, ACE consistently improves over the base L.M,, including when the Reflector is much weaker. While stronger reflectors yield larger gains, the method remains effective across a wide range of reflector strengths.
Robustness to Noisy Harmful Reflector Feedback We further stress-test ACE with actively harmful reflector outputs by injecting adversarial or conflicting bullets: we invoke a "harmful" re- flector that is explicitly instructed to inject harmful reflection once every X adaptation steps, where
19

---

Published as a conference paper at ICLR 2026
Method
Generator LLM
Reflector LLM
Curator LLM
Accuracy (1)
Base LLM
DeepSeek-V33 V
70.7
ACE
DeepScek-V3..
GPT-OSS-1201
DeepSeek- V3.1
76.6 (45.9)
ACE
DeepSeek- V3.1
DeepSeek- V3.11 GPT-5.1
DeepSeek-Ve V3.1
78.3 (+7.6)
ACE
DeepScek-Va.
DeepSeek-V3.1
78.5 (+7.8)
Table 16: Weaker Reflector Models on FINER. We vary the Reflector while keeping the Genera- tor/Curator fixed. Parentheses report deltas vs. the base LLM.
Harmful Reflector Frequency (every X iters)
Accuracy (t)
base LLM
70.7
66.7 (-4.0)
5
76.1 (+5.4)
10
77.0 (+6.3)
25
77.8 (+7.1)
50
78.2 (+7.5)
100
78.2 (47.5)
No harmful reflector
78.3 (+7.6)
Table 17: Robustness to Noisy Harmful Reflector Feedback on FiNER. We invoke harmful reflector once every X adaptation steps. Parentheses report deltas vs. the base LLM.
larger X means less frequent corruption (Table 17). ACE is robust to moderate noise levels: per- formance degrades gradually as corruption becomes more frequent and stays above the base LLM except in the extreme case of injecting harmful updates every iteration. This suggests that ACE's update mechanism tolerates substantial noise in the reflection stream, with failures emerging only under intentionally adversarial conditions.
Takeaway and Mitigation ACE is not highly sensitive to reflector quality: (1) weaker reflectors still provide substantial gains, (2) moderate noise or conflicting updates are largely tolerated, and (3) performance drops below the base model only under sustained adversarial corruption. In practice, ACE's bullet-point analyzer "groo-and-refine", $3.2), which merges and deduplicates semantically similar bullets and can filter entries flagged as potentially harmful via metadata, serves first line of defense against context noise. Additional safeguards (e.g., contradiction detection, prompting the Curator to prioritize high-confidence updates, periodic pruning of outdated entries) compatible extensions that could further improve playbook compactness and consistency (Zhou et al., 2024).
A.5 ABLATION ON INCREMENTAL CONTEXT UPDATE
In this ablation, we run offline context adaptation on AppWorld using ACE with and without in- cremental context updates, and evaluate on the test-normal split with DeepSeek-V3. -3.11 1. We find that incremental updates are critical: by preserving useful information that would otherwise be lost to context collapse, they account for large share of ACE 's gains.
Method
Normal TGC (1)
Test-Normal SGC (1)
Average
DeepSeek-V3.1 as Base LLM
ReAct
63.7
42.9
53.3
Ofrl ine Adaptat ion
ReAct ACE (no incremental update)
67.3
46.44a.5 64.3
56.9
ReAct ACE (with incremental update) 76. 1
70.3
Table 18: Ablation Incremental Context Updates (AppWorld, DeepSeek- We offline context adaptation with ACE with/without incremental updates and evaluate on test-normal. Improvements relative to ReAct.
20

---

Published as a conference paper at ICLR 2026
A.6 SENSITIVITY ANALYSIS ON HYPERPARAMETER CHOICE
Reflection Iterations This parameter trades off (1) extracting enough high-quality insights from the inference traces and (2) avoiding "overthinking" that introduces noisy or unnecessary updates. Empirically, 5 rounds offers good balance. On AppWorld, round under-extracts useful strategy fragments and leaves clear headroom, while too many rounds (e.g., 10) can degrade performance.
Reflection Iterations
Test-Normal TGC (1) Test-Normal SGC (f)
Average
DeepSeek-V3..
Base LIM
N/A (without ACE)
63.7
42,9
53.3
Offline Adaptation
69.0 15.3
53.6 110.7
61.3 8.0
74.4 10.7
57.1
65.8
12.5
72.6 18.9
62.5 19..6
67.6 14.3
10
71.4
58.9 (16.0
65.2 (1.0
Effect of Reflection Iterations (AppWorld, DeepSeek-V3.J We report test-normal results under offline context adaptation. Improvements relative to running ReAct without ACE.
Table 19:
Deduplication Threshold This controls how aggressively newly extracted insights are merged with existing entries. On FINER, performance changes only mildly across the tested range, suggest- ing ACE is robust to moderate variation in dedup aggressiveness.
Deduplication Threshold
FiNER (Ace 1)
DeepSeek-V3.1
Base LLM
N/A (without ACE)
70.7
Offline Adaptation
50%
77.0
70%
73.9
90%
78.6
Table 20: Effect of Deduplication Threshold (FINER, DeepSeek-V3. V3.1).
Pruning Trigger (Maximum Context Length) This threshold determines when ACE merges and prunes older or low-utility entries to prevent unbounded growth. It balances (1) retaining enough accumulated context to improve learning from experience and (2) keeping the context compact to reduce cost and limit noise. On FiNER, performance stable from 10K 100K tokens, indicating ACE does not require finely tuned length thresholds; pruning mainly removes stale or harmful fragments while preserving core reusable strategies.
Max Context Length FINER (Aee t)
DeepSeek-V8 -VeSeekk-33. .1 as Base LLM
N/A (without ACE)
70.7
Offline Adaptatio ion
10K
78.6
50K
78.4+7.7
100K
78.3
Table 21: Effect of Pruning Trigger (FiNER, DeepSeek-V3.1).
Overall, ACE is highly sensitive to these hyperparameters: reasonable choices (e.g., 3-5 flection rounds, 50-90% dedup threshold, and 10K-100K pruning triggers) consistently yield strong performance.
21

---

Published as a conference paper at ICLR 2026
B EXTENDED RELATED WORK
B. AGENT MEMORY
growing body of work explores how agents can accumulate experience from past trajectories and leverage external (often non-parametric) memory to guide future actions. AgentFly (Zhou et al., 2025) presents an extensible framework where memory evolves continuously as agents solve tasks, enabling scalable reinforcement learning and long-horizon reasoning across diverse environments. AWM (Agent Workflow Memory) (Wang et al., 2025b) induces reusable workflows, i.e., structured routines distilled from past trajectories, and selectively injects them into memory to improve effi- ciency and generalization in web navigation benchmarks. A-MEM (Xu et al., 2025) introduces a dynamically organized memory system inspired by the Zettelkusten method: each stored memory is annotated with structured attributes (e.g, tags, keywords, contextual descriptions) and automati- cally linked to relevant past entries, while existing entries are updated to integrate new knowledge, yielding adaptive and context-award retrieval. Agentic Plan Caching (Zhang et al., 2025c) instead focuses on cost efficiency by extracting reusable plan templates from agent trajectories and caching them for fast execution at test time.
Together, these works demonstrate the value of external memory for improving adaptability, effi- ciency, and generalization in LLM agents. Our work differs by tackling the broader challenge of context adaptation, which spans not only agent memory but also system prompts, factual evidence, and other inputs underpinning AI systems. We further highlight two fundamental limitations of existing adaptation methods: brevity bias and context collapse; and show that addressing them essential for robustness, reliability, and scalability beyond raw task performance. Accordingly, our evaluation considers not only accuracy but also cost, latency, and scalability.
C EXTENDED DISCUSSIONS
C.I ACE VS. GEPA
Scope and Objective Both GEPA and ACE improve model agent behavior by adapting context at test time (rather than updating model weights), but they are designed for different forms of adap- tation. GEPA treats adaptation as prompt evolution: it iteratively proposes and selects improved instruction prompts using rollout trajectories and reflective feedback, aiming to maximize task evaluator under a rollout budget. ACE targets settings where performance depends on accumulating and preserving many granular, reusable insights over long horizons. For multi-turn agents (e.g., Ap- pWorld), the model must retain step-by-step procedures and tool-use rules across an interaction. For domain-specific and mnowledgeiintesivee benchmarks (e.g., FiNER, Formula), accuracy depends on keeping many specific rules, edge cases, and domain concepts that are difficult to compress into a single instruction prompt without losing detail.
Update Mechanism and Representation GEPA updates context by generating and selecting new prompt variants in evolutionary loop, where each candidate is full prompt optimized end-to- end. ACE instead represents context as a structured, itemized Playbook and applies incremental delta updates: the Curator writes only the new insight, and we merge it into the Playbook with simple deterministic logic. This avoids repeated full-prompt rewrites, helps keep earlier rules stable over long runs, and enables fine-grained bookkeeping (e.g., de-duplication, targeted refinement, and tracking which entries helped or harmed accuracy).
C.2 ACE vs. DYNAMIC CHEATSHEET (DC)
Scope and Objective Both DC and ACE collect reusable insights at test time, but they are aimed at different settings. DC is mainly evaluated on single-turn reasoning benchmarks (e.g., AIME, Game-of-24, GPQA) where each query is independent. In this regime, improvements often come from saving short, reusable heuristics and executable artifacts (e.g., code snippets) that help on later problems. ACE focuses settings where the details and high-fidelity guidenace need to stick around. For multi-turn agents (e.g., AppWorld), the model must remember step- be--bb-stepp procedures and tool-use rules across interaction. For doeain- and inowledge-intensive benchmarks
22

---

Published as a conference paper at ICLR 2026
(e.g., FINER, Formula), accuracy depends keeping many specific rules, edge cases, and domain concepts, which are hard to compress without losing information.
Update Mechanism DC updates its memory by rewriting the cheatsheet whole, either by generating the full cheatsheet each step (DC-CU) or by writing a new summary from retrieved examples (DC-RS). With repeated full rewrites, the model tends shorten and compress what was written before. This can cause context collapse, which means that useful domain-speciff details get dropped over time disappear suddenly ($2.2). ACE avoids full rewrites by using incremental delta updates. The Curator only writes the new insight, and we merge it into a structured and itemized Playbook with simple deterministic logic. This keeps earlier rules stable over long runs and also makes it easier to track which items helped, remove duplicates, and refine entries. In our ablations ($4.6), removing delta updates leads to a large drop on App (-11.7% TGC and -27.8% SGC on test-normal), showing that delta updates are core part of our method.
D APPWORLD LEADERBOARD SNAPSHOT (09/2025)
Agent Scores
your agent Isadarboard (iliniioo the tnto ciiata Gittuu.
Scores
Sceres Intenst ora
Mathod
LLM
Test-Challenge
Link
suostring
substrig
TGC
800
IBM CUBA
GPT-4.
78.2
625
678
482
LOOK
Gwen2.5-528
4033- 44-40
/2.8
538
4/2
288
SeIBSR Demoe
GPT-4o
0328-22-111
571
Figure 5: The AppWorld leaderboard as accessed on 09/2025.
E THE USE OF LARGE LANGUAGE MODELS (LLMs)
This work focuses developing algorithms and system frameworks for effective context adaptation in large language models (LLMs). Accordingly, our experiments employ LLMs for the empirical evaluation of the proposed methods. For paper preparation, used LLMs only to polish writing (e.g,, correcting grammatical errors), and not to generate new text from scratch.
23

---

Published as a conference paper at ICLR 2026
F PROMPTS
am supervisor and super intelligent Assistant whose job to achieve day-to-day tasks completely autonomously.
To this, will need interact with
spotify,
etc) using their associated
behalf. For this will
undertake muttiistep conversation using python environment. That you
python code the environment execute it and show you the result, based on which, you will write python code for the next step and so on, until you've achieved the goal. envirenment
interact with app/s using their associated APIs behalf.
Here three key APIS you
know get information
ger Hstt of apps that avod lable you.
print(apis. api_docs, wwww_spp_ (pppppddccripptton(111111
get the Hier of apts (ppssrpgttoootp.pn.nesssot))))))
app Histed e.g. spotiity
print(apis. casss.pp_ddoss ttto.ppp.eescrriitionnnt nape_
To ger the spectificatio ton of particular apt, sportfy login apt
print(apis. aapppppdoooo docs. swww_shsi_steeeeeeeoooeeeeo api_doo|spp__anrr spotify', api_nanes "login ')
Each code execution will produce an output that you can use subsequent calls, Using these APIs, you can now generate code, that will execute, to solve the task.
Let's start with the task
shot example]
Instructions:
Make cade blacks with ** followed newlinne)).
Remember you
variables your
Remember that addresses, access tokens variables (e.g. spotify_ spotify_posswerd) example above not
anymore.
4. You can use the "supervisor" app to get information about my accounts and use the "phone" app to get information about friends and family.
Always
specifications (using apás.api piss.ppidocss show_api_doc calling an
code and only one chunk every stop. sure everything is working correctly before making any irreversible change.
Write
7. Many APIs return items in "pages". Make
through all the by looping page_index.
Once you have completed return as the answer argument, lie. call epis supervisor. complete, tasktanswer-- enswerr<answwrr> Many tasks do not require
apis supervisor conpleteettskkeeee
information,
just call apís. supervi corplete_ task() l.e. pass any argument.
Using APIs, generate to the actual
My name Ef main user.firett first_naamee }} {( (main_ userilast_name name }} My personal email {( main main_user-eme user-emaill }} phone number is main, uswr.phone_numeeee number }).
Task: {{ input_str str }}
Figure 6: ICL-baseline Generator prompt on Aorlorld
24

---

Published as a conference paper at ICLR 2026
I am your supervisor and you are super intelligent Al Assistant whose job is to achieve my day to day tasks completely autonomously. You will grven cheatsheat containing melovant strategies, patterns, and examples from similar problems apply and solve the current task.
To this, you will need to interact with appls (e.g. spotify, veamo etc) using their associated APIs on my behalf. For this you will undertale a muld step conversation using a python REPL envtronment, That is, you will write the python code and the environment, will you
which, you write python code for This environment will let you interact with appls using their associated APIs on my behelf.
execute
step on, until you've achieved the gool.
Here are three koy APIs that you need to know to get more information
To get a Hist of apps that are available to you.
(apnt aap.ppppppoocc. docs.ddosssss.s..s.. shwssshhooppppoo sip_ddecriitionn(])
To got the list of apts under any app listed above, o.g. spority print api docs srow_ap__oee deldercrpttionsappp (app__ane- 'spttify11
To got the spectfication paint ap1 docss show_api Show__pi_ddee spi_doc(spp_nar Sariop_areeeaee 'spotify'. ap1 nanne="loggnn"
particular apt, o.g. spotify app logtn apf
Each code execution will produce
that
subsequent calls. Using these APIs, you generiate code, that I will
execute, task.
CHEATSHERT: {( cheat sheet:) }
ANALYSIS STRATEGY
Carefully analyze both the question and cheatsheet before starting
Search for and ideatify any applicable patterns, strategies, examples within the cheatsheet
Create structured approach to solving the problem at hand
Review and document any limitations in the provided reference matertals
SOLUTION DEVELOPMENT
Present. your solution using cleat, logical sleps thet others follow and review
Explain your reasoning and methodology before presenting conclusions
Provide detailed explnattios for each stop of the process
Check and verily all assumptions and Intermediate calculations
PROGRAMMING TASKS
When coding required: Write clean, efficient Python code - Follow the strict code formatting and execution protocol (always the Python code formatting block; furthermoce, after the block, always explicitly request execution by appending: "EXECUTE CODE!") python * Your code here EXBCUTE CODE!
All required imports and degendencies should be clearfy declared al the of code comments explain any complex programming logic Perform result validation after executing your code
Include
Apply optimization techaiques from the cheatsheet when applicable
code should completely self-contained without external dependencies-It should be ready be executed right Do not include any placeholders, system-specilic pellis, or bard-coded local pelhs
Feel free to use standard and wodely used pip packages
Opt for alternative methods errors persist during execution
Exclude local pellis and engiae-specific sellings (e avoid conligurations like
chess. engine. SumpleEniine.pope ucil "ussobansstckiisaa))
Let's start with the task
sbot example]
instructions:
with followed by newline().
Remember you can use the variables your code subsequent code blocks.
Remember Usat the email addresses, access tokens and variables ge spolify password) in the example above are not valid anymore.
4. You can use the "supervisor" get information about accounts and use the "phone" app to get information ahout friends family.
5. Always look at API specifications (using apis.epl _pp._oosss.._p.peeee_pp wtw.ddossssssscoeooooooooo show__pi_doo before calling an API.
6. Write small chunles of code and only one chunks of code in every step. Make sure everything is working correctly before makinn any imeversible change.
Many return
"peges".
sure through pages by looping page_ Index.
Once you have completed the task, make sure to call spis. supervisor. corplete task(). If the Lask asked for some information, return it as the answer argument, i.e. call apis. supervisor. corplete, task(aaseerssannseee ). Many tasks not require an answer, so in those cases, just call apis supervisor. complete_ [ask((] i.e. do not pess any argument.
Using these APls, generate code to solve the actual task:
My name is: {f main first name }} {4 main user last name }}. My personal email is {( main, usenemail }} and phone cumber {{ main phone number 1). Task: (1 Linpl, sir })
Figure 7: Dynamic Cheatsheet Generator prompt on AppWorld
25

---

Published as a conference paper at ICLR 2026
am your supervisor and you are super intelligent AI Assistant whose job is to achieve my day-to-day tasks completely autonomously.
To do this, you will nend to interact with appls (o.g. spotify, venmo etc) using their associated APIs on my bohalf. For this you will underlake moili-step conversation using python REPL environment, Thal
will write the python code and the environment will show the result, based which, you will python for the stop This environment will let you interect with appls using their essocialed APIs on my behall.
until you've achieved the goal.
Here are three key APIs that you need to know to get more information:
# To get list of apps thet aze available to you. print(apts
doccssshan app cepp_desrriptoons(
# To get the List of apis under any app listed above, e.p. spotity print(apis.api www._dccsssshooeeeeeeo.. shon_api_descriptionn (app_nane=" spotify }}
# To get the specification
a particulor api, c.g. spotiffy app 's login api printlapis. siint(apis.api_dcc api_decs, hhtw_spi__oc(apppneeee 'spotify', api_nane- login'))
Each cade execution will produce output that you in subsequent calls. Using these APls, you generate code, that will execute, to solive the task.
Key Instructions:
1. Always end code blocks with followed by newlinef).
2. Remember you can use vartables in your code in subsoquent code blocks.
3. Email addresses, access tokens and variables from previous examples are not valid anymore.
4. Use the "supervisor"
information about mny accounts and the "phone"
information about friends and family.
Always look specifications (using apis, apis.api__oos api_docs. Soocs.sho__app.e shox_api_doc before calling an API.
6. Write small chunks of code and only one chunk of code in every step. Make sure everything is working correctly before making any irreversible changes.
7. Many APIs return items "pages". Make
through all the pages looping page_index.
Once you completed task, apis supervisor. aupervisor.compeeee... answer argument: apis supervisor. cowp.eoooeeeeeeeeeooeoe sampllte_ttskkaaae (ansssssssrsssssserrr)) For taske without required answers, just call
conplete_tasieeeeeeeeeeeeeeeeeee jaske]] task asked information, return
spis.supervisor www.svvisor.copplee............. complete_taski without arguments.
Whea splitting bills among roomantess, remember to: First identify roommates using phone search contacts with 'roommate" relationship query. Access bill recespts in file system under
Domain-SSeciiff Strategy for Bill Splitting Tasks:
mnamm/jssmmmmmllla V/lllss directory structure- Ca lollatte equal shares dividing total amount by (number of mommates 1) including yoursell Use Venmo's creale paymenl request AP! with roommetes' email addresses- Eusure peyment requests are only sent to actuel roommaaes (not coworkers or other contacts) Verify that all roommates have the same home address their contact information Use the description pold cable bill." for payment requests
organising Giles based creation the file system using credentials from superviser Use show directory() to list files and show file() to get file metadata including created at Create destination directortes using create directory() before moving files Use move filel) to organize files while meintaining original Iilenames Files created in specific months should moved to corresponding destination directories fe.g. March
Domain-Specinl Speciffc Stralegy
Organization Tasks:
remember First login lo
Rome, April Sentoriai, others- Berlin]
When creating playlsts for specific durations, remember to: Calculate total duration needed (e.g. 90 minutes 5400 seconds) Search for approgriate songs across different genres (workout, energetic, rock, pop. dance)- Use song() gel individual song durations- songs playlist until total duration requirement met play musisc) with playlist id to start playback
Nomain-Spectiii Strategy for Music Playlist Tasks:
When compressing vacation photo directories, remember to: Compress each vacation spot directory indiviuaalyy Save compressed files specified destination path format (e.g.. --phatographhavacatooo Delete the original directories after successhil compression- Verity that the compressed files am created
Domain-Speen cffi Strategy for File Compression Tasks:
correct location
Domain- Specific Strategy for Alarm Management Tasks: When modify ing phone alarms, remember to: Identily the specific elarm by its label (e.g., "Wake Up") Calculate new times accurately (convert HHLMM to minutes for artthmetic operations) - Disable all other enalled alarms except the heing modified Preserve other alarm settings while making changes
handling text/voice messages, remember functions to find specific messages by phone number or content- - Handle pegination to ensure all relevant messages are processed Delete messages using their specific massage IDs Verily deletion by checking that no messages remain
Domain-Spert Speciin-Speiifeee ifie Strategy for Message Management Tasks;
search
Let's start with the task:
Figure 8: GEPA prompt on AppWorld
26

---

Published as a conference paper at ICLR 2026
I am your supervisor and you are a super intelligent Al Assistant whose job to achieve my day-to day tasks complotely autonomously.
To do this, you will need to interact with appls (eg spotily, vemmo etc) using their ascociated APIs on my behalf: For this you will undertake mullissep conversation execute show you This environment will let you interact with appls using their associated APIs on my behalf.
python REPL environment. That is, will write the python code and the eavironment will python
you
step
until you've
the goal.
Here are three key APIs that you need to know to get mare information
To get Hist of apps thar available you. print(apis, easseppp____ wtb.c..shw.spp..escrippeee appp.eescrritionns()
listed above, spotify paint(apis _oc_ shows.sswwwaaed show_app__esssee ( app parunare-eae spotify ))
To the list of apis under
To get the specification of particular api, e.g. spotify app logīn apí api_namer login'))
print(apis, docs shoos..howwaae ppp__eecepppnane
Each code execation will produce au oulput that you can use subsequent calls. Using these APls, you can now gecerate code, that will execute, to solve the task.
You are also provided with curated cheatshent of strategies, APl-specific Information, common mistalies, and proven solutions to help you lask ellectively.
Playbook:- Read Playbook then execute the task explicitly loveraging each relovant soction:
PLAYBOOK BEGIN
U( playbook
PLAYBOOK END
example]
Key instructions:
1. Make sure to end code blocks with followed by a newline().
2. Remember you the variables code subsequent code blocks.
3. Remember that the email addresses, tokens and variahles (e.g. spotify password) the example above valid anymore.
You can use the "supervisor" app to get information about my accounts and use the "phone" app get information about friends and family.
Always look specifications tusing ap apí show_api_ddee dol_ before calling
only one chunk every step. sure everything working correctly making any irreversible change.
small chunks
7. Many APIs return items in "pages". Make
through all the pages by looping page_index.
for some information, return it as the answer argument, i.e. call epis supervisor. complete, taski (anseer=snnssees> ). Many tasks do not require an answer, in cases, just apis supervisoz. carplete_taski i.e. pass any argument.
Once you have completed
sure apis supervisor. complete_ (askk)
only the parts are relevant and applicable to your specttic situation task contert, otherwise use your own judgement.
Treat cheatsheet
Using these APIs and cheatshost, generste code to solve the actual task:
My main user first name { mein usenlast }). personal email {{ main user.email }} and phone number {{
main user phone number )). [[ input ))
Figure 9; ACE Generator prompt on AppWorld
27

---

Published as a conference paper at ICLR 2026
You anw expert ApplWorld ooding agent and aducator: Your job is dlagross the current Ingettury. ahentily what went wrong for could better), grounded etsetation seege, report, ground
applizable.
tims:: Canefully andlyza the modelss revening troee identity when went wnong. Takee aevemumentt feedburk into arount, owmpanig proditzed nistake
pap
specific conceproal
calculation mistakes er misageliedd www.rrrnnniiiittnneneeoo perooiiierttinneattrrr fsematting
Provde artinable lnsights
could the meddl curnect them PProosle concrate, stap lyyttip turrections model should bake the task specitic about what the mudel shurld have does onthemtcationn and diffeennly- - You will neceive briletpuntt that sew part playhouk thai's used by the gensenioe unswer the queecaon. You ueed anelyoe these bulseipsints, and give the tag for each bulletpeint, tog con be ('aegtul: "haruful" "teutraa" (de the generatoe geserate the coctect answect) Explichily curate from the envrronmntt Stedback the ourput frmattschemm of APIs used when undear or mismatcched with expertations (e.g. apts blaah show contents() retorns content ids (strings), not content otgects)
Irgeats:
Ground truth code treferenco, knewn-ceemtt
GROUND TRUTTI CODR CODELSTART START
((cround code])
Dist tuntt tests cosut for the task after the gunerated oode was rua):
TEST RERORRRRTRSSS REPORT-START START
([unit results))
TEST, REPORT END
ACE playbook (playbock that's usrd by model for toda generatann):
WTAYOOOK START
([xlaboood)
PLAYBOOK END
Exumplos:
Esample 1:
apss
Gerancedd Cade; [Lade that tlentify roammates by parding Venmu tramorctinn descrptions uxing kaywerte like "rent", "stiltaec"]
Desostion Eree. Assetunntraur Respected 1050.0 but get 79.6
Thet Begurt FAILED WWring total calcslated duw insoreet mommale identification
Responen
"meesning"" "The genersted onde attempred to simitify nusmmates by parsing Vinmo transaction descrtpeinne nother then sxing the authertistve Phone app contacts. This to missnng most commate transction end coltulating an incomest
methed 1088 o.",
"wrurr ideetiftoation" "The agent used unreliable heuratios (tyyorrd matthing transection description) to siantily mommales inctaed the oornect API (Phune contocts)."
"mott canss anelyce" "The agent coundeestodd the dats anchitecture it secmmed tranccctoon descriptions conteined relabie reletunchip information, when the Phone app the authoctaalive source for contact rehttossipp...
"carrett approach": "Fust outhosticate with Phone use apís phone search contacts)) to ideatity ocntacts with 'rommate" relationsiip then Elber Venno transactions by those specific contact enalispphone numbers.."
"Jy Insigat": "Always zeselve sdeatiies from the cocrect sourcs app Phone app for relarionship, sever rely trasscttonn descriptions ce other indirect heursties whlch ane uoraliable
Tsumple
Ground Trath Code (Gode thas sows groper while True pegination loep to get all Spocity piaylict))
Genwroted Cade (rode that uses for tn ringect0) to pagrante through playlsts)
Exceution Eroc: Note (codo succensfult)
Expected playlista
incompltte pagination
Responas:
((
"reassming": "The gunorated oode used fined range loop (ousqe(10)) peqination unstoad of propecly nurwiing untá more results rstumed. This cussed tae onl collect the first 10 pages poaylists, missing 13 addiiiionl playliste that extated on inter pages."
"error jdentiffcation"; "The pegination
aetitrary flodd linit instead of continuing until
"moot analyce"" agent used approach fleed rgper excended
looge, this prevented complete
"coreett approach" Troe loop proper break
calling with incrementing page. Index page_index range Rteatonns complete data acroes
empty
then
"eey Insight" pagination, always
keop
pages."
11
Outpats: Your output should be json object, which contains the fallowing Selds- reasoning: your chain of thought. reasening / ttinkingg process, detalled analysts and calculatons seroe ilentiiicaton: what specilioully went woung the reasocingg root cusee andiysss why did this ezoor occur? What concapt was misundantioo?. correct appeoach: what abould the model
itstoud? Jay insight what strutogy, foemula, or priseple should be romembered to avoid the eror?
Answer in this exact JSON format:
((
"ceassning"
thougls. masscnng prensee,
caleslation)"
urzur dentiftdiis" "[What spaciisally went wrong the ressoming""..
"not casse anelyeat: "[whyy dal thes arnor ouzur" What tunoppt was maundansseil"""
"osrect approch": TWhat should the modal have done matesd?]:
"ayy inightt serategy
princpii
sercef)"
(FULL AITNT-RRWWROOOOEE TRAJECTORY ATTACHED HEnB)
Figure 10: ACE Reflector prompt on AppWorld
28

---

Published as a conference paper at ICLR 2026
knovledge Your job iienctly treghts
eclciig playbook
prestoos atternge.
Conteat:- The plasbook you created be wed to help ussverza saniarr qurstarn reflection genseuted wsing ground unswers will NOT avallable playhokk being
up
playbouk
grodections Melly algne ground
Instrer toone Beview wcieting plaghook
reflection from the prwrious attengt Identity ONLY NEW tnoghts, etrategres or mistaise
MUSSING from
odditions nceded simetly
complemnt: better
esleting playsook
negenetate
plashook
Socused,
resporse FURE 19CN azject with specite sectins For operation to now content ald, retura empty list for the operotions fidd Be cancise and specite.
each widitinn should be actionsble Poe rading taoks, eeplictlly cursis from the rellectinns the oxtput turmel/chher of ArTs used when unclesr or mismaaicee with espaciation (n.g. spis blan, sontenta rnturns last of cintent, itk (etrings), zot cuntent objects)
Task Contest actual task instruction):
(question,
Current PlayBooko (cursent p playhook)
Current Generated Attempt (latest attempt, with reasoning and planning): caool_gonncttdd_cos
Current Reflections (priuciples and strategies that belped to achieve current task]: (guSdebook)
Ersmples:
Prommple
money
since this year"
Gurmet Hayhonk: [flec usage guidelinee)
Carenated Attempt: (Coda that fwlled becausen it used un descrppions to slantify nuommntee inclred of Phane contects)
The eittine "The felld bwasuse tried identily commetes by paning Vanmo tounorction doszriptions insteed of oiiiiig the Phone app's contact relttoonsipe Thix led to tncornect ddentifioctinn and siring results."
Tregorss
"seasoning" reflection critical crror where sgont used unzellable houristics (tronsoction descrigtions) instead
princisle
captured
playbout pravent similax fallures identity resolution tasks.",
"typ": "AOD",
section": strategies_ins anteeardddde purde
consent": "Ilayys reselve identities from the corsect source appin- when you need to identiff relationships [100 [xoomrates, contacts, etc.),
alnays use Pione sop's contact, and revvzz tay othez heuristics tronsaction desceiptions, name patterns, other indizect
Esample
Contect: "Count plaslists in Spocity
Currest Haybook: [Buie auchemication and APt calling guidelises)
Geserated Attempt: (Code that used foe ranpotto) losp and misedd pluylata on latse pages]
fined
pigination
derating theough paçua
caused iccopplte
data collection.
Raspoase:
"reasoning": reflection Ident iftee paginstion tandling error where agent used as arbittrary fraed rarge insteed proper pagination logic. is comton API usage pattizrn that should explicitly docueinttd to ensure cosplete data retricvel."
"sperationx":
"yse": "A2D",
"section:: "apix_to aor. ofe ieeeeiieeetooeeeee inforeation".
"cuntent" "About pegination: APIS ruturn stems ""pages"", ". Nake through all the pages exing while True koop insteed of for in rongec10) over "ond__dndxx".
Your Taskc Detpot ONLY a valid ISDN olysct with these stacct fiiike reseening: your chain of though: messaaing / thiniang procaso, detailed andlysts and colculations operstame of sperntions to be prrformed the payybook typw. the typs of operation to performed suction. the suction to buiet to contant the bullet
Avoilable Operations: 1. ADD: Create sow bullet points with fresh DDs section: the section to odd the now bullet to contest: the now contest the bullet, Note: zo nerd Include
Tctx helpeil=) harmfale0 si; bullet
by system.
RESPONSE FORMAT- Outpet ONLY this JSON structure (no marladown, no code blocks);
zeasoning thinking detailed analysis calculatiors heze]".
"speration""
typet: "A20",
section": warariacttoonnccccaaae
"custentt: "Wew checklist ites API schers clerification..."
Figure 11: ACE Curator prompt on AppWorld
29

---

Published as a conference paper at ICLR 2026
analysis export tasked answering questions using your knowladge, reflection that goes over Uhe diegoosis of previous mistakes made while enswering the question.
playbook strategles and Insights
Instructions: Read the playbook carefully and apply relevant strategies, formulas, and insights - Pay attention to common mistakes listed in the playbools and avoid them Show your reasening step-by pep-by-step... Be concise but thorough appropriately
analysts- If the playbook your calculations logic before providing the tinal
relevant code snippels
answer
Your output should be a json object, which contains following fields: reasaning: your chain of thought / ressoning / thinking process, detailed analysis and calcalations bullet ids: each line the playbook has bullet id. all bulletpoints in the playbook that's relevant, question, you
helpful for you
bullet
answer: your final
Playbook:
0
Reflection:
0
Question:
Context:
()
Answer this JSON format:
"reasoning": "[Your chain of thought reasoning thinking process, detailed analysis and calculations] ids": ('ealc-poa81", "fin-8rea2"), "final_inswer"; "[Your cancise final answer hare]"
Figure 12: ACE Generator prompt on FINER
30

---

Published as a conference paper at ICLR 2026
You expert anelysl, predicted answer and the ground truth.
diegnose why model's reasoning wrong anelyzing gap
Carefully analyze the model's reasaning trace to Identify where it went wrong Take environment feedhack into account, comparing the predicted answer with the ground truth understand the gep Identity specific conceptual errors, calculation mistakes, misapalied strategies
Instructions:
actionable insights root cause, not just surface-level emrrs Be specific about what the model should have done differently - You will recsive bulletpoints that playbook that's used by the generator bulletpoint, tag
help model avoid
on
the question. You need to analyze these bulletpoints, and give the for l'belpful', hharmfal', 'neutral') (for generator to generate correct answer)
Your output should json object,
contains following Neelds reasoning: your chain thought reasoning / tthinking process,
detailed analysts and calculations crror identification: what specifically went wrong in the reasening? root, cause, analysts: why did this instead? insight: what
misunder correct approach: should the model strategy, formula, or principle should be remembered to avoid this ecroz? hollet tags; a jon objects with bullet, and tag for each bulletpoint used by the generator
What concept
Question:
Model's Reasoning
Model's Predicted Answer:
()
Ground Truth Answer:
Environment Feedback:
Playbook
generator answer question:
Answer in this exact JSON format:
"reasoning"; "Your chain thought / reasoning / thinking process, detailed analysis and calculations]",
"exror_ identificationn: "[What specifically went wzong in the ressoning?]"
"root_c crct__cause__aaaaeeee sar_acuss__nnlssss.... "[Mhy did this esror occur? what concept was misunderstood?)",
"correct soppocct_oppoecch": "[What should the nodel have "key_in hey_insight"; "[bhat strategy, formula, or principle should renerbered avoid this error?]",
insteed?]',
"bullet_tags":
(1"id"; "calc-o2e01", "tag": 'helpful"13. (t"id"; "fin-008e2", "tag": "harnful"]]
Figure 13: ACE Reflector prompt on FINER
31

---

Published as a conference paper at ICLR 2026
master curator knowledge, Yourjob ideatify new insights reflection from a previous attempt.
existing playbook based
Context: The playhook you created will be used to help answering simillar questions. - The reflection is generated using ground truth suswers thai will NOT available when the playbook being used. So you need to come with content lhat aid the playbook predictions likey align ground truth.
CRITICAL: You MUST respond with valid JSON only. Do not use markdowa formatting or code blocks.
Instructions: Review the existing playbook and the reflection from the previous attempt- Identify ONLY the NEW insights, strategpes, mista kos that are MISSING from the current playbook- Avoid redundancy If similar advice almady exists, only add new content that complement
esisling playbook- NOT regenerate quality over quantity a focused, organzzga playbock better than an exhaustive one Format your respease as PURE JSON object with spectfic sections For any operation if new content to add, return an empty list for the operations field Be concise and specific. addition
entire playbook only provide additions needed
on
actionable
Training Context:
Total token budgel: [token budgel) lokens Training progress: Sample (curreat step) out of (total samples)
Current Playbook Stats:
(playbook, stats)
Recent Reflection:
(recent releetttellecios))
Playbook:
(ourrent, playbook)
Question Context:
(question coolext)
Your Task: Ourput ONLY valid JSON object with these exact fields: reasoning: your chain of thought, reasening / thinkingg process, delailed analysia
operations performed performed section: the section to add the ballet coatent: the new content the builet
opeer
playbook lype: the type operation
Available Operations: ADD: Create new builet point with fresh IDs section: the soction to add the new bullet to content: the new content of the bullet. Note: need include the bullet id in the content like ([cts-00263) helplat-1 harmful-Q the bullet id will be added system.
RESPONSE FORMAT- Output ONLY this JSON structure (no markdown, no code blocks):
'reasoning": "[Your chain thought reasoning thinking process, detailed analysis calculations here]",
"operations" ":
"type": "ADO",
"section": "forulass_ cacos_nn___allll calculaaiion"",
"content": "[New calculation rethod...]"
Figure 14: ACE Curator prompt on FINER
32


Reviews:
[{"review_id": "78Fy4hTmdP", "reviewer": "Reviewer_CtWY", "summary": "This paper introduces ACE (Agentic Context Engineering), a framework for context adaptation in large language models (LLMs). The core idea is to treat model context as an evolving \"playbook\" that accumulates domain-specific strategies over time. ACE uses a modular setup with three components: a Generator, a Reflector, and a Curator. It aims to avoid two problems found in existing methods: brevity bias, where important details are lost due to excessive summarization, and context collapse, where repeated updates degrade the quality of context. The authors evaluate ACE on agentic and domain-specific benchmarks. Results show consistent gains over strong baselines, both in offline and online adaptation settings.", "questions": "1. How sensitive is ACE to the Reflector’s performance? Would a weaker model lead to significant degradation?\n\n2. Could ACE be combined with retrieval-based augmentation to further improve performance in low-data settings?", "limitations": "", "rating": 4, "confidence": 4, "soundness": 2, "presentation": 3, "contribution": 2, "strengths": "1. The paper addresses a relevant and underexplored problem in LLM system design.\n\n2. The ACE framework is well-structured and motivated by observed failure modes in prior work.\n\n3. The paper is clearly written and provides sufficient technical detail.", "weaknesses": "1. The novelty is moderate. ACE extends prior methods like Dynamic Cheatsheet and GEPA rather than introducing a fundamentally new paradigm.\n\n2. The approach depends on the quality of the Reflector. In settings without reliable feedback, performance drops.\n\n3. There is limited discussion of failure cases. For example, when the context grows too large or accumulates conflicting strategies, how does ACE prevent quality degradation?", "quality": null, "clarity": null, "significance": null, "originality": null, "strengths_and_weaknesses": "", "was_revised": false, "final_justification": "", "rebuttal": "", "claims_and_evidence": "", "methods_and_evaluation_criteria": "", "theoretical_claims": "", "experimental_designs_or_analyses": "", "relation_to_broader_scientific_literature": "", "essential_references_not_discussed": "", "other_strengths_and_weaknesses": "", "other_comments_or_suggestions": "", "questions_for_authors": "", "summary_of_paper": "", "summary_of_recommendation": "", "technical_quality": "", "clarity_of_presentation": "", "potential_impact": "", "robotics_focus": "", "quality_of_limitations": "", "questions_for_rebuttal": "", "reasons_to_accept": "", "reasons_to_reject": "", "questions_to_authors": "", "extra_scores": {}}, {"review_id": "48eBOVNqPD", "reviewer": "Reviewer_HBCS", "summary": "This paper proposed ACE which addresses 2 observations found from existing context engineering methods : diversity ( brevity bias ) and context collapses. The framework uses incremental delta updates and a grow-and-refine mechanism to preserve detailed knowledge while preventing information loss. Evaluated on agent benchmarks (AppWorld) and domain-specific tasks (FiNER, Formula), ACE achieves 9.0% average improvement over strong baselines while reducing adaptation latency by 82-91% and costs by 75-84%.", "questions": "1. Could you provide a cost ( token counts ) per eval breakdown comparison between ACE, GEPA and baseline?\n   \n     a. Figure 5b shows dollar costs for FiNER but similar analysis for AppWorld would strengthen cost claims. Specifically: Tokens per query (input/output), Cumulative tokens over full evaluation, Breakdown by component (Generator vs Reflector vs Curator)\n\n2. How does ACE perform more real world repetitive tasks such as text-to-sql or ddxplus? A benchmark called streambench would be well suited for this kind of scenario.\n\n3. Only one model is selected ( DeepSeek-v3.1 ) which is an odd choice, any reason why smaller models or cheaper models are not evaluated as well?\n\n4. In section 5 the claim that longer context does not cause higher cost due to KV caching does not seem to hold in ACE as the context memory would reset on every delta update right?", "limitations": "", "rating": 6, "confidence": 4, "soundness": 4, "presentation": 4, "contribution": 3, "strengths": "1. The motivation and proposals are grounded on real world observations with strong empirical results.\n\n2.  Experiments on different benchmarks (ICL, MIPROv2, GEPA, DC) and ablations (Reflector, multi-epoch, offline warmup) are robust and well thought out.", "weaknesses": "1. Only DeepSeek-V3.1 tested; generalization to other LLMs unclear.\n\n2. While the framework is effective, it primarily extends Dynamic Cheatsheet with engineering improvements rather than introducing novel concepts", "quality": null, "clarity": null, "significance": null, "originality": null, "strengths_and_weaknesses": "", "was_revised": false, "final_justification": "", "rebuttal": "", "claims_and_evidence": "", "methods_and_evaluation_criteria": "", "theoretical_claims": "", "experimental_designs_or_analyses": "", "relation_to_broader_scientific_literature": "", "essential_references_not_discussed": "", "other_strengths_and_weaknesses": "", "other_comments_or_suggestions": "", "questions_for_authors": "", "summary_of_paper": "", "summary_of_recommendation": "", "technical_quality": "", "clarity_of_presentation": "", "potential_impact": "", "robotics_focus": "", "quality_of_limitations": "", "questions_for_rebuttal": "", "reasons_to_accept": "", "reasons_to_reject": "", "questions_to_authors": "", "extra_scores": {}}, {"review_id": "wqSmg9eKx7", "reviewer": "Reviewer_KcGQ", "summary": "The paper introduces ACE (Agentic Context Engineering), a framework for context-based self-improvement of LLMs that treats prompts as evolving, structured playbooks rather than concise summaries. It addresses two common failures in prior prompt optimization—brevity bias and context collapse—by separating roles into a Generator, Reflector, and Curator; applying incremental delta updates instead of monolithic rewrites; and using a grow-and-refine mechanism for de-duplication and maintenance. ACE operates in both offline (prompt/system prompt optimization) and online (test-time memory) settings, leveraging natural execution feedback and optionally ground-truth labels. Across agent (AppWorld) and domain-specific (FiNER, Formula) benchmarks, ACE outperforms strong baselines (e.g., GEPA, DC), delivering average gains around 9–11%, matching or exceeding a top production agent on AppWorld using a smaller open-source model, and substantially reducing adaptation latency and cost (e.g., up to ~82–92% latency reduction). Ablations confirm the value of the Reflector, multi-epoch refinement, and offline warmup. Limitations include reliance on feedback quality and a capable Reflector, and reduced benefits in tasks that favor concise instructions over rich, accumulated context.", "questions": "Could you provide some examples on context collapse as shown in Figure 2?", "limitations": "", "rating": 4, "confidence": 4, "soundness": 2, "presentation": 3, "contribution": 2, "strengths": "1. The paper is in general well-written.\n2. The benchmarks are carefully selected and representative, but would be better to include more to make the conclusions more solid, e.g., 1 or 2 more.\n3. The paper identifies two important pitfalls in existing works, and designs better approaches to address the issue.", "weaknesses": "1. It is not clear that whether the proposed will still be effective for more powerful (and potentially more knowledgeable model like GPT-5)\n2. It is not accurate to claim that ACE uses much smaller model (DeepSeek-V3.1, 685B) than GPT-4.1 (unknown size)\n3. This work builds on top of Dynamic cheatsheet. More detailed comparison and analysis to it is necessary. What is the main difference to it? What are their scores in the benchmark? Currently, I feel that ACE makes minore changes, while the core idea to evolving playbooks s that accumulate, refine, and organize strategies is similar to Dynamic cheatsheet.", "quality": null, "clarity": null, "significance": null, "originality": null, "strengths_and_weaknesses": "", "was_revised": false, "final_justification": "", "rebuttal": "", "claims_and_evidence": "", "methods_and_evaluation_criteria": "", "theoretical_claims": "", "experimental_designs_or_analyses": "", "relation_to_broader_scientific_literature": "", "essential_references_not_discussed": "", "other_strengths_and_weaknesses": "", "other_comments_or_suggestions": "", "questions_for_authors": "", "summary_of_paper": "", "summary_of_recommendation": "", "technical_quality": "", "clarity_of_presentation": "", "potential_impact": "", "robotics_focus": "", "quality_of_limitations": "", "questions_for_rebuttal": "", "reasons_to_accept": "", "reasons_to_reject": "", "questions_to_authors": "", "extra_scores": {}}, {"review_id": "6nD8NiLo3k", "reviewer": "Reviewer_LJpr", "summary": "This paper introduces ACE, a framework where the model adjusts its inputs using “reference materials” such as task instructions, coping strategies, or past experiences. By leveraging these contextual references, ACE helps improve the model’s overall performance.", "questions": "1. The paper states that ACE relies heavily on reliable feedback signals (e.g., code execution results or ground-truth labels), but doesn’t explain what happens when feedback quality is poor. Experiments show that when there are no gold labels or the feedback is noisy (like in ambiguous financial tasks), ACE’s performance drops sharply—sometimes even below baseline. However, this is only listed as a “limitation,” with no mitigation strategies explored. The paper also lacks quantitative tests on low-quality feedback (e.g., different noise levels), so we can’t tell how robust ACE is in messy real-world environments where feedback can be unreliable.\n\n2. The current ablation only compares “with vs. without reflection” and “single-round vs. multi-round adaptation,” but doesn’t isolate the two key designs — incremental update and refine-as-you-extend. As a result, it’s unclear whether the gains come mainly from reducing information loss (via incremental updates), cutting redundancy (via refine-as-you-extend), or both. This makes it harder for future research to pinpoint which component drives the improvement.\n\n3. The paper doesn’t test what happens when the generator, reflector, and summarizer use models of different strengths. All components use the same model (DeepSeek-V3.1), but in real scenarios, one might use a stronger model for the reflector. Would ACE still be stable in that case? Would costs rise significantly? These are important but unexplored questions.\n\n4. The paper mentions using “KV cache reuse” to reduce cost, but doesn’t actually show numbers. For instance, how does ACE’s inference time or memory usage change when handling 18k-token contexts with and without caching? How does that compare to short-context methods (like GEPA’s concise prompts)? Without this data, the claim of “low cost” feels unsubstantiated for practical readers.\n\n5. The paper also skips the retrieval efficiency problem for long contexts. ACE’s context is a structured “playbook,” but as it grows, how does the model quickly find the relevant parts (e.g., specific financial rules)? If retrieval time increases, it could cancel out the latency benefits of incremental updates. The paper doesn’t discuss or test any such optimization.\n\n6. In the AppWorld experiments, ACE is compared against a “top commercial agent (IBM-CUGA)” that’s said to be “based on GPT-4.1.” However, the paper doesn’t reveal whether that system also used context optimization or even had the same test setup. If not, ACE’s “catch-up” advantage might be overstated, raising concerns about fairness.\n\n7. In ACE’s refine-as-you-extend mechanism, key parameters like the deduplication threshold (how to judge when two strategy fragments are semantically redundant), maximum context length (when to trigger pruning), and number of reflection iterations (set to 5) are not specified or justified. Without details on why “5 rounds” were chosen or how different values affect performance, it’s hard for others to reproduce the reported results accurately.", "limitations": "", "rating": 4, "confidence": 3, "soundness": 2, "presentation": 2, "contribution": 2, "strengths": "1. I really like Section 2.2 — it clearly sets up the motivation by analyzing Brevity Bias and Context Collapse before presenting the problem.\n\n2. The proposed method looks quite effective.", "weaknesses": "1. The method heavily depends on feedback quality, but lacks a clear solution for unreliable feedback and has limited robustness evaluation.\n\n2. The causal attribution of each core module’s effectiveness is unclear, and the ablation study is somewhat incomplete.\n\n3. The discussion on long-context cost is not convincing enough and doesn’t fully reflect real-world deployment concerns.", "quality": null, "clarity": null, "significance": null, "originality": null, "strengths_and_weaknesses": "", "was_revised": false, "final_justification": "", "rebuttal": "", "claims_and_evidence": "", "methods_and_evaluation_criteria": "", "theoretical_claims": "", "experimental_designs_or_analyses": "", "relation_to_broader_scientific_literature": "", "essential_references_not_discussed": "", "other_strengths_and_weaknesses": "", "other_comments_or_suggestions": "", "questions_for_authors": "", "summary_of_paper": "", "summary_of_recommendation": "", "technical_quality": "", "clarity_of_presentation": "", "potential_impact": "", "robotics_focus": "", "quality_of_limitations": "", "questions_for_rebuttal": "", "reasons_to_accept": "", "reasons_to_reject": "", "questions_to_authors": "", "extra_scores": {}}]

Author rebuttal:

Decision: Accept (Poster)