acceptodds
Under review as a conference paper at ICLR 2027

One Tree, Three Roles: Goal-Structured Extraction, Admission, and Reuse of Procedural Memory

42 views

Abstract

Large language model agents can improve by reusing procedures from past executions. However, long-horizon trajectories interleave multiple goals, failed attempts, and later corrections, making it difficult to identify coherent procedures and determine which execution evidence supports them. Reusable procedures also vary in scope, from local tool-use steps to multi-step workflows. We introduce GPM (Goal-structured Procedural Memory), a training-free framework for procedural memory that reconstructs the goal hierarchy reflected in a completed task trajectory. Higher-level goals are accomplished through lower-level subgoals, which may themselves be further decomposed. We reconstruct these relations from the finished ReAct trajectory to form a Goal Tree, while linking each goal to the actions and observations for it. The same tree is used across the memory pipeline: a goal or subtree defines the scope of a procedure, its linked execution records provide the evidence used to decide whether that procedure should be stored, and procedures can later be retrieved at different levels of granularity. Because the tree is reconstructed only after execution, the agent needs no hierarchical planner while acting. Experiments on AppWorld show that GPM improves Task Goal Completion by 3.8 and 7.4 percentage points across two executor backbones. A controlled admission study further shows that goal-scoped verification reduces invalid admission by 7.6 percentage points while largely preserving valid memories.

Primary area:
foundation or frontier models, including LLMs
Keywords:
LLM Agents, Agent Memory, Procedural Memory

Reviews

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

This paper proposes Goal-structured Procedural Memory, a procedural memory framework for LLM agents. The method reconstructs a goal tree from completed React trajectories and uses it for memory extraction, verification, and reuse at different granularities. Through goal scoped verification, GPM verifies memory cards against goal relevant execution evidence before storing them for reuse in future tasks. Experiments on AppWorld with two different LLM backbones show that GPM improves task completion rates by 3.8 and 7.4 pp, respectively. Ablation studies further demonstrate the effectiveness of goal scoped verification and multi-granularity memory design.

Critical strengths
  1. The unified goal tree design supports multi-granularity memory extraction and verification. The authors reconstruct a goal tree from completed ReAct trajectories and uses it for memory extraction, admission, and reuse. This design allows the agent to extract and reuse procedures at different granularities while using goal-related execution records to verify the extracted memories. The goal tree is constructed after execution, so the method does not require additional model training or hierarchical planning during runtime. This makes the framework relatively simple and practical.

  2. Goal-scoped verification improves memory reliability. The authors conduct a controlled ablation study to evaluate goal-scoped verification. By restricting the verification evidence from the full trajectory to the corresponding goal tree region, invalid admission decreases from 39.5% to 31.9%, while valid retention only slightly decreases from 92.9% to 91.7%. These results provide direct evidence that goal-scoped verification can reduce invalid memories without significantly affecting the retention of valid ones, which is important for maintaining reliable long-term procedural memory.

Critical weaknesses
  1. Lack of direct comparisons with existing procedural memory methods. The paper mainly compares GPM with ReAct and ReAct + TODO, without direct comparisons with existing procedural memory methods such as MetaFlowLLM and MemP. These methods also investigate hierarchical experience organization and multi-granularity memory reuse. Therefore, the current experiments do not sufficiently demonstrate the advantages of GPM over existing approaches.

  2. Lack of validation of goal tree reconstruction reliability. Memory extraction, admission, and reuse in GPM all depend on the reconstructed goal tree. Errors in the goal hierarchy or the assignment of action-observation records may directly affect memory quality and downstream task performance. The paper does not directly evaluate the accuracy of goal tree reconstruction or analyze how reconstruction errors affect memory admission and task success rates.

Questions for authors
  1. Given the similarities with existing procedural memory methods discussed above, could the authors provide direct comparisons with existing procedural memory methods such as MetaFlowLLM and MemP to better demonstrate the advantages of GPM?

  2. The reliability of goal tree reconstruction remains a concern. Could the authors evaluate the accuracy of goal tree reconstruction and analyze how reconstruction errors affect memory admission and downstream task performance?

