Skip to content

ACE: Pluggable Adaptive Context Elasticizer across Agents

🕒 Published (v1): 2026-06-30 12:20 UTC · Source: Arxiv · link

Why this paper was selected

Addresses fundamental harness bottleneck: adaptive context management across agents

Ask a follow-up

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

💬 Ask ChatGPT✦ Ask Claude

TL;DR

ACE is a training-free, plug-and-play context management module that wraps existing LLM agent frameworks and elastically assigns each historical step one of three rendering modes—raw, abstract, or drop—at every decision step. Unlike truncation or summarization, ACE maintains a lossless message maintenance layer so decisions are fully reversible. It consistently improves performance across ReAct, DeepAgent, WebThinker, and MiroFlow without modifying their action spaces or requiring fine-tuning.

Problem

LLM-based agents operating on long-horizon tasks accumulate trajectories that exceed fixed context windows, degrading reasoning quality. Existing remedies (truncation, threshold-triggered compression, recurrent compression, agent-controlled compression) are inflexible and irreversible: once a historical step is discarded or abstracted, that information is permanently lost even if it becomes critical later. No prior method allows per-step, per-history-entry decisions that can be revised at any subsequent step.

Method

ACE introduces a two-layer architecture inserted as an external wrapper around an existing agent's reasoning loop:

Message Maintenance Layer \(\mathcal{M}\): Stores, immutably, both the raw message \(h_i^{\text{raw}} = (r_i, a_i, o_i)\) and an auxiliary-LLM-generated compressed abstraction \(h_i^{\text{abs}}\) for every historical step \(i\). Abstractions are structured to lead with a conclusive result and preserve task-critical facts (numbers, URLs, dates, tool schemas, failure causes).

Context Orchestration Layer: Before each decision step \(t\), an elasticizer LLM \(E\) reads the task description \(\mathcal{T}\) plus all compressed abstractions \(\{h_i^{\text{abs}}\}_{i=1}^{t-1}\) and predicts a decision \(d_i^t \in \{\text{Raw}, \text{Abs}, \text{Drop}\}\) for each historical step \(i \in [1, t-2]\):

\[d_i^t = E\!\left(\mathcal{T},\, h_1^{\text{abs}}, \ldots, h_{t-1}^{\text{abs}}\right)\]

The actual context delivered to the main LLM is:

\[C_t = \text{Concat}\!\left(\mathcal{T},\; \varphi(h_1^{\text{raw}}, h_1^{\text{abs}}, d_1^t),\; \ldots,\; \varphi(h_{t-2}^{\text{raw}}, h_{t-2}^{\text{abs}}, d_{t-2}^t),\; h_{t-1}^{\text{raw}}\right)\]

where \(\varphi\) selects the raw message, abstraction, or nothing per decision, and the most recent step \(t-1\) is always included as raw. Because \(\mathcal{M}\) is never overwritten, any decision made at step \(t\) can be reversed at step \(t+k\).

Integration is implemented as a post-step hook (store raw + abstraction into \(\mathcal{M}\)) and a pre-step hook (rebuild \(C_t\)), requiring no modification to the wrapped agent's state, action space, or training.

Key Contributions

  • Lossless decoupling: separates the agent's raw trajectory from the context it actually receives, enabling reversible orchestration decisions.
  • Per-step elastic orchestration: reassigns Raw/Abs/Drop to every historical step at every decision step, so context composition adapts to evolving task state.
  • Training-free plug-and-play wrapper: integrates into ReAct, DeepAgent, WebThinker, and MiroFlow via a two-hook interface with no action-space or architectural changes.
  • Empirical validation: consistent gains over truncation and summarization baselines across GAIA, HLE, WebShop, WebWalkerQA, xBench-DS, and BrowseComp-ZH.

Results

  • ReAct + ACE vs. ReAct (GPT-4.1), GAIA overall: 42.4 vs. 38.8 (+3.6 pts); vs. truncation 37.0, vs. summarization 40.0.
  • ReAct + ACE vs. ReAct (Gemini-3.1-flash-lite-preview), GAIA overall: 52.7 vs. 46.1 (+6.6 pts); vs. truncation 43.0, vs. summarization 38.8.
  • DeepAgent + ACE (GPT-4.1), GAIA overall: 41.8 vs. 40.0 baseline; (Gemini) 51.5 vs. 46.7.
  • WebThinker + ACE (GPT-4.1), GAIA overall: 42.7 vs. 32.0 (+10.7 pts); (Gemini) 40.8 vs. 32.0.
  • MiroFlow + ACE (GPT-4.1), GAIA Val AVG: 43.6 vs. 33.3 (+10.3 pts); BrowseComp-ZH: 12.5 vs. 9.7.
  • ACE consistently improves WebShop success/score metrics and HLE across all framework variants.
  • Per-step token analysis (Fig. 2) shows ACE keeps input token length substantially lower than raw ReAct at later steps while avoiding the aggressive cuts of truncation.

Limitations

  • The elasticizer and auxiliary abstraction LLM add extra inference calls per step, increasing per-step latency and cost relative to truncation.
  • The elasticizer \(E\) is set to the same LLM as the main agent; its decision quality is therefore bounded by that model's ability to assess relevance from compressed abstractions alone.
  • Abstraction quality depends on the auxiliary LLM (GPT-4o in all experiments); degraded summaries could lead to poor orchestration decisions even if raw messages are preserved.
  • No evaluation of failure modes when the elasticizer mis-classifies a critical step as Drop; reversibility is theoretically guaranteed but the frequency of such errors is not quantified.
  • Experiments use a fixed elasticizer prompt; no ablation on prompt sensitivity or domain-specific prompt tuning is reported.

Relevance to Harnesses / Meta-Harnesses

ACE is a canonical example of a meta-harness: a framework-agnostic wrapper that orchestrates the information flow between an agent's internal state and its reasoning LLM without touching the agent's own logic. Its two-hook interface (post-step storage, pre-step context rebuild) is precisely the design pattern that harness builders use to instrument existing pipelines—demonstrating how a thin orchestration layer can add reversible, stateful control over trajectory management across heterogeneous frameworks. The plug-and-play integration across four structurally distinct agent topologies (single-agent, main-auxiliary, multi-agent) validates that such meta-harness abstractions can generalize without co-design. For researchers building harnesses, ACE's lossless maintenance layer pattern—storing both compressed and raw representations and deciding presentation dynamically—offers a reusable architectural primitive for any system where long-context degradation threatens downstream reasoning quality.