acceptodds
Withdrawn from ICLR 2027

From Memory to Action: Executable and Self-Evolving Contract Graphs for Tool Agents

Withdrawn from ICLR 2027, so left out of the paper lists and the map.

Abstract

Tool-using agents can improve future decisions by extracting reusable knowledge from past interactions and retrieving it when needed. Existing approaches often distill such interactions into textual experience that is retrieved as guidance for future tasks. However, this form of experience reuse leaves unclear how retrieved experience should be executed, composed with other experience, and updated from feedback. We introduce ContractFlow, a framework for transforming accumulated experience into executable, self-evolving knowledge. ContractFlow first compiles experience into executable contracts specifying goals, prerequisites, stable knowledge, runtime variables, tool actions, and completion criteria. It then organizes these contracts into a dependency graph that coordinates their execution according to the current task state. Within each episode, the graph guides observation gathering, binds variables to current evidence, and permits actions only when their prerequisites and execution conditions are satisfied, while tracking completion. Across episodes, successful executions, failures, and local repairs drive updates to contract nodes and relations, allowing subsequent tasks to reuse a refined execution structure. This process preserves reusable action rules across episodes, while keeping runtime-specific variables and completion states local to each episode, making the same graph both an execution structure and an object of continual improvement. Extensive evaluations across diverse tool-use benchmarks demonstrate that ContractFlow delivers consistent and substantial improvements over strong baselines. These results support a shift from treating experience as textual advice to representing it as executable knowledge that is organized, tested, and refined through action.

Primary area:
foundation or frontier models, including LLMs
Keywords:
Tool-Using Agents, Graph Memory, Self-Evolving Agents

Reviews

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

This paper proposes ContractFlow, a framework that converts agents’ past task-execution experiences into reusable executable contracts organized as a control graph. Each contract specifies prerequisites, runtime variables, tool actions, and completion criteria, while the graph coordinates dependencies and failure recovery. Execution feedback is used to update relevant contracts and graph relations for subsequent tasks. Experiments on APOLLO, CROSSEP-TOOL, and MemoryArena report improvements over existing experience-memory baselines.

Critical strengths

None

Critical weaknesses
  1. The paper lacks critical citations. For example, I had never heard of APOLLO or CROSSEP-TOOL, which the authors use, and could not find them through a search. The paper provides no corresponding citations either. The entire paper has only 15 references.
  2. The overall idea is very similar to prior work, such as AWM and GraphMind: abstracting experience into workflows and updating them after execution. The proposed method is essentially a complex workflow incorporating multiple mechanisms, but the contribution of each mechanism is unclear. I consider the overall novelty and contribution to be rather limited.
  3. The benchmarks used by the authors have obvious, major problems, making the experimental results unreliable. Shouldn’t they at least use benchmarks such as τ-bench, BFCL, and AutomationBench?
Questions for authors

None

Reviewer_prbjOpenReview ↗
Rating
1
Confidence
4
Informativeness
2
Presentation
1
Soundness
1
Read review
Paper summary

This paper addresses the experience–execution gap in experience-guided tool agents: agents may retrieve relevant experience yet still struggle to execute it reliably. It introduces ContractFlow, which compiles past interactions into executable Contracts specifying goals, prerequisites, runtime variables, tool actions, and completion criteria, and organizes them into an Executable Control Graph that explicitly represents dependencies, evidence flow, continuation, and recovery. Within an episode, the framework grounds variables in current evidence, authorizes actions, and verifies completion; across episodes, it updates the execution structure using successful runs, failures, and local repairs. The authors report improvements over strong baselines on three tool-use benchmarks, with particularly notable gains in state-dependent action selection. Overall, the work seeks to move agent experience beyond textual advice toward executable knowledge that is composable, verifiable, and capable of continual evolution.

Critical strengths

Transforming retrieved experience from past interactions into executable workflows is an interesting idea.

Critical weaknesses
  1. A reusable Executable Control Graph represented solely in text is not necessarily an effective solution. Given the recent success of coding agents, compiling past experience directly into code may offer a more practical, compact, and efficient alternative.
  2. The paper devotes considerable space to defining the reusable Executable Control Graph, yet provides little detail on how past experience is actually transformed into such a graph.
  3. Neither APOLLO nor CROSSEP-TOOL is a widely used benchmark, and the paper provides no citation for either. CROSSEP-TOOL can at least be traced to EvoMemBench, whereas I was unable to identify any source for APOLLO.
  4. The two sets of results in Table 1 have no row-wise correspondence and could therefore be presented as two separate tables. Combining them into a single table instead makes the results harder to follow.
  5. The paper also contains several AI-generated figures.
Questions for authors

Please check the section of critical weaknesses

Reviewer_1vgtOpenReview ↗
Rating
2
Confidence
2
Informativeness
2
Presentation
2
Soundness
2
Read review
Paper summary

The paper introduces ContractFlow, a framework that turns past agent interactions into reusable contracts with explicit prerequisites, variable bindings, tool actions, and completion conditions. A control graph coordinates these contracts during execution, while persistent updates incorporate outcomes and reusable repairs after each episode. The central idea is to separate reusable knowledge from the state that must be established for the current task. Experiments with Qwen3.5-9B cover APOLLO, CROSSEP-TOOL, and the group-travel setting of MemoryArena. The largest reported gain is on APOLLO. A comparison with a frozen graph on CROSSEP-TOOL provides more targeted evidence for the benefit of online updates.

Critical strengths
  • The distinction between reusable rules and current execution state addresses a real failure mode in memory-based agents. A past object identifier, availability observation, or completed action should not automatically remain valid in a new task. Equations 5 through 9 make evidence support, local validity, dependencies, and completion separate conditions. This gives the framework a clearer execution interpretation than simply appending a retrieved trajectory to the prompt.

  • The empirical results cover several forms of tool use. ContractFlow reaches 77.50% exact accuracy on APOLLO, compared with 39.32% for ReasoningBank. On MemoryArena, it improves both requested modifications and preservation of unrelated slots. Reporting Changed, Person, Preserve, and All-slot separately helps distinguish successful editing from merely retaining most of an existing plan.

Critical weaknesses
  • Sections 3.1 through 3.3 define Supports, Sat, Certify, and the update operator, but do not explain sufficiently how their decisions are implemented. It is unclear which checks are deterministic, which invoke an LLM, how a candidate contract is validated, and what evidence causes an edge or contract to be revised or retired. Appendix C provides a high-level execution loop, while Appendix E gives a MemoryArena schema and runtime instructions. These are useful, but they do not specify the compiler and update procedure across all three benchmarks. The distinction matters because the claimed prevention of unsupported actions depends on the reliability of those checks. An implementation artifact and an actual before-and-after graph update would make the contribution much easier to assess.

  • The 71.5% success rate corresponds to 143 successes out of 200 episodes, compared with 138 for ReasoningBank and 134 for the frozen graph. These are promising differences, but the paper does not report repeated streams or paired uncertainty. Episodes within a stream share evolving memory, so treating all 200 outcomes as independent samples would be inappropriate. The results should include paired wins and losses and variability across repeated executions of the same ordered streams. The paper should also separate the 180 episodes after bootstrap from the 20 bootstrap episodes included in the overall protocol. Figure 3 explicitly has no error bars, and the choice of its 144-group subset from the full 240 MemoryArena groups is not explained in enough detail.

Questions for authors

Plz see the weakness section

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

Related papers

Discussion (0)

Sign in to comment.