2 comments

The response from author addressed my concern. I will keep my score unchanged.

Thank you for your thoughtful review and for taking the time to follow up. We're glad to hear that the revised manuscript addressed the concerns you raised. Your suggestions on the baseline comparisons and the evaluation of Goal Tree reconstruction helped us strengthen the paper. We appreciate the care you took in reviewing our work and the opportunity to improve it.

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

GPM (Goal-structured Procedural Memory) is a training-free procedural-memory framework for LLM agents. Its central idea — "one tree, three roles" — is to reconstruct a Goal Tree post-hoc from a completed ReAct trajectory and reuse that single structure for three jobs: (1) defining the extraction unit (a leaf goal gives a "local source," an internal node plus its subtree gives a "composite source"); (2) bounding the execution evidence used to verify/admit a candidate procedure (verification is restricted to the records in the candidate's goal-tree region); and (3) supporting retrieval/reuse at variable granularity. Because the tree is built only after execution, no hierarchical planner is needed at act time. Memory Cards come in positive/correction/guard types plus a separate Function Memory for call-level repairs, and admission runs deterministic structural checks followed by an LLM Verifier scoped to the source records. Evaluation is on AppWorld: a frozen memory bank built from 90 training tasks (with MiMo-V2.5) is evaluated on the 168-task test-normal split with two executor backbones, improving Task Goal Completion by 3.8 pp (MiMo-V2.5, 81.7→85.5) and 7.4 pp (Qwen3.7-Flash, 73.6→81.0) over the strongest non-GPM configuration, averaged over three runs. A controlled admission study on 156 adjudicated candidate cards shows goal-tree-scoped verification cuts Invalid Admission from 39.5% to 31.9% (−7.6 pp) while Valid Retention drops only 92.9%→91.7%, and a granularity ablation shows keeping both Local and Composite cards beats either alone by ~8 pp.

Critical strengths
  1. The "one structure, three roles" design is genuinely elegant and the evidence-scoping idea is a real contribution. Most procedural-memory work treats extraction, verification, and retrieval as separate machinery; tying all three to the same reconstructed goal hierarchy is a clean unifying move, and the specific insight that verification evidence should be scoped to the candidate's goal region is both novel and well-motivated — using the whole trajectory as evidence lets irrelevant records masquerade as support. The admission study isolates exactly this, and the error analysis (Table 4) gives it mechanism: temporal leakage errors drop from 12 to 2 under goal-tree scoping, which is precisely the failure mode the design targets. A controlled experiment whose error-type breakdown matches the proposed mechanism is more convincing than an aggregate number alone, and this is the paper's strongest evidence.

  2. Evaluation hygiene is better than typical for this subfield. Results are averaged over three runs, the memory bank is frozen before evaluation with evaluation trajectories never written back, the admission study uses a manually adjudicated ground-truth set, and the ReAct+TODO control correctly isolates the lightweight execution-state mechanism from the memory pipeline so the reported gain isn't attributable to the TODO scaffold. These are the right controls, and the two-backbone design shows the downstream effect isn't specific to one executor.

Critical weaknesses
  1. The main experiment has no procedural-memory baseline — the "strongest non-GPM baseline" is just the memoryless executor. The related-work section carefully positions GPM against roughly ten existing systems (ExpeL, AWM, ReasoningBank, MemP, ReMe, Skill-Pro, SkillX, MACLA, HMT, MetaFlowLLM), and then Table 1 compares against none of them — only ReAct and ReAct+TODO, both of which are GPM's own ablated selves. So the headline claim reduces to "adding our memory beats having no memory," which no reader doubts. The paper's actual thesis is that goal-tree structuring is better than flatter alternatives, and that is exactly what is not tested: there is no flat-memory, workflow-induction, or insight-distillation baseline built from the same 90 trajectories and evaluated under the same budget. Without at least one or two such comparisons, I cannot tell whether the +3.8/+7.4 pp comes from the goal-tree idea or simply from having any reasonable procedural memory. This is the single reason the soundness score is a 2 and the rating is what it is: the central contribution is plausible but unsubstantiated against the field the paper situates itself in.

  2. Cost is entirely unreported, which undercuts the framework's implicit value proposition and leaves the gains unpriced. This whole research area exists because reflective memory incurs heavy context overhead; competing papers report tokens/turns precisely because a memory method is only useful if its benefit beats its cost. GPM's pipeline is unusually heavy at construction time — LLM-based goal-tree reconstruction, abstraction, structural checks, and an LLM Verifier per candidate, times 90 trajectories — and at inference time adds retrieval, two rerankers, and injected cards, yet the paper reports no token counts, no turn counts, no construction cost, and no latency anywhere. Combined with the first weakness, this means a reader cannot place GPM on the effectiveness–cost frontier at all: a +3.8 pp gain that doubles token spend is a very different result from one that is free, and the paper gives no way to tell which it is. Secondary to this: admission remains at 31.9% Invalid Admission even after goal-scoping (and "No verification" at 42.9% vs full-trajectory 39.5% shows semantic verification on the full trajectory barely helps) — so a third of admitted memories are still unsupported, which the paper should foreground rather than leave to the table.

Questions for authors
  1. Can you add at least one or two procedural-memory baselines (e.g., AWM, ReasoningBank, or an insight-distillation method) built from the same 90 training trajectories and evaluated under the same budget on AppWorld? Without this, how do you distinguish the contribution of goal-tree structuring from that of having any procedural memory? (Clarification — this is the decisive question for the main claim.)

  2. What is the token/turn cost of GPM at construction and at inference, relative to ReAct+TODO and to any memory baseline? A gain of +3.8 pp needs to be priced to be interpretable. (Clarification.)

  3. Main results are averaged over three runs but no variance is reported. What are the std/CIs, and is the +3.8 pp MiMo gain outside run-to-run noise? (Clarification.)

  4. The Goal Tree is itself reconstructed by an LLM and can hallucinate structure. Do you have any evaluation of reconstruction quality (e.g., against human-annotated goal hierarchies on a subset), and how sensitive are downstream gains to reconstruction errors? (Clarification — the whole pipeline rests on tree quality.)

  5. 31.9% Invalid Admission remains after goal-scoping. What are these residual unsupported admissions (the "unsupported generalization" row stays at 18), and do they measurably harm downstream execution? (Clarification.)

  6. The admission study, granularity ablation, and memory bank all use MiMo-V2.5 for construction. How much does construction-model choice affect the results — would a different constructor change the admission or granularity conclusions?

3 comments
AuthorsOpenReview ↗

Response to Reviewer mQkD (1/3)

Dear Reviewer mQkD,

We sincerely thank you for your careful and thoughtful review. We greatly appreciate the time and effort you have devoted to our paper and your constructive suggestions for strengthening the evaluation. Your comments have been very helpful in guiding our revisions. We respond to each point below.

Xiaomi retired MiMo-V2.5 from its official API on October 21, 2026 Xiaomi model retirement notice. To evaluate GPM and the additional baselines with currently available models, and to examine performance across different backbones, we conducted the revised main evaluation with GPT-5.6 Luna and Qwen3.6-Flash. The results below use these updated configurations.

W1/Q1/Q3. Comparison with procedural memory baselines and variability across evaluation runs

We appreciate your recommendation to strengthen the comparison with existing procedural memory methods. In response, we adapted AWM, ReasoningBank, and MemP to AppWorld and added their results to the main evaluation (Section 4.2, Table 1). Each memory baseline builds its bank on the same 90 training tasks and keeps it frozen during evaluation on all 168 test_normal tasks.

To address your question about variability, we now report mean ± sample standard deviation over three runs for every method and backbone. Task Goal Completion (TGC) and Scenario Goal Completion (SGC) are expressed as percentages.

MethodGPT-5.6 Luna TGCGPT-5.6 Luna SGCQwen3.6-Flash TGCQwen3.6-Flash SGC
ReAct71.4 ± 2.655.4 ± 3.162.9 ± 1.241.7 ± 2.7
ReAct+TODO72.0 ± 2.155.4 ± 3.162.5 ± 1.042.3 ± 2.1
AWM78.6 ± 1.269.0 ± 2.167.1 ± 0.744.6 ± 3.1
ReasoningBank77.6 ± 1.864.3 ± 3.666.5 ± 1.245.2 ± 2.7
MemP77.0 ± 1.565.5 ± 2.164.5 ± 0.345.2 ± 2.7
GPM81.2 ± 1.471.4 ± 1.870.0 ± 0.949.4 ± 2.1

GPM achieves the highest mean TGC and SGC on both backbones. With GPT-5.6 Luna, GPM improves TGC by 9.8 percentage points and SGC by 16.0 points over ReAct. Relative to the strongest memory baseline for each metric, the gains are 2.6 TGC and 2.4 SGC points with Luna, and 2.9 TGC and 4.2 SGC points with Qwen3.6-Flash. These comparisons show that GPM improves execution even when the alternatives also have procedural memory.

AuthorsOpenReview ↗

Response to Reviewer mQkD (2/3)

W2/Q2. Memory construction and inference costs

Thank you for emphasizing the importance of assessing performance gains alongside computational cost.

Inference cost. Appendix A.3 (Table 7) reports input and output token usage alongside cache hit rates on the 168 AppWorld test tasks with GPT-5.6 Luna. Token counts are means per task.

MethodTGC (%)Input tokens (K)Output tokens (K)Total tokens (K)Cache hit (%)
ReAct71.41350.8813688.6
ReAct+TODO72.02221.2223.292.6
GPM81.24241.4425.489.2

GPM uses approximately 3.1 times the total tokens of memoryless ReAct and improves TGC by 9.8 percentage points. Almost all the additional tokens are input. Relative to ReAct+TODO, the total increases by 90.6%, with input accounting for 202.0K of the 202.2K increase. Although GPM substantially increases token usage, its high cache hit rate means that most input tokens are billed at the much lower cached-input rate, keeping the additional monetary cost manageable.

Construction cost. We have identified inefficiencies in the Abstractor’s context management and the retry mechanism between the Abstractor and Verifier. These implementation issues cause unusually high token consumption in both modules during memory construction. We are addressing these implementation inefficiencies and expect to share the construction-cost results very soon.

Q4. Goal Tree quality and sensitivity to reconstruction errors

We appreciate your suggestion to examine both the quality of the reconstructed trees and its implications for downstream execution.

Reconstruction quality. We added an evaluation of the 90 trees used to construct the GPT-5.6 Luna memory bank (Appendix A.1, Table 4). We manually annotated five examples to illustrate the scoring rubric and included them in the judge prompt as few-shot demonstrations. Given the task instruction, execution trace, and recovered tree, GPT-6.1-Sol with extra-high reasoning effort scores each tree twice on four dimensions, each ranging from 1 to 5.

DimensionMean score out of 5Exact agreement across runs
Validity4.70694.4%
Coverage4.02297.8%
Attribution4.30091.1%
Hierarchy3.46788.9%

The overall mean is 4.124/5. Validity and Attribution indicate that the recovered goals are generally supported by execution and that actions are assigned to the appropriate goals. Hierarchy is the weakest dimension, with manual spot checks identifying coarse decomposition and redundant intermediate nodes. Across all four dimensions, the two ratings for every tree differ by at most one point.

Sensitivity to reconstruction errors. The way GPM uses the tree suggests different consequences for errors in each dimension.

  • Validity. A fabricated goal could lead to misleading memory if it survives extraction and verification. Minor imprecision in a goal description is likely to have a smaller effect.
  • Coverage. Omitting a secondary goal mainly reduces the reusable experience available. Omitting a key decision, prerequisite, or verification goal could have a larger effect on later execution.
  • Attribution. Incorrect action ownership directly changes the evidence available to the verifier. It can lead to unsupported cards being admitted or useful experience being rejected.
  • Hierarchy. Redundant intermediate nodes and small differences in granularity are expected to have relatively limited effects. Incorrect parent–child relations can have a larger impact when they change the subtree evidence associated with a procedure.

The hierarchy issues found in our spot checks were primarily redundancy and coarse granularity. We therefore expect their direct impact to be smaller than errors that change goal meaning or action ownership.

AuthorsOpenReview ↗

Response to Reviewer mQkD (3/3)

W2/Q5. Residual admission errors and their downstream effects

We appreciate your question about the remaining admission errors and their implications for execution. Goal scoping reduces Invalid Admission from 39.5% to 31.9%, while Valid Retention changes from 92.9% to 91.7%. The error analysis in Appendix A.2 helps explain both the improvement and the remaining failures. Temporal leakage falls from 12 cases to 2, while unsupported generalization remains the largest residual category, accounting for 18 of the 36 invalid admissions.

We added a breakdown of these 18 cases in Table 6.

Failure modeCountShare (%)
Parameter-role mismatch844.4
Incomplete parameterization422.2
Unverified target-set eligibility316.7
Overgeneralized explanations316.7
Total18100.0

Parameter-role mismatch changes the roles of entities when concrete values are replaced by parameters. Incomplete parameterization leaves task-specific details insufficiently abstracted in a reusable procedure. The other two categories extend a procedure to targets whose eligibility was unverified, or turn a local observation into a general explanatory claim. These semantic errors can survive verification even when the evidence belongs to the correct goal.

Such errors can mislead the executor about which operations or conditions apply and can harm task completion. They are a current limitation of GPM, as discussed in Section 5. We will continue improving admission, particularly the verification of parameter roles, applicability conditions, and claims made during abstraction.

Q6. Influence of the memory construction model

We appreciate your question about how the memory construction model affects the results. In the revised main evaluation, GPT-5.6 Luna and Qwen3.6-Flash each use a separate memory bank constructed by the corresponding model, using 90 official training tasks. Each bank is frozen before evaluation.

GPM improves TGC over ReAct by 9.8 points with Luna and 7.1 points with Qwen3.6-Flash, and also outperforms the procedural memory baselines with both models. These results show that GPM can construct and reuse effective memory with either model. The admission and granularity studies retain the original MiMo-V2.5 configuration. The admission and reuse mechanisms operate on goal regions, supporting evidence, and card structure. We expect their benefits to carry over to other construction models with comparable capabilities. We agree that repeating the independent admission study and granularity ablation with alternative memory banks would provide a more direct assessment, and we plan to add these controlled results as soon as possible.

Thank you again for your thoughtful review and the time you have devoted to our work. We hope these additions and clarifications address your concerns, and we would be happy to answer any further questions.

Best regards

All Authors

Reviewer_uBprOpenReview ↗
Rating
3(+1)
Confidence
2
Informativeness
2
Presentation
3
Soundness
2
Read review
Paper summary

This paper proposes GPM, a training-free procedural memory framework that reconstructs Goal Trees from agent trajectories to support memory extraction, verification, and reuse. Experiments on AppWorld demonstrate improvements in task completion and memory admission quality.

Critical strengths
  1. The paper identifies an important challenge in procedural memory: how to extract reusable procedures from complex execution trajectories while ensuring that the extracted memories are supported by relevant execution evidence.
  2. The proposed Goal Tree framework and its associated memory verification mechanism are well-motivated and reasonably designed.
  3. The paper is clearly written and well-organized, making the overall framework easy to follow.
Critical weaknesses
  1. The paper lacks comparisons with closely related approaches, such as MetaFlowLLM and HMT, which are discussed in the related work section. These comparisons would help establish the advantages of GPM over existing hierarchical memory methods.
  2. The Goal Tree is central to GPM, yet its contribution and reconstruction quality are not directly evaluated. The current comparison with memoryless baselines cannot establish whether the improvements stem from the hierarchical structure itself. I suggest to compare Goal Tree against flat trajectories and linear segmentation under the same memory pipeline and budgets.
Questions for authors
  1. Could the authors provide concrete examples showing how the Goal Tree helps the agent successfully complete tasks that it would otherwise fail?
  2. Could the authors report statistics on memory reuse, such as Retrieval Rate, Memory Utilization, Reuse Frequency, and Reuse Success Rate?
  3. What is the additional token overhead introduced by GPM compared to directly executing tasks without memory?
  4. What are the main limitations of the proposed framework? A more detailed discussion of its limitations would be helpful.
2 comments
AuthorsOpenReview ↗

Response to Reviewer uBpr (1/2)

Dear Reviewer uBpr,

We sincerely thank you for the time and care you have put into reviewing our paper. We appreciate your constructive comments and helpful suggestions, which have guided our revisions. Below, we respond to each point in turn.

W1. Comparison with procedural memory baselines

We appreciate your helpful suggestion to strengthen the comparisons with related memory methods. We regard MetaFlowLLM and HMT as valuable contributions to hierarchical memory and have drawn inspiration from both. We would have liked to include direct comparisons with these methods. However, reproducing MetaFlowLLM requires training its workflow generator, which is challenging within our available compute budget. For HMT, we could not locate an official implementation, and reproducing and adapting it to AppWorld would require more implementation time than this revision allows. To broaden the empirical comparison within these constraints, we adapted AWM, ReasoningBank, and MemP to AppWorld. These baselines allow us to compare GPM with three established approaches to extracting and reusing experience.

The results are included in the revised main evaluation (Section 4.2, Table 1). Each memory baseline builds its bank on 90 training tasks and keeps it frozen during evaluation on the 168 test_normal tasks. The table below reports Task Goal Completion (TGC) and Scenario Goal Completion (SGC) as percentages, with mean ± standard deviation over three runs.

MethodGPT-5.6 Luna TGCGPT-5.6 Luna SGCQwen3.6-Flash TGCQwen3.6-Flash SGC
ReAct71.4 ± 2.655.4 ± 3.162.9 ± 1.241.7 ± 2.7
ReAct+TODO72.0 ± 2.155.4 ± 3.162.5 ± 1.042.3 ± 2.1
AWM78.6 ± 1.269.0 ± 2.167.1 ± 0.744.6 ± 3.1
ReasoningBank77.6 ± 1.864.3 ± 3.666.5 ± 1.245.2 ± 2.7
MemP77.0 ± 1.565.5 ± 2.164.5 ± 0.345.2 ± 2.7
GPM81.2 ± 1.471.4 ± 1.870.0 ± 0.949.4 ± 2.1

GPM outperforms all three memory baselines on both metrics with both backbones. With GPT-5.6 Luna, GPM improves TGC by 9.8 percentage points and SGC by 16.0 points over ReAct. Relative to the strongest memory baseline for each metric, the gains are 2.6 TGC and 2.4 SGC points with Luna, and 2.9 TGC and 4.2 SGC points with Qwen3.6-Flash.

W2. Goal Tree quality and contribution

Thank you for your suggestion to examine both the reconstruction quality and the contribution of the Goal Tree. We have added a reconstruction-quality assessment and provide the relevant controlled results below.

Reconstruction quality. Appendix A.1 (Table 4) evaluates the 90 trees used to construct the GPT-5.6 Luna memory bank. The judge, GPT-6.1-Sol with extra-high reasoning effort, receives the task instruction, execution trace, and recovered tree. It scores each tree twice on four dimensions, with scores ranging from 1 to 5.

DimensionMean score out of 5Exact agreement across runs
Validity4.70694.4%
Coverage4.02297.8%
Attribution4.30091.1%
Hierarchy3.46788.9%

The overall mean is 4.124/5. The high Validity and Attribution scores indicate that the trees generally capture goals supported by execution and assign actions to the appropriate goals. The main weakness is Hierarchy, where manual spot checks found coarse decomposition and redundant intermediate nodes. Across all four dimensions, the two ratings for every tree differ by at most one point.

Contribution of the Goal Tree. Regarding the suggested comparison under the same pipeline and budgets, GPM’s stages are designed around the Goal Tree and the resulting Memory Cards. Extraction uses nodes and subtrees as procedure sources, verification uses their assigned actions as evidence, and the retrieval and executor prompts interpret the resulting Memory Cards. A flat or linearly segmented variant would therefore require defining its procedure units and evidence scopes and adapting the downstream prompts accordingly. The measured difference would depend on those adaptations as well as the representation.

With the same 156 candidates and verifier, goal-scoped evidence reduces invalid admission from 39.5% to 31.9%, while valid retention changes from 92.9% to 91.7% (Table 2). On 57 development tasks, access to both card types yields 81.9% TGC versus 73.7% for local-only and 74.3% for composite-only, with the memory bank, retrieval pipeline, and budgets fixed (Table 3). These experiments show the benefits of goal-scoped evidence and access to procedures at both granularities.

AuthorsOpenReview ↗

Response to Reviewer uBpr (2/2)

Q1. Concrete examples of reuse

Thank you for this helpful suggestion. Appendix A.4 now presents two case studies comparing execution with and without memory (Figures 2 and 3), alongside the cards provided to the executor. Appendix A.4.1 presents the key fields of these cards.

In the Spotify example (Figure 2), the memoryless run uses the liked lists as its source and produces an incorrect playlist. With GPM, the retrieved cards guide the executor to enumerate all three libraries, expand albums and playlists into songs, and deduplicate the resulting IDs. It then identifies the 11 liked songs and successfully completes the task.

A Memory Card carries information from the Goal Tree at both planning and execution levels. Its goal_pattern comes from the corresponding node, and its subgoal_pattern (represented in method.steps.items) comes from the child nodes. Its action_pattern (stored in method.steps.action_pattern) abstracts the actions associated with the node. The goal and subgoal patterns guide what the executor plans to accomplish, and the action pattern guides how to carry it out. The executor can flexibly select and adapt relevant parts of the retrieved guidance based on the current task state.

Q2. Aggregate reuse statistics

We appreciate your suggestion to report aggregate reuse statistics. For systems like GPM that inject retrieved memory as contextual guidance, it is difficult to reliably measure how often the executor uses that guidance and how successful reuse is. For example, even when an action matches a card’s recommendation, the executor may have reached the same decision independently based on the task instructions or earlier observations. A reliable evaluation may require substantial manual analysis or a dedicated method for trajectory-level attribution MemUse. We are exploring how to adapt this type of analysis to GPM and hope to have preliminary results soon.

Q3. Token overhead

We appreciate your suggestion to examine the computational overhead of GPM. Appendix A.3 (Table 7) reports input and output token usage alongside cache hit rates on the 168 AppWorld test tasks with GPT-5.6 Luna. Token counts are means per task.

MethodTGC (%)Input tokens (K)Output tokens (K)Total tokens (K)Cache hit (%)
ReAct71.41350.8813688.6
ReAct+TODO72.02221.2223.292.6
GPM81.24241.4425.489.2

GPM uses approximately 3.1 times the total tokens of memoryless ReAct and improves TGC by 9.8 percentage points. Almost all the additional tokens are input. Relative to ReAct+TODO, the total increases by 90.6%, with input accounting for 202.0K of the 202.2K increase. Although GPM substantially increases token usage, its high cache hit rate means that most input tokens are billed at the much lower cached-input rate, keeping the additional monetary cost manageable.

Q4. Limitations

We appreciate your suggestion to discuss the framework’s limitations more fully. Section 5 identifies two areas for improvement. First, the goal-scoped verifier can still accept unsupported generalizations when the cited records belong to the correct goal. Improving the reliability of semantic verification remains an important direction. Second, constructing the memory bank requires model calls for tree reconstruction, procedure extraction, and candidate verification. Reusing computations across overlapping subtrees and batching candidate checks could reduce this cost while preserving each candidate’s evidence scope.

Thank you again for your thoughtful review and the time you have devoted to our work. We hope these revisions and clarifications address your concerns, and we would be happy to answer any further questions.

Best regards

All Authors

Comments on the paper

1 comment
AuthorsOpenReview ↗

Summary of Rebuttal and Revisions for the Area Chair

Dear Area Chair,

We sincerely thank you and the reviewers for your time and careful consideration. We summarize GPM’s core strengths and the evidence added during the discussion.

Core strengths of GPM

GPM uses a Goal Tree reconstructed from completed ReAct trajectories to connect procedure extraction, evidence-scoped admission, and variable-granularity reuse, without model training or hierarchical planning during execution. The core strengths of GPM are as follows.

  1. One structure connects extraction, admission, and reuse. The same goal region defines both the procedure to be extracted and the evidence supporting its admission (Section 3).

  2. Training-free, post-hoc Goal Tree reconstruction. GPM recovers goals, action ownership, and parent–child relations from completed ReAct traces. This makes goal-structured memory available without requiring hierarchical planning during execution or additional model training. The tree-quality evaluation provides evidence that the recovered goals and action assignments are grounded in execution (Section 3.2; Appendix A.1, Table 4).

  3. Controlled evidence supports better memory admission. In the original controlled study, we held the 156 candidates and verifier fixed and restricted the evidence to the relevant goal region. Invalid Admission fell from 39.5% to 31.9%, while Valid Retention changed from 92.9% to 91.7%. Temporal leakage errors fell from 12 cases to 2, consistent with the method’s aim of preventing unrelated execution records from being mistaken for support (Section 4.3, Table 2; Appendix A.2, Table 5).

We appreciate the reviewers’ recognition of GPM’s contributions, especially Reviewer mQkD’s acknowledgment of the unified design, the evidence-scoping insight, and the supporting controlled experiments.

Evidence added during the discussion

Since Xiaomi discontinued MiMo-V2.5 on its official API about a month ago, we reran the main evaluation with GPT-5.6 Luna and Qwen3.6-Flash. We evaluated all methods in the revised Table 1 with these backbones. Each GPM executor uses a separate memory bank constructed by the corresponding model. The controlled admission and granularity studies retain the original MiMo-V2.5 configuration. Xiaomi’s official model retirement notice

  • Stronger baselines and reported variability. We added AWM, ReasoningBank, and MemP (Appendix B.5) and report mean ± sample standard deviation over three runs, including the newly added SGC results. GPM achieves 81.2 ± 1.4% TGC and 71.4 ± 1.8% SGC with Luna, and 70.0 ± 0.9% TGC and 49.4 ± 2.1% SGC with Qwen3.6-Flash. Over the strongest memory baselines, TGC gains are 2.6 and 2.9 points, and SGC gains are 2.4 and 4.2 points, respectively. TGC gains over memoryless ReAct are 9.8 and 7.1 points (Section 4.2, Table 1).

  • Tree quality and concrete reuse. We evaluated 90 reconstructed trees using GPT-6.1-Sol, with two judgments per tree and five manually annotated few-shot examples. The overall mean is 4.124/5, with Validity at 4.706 and Attribution at 4.300 (Appendix A.1, Table 4). Our response to mQkD Q4 discusses how reconstruction errors may affect admission and reuse. New Spotify and Venmo case studies show how retrieved procedures guide execution and are adapted to the current state (Appendix A.4, Figures 2–3).

  • Measured inference overhead and caching. We added token usage and cache hit measurements. With Luna, GPM uses 90.6% more tokens than ReAct+TODO, with input accounting for 202.0K of the 202.2K increase. With a cache hit rate of 89.2%, most of GPM’s input tokens are billed at the discounted cached-input rate, reducing the cost of the additional input (Appendix A.3, Table 7).

  • A more precise account of residual errors. We expanded the analysis of unsupported generalization, which accounts for 18 of the 36 remaining invalid admissions. The new breakdown identifies parameter-role mismatch as the largest category (8 of 18), followed by incomplete parameterization, unverified target-set eligibility, and overgeneralized explanations. These findings clarify the semantic abstraction errors that can persist even when the evidence belongs to the correct goal (Appendix A.2, Table 6).

At the time of this summary, we have not received follow-up comments from Reviewers uBpr and mQkD.

Residual admission errors and construction efficiency remain limitations (Section 5). We have not yet quantified memory-construction cost or isolated the effect of the construction model. We respectfully ask that the clarified contributions and expanded empirical evidence be considered in the final assessment.

Best regards

All Authors

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

Related papers

Loading the map…

Discussion (0)

Sign in to comment.