acceptodds
Under review as a conference paper at ICLR 2027

EvoState: Multi-Operation Context-State Transitions for Long-Horizon LLM Agents

Abstract

Long-horizon LLM agents must preserve action-critical information while tracking which facts remain valid and which requirements remain unresolved. As execution progresses, new evidence can change both the status of retained information and its relevance to subsequent actions. We introduce EvoState, a training-free framework for maintaining evolving context state. The framework models context state in three complementary parts: Current Trace for ongoing execution evidence, Event Memory for historical outcomes, and Task State for current facts and requirements, each with distinct retention and update rules. Its Multi-Operation Context Editor combines rule-based updates with conditional LLM-based consolidation to maintain these records as new evidence arrives. The Dependency-Aware Context Assembler uses the revised state to prioritize exact dependencies, current facts, and unresolved requirements for the next decision, allowing necessary evidence to exceed a soft token target. Using GLM-5.1, we evaluate EvoState on AppWorld Normal and Challenge, BFCL Long Context, and an interactive exact-match subset of CRMArena-Pro. EvoState lies on the observed success–token Pareto frontier in all four settings, with gains of up to 7.1 percentage points in success and reductions of up to 29.4% in tokens per task relative to Full History. Controlled analyses further show improved reference retention and next-action progress.

Primary area:
foundation or frontier models, including LLMs
Keywords:
LLM Agents, Long-Horizon Agents, Context Management, Agent Memory

Reviews

Among:
Shape:
1234this paper, Bottom 27%
Figure 1. Mean review rating of the reviewed papers at ICLR 2027. This paper averages 2.00 over 4 reviews, above 27% of the others.
Reviewer_TCnDOpenReview ↗
Rating
2
Confidence
2
Informativeness
2
Presentation
2
Soundness
2
Read review
Paper summary

This paper proposes EvoState, a training-free memory module for LLM agents doing long multi-step tool use. It stores key facts from tool outputs, such as IDs and current values, in a structured state and updates them as new results arrive. When building each prompt, it includes facts the agent will still need. Across three benchmarks (AppWorld, BFCL, CRMArena-Pro), EvoState improves task success over the strategy keeping the full history (+2–7 pp), while using 10–29% fewer tokens.

Critical strengths

S1. Important problem. Long-horizon tool-using tasks require agents to reuse exact values from earlier outputs, and truncation and summarization could drop or distort these values. The paper targets this practical failure mode.

S2. Careful evaluation. The paper covers several benchmarks and reports the cost of every memory-management call and failed run. It also uses three runs with significance tests and openly reports where gains are not significant.

Critical weaknesses

W1. Insufficient differentiation from existing context-management and memory methods. Many methods already try to summarize interaction histories, organize reusable information, maintain task-related state, and prompt LLMs to preserve important details. However, the main text does not provide a sharp characterization of which capabilities existing methods lack or why their mechanisms are insufficient to solve difficult tasks. I recommend authors to provide a comparison table explicitly showing which functionalities differ between EvoState and the closest existing methods, or, which functionalities are absent from each existing method. Also, qualitative comparison figure showing when and why they fail while EvoState succeeds would be helpful.

W2. Unclear distinction between LLM-based and rule-based components. The main text's method section does not state clearly whether each operation is performed by an LLM or by pre-defined rules (e.g., which records are classified as protected, how fields and spans are selected in assembly, and how the verifier V and Merge operation works in Eq (6), and more). I suspect that pre-defined rules likely drive the gain over prior baselines: removing LLM consolidation (N4) costs only 4.8 pp, while removing protection in assembly (N6) costs 19.4 pp. Please mark each component as LLM-based or rule-based in the main text, and add a concrete example of what the rules do.

Questions for authors

See weaknesses

6 comments
AuthorsOpenReview ↗

Initial Response to Reviewer TCnD(Part 1/2)

Thank you for the reviewer’s specific suggestions regarding method distinctions and module responsibilities. We have added comparisons with existing methods, trajectory cases on the same tasks, and descriptions of the responsibilities of rules and LLMs, and have further clarified the scope of interpretation of the relevant ablation experiments.

W1. Differences from existing methods

The main distinction of EvoState is not simply the addition of structured memory or summarization, but the joint maintenance of changes in the validity of historical information, task completion conditions, and dependencies of subsequent actions, which are then used to assemble the next input.

For example, after a stage ends, the exact IDs obtained during that stage may still need to be reused across stages. When a new observation invalidates an old fact, its old value can still be retained as historical evidence, but is no longer prioritized as the current value. Task requirements, in turn, can only be discharged with matching evidence.

Table 7 in Appendix A.7 provides a functional comparison with existing methods. The core distinctions can be summarized as follows:

Existing methodMain approach to organizing informationAdditional handling explicitly specified by EvoState
HiAgentSubgoal summaries and historical trajectory retrievalSeparates stage completion from condition satisfaction and protects dependencies across stages
ACON-HistoryHistory compression and retention of recent interactionsExplicitly maintains replacement, invalidation, and requirement discharge
Retrieval MemoryRelevance-based selection of historyIncorporates execution dependencies into assembly priorities
StructMemOrganization of facts, relations, and eventsJointly maintains currently valid values, outstanding requirements, and their reading priorities

EvoState directly defines these operations as state-maintenance rules during execution, making this a dynamic process.

For the qualitative cases you suggested, we added two comparisons on the same tasks in Appendix G.7:

G.7.1: Subsequent use of an already-read song list.

In a note-update task involving 13 songs, Retrieval Memory had already read the target note, but the subsequently selected Actor input did not contain the note body. The trajectory then exhibited repeated searches and note reads, eventually passing 1/8 official checks. EvoState’s subsequent inputs retained the list of songs to process and the release-month information already obtained, eventually passing 8/8 checks while using 46.20% fewer total tokens than Retrieval Memory.

G.7.2: Reuse of song–playlist associations after a stage transition.

In a playlist-migration task involving 18 songs, HiAgent’s input after a subgoal transition did not directly provide the complete song–playlist mappings. The subsequent trajectory exhibited repeated logins, repeated file reads, and code and call errors, eventually passing 0/7 official checks. EvoState retained the required song list and relevant associations, completed the migration, and passed 7/7 checks while using 51.96% fewer total tokens than HiAgent.

The official checks, interaction counts, and token usage for both tasks are reported in Table 55. Because each method executes its own complete trajectory, we treat these only as qualitative comparisons.

In addition, Figure 6(c) in the main text compares progress rate and token usage for five methods at 202 identical execution states. Table 27 in Appendix C.3.4 includes the complete results, providing a controlled comparison with external methods independent of the above cases.

W2. Rule-based and LLM-based responsibilities

We have directly marked these responsibilities in §3.3–3.4 of the main text and listed them in full in Table 5 of Appendix A.5:

ModuleExecution typeResponsibility
Evidence UpdatesRule-basedExtract evidence from actual observations and update the state
Consolidation TriggerRule-basedDetermine whether semantic consolidation is needed
Memory ConsolidationLLM-basedOrganize historical information and propose edits
Verification / MergeRule-basedVerify sources, resolve conflicts, and commit updates
Context AssemblyRule-basedClassify, protect, rank, and select information
ActorLLM-basedDetermine the next action based on the assembled input
AuthorsOpenReview ↗

Initial Response to Reviewer TCnD(Part 2/2)

We further clarify the specific details you asked about below.

Which records are protected.

Section 3.4 of the main text and Appendix A.4 designate currently valid exact dependencies, state records needed to continue execution, outstanding task requirements, and records needed for the current working stage as protected content. Dependency identification uses fields in tool responses and suffix rules; the specific scope is described in Appendix A.6.1. The end of a stage does not by itself automatically release dependencies still needed by subsequent actions. Requirement discharge and fact invalidation, in turn, change their protection status or reading priority accordingly.

How fields and text spans are selected.

The Assembler first includes mandatory and protected information, then selects optional content. For excessively long observations, it first uses a compact format that preserves fields and values. If the observation is still too long, fields and text spans are selected based on task relevance, entity information, and identified dependencies. Content not included in the current input remains in the original records; input selection and source deletion are two distinct operations. Candidates beyond the soft target must also satisfy the admission conditions in Appendix A.6.5 and are always subject to the model’s hard capacity limit. The complete procedure is provided in Algorithm 2 of Appendix A.4.

How the Verifier (V) works.

The Verifier performs support checks on identified concrete values in proposals and their sources, checks whether requirement discharge has applicable evidence, and checks whether summaries cover the information needed to permit replacement of source records. The specific criteria are described in Appendices A.6.2–A.6.4.

How Merge works.

Merge handles duplicate and conflicting operations, prioritizes direct tool evidence over conflicting proposals, and applies compatible edits in the prescribed order. Combined updates are first applied to a copy of the state and committed only after passing rule checks. If a check fails, the system falls back to rule-generated updates or rejects the update, depending on the configuration. The procedure is provided in Algorithm 1 of Appendix A.2.

An actual editing cycle.

Appendix G.2 presents a complete update after a tool returns eight playlists and their song IDs:

  • The rules generate three operations: write the grouped song IDs into Task State; retain the action that obtained these lists and its authentication bindings; and retain the complete tool observation.
  • The LLM proposes two operations: compress five older records into a summary and remove one superseded record.

All five operations pass the rule checks and are committed together, reducing Current Trace from 12 records to 9. The song IDs and their groupings are preserved. After broader login observations are summarized, the exact login dependencies still needed for subsequent calls are also retained. The Actor then uses this information to complete deduplication, song queries, and artist following, and the task ultimately passes all 4 official checks. This case concretely illustrates how rule-generated updates, LLM proposals, and dependency retention work together within a single editing cycle.

The different performance drops of N4 and N6.

We agree with the reviewer that the N6 result highlights the importance of the assembly policy in our current system. However, the larger drop in N6 does not establish that predefined rules are the primary source of the gains, because N4 and N6 are not matched ablations:

  • N4 disables conditional LLM consolidation while retaining rule-based state updates and the original assembler. Mean success rate decreases from 86.11% to 81.35% (−4.76 percentage points).
  • N6 retains state storage and editing but changes dependency protection, necessary-state priority, and admission rules beyond the soft target. Mean success rate decreases to 66.67% (−19.44 percentage points).

These results show that the tested assembly-policy changes have a substantial effect on performance, but the two drops cannot be compared as estimates of the relative contributions of LLM consolidation and rule-based assembly. We clarify the intervention scope in Appendix D.1 and provide the complete results in Table 32.

Thank you for the detailed response. I will maintain my score.

My main concern remains. The new comparison table and qualitative cases for W1 are helpful, but they remain in the appendix and describe what EvoState does rather than what existing methods lack or why existing methods fail at the mechanism level. As the response acknowledges, the distinction from prior methods is that EvoState handles fact replacement, requirement resolution, and cross-stage dependency retention through explicit rules rather than leaving them to the Actor. Consistent with this, the ablations suggest the rules drive most of the gain: without LLM consolidation, EvoState still reaches 81.35% on Normal, above all tuned baselines. The paper does not explain how the many rule constants were chosen, so it remains unclear whether the gains generalize beyond these API environments.

Reviewer_sGiPOpenReview ↗
Rating
3
Confidence
3
Informativeness
2
Presentation
2
Soundness
2
Read review
Paper summary

EvoState is a training-free context-management framework that separates Current Trace, Event Memory, and Task State. Rule-based updates and conditional LLM consolidation produce multiple edits, while a dependency-aware assembler constructs the next model input using valid facts, unresolved requirements, and exact dependencies. Necessary information may exceed a soft token target while remaining subject to the model’s hard context limit.

Critical strengths
  1. Clear separation of information lifecycles. Historical events remain distinct from currently valid facts and unresolved requirements. This makes replacement, invalidation, and requirement resolution more explicit than in approaches based on a single repeatedly rewritten summary.
  2. Substantial empirical experiment coverage.
  3. Transparent reporting of costs and limitations.
Critical weaknesses
  1. Core validation and selection rules are not yet sufficiently operationalized. Exact-dependency recognition, source-support checking, adequate replacement, requirement resolution, and prioritization beyond the soft target are central to the method. The descriptions and pseudocode explain the intended behavior, but do not fully determine the predicates, pattern coverage, and failure handling needed to reproduce it.
  2. The ablations support the complete policies more strongly than the individual mechanisms. N3 applies updates to only one component and discards the others rather than queuing them. It therefore does not provide an information-equivalent comparison between joint and sequential editing. N6 simultaneously demotes dependencies and mandatory state constraints and changes the treatment of the soft budget. In the matched next-action analysis, the full method consumes 8.84K tokens per request versus 7.17K for N6, approximately 23.3% more. These totals include both input and output tokens and should not be interpreted entirely as an input-budget difference.
Questions for authors
  1. Can you provide executable rules for dependency recognition, validation, requirement resolution, and selection beyond the soft target, together with complete baseline configurations?
  2. Does the assembly advantage persist when mandatory constraints are retained and actual input-token budgets are matched?
3 comments
AuthorsOpenReview ↗

Initial Response to Reviewer sGiP(Part 1/2)

Thank you for the reviewer’s specific suggestions regarding rule reproducibility and the scope of experimental interpretation. We have added descriptions of the core rules, failure handling, and experimental configurations, clarified the intervention scope of N3 and N6, and added an assembly comparison with approximately matched actual Actor input lengths. We respond to each point below.

W1 / Q1. Core rules, failure handling, and experimental configurations

We have further clarified the responsibilities of rules and LLMs in Section 3.3–3.4 of the main text and added the core verification criteria and their scope of applicability in Appendices A.5–A.6.

In the memory-maintenance process, evidence extraction, consolidation triggering, proposal checking, conflict handling, and context assembly are performed by rules. The LLM generates summaries and editing proposals when consolidation is triggered. The Actor, also an LLM, generates the next action based on the assembled input. Table 5 in Appendix A.5 lists the responsibilities of each component.

For the specific rules raised by the reviewer, the revisions are as follows:

IssueAdded rules and handling proceduresLocation in the paper
Exact dependency identificationIdentify fields such as id, path, authentication token, and url, as well as prescribed suffixes, from successful tool responses. General fields are scoped by tool, and authentication fields are scoped by application. The maximum traversal depth is 6, and at most the first 200 items of each list are visited.A.6.1
Source-support checkingCompare identified identifiers, paths, and other extracted values in a proposal against the corresponding observations and supporting records. Some state fields use heuristic term matching; action intentions, code comments, or model-declared completion states cannot alone serve as evidence of outcomes.A.6.2
Replacing source records with summariesCheck coverage of identified necessary information. For collection records, identified member IDs must remain in the summary, state, retained records, or proposed state updates. If the check fails, reject the compression and retain the source. Records marked for exact retention are excluded from ordinary summary replacement.A.6.3
Requirement dischargeCheck evidence according to requirement type and scope, including structured completion fields, evidence of pagination termination under the same tool and non-pagination query parameters, and successful execution matching the scope of a blocked operation. Other discharge operations proposed by the LLM must still pass the applicable support checks.A.6.4, Table 6
Admission beyond the soft targetAfter mandatory and protected information has been included, determine whether optional content is admitted based on dependency links, shared entities or tool identifiers, outstanding requirements, recent valid records, and term relevance. The relevance conditions include at least 3 overlapping valid query terms and a ratio of overlap to token length of at least 0.015; older raw interactions additionally require a dependency link. All candidates are subject to the hard capacity limit.A.6.5

We have also added the procedure for handling failed checks. Algorithm 1 in Appendix A.2 describes proposal checking, conflict handling, application in a fixed order, and commitment. Candidate updates are first applied to a copy of the state and committed only after passing the rule checks. If the combined update fails and rule-only fallback is enabled, the rule-generated updates are checked separately. Otherwise, the update is rejected, while the original state and the received interaction records are retained.

Algorithm 2 in Appendix A.4 describes the context-selection process. Mandatory and protected information is included before optional content, and all candidates must satisfy the hard capacity requirement for the complete request. If the mandatory and protected content alone cannot fit, a capacity failure is reported rather than silently truncating the content.

The main baseline parameters, capacities, and interaction limits are described together in Appendix B.2 and Table 8. Table 10 in Appendix B.4 further lists the parameter sensitivity configurations and results for Sliding Window, Rolling Summary, and Retrieval Memory.

AuthorsOpenReview ↗

Initial Response to Reviewer sGiP(Part 2/2)

W2 / Q2. Assembly effectiveness after matching the actual input budget

We agree that the original ablations are better suited to illustrating the role of the complete maintenance and assembly strategies and cannot be directly interpreted as the independent contributions of individual mechanisms. The revised manuscript clarifies this in Appendix D.1.

N3 restricts each logical update batch to a single memory component, while still allowing multiple compatible operations within that component. Edits to other components are discarded rather than deferred. Thus, it tests the completeness of maintenance across components.

N6 simultaneously changes dependency protection, necessary-state priority, and admission rules beyond the soft target, and is therefore a combined intervention. In addition, the 8.84K and 7.17K tokens in the original next-action comparison include both input and output tokens and cannot be interpreted entirely as differences in the Actor input budget.

To further examine assembly effectiveness when actual input lengths are approximately matched, we added an Input-Matched Assembly experiment. The experiment uses 202 shared execution checkpoints from AppWorld Normal, covering 154 tasks and 55 scenarios. The two groups share the saved state, candidate information pool, task text, public completion requirements, and necessary interaction information, and restore the same environment state, simulated time, and execution variables.

EvoState uses its native dependency-aware assembly. The control ranks complete information units by BM25 relevance, using recency to break ties, without dependency-specific priorities. We use the input length of the native assembly as the matching target, measure the complete Actor input tokens reported by the API, and determine the matched set using a prespecified symmetric length tolerance of 5%. A total of 197 pairs satisfy this criterion.

MetricEvoStateBM25 assembly
Matched checkpoints197197
Strict next-action progress163/197134/197
Progress rate82.74%68.02%
Mean Actor input8,646.718,576.59

The mean input lengths of the two groups differ by only 0.82%, while EvoState’s strict progress rate is 14.72 percentage points higher. The 95% confidence interval clustered by scenario is [8.29, 21.17] percentage points. Thus, with shared necessary information retained and actual input lengths approximately matched, dependency-aware assembly still achieves better next-action progress. Figure 6(b) in the main text presents this result.

Thank you for the detailed response. My concerns have been well addressed.

Reviewer_N6ctOpenReview ↗
Rating
1
Confidence
3
Informativeness
2
Presentation
2
Soundness
1
Read review
Paper summary

EvoState is a training-free context manager for long-horizon tool-using agents. Instead of replaying full history, it keeps a structured state (recent trace with exact values like IDs and tokens, summaries of finished sub-tasks, current facts and open requirements), updates it mostly with rules, and builds each prompt around needed values. With GLM-5.1 on AppWorld, BFCL and CRMArena-Pro, it uses 10-29% fewer tokens than Full History with similar or higher success.

Critical strengths
  • The problem is real, long agent tasks blow up context and simple compression drops IDs, tokens and open requirements that later steps need.
  • Training-free and fair token accounting: costs include failed tasks and the memory system's own LLM calls.
  • Consistent token savings (10-29%) with equal or better success across 4 settings, with careful paired statistics and controlled analyses showing why it works (reference retention, next-step progress).
Critical weaknesses
  • Success gains are not consistent. vs Full History they are significant on BFCL and AppWorld Normal but not on AppWorld Challenge or CRM (Table 6). The solid result is similar success with 10-29% fewer tokens.
  • Tokens are not cost. Full History is append-only and benefits from prompt caching, EvoState rebuilds the prompt every step (breaks caching) and adds LLM calls. Cost and latency are not reported.
  • Some baselines look weak, it seems like the authors didn't tune their thresholds while carefully tuning EvoState to the task (unfair comparison). Probably tuned on AppWorld: rules and case studies come from AppWorld train/dev, and all ablations are only on AppWorld Normal.
  • One main model with reasoning disabled; second model is a single run without CRM.
  • The controlled analyses (reference retention, next-step progress) only compare against EvoState's own ablations, not against the baselines.
Questions for authors
  • Can you report dollar cost and latency with prompt caching enabled for Full History vs EvoState?
  • Why are some baselines so low (Retrieval Memory, StructMem on Challenge)? Were their settings tuned like EvoState's thresholds?
  • Do the results hold with reasoning enabled and with more runs for the second model? How about a third model?

For now I recommend rejection, but to be fair, I don't think this is a bad paper. But I think it needs subtantially more work (more models, at least 3, proper baseline tuning and statistical significance in at least 3 benchmarks), if the authors provide evidence that their method holds under improved and tuned baselines and across benchmarks I would be willing to update the score.

7 comments
AuthorsOpenReview ↗

Initial Response to Reviewer N6ct(Part 1/3)

Thank you for the reviewer’s detailed comments on the experimental design and interpretation of the results. We have added repeated runs with the DeepSeek models, comparisons with external baselines at identical execution states, parameter sensitivity analyses, and analyses of cache-aware billing and task completion time. We respond to each point below.

W1. Statistical significance of success rates

We agree that a higher mean success rate does not imply that the difference is statistically significant in every evaluation. The revised manuscript explicitly distinguishes mean differences, confidence intervals, and test results after correction for multiple comparisons. Accordingly, the paper primarily emphasizes the success–token trade-off observed under the evaluated methods and configurations, as well as the empirical Pareto frontier based on mean values. We do not describe the higher mean success rates in all four evaluations as statistically significant improvements, but rather as maintaining success rates at a high level.

W2 / Q1. Cache-aware costs, latency, and additional memory overhead

We have added API costs and task completion times for DeepSeek-V4-Flash/Pro, covering EvoState, Full History, Observation Masking, HiAgent, and ACON-History.

Table 49 in Appendix F.3 calculates costs with and without cache discounts based on recorded model usage and API rates. Table 50 in Appendix F.4 reports the mean task completion time for the two models across the four evaluations.

The following are the cost results for AppWorld Normal (unit: (10−210^{-2}) USD/task; a single paired run, with caching / without caching):

MethodDeepSeek-V4-FlashDeepSeek-V4-Pro
Full History1.08 / 4.184.05 / 14.13
ObsMask2.51 / 3.618.97 / 13.47
HiAgent1.52 / 3.704.41 / 14.76
ACON-History1.14 / 2.273.89 / 7.83
EvoState1.56 / 2.625.79 / 8.72

When caching is considered, Full History indeed has a clear billing advantage: EvoState’s costs with Flash and Pro are approximately 44.4% and 43.0% higher than Full History’s, respectively. However, this issue is not unique to EvoState. Across the eight model–task combinations in Table 49, 29 of the 32 comparisons involving methods other than Full History have higher cache-aware costs than Full History, indicating that this caching advantage also broadly affects other context-management methods.

Without cache discounts, EvoState’s costs on Normal are 37.3% and 38.3% lower than Full History’s, respectively, and are also lower than those of ObsMask and HiAgent. Although ACON-History has lower costs, its mean success rates across three seeds are 36.11%/68.65% with Flash/Pro, whereas EvoState achieves 75.00%/80.36%, the highest among the five methods.

This cost–success trade-off is also reflected in other configurations: without cache discounts, EvoState’s cost per task is lower than that of Full History, ObsMask, and HiAgent in all eight model–task combinations. Table 49 provides the complete comparison.

For latency, Table 50 in Appendix F.4 reports the mean task completion times of five methods across four evaluations with the two DeepSeek models. Latency varies across evaluations. In the reported results, EvoState is faster in the CRM evaluations with both models and the BFCL evaluation with Pro, and slower in the other five comparisons. Taking CRM as an example:

MethodFlash model success rateFlash model seconds/taskPro model success ratePro model seconds/task
Full History34.56%79.125.25%84.0
ObsMask30.15%80.827.45%85.6
HiAgent24.51%73.930.64%84.5
ACON-History34.80%87.742.40%82.9
EvoState37.01%76.447.30%72.7

In the CRM evaluation with DeepSeek-V4-Pro, EvoState achieves the highest mean success rate and the shortest mean task completion time among the five methods. With Flash, it achieves the highest mean success rate and takes less time than Full History, Observation Masking, and ACON-History. Compared with ACON-History, EvoState achieves both a higher mean success rate and a shorter mean task completion time in all eight model–setting combinations. In the other five comparisons, EvoState has higher latency than Full History, while maintaining a higher mean success rate and lower total token usage per task.

Regarding additional memory overhead, method token counts include the inputs and outputs of both the Actor and the memory-management model, as well as failed trajectories. Tables 44–47 in Appendix F.1 list these components separately, avoiding counting only Actor savings while ignoring memory-maintenance calls. The cost statistics in Table 49 also include recorded memory-management calls; for CRM, they additionally include user simulation and answer extraction.

AuthorsOpenReview ↗

Initial Response to Reviewer N6ct(Part 2/3)

Furthermore, Table 48 in Appendix F.2 shows that, in the main GLM-5.1 experiments, EvoState reduces the maximum single Actor input by 56.71%–76.28% relative to Full History. This metric reflects logical context occupancy and is measured separately from cache-aware billing and task latency. Our conclusion is that the method achieves a competitive trade-off between success rate and token usage, while explicitly reporting its costs when caching is accounted for and its latency costs.

W3 / Q2. Baseline parameters and their relatively low results

We have added a parameter sensitivity analysis and reevaluated three baselines with selected configurations to examine whether the original conclusions depend on particular parameter settings.

The sensitivity analysis uses all 57 AppWorld Dev tasks, consistently employing GLM-5.1 with temperature=0. We report 14 configurations, totaling 798 configuration–task evaluation results: Sliding Window retains 2, 4, 6, 8, or 10 steps of complete interactions; Retrieval Memory retrieves 3, 5, 6, 8, or 10 complete interactions; and Rolling Summary compares four combinations of compression thresholds of 4096 or 8192 and retention of the most recent 3 or 6 steps. Complete results are provided in Appendix B.4.

Within this candidate range, we prioritize configurations with the highest Dev success rate, choosing the one with lower total token usage when success rates are tied, while also further considering the trade-off between success rate and token overhead. Representative results are as follows:

MethodParameter changeSuccess (%) ↑Tokens/success (M) ↓
Sliding WindowRetain 6 steps → 10 steps75.44 → 84.210.1628 → 0.1500
Rolling SummaryThreshold 4096, retain 3 steps → 6 steps78.95 → 87.720.1595 → 0.1414
Retrieval MemoryComplete interactions, k=5 → k=1059.65 → 80.700.2447 → 0.1616

At the same time, retaining more information does not necessarily improve overall efficiency. For example, Rolling Summary with 4096 + 6 steps and 8192 + 6 steps succeeds on 50 tasks in both cases, but the former uses fewer total tokens. Therefore, we consider both task success rate and the resource consumption required to complete tasks.

We then used Sliding Window with 10 steps, Retrieval Memory with k=10 complete interactions, and Rolling Summary with 4096 + 6 steps in the four full evaluations. All results use GLM-5.1, temperature=0, reasoning disabled, and seed 0; EvoState reuses the results from the same seed in the paper. Appendix B.4.2 reports this comparison.

The following table presents the results from Table 11 in Appendix B.4.2. Tokens/success is calculated as the total tokens across all tasks divided by the number of successful tasks, including consumption from failed trajectories and model calls internal to each method, in millions of tokens.

MethodNormal Success (%) ↑Normal Tokens/success (M) ↓Challenge Success (%) ↑Challenge Tokens/success (M) ↓BFCL Success (%) ↑BFCL Tokens/success (M) ↓CRM Success (%) ↑CRM Tokens/success (M) ↓
Sliding Window: 10 steps76.790.181062.830.326568.500.179242.650.1794
Retrieval Memory: complete interactions, k=1075.000.197858.990.347366.500.185541.180.2312
Rolling Summary: 4096 + 6 steps79.760.184063.790.316069.500.173644.850.1729
EvoState86.310.151772.660.286071.500.129745.590.1323

Note: Normal, Challenge, BFCL Long Context, and CRMArena-Pro contain 168, 417, 200, and 136 tasks, respectively.

With the tuned baselines, EvoState still achieves both higher success rates and lower tokens per success across all four settings. Compared with Rolling Summary, which has the highest success rate among the three baselines, EvoState improves success rates on Normal, Challenge, and BFCL by 6.55, 8.87, and 2.00 percentage points, respectively. On CRM, their success rates are close, but EvoState reduces Tokens/success by 23.50%.

AuthorsOpenReview ↗

Initial Response to Reviewer N6ct(Part 3/3)

W4 / Q3. Repeated experiments with the second model and additional models

We have extended DeepSeek-V4-Flash from a single run to three seeds and added DeepSeek-V4-Pro. Both models have completed all four evaluations: AppWorld Normal, AppWorld Challenge, BFCL Long Context, and CRMArena-Pro.

We compare five methods under the corresponding task protocols. Each cell reports three-seed mean success (%) ↑ / tokens per task (K) ↓:

Model / MethodNormalChallengeBFCLCRM
DeepSeek-V4-Flash
Full History67.46 / 268.6544.92 / 424.0048.50 / 188.9534.56 / 163.55
ObsMask60.71 / 236.9037.25 / 329.8052.33 / 163.5730.15 / 149.78
HiAgent45.24 / 228.8823.74 / 315.6953.50 / 177.1524.51 / 162.45
ACON-History36.11 / 139.9218.63 / 178.7850.83 / 104.9434.80 / 116.20
EvoState75.00 / 181.7154.44 / 268.1158.83 / 114.2737.01 / 126.36
DeepSeek-V4-Pro
Full History73.21 / 211.3557.47 / 359.2253.00 / 105.3525.25 / 213.50
ObsMask74.60 / 188.2657.23 / 281.2755.67 / 130.4927.45 / 195.09
HiAgent75.20 / 214.4455.08 / 336.3545.50 / 106.8730.64 / 214.38
ACON-History68.65 / 114.5044.84 / 151.8150.50 / 76.4942.40 / 73.96
EvoState80.36 / 129.8469.62 / 222.4858.17 / 92.1947.30 / 105.33

Across all eight model–evaluation task combinations, EvoState achieves both a higher mean success rate and fewer method tokens per task.

Table 3 in §4.5 of the main text provides complete results for the two models, five methods, and four evaluations. Tables 38–41 in Appendix E.2 correspond to Normal, Challenge, BFCL, and CRM, respectively, and report the success counts, total tokens, means, standard deviations, and tokens per success for the three seeds.

Regarding the reasoning setting, we consistently disable reasoning in the main experiments for two main reasons.

First, we want the primary evaluation variable to be the context-management strategy, rather than additional capabilities arising from different amounts of reasoning computation. Enabling reasoning typically introduces additional reasoning tokens and computation, increasing the token and latency overhead of model calls. In multi-step agent tasks, these additional costs also accumulate over interactions. Consistently disabling reasoning allows a more direct comparison of the context-management effects of different methods under the same reasoning configuration, while controlling experimental costs.

Second, the Actors of all methods use the same setting; reasoning is not disabled only for EvoState. Therefore, this configuration does not give our method an additional reasoning-budget advantage. We also conducted a supplementary reasoning-on comparison using GLM-5.1, AppWorld Normal, and seed 0. Reasoning is enabled for the Actors of both methods. Under this setting, EvoState still maintains competitive success performance and lower total token overhead.

W5. Lack of external baselines in the mechanism analysis

In response to this comment, we have added a next-action comparison of five methods at identical execution states.

The experiment uses 202 checkpoints from EvoState seed-0 trajectories on AppWorld Normal. All methods share the execution prefix that has already occurred, the restored environment state, and public execution guidance. Each method constructs its own context and then independently generates and executes the next action. This design compares context use at the same reached states.

“Next-action progress” is defined as passing at least one additional official check after execution. The results are as follows:

MethodNext-action progressTokens/decision
EvoState84.65%8.83K
Full History83.66%14.85K
ObsMask78.22%11.78K
HiAgent64.85%9.37K
ACON-History65.84%4.82K

EvoState’s observed progress rate is close to that of Full History, while using 40.54% fewer decision tokens. Relative to HiAgent, its progress rate is 19.80 percentage points higher and its decision token usage is 5.75% lower. Relative to ACON-History, its progress rate is 18.81 percentage points higher, but it uses more decision tokens.

Figure 6(c) in §4.4 of the main text shows the relationship between progress rate and decision tokens. Table 27 in Appendix C.3.4 reports ordinary progress, strict progress, total decision tokens, and mean tokens per decision. Strict progress additionally requires no execution errors and no regressions on previously passed checks.

Reviewer_aF6POpenReview ↗
Rating
2
Confidence
2
Informativeness
2
Presentation
3
Soundness
2
Read review
Paper summary

This work introduces EvoState, a training free framework for long context management in LLM agent to preserve action critical information while tracking changes in the task status. The framework represents context with three components: Current Trace, Event Memory and Task State. A multi-operation editor coordinates updates among the components using rule based edits and LLM based consolidation. The major contribution is the explicit representations of evolving context states, the coordinator editing and assembly mechanism. The emprical evaluations on 4 benchamrks improved task success and reduced token usage by 10-30 percentages. More ablation and comparsions support the effectiveness of propsed method.

Critical strengths
  1. the motivation is strong as the retained information in long horizon agents change in validity and relevance.

  2. the framework design is coherent and the three components are well aligned with different rentetion and update requirements.

  3. With GLM-5.,1, EvoState achieves higher mean success and low token cost. Also the paper provides comprehensive controlled analysis.

Critical weaknesses
  1. The technical novelty is not strong. Though well-motivated designs, it appears to lie in their coordinated integration. The paper can be strong by clearly explain which capabilities can not be achieved via simpler extension of existing memory systems.

  2. The evaluation is not convincing as it primarily covers API based environment. Those results provide limited evidences about more complicated long horizon tasks.

  3. Lack of trade-off between token usage and latency/implementation complexity.

Questions for authors

EvoState underperforms Full History on the AppWorld Challenge Hard subset. What failure modes explain this result? Does compression remove information that is particularly important for these tasks?

2 comments
AuthorsOpenReview ↗

Initial Response to Reviewer aF6P(Part 1/2)

Thank you for the reviewer’s suggestions. We have further clarified the technical contributions and evaluation scope of our method, added measurements of resource overhead, and examined failure cases on AppWorld Challenge Hard. We respond to each point below.

W1. Technical novelty

The main distinction of EvoState is not the use of three memory layers or the addition of summarization operations, but the explicit maintenance of the different states of historical evidence during execution and the use of these states to select the next input.

For example, after a working stage ends, its execution results can be stored as historical events, while the entity IDs or variable bindings obtained during that stage may remain necessary dependencies for subsequent operations. New tool observations may also update a fact and invalidate its previous value, or provide evidence for discharging an outstanding requirement. EvoState jointly maintains these changes through multiple editing operations, after which the dependency-aware assembler selects the information needed for the next action.

In Table 7 of Appendix A.7, we compare the maintenance and reading strategies of existing methods. For example, HiAgent reuses information through subgoal summaries and historical retrieval, Retrieval Memory selects previous records based on relevance, and ACON-History compresses the interaction history. EvoState further explicitly maintains fact replacement, completion conditions, and execution dependencies across stages, and uses these state changes to determine subsequent inputs.

We do not claim that these capabilities are theoretically impossible to achieve by extending existing methods. The distinction is that EvoState implements them as explicit state-update and assembly rules, rather than relying solely on the Actor to infer them again from historical summaries.

Appendices G.7.1 and G.7.2 further illustrate this distinction through two actual tasks: the former shows that a song list already read by Retrieval Memory was not included in subsequent inputs; the latter shows that HiAgent did not directly provide the song–playlist mappings needed by the next stage after a subgoal transition. The official check results, execution steps, and token consumption for both tasks are listed in Table 55.

W2. Evaluation environments

We agree that the current evaluation primarily covers stateful tool-interaction environments, and therefore restrict our conclusions to this scope. Within this scope, the three benchmarks examine different task structures:

  • AppWorld: We evaluate the complete Normal set of 168 tasks and Challenge set of 417 tasks. Agents need to execute code in stateful applications, link information across applications, and complete a sequence of state-modifying operations.
  • BFCL Long Context: We evaluate 200 complete multi-turn conversations involving file systems, vehicle control, trading, and travel booking. These tasks examine how agents handle changing requests across turns and correctly reuse information from earlier interactions.
  • CRMArena-Pro: We evaluate an interactive exact-match subset of 136 tasks, covering 17 task types across B2B and B2C organizations. These tasks primarily examine business queries and task requirements that become progressively clearer during interaction.

Thus, the experiments cover three different task structures: cross-application execution, multi-turn function calling, and interactive business queries. We restrict our conclusions about the method’s effectiveness to these stateful tool-interaction scenarios.

W3. Trade-offs among tokens, latency, and implementation complexity

We have added a resource analysis that distinguishes total token usage, peak input length, and task completion time.

Tables 44–47 in Appendix F.1 separately report token usage for Actor inputs, Actor outputs, and the memory-management model, including failed trajectories. Table 48 in Appendix F.2 reports the maximum single Actor input under GLM-5.1. Relative to Full History, EvoState reduces this measure by 76.28%, 56.71%, 56.96%, and 73.66% on Normal, Challenge, BFCL, and CRM, respectively. This metric reflects the reduction in peak context occupancy.

Table 50 in Appendix F.4 reports the mean task completion time for the two DeepSeek models. In the reported results, EvoState is faster in the CRM evaluations with both models and the BFCL evaluation with Pro, and slower in the other five comparisons. Meanwhile, Table 3 shows that EvoState achieves both a higher mean success rate and lower total token usage per task than Full History in all eight model–evaluation combinations. Thus, the experiments support an improved success–token trade-off, while latency varies across configurations and incurs a cost in some cases.

AuthorsOpenReview ↗

Initial Response to Reviewer aF6P(Part 2/2)

Taking CRM as an example:

MethodFlash model success rateFlash model seconds/taskPro model success ratePro model seconds/task
Full History34.56%79.125.25%84.0
ObsMask30.15%80.827.45%85.6
HiAgent24.51%73.930.64%84.5
ACON-History34.80%87.742.40%82.9
EvoState37.01%76.447.30%72.7

In the CRM evaluation with DeepSeek-V4-Pro, EvoState achieves the highest mean success rate and the shortest mean task completion time among the five methods. With Flash, it achieves the highest mean success rate and takes less time than Full History, Observation Masking, and ACON-History. Compared with ACON-History, EvoState achieves both a higher mean success rate and a shorter mean task completion time in all eight model–setting combinations. In the other five comparisons, EvoState has higher latency than Full History, while maintaining a higher mean success rate and lower total token usage per task.

Compared with Full History, EvoState also requires additional logic for state maintenance, verification, and context assembly. This additional implementation effort, together with the measured token usage and latency, constitutes the practical trade-off of the method.

Q1. Performance decline on Challenge Hard

We further examined the results of three runs on the 195 Challenge Hard tasks, as shown in the table below. Table 21 in Appendix C.2 also provides detailed results for all nine methods on the three difficulty subsets of AppWorld Challenge.

MethodSuccess (%) ↑Tokens/success (M) ↓
Full History76.41 ± 1.030.3690 ± 0.0105
EvoState72.99 ± 1.290.3608 ± 0.0072
Observation Masking68.38 ± 2.070.3608 ± 0.0104
Rolling Summary51.62 ± 0.780.4727 ± 0.0109
HiAgent45.47 ± 3.920.5971 ± 0.0607
ACON-History32.31 ± 2.660.4815 ± 0.0442
Sliding Window31.28 ± 2.240.7670 ± 0.0575
Retrieval Memory9.40 ± 0.592.4480 ± 0.2078
StructMem3.25 ± 1.5714.8223 ± 9.0942

First, in terms of overall performance, although EvoState’s success rate of 72.99% is lower than Full History’s 76.41%, it is still the second highest among the nine methods compared. It exceeds Observation Masking’s 68.38% and HiAgent’s 45.47% by 4.61 and 27.52 percentage points, respectively.

Meanwhile, compared with Full History, EvoState reduces tokens per task by 6.61% and tokens per success by 2.24%. Thus, on the Hard subset, EvoState remains competitive in balancing a high task success rate with lower resource consumption, although it does not reach Full History’s highest success rate. Moreover, EvoState maintains a high success rate in the overall AppWorld Challenge evaluation, with a more detailed comparison provided in Table 1 of the main text.

To investigate the success-rate gap, we further examined execution trajectories on which the two methods produced different outcomes. The observed failures do not have a single cause; they include incomplete query coverage, execution errors, distorted summaries, and evidence that had been saved but was not included in the input for a critical action.

For example, in task f86d850_3, the actual payment amount of 104.0 had already been saved in both the raw observation and Event Memory, but was not presented in the input for the next critical action, and the Actor used the product’s listed price of 90.0 instead. This case shows that the problem is not necessarily an inability to recover the original evidence after compression; it can also arise during input selection after the information has been saved.

Such Hard tasks often impose demanding requirements on complete set coverage, exact field associations, and multiple dependent operations. The full details retained by Full History can sometimes provide additional information for cross-checking, whereas EvoState’s selective assembly may omit such information in some cases.

Therefore, the decline on Hard reflects a success–efficiency trade-off on some detail-sensitive tasks, rather than a general failure of EvoState on difficult tasks, and cannot be simply attributed to compression permanently deleting necessary information.

From OpenReview, CC BY 4.0. Authors as signed there; shown unedited.

Related papers

Loading the map…

Discussion (0)

Sign in to comment.