acceptodds
Under review as a conference paper at ICLR 2027

EvoRAM: A Self-Evolving Embodied Agent through Executable Memory Accumulation

Abstract

Embodied agents are increasingly capable of solving complex robotic tasks through powerful foundation models and diverse tools, yet they often approach new problems from scratch, with successful exploration providing limited benefit to future interactions. We argue that a self-evolving embodied agent should instead continuously transform successful exploration into persistent experience and leverage accumulated experience to facilitate subsequent exploration. To this end, we introduce EvoRAM (Evolving Robotic Agent with Memory), a self-evolving embodied agent built around executable memory accumulation. EvoRAM combines a VLA loop for flexible and reactive interaction with a code loop for deliberate exploration and reproducible execution. Successful solutions discovered through exploration are physically verified and consolidated into structured executable memory, which can be directly reused, adapted, and further refined when solving subsequent problems. The two loops further complement each other: diverse VLA behaviors broaden code-based exploration, while verified code provides reliable recovery from VLA failures. Experiments in simulation and on a real-world dual-arm robot demonstrate this self-evolution process. On LIBERO, EvoRAM progressively acquires, reuses, and refines executable experience, which in turn enhances subsequent exploration, ultimately enabling it to solve 121/130 (93.1%) tasks. Real-world experiments further demonstrate that such executable experience can generalize to novel but related objects, while Code–VLA collaboration broadens the exploration space and accelerates the accumulation of executable memory. Remarkably, after acquiring the relevant memory, EvoRAM can autonomously calibrate its camera intrinsics and camera–robot extrinsics, enabling sustained exploration in the physical world despite calibration degradation. These results demonstrate a self-evolution loop in which exploration continuously expands executable memory, while accumulated memory in turn strengthens subsequent exploration.

Primary area:
applications to robotics, autonomy, planning
Keywords:
Embodied Agents, Self-Evolution, Executable Memory, Robotic Manipulation

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_sTVKOpenReview ↗
Rating
2
Confidence
2
Informativeness
2
Presentation
3
Soundness
2
Read review
Paper summary

EvoRAM combines a vision-language-action (VLA) policy with an agent that writes robot control code. Successful solutions are saved as object memory (a description, a CAD model, and code), task memory (verified code), and planning memory (mainly natural-language corrections). The agent can reuse or revise this memory when solving later tasks. Using the code loop alone, it eventually solves 121 of 130 LIBERO tasks through repeated exploration. Real robot tests show bottle opening, code-based recovery from VLA failures, and camera recalibration using memory acquired during an earlier guided run.

Critical strengths
  1. The paper gives concrete examples of what the agent learns and reuses. The appendices explain how object-level code, complete task programs, and planning corrections change during exploration. These examples make the memory design easier to assess than a general claim that the agent “learns from experience.”

  2. The physical demonstrations show useful ways for code and VLA control to help each other. Code-based recovery completes two-layer cube stacking in 16 of 20 trials. VLA exploration also helps the code agent find a tissue-pack grasp, which then works in 8 of 10 tested orientations. These results provide useful evidence that the two forms of control have different strengths.

Critical weaknesses
  1. The experiments do not separate the benefit of memory from the benefit of further attempts. On LIBERO, the agent revisits unresolved tasks while its code and memory grow. However, there is no comparison with the same agent given the same exploration budget but without memory shared across tasks. For LIBERO, the total number of attempts, runtime, and model usage are also not reported, and the paper never gives the value of the exploration budget in Algorithm 1. The 93.1% result shows that the system can acquire solutions during exploration. It does not, by itself, show how much memory speeds up learning or how reliably the final programs work when run again. The agent judged all 130 tasks solved, but 9 had actually failed, and tasks marked as solved are not revisited (Appendix F3). This makes re-running the final programs especially important. A comparison with a simpler task-code cache would also help establish the value of the proposed memory structure. This matters because prior work such as ASPIRE already builds and reuses executable skills. The paper discusses ASPIRE and argues in Appendix A1 that its memory is organized around task-level skills, but this distinction is not tested experimentally.

  2. The real-world evidence is too limited to support some of the broader claims. The bottle experiment compares about two hours of exploration on a detergent bottle with 40 minutes on a different bottle using memory. Without testing that second bottle from scratch, the time difference cannot be attributed to memory alone.

Questions for authors
  1. What exploration budget (B in Algorithm 1) and total resource use did the LIBERO run have? How does performance compare with memory disabled under the same budget?

  2. After freezing the final memory, how reliably can the agent repeat the tasks from new starting states, as judged by the benchmark rather than the agent itself? Do later memory changes preserve earlier skills?

  3. Can you test the same new bottle with and without prior memory, using repeated runs and the same exploration limits?

7 comments
AuthorsOpenReview ↗

Response to Reviewer sTVK

Thank you for your insightful comments and helpful suggestions. We provide detailed responses to your questions below.

W1

(1) Lack of Quantitative Memory Ablations

We thank the reviewer for this valuable suggestion. To further evaluate the effectiveness and generalization of our executable memory, we conducted additional experiments on RoboDojo using memory accumulated from LIBERO and previous real-world robotic experiments.

Due to the limited time available during the rebuttal period, we evaluated the first 10 RoboDojo tasks, with 5 trials per task, using GPT-6.1 Sol with High reasoning effort. We compared EvoRAM with and without memory under the same model and experimental settings, and additionally included the reported results of other RoboDojo agents for reference. The results are presented below.

methodavg. acc/scorealign blocksarrange numbersarrange numbers (random)build towerclassify objectsclassify by languagecover blocksdeposit coinfasten screwsfill egg holder
Q0-Preview74.40/78.2492/9288/89.492/93.472/7794/96.486/88.8100/10042/50.478/86.80/8.2
GO-3 Nano Preview69.20/73.3788/8876/82.648/53100/10072/79.766/74.6100/10048/5494/96.40/5.4
PyRUA-Lean63.00/69.6976/7680/83.868/76.44/23.296/97.192/94.6100/10040/4468/80.66/21.2
SenseNova-RoboRSI52.20/62.6388/8880/86.892/95.268/71.870/8236/55.448/52.432/44.84/27.64/22.3
WorldScape-R²SI51.80/60.7196/9672/77.452/64.636/51.690/91.958/66.898/98.60/7.614/35.42/17.2
EvoRAM (w/ Memory)46.00/50.5060/6020/3320/270/060/6380/8080/86100/10020/3620/20
HexaShell-Preview43.60/51.6178/7812/17.832/42.630/4878/85.372/79.4100/10016/26.418/29.80/8.8
JoyAI-VL43.60/51.6178/7812/17.832/42.630/4878/85.372/79.4100/10016/26.418/29.80/8.8
EmbodiedEvo36.20/49.0798/9836/52.628/440/916/35.540/5884/84.622/37.638/55.60/15.8
PhysicalRSI33.93/40.8086/861.33/3.8721.33/32.4728.67/37.1340/55.836/20.93100/10056/62.270/7.60/1.9
GPT-6-Astra32.20/42.6050/5068/7652/61.42/16.456/6930/4646/49.32/16.416/36.40/5.5
EvoRAM (w/o Memory)26.00/30.1060/600/80/10/040/4040/64100/10020/280/00/0
GPT-5.50.00/0.230/00/00/00/00/0.30/0.20/00/1.60/00/0.2

As shown in the table, EvoRAM with memory achieves 46.00% average accuracy and a score of 50.50, outperforming several reported RoboDojo agents, including EmbodiedEvo, PhysicalRSI, and GPT-6-Astra. In contrast, disabling memory reduces performance to 26.00% accuracy and a score of 30.10, representing improvements of 20.00 percentage points in accuracy and 20.40 points in score, demonstrating the effectiveness of accumulated executable experience.

More importantly, all memory used in this experiment was accumulated from LIBERO and previous real-world experiments, without any prior exploration or memory accumulation on RoboDojo. Despite the differences between the previously explored tasks and RoboDojo, the accumulated memory remains useful for solving unseen tasks. This provides evidence of cross-task transfer beyond merely reusing solutions for previously encountered task instances.

For transparency and reproducibility, we provide the detailed execution videos of these experiments in our anonymized GitLab repository: EvoRAM Experiment Videos

We acknowledge that the current evaluation covers only a subset of RoboDojo due to the limited rebuttal period. We plan to extend the evaluation to the full benchmark with 50 trials per task in a future version.

AuthorsOpenReview ↗

Response to Reviewer sTVK (2)

W1

(2) Repeatability of Consolidated Memory

We thank the reviewer for highlighting the importance of memory repeatability. While the reported 121/130 (93.1%) on LIBERO measures successful task discovery during iterative exploration, our real-world cube-stacking experiment (Section 3.2.1) directly evaluates the repeated reuse of previously accumulated Task Memory.

Specifically, after VLA placement failures, EvoRAM retrieves and executes the previously verified code through Quick Mode (Appendix D), without additional code exploration, achieving 16/20 successful two-layer stacking trials (80%), with 5 trials further completing three-layer stacking.

To further evaluate the generalization of accumulated memory, our additional RoboDojo experiments evaluate the first 10 tasks with 5 trials under different random seeds per task, using executable memory transferred from LIBERO and previous real-world experiments. These results provide complementary evidence that accumulated executable experience can be reused across different initial states and task configurations, without prior exploration of RoboDojo tasks.

(3) Comparison with Simpler Task-Code Memory

We thank the reviewer for suggesting a comparison with a simpler task-code cache baseline.

Unlike a simple task-code cache that primarily stores complete task implementations, EvoRAM explicitly maintains reusable object-level manipulation capabilities. In our RoboDojo experiments, all transferred memory was accumulated from LIBERO and previous real-world experiments, without any prior exploration of RoboDojo tasks.

For example, in the Fasten Screws task, EvoRAM without memory fails to tighten any screws. In contrast, with accumulated memory from previous bottle-opening experiments, EvoRAM can transfer rotational manipulation capabilities to screw tightening. Although the overall task success rate remains limited, the agent successfully tightens at least one screw in all five random-seed trials. This demonstrates the potential of Object Memory to support cross-task transfer beyond direct reuse of complete task implementations.

We will conduct a controlled comparison with a simpler task-code cache baseline in future versions of our work to further quantify the benefits of structured memory.

W2. Limited Evidence for Bottle-Opening Transfer

We agree that the approximately two-hour detergent-bottle episode and 40-minute mineral-water-bottle episode do not constitute a strictly controlled speedup comparison, given the differences in object geometry and physical properties.

However, the acquired Task Memory can be directly executed for the same previously explored bottle, completing the opening procedure in approximately 10 minutes without repeating the original exploration process, as supported by the Quick Mode mechanism described in Appendix D.

Furthermore, Appendix G provides a detailed analysis of the two bottle-opening episodes, including the executable functions accumulated during the first episode and the specific components reused during the second. In particular, the agent reuses bimanual stabilization, cap-grasp constraints, repeated turning and regrasping, and separation-verification logic, while adapting the geometric parameters to the new bottle.

We appreciate the reviewer's suggestion and plan to include more comprehensive controlled transfer experiments in future versions of our work.

AuthorsOpenReview ↗

Response to Reviewer sTVK (3)

Q1. Exploration Budget and No-Memory Performance

As discussed in W1 (1), we conducted additional RoboDojo experiments comparing EvoRAM with and without memory under the same model, tools, tasks, random seeds, and evaluation settings. EvoRAM achieves 46.00% average accuracy with memory, compared with 26.00% without memory, representing an improvement of 20.00 percentage points and providing direct evidence of the effectiveness of accumulated executable memory in improving task performance on previously unseen tasks.

Regarding exploration resources, the exploration budget is limited to at most two hours per task, with a maximum of 200 tool-call steps, during which model API calls are made as needed for reasoning, tool invocation, execution, and failure diagnosis. We will provide more detailed statistics on API usage and wall-clock time in future versions of our work.

Q2. Reliability of Frozen Memory Across New Initial States

As discussed in W1 (2), our real-world cube-stacking experiment demonstrates repeated execution of previously accumulated Task Memory through Quick Mode, achieving 16/20 successful two-layer stacking trials without additional code exploration. Furthermore, our additional RoboDojo experiments evaluate memory transfer across 5 random seeds per task, providing evidence of generalization across different initial configurations and benchmarks. We thank the reviewer for this valuable suggestion, which helped us strengthen the evaluation of memory reuse and generalization.

Q3. Same-Bottle Evaluation With and Without Memory

As discussed in W2, the previously acquired Task Memory can be directly executed on the same bottle through Quick Mode, completing the opening procedure in approximately 10 minutes without repeating the original exploration process. Appendix G further details how the acquired bottle-opening experience is reused and adapted to a novel bottle with different geometry. We appreciate the reviewer's suggestion and plan to include additional controlled same-object transfer experiments in future versions of our work.

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

This paper presents EvoRAM, a self-evolving embodied agent that combines code-based exploration with VLA execution. A VLA loop performs efficient subtask execution with a verifier; when the VLA fails, a code loop diagnoses the failure, invokes perception/planning/execution tools, and writes executable programs to explore alternative solutions. Successful, physically verified solutions are consolidated into persistent executable memory organized into Object, Task, and Plan Memory, which can be reused, adapted, and refined in later exploration. The paper evaluates self-evolution on LIBERO (121/130 tasks solved after iterative exploration), real-world bottle-opening transfer, code-based recovery for precise cube stacking, VLA-assisted exploration for deformable-object grasping, and autonomous camera-robot recalibration.

Critical strengths
  1. The Object/Task/Plan memory design and the bidirectional code-VLA collaboration are concrete and useful. The real-world autonomous recalibration and bottle-opening transfer demonstrate a meaningful path toward physical maintenance and lifelong operation, which is consequential for embodied intelligence.

  2. The LIBERO progression from an empty memory to 121/130 solved tasks, together with real-world failure recovery and memory reuse, provides useful evidence that executable experience can be accumulated and reused beyond single-episode task solving.

Critical weaknesses
  1. The paper does not provide same-task, same-platform, same-budget comparisons against the most relevant self-evolving/agentic memory methods (e.g., ASPIRE, EmbodiedCoder, ENPIRE, Harness VLA), nor no-memory/no-revisit/no-VLA ablations. Table 1 is qualitative, and the LIBERO result is a single accumulation trajectory. This is material because the central claim is that exploration expands memory and memory strengthens subsequent exploration; without controls, the observed gains cannot be cleanly attributed to the proposed self-evolution loop rather than task ordering, repeated retries, or strong foundation-model agents.

  2. voRAM judges all 130 LIBERO tasks as solved while 9 are actual failures, and the paper also notes real-world visual verification errors. Since successful experience is consolidated into executable memory, false positives can contaminate memory and affect later reuse. The paper acknowledges the issue but does not quantify its propagation or impact on self-evolution. Real-world bottle-opening and recalibration are also largely single-case demonstrations, limiting statistical support.

Questions for authors
  1. Can you provide same-setting quantitative comparisons against at least 2–3 most relevant baselines (e.g., ASPIRE, EmbodiedCoder, ENPIRE, Harness VLA) on LIBERO and/or your real-world tasks, including exploration time and success rate?

  2. Can you add controlled ablations on LIBERO: no memory, memory without revisit, fixed/random memory retrieval, and code-only without VLA-assisted exploration? This would directly test whether memory causes the claimed improvement.

  3. How do verifier false positives affect memory quality? Please quantify the false-positive rate, whether incorrect “successful” programs are written into memory, and how such contamination propagates to later tasks.

  4. How stable are the results across random seeds, task orders, and repeated real-world trials? Also, what are the API/model costs and wall-clock budgets for the reported exploration episodes?

8 comments
AuthorsOpenReview ↗

Response to Reviewer sB1H

We greatly appreciate your careful review and valuable suggestions. We address your concerns point by point below.

W1

(1) Lack of Quantitative Baselines

We thank the reviewer for this valuable suggestion. To provide additional quantitative comparisons and evaluate the generalization of our executable memory, we conducted new experiments on RoboDojo using memory accumulated from LIBERO and previous real-world robotic experiments.

Due to the limited time available during the rebuttal period, we evaluated the first 10 RoboDojo tasks, with 5 trials per task, using GPT-6.1 Sol with High reasoning effort. We compared EvoRAM with and without memory under the same model and experimental settings, and additionally included the reported results of other RoboDojo agents for reference. The results are presented below.

methodavg. acc/scorealign blocksarrange numbersarrange numbers (random)build towerclassify objectsclassify by languagecover blocksdeposit coinfasten screwsfill egg holder
Q0-Preview74.40/78.2492/9288/89.492/93.472/7794/96.486/88.8100/10042/50.478/86.80/8.2
GO-3 Nano Preview69.20/73.3788/8876/82.648/53100/10072/79.766/74.6100/10048/5494/96.40/5.4
PyRUA-Lean63.00/69.6976/7680/83.868/76.44/23.296/97.192/94.6100/10040/4468/80.66/21.2
SenseNova-RoboRSI52.20/62.6388/8880/86.892/95.268/71.870/8236/55.448/52.432/44.84/27.64/22.3
WorldScape-R²SI51.80/60.7196/9672/77.452/64.636/51.690/91.958/66.898/98.60/7.614/35.42/17.2
EvoRAM (w/ Memory)46.00/50.5060/6020/3320/270/060/6380/8080/86100/10020/3620/20
HexaShell-Preview43.60/51.6178/7812/17.832/42.630/4878/85.372/79.4100/10016/26.418/29.80/8.8
JoyAI-VL43.60/51.6178/7812/17.832/42.630/4878/85.372/79.4100/10016/26.418/29.80/8.8
EmbodiedEvo36.20/49.0798/9836/52.628/440/916/35.540/5884/84.622/37.638/55.60/15.8
PhysicalRSI33.93/40.8086/861.33/3.8721.33/32.4728.67/37.1340/55.836/20.93100/10056/62.270/7.60/1.9
GPT-6-Astra32.20/42.6050/5068/7652/61.42/16.456/6930/4646/49.32/16.416/36.40/5.5
EvoRAM (w/o Memory)26.00/30.1060/600/80/10/040/4040/64100/10020/280/00/0
GPT-5.50.00/0.230/00/00/00/00/0.30/0.20/00/1.60/00/0.2

As shown in the table, EvoRAM with memory achieves 46.00% average accuracy and a score of 50.50, outperforming several reported RoboDojo agents, including EmbodiedEvo, PhysicalRSI, and GPT-6-Astra.

More importantly, all memory used in this experiment was accumulated from LIBERO and previous real-world experiments, without any prior exploration or memory accumulation on RoboDojo. This evaluation therefore examines whether previously acquired executable experience can facilitate unseen tasks in a new benchmark.

For transparency and reproducibility, we provide the detailed execution videos in our anonymized GitLab repository: EvoRAM Experiment Videos.

We acknowledge that the current evaluation covers only a subset of RoboDojo due to the limited rebuttal period. We plan to extend it to the full benchmark with 50 trials per task in a future version.

(2) Lack of Controlled Memory Ablations

We agree that controlled ablations are essential for distinguishing the contribution of memory from that of additional exploration.

To address this concern, we compared EvoRAM with and without accumulated memory from LIBERO and previous real-world experiments, using the same GPT-6.1 Sol model, tools, tasks, random seeds, and evaluation budget. Both configurations use only the code loop, allowing us to isolate the contribution of executable memory without introducing VLA execution as an additional variable.

As shown in the table above, EvoRAM achieves 46.00% average accuracy with memory, compared with 26.00% without memory, representing an improvement of 20.00 percentage points. These results demonstrate the effectiveness of accumulated executable memory in improving task performance and facilitating the transfer of previously acquired manipulation capabilities to unseen tasks.

AuthorsOpenReview ↗

Response to Reviewer sB1H (2)

W2

(1) False Positives and Memory Contamination

We thank the reviewer for highlighting this important issue. As discussed in Appendix F.3, EvoRAM incorrectly judges 9 out of 130 LIBERO tasks as successful, corresponding to a 6.9% false-positive rate among agent-declared successes. Since memory consolidation relies on the agent's verification results, incorrectly verified programs can indeed be incorporated into Object and Task Memory.

However, accumulated memory is not immutable. When previously stored implementations fail under new task configurations, EvoRAM analyzes the observed failures and refines the corresponding code, either by improving reusable object-level functions or adapting task-specific procedures.

As illustrated in Appendix F.2, the final four LIBERO tasks required substantial refinement of previously accumulated memory. During this stage, Object Memory increased from 4,036 to 5,266 lines of code, while the number of object types remained unchanged at 33 (Figure 2). This illustrates how subsequent exploration can identify limitations in existing implementations and improve their applicability to new task configurations.

(2) Limited Real-World Evaluation

We thank the reviewer for highlighting the importance of repeated real-world evaluations.

Our bottle-opening and autonomous recalibration experiments are presented as detailed case studies of EvoRAM's self-evolution capabilities, rather than as large-scale statistical evaluations. These case studies provide an in-depth analysis of how the agent accumulates, refines, and reuses executable experience during real-world interactions.

Specifically, the bottle-opening experiment (Section 3.1 and Appendix G) demonstrates how experience acquired from opening a detergent bottle can be reused and adapted to open a geometrically different bottle. The autonomous recalibration experiment (Section 3.3 and Appendix H) demonstrates how EvoRAM consolidates a calibration procedure through initial exploration and subsequently reuses the acquired memory to autonomously recover from calibration drift.

We will conduct additional repeated real-world experiments in future versions of our work to further evaluate the reliability and consistency of these capabilities.

Q1. Same-Setting Quantitative Comparisons with Existing Agents

As discussed in W1 (1), we conducted additional experiments on RoboDojo to evaluate the effectiveness of our accumulated memory and compared EvoRAM with several existing agents, including EmbodiedEvo, PhysicalRSI, and GPT-6-Astra. The results demonstrate competitive performance and the cross-benchmark generalization capability of our executable memory.

Q2. Controlled Memory Ablations

As discussed in W1 (2), we conducted a controlled with-memory versus without-memory comparison on RoboDojo, using the same code agent, tools, tasks, and evaluation settings. EvoRAM achieves 46.00% accuracy with memory, compared with 26.00% without memory, representing an improvement of 20.00 percentage points and providing direct evidence of the effectiveness of accumulated executable memory. We appreciate the reviewer's suggestions regarding additional retrieval and memory-structure ablations and will investigate them in future versions of our work.

Q3. Impact of False Positives on Memory Quality

As explained in W2 (1), the LIBERO experiment contains 9 false-positive completions out of 130 (6.9%), and incorrectly verified programs can indeed be consolidated into Object and Task Memory. EvoRAM can subsequently refine inadequate implementations when they fail in new configurations, as illustrated by the memory refinement cases in Appendix F.2.

Q4. Stability Across Random Seeds, Task Orders, and Resource Budgets

We thank the reviewer for raising this important question. To further evaluate stability across different initial configurations, we conducted additional RoboDojo experiments on the first 10 tasks, with 5 trials under different random seeds per task, using executable memory accumulated from LIBERO and previous real-world experiments. These experiments provide additional evidence of memory reuse and generalization across different task configurations.

Regarding exploration resources, the exploration budget is limited to at most two hours per task, with a maximum of 200 tool-call steps, during which model API calls are made as needed for reasoning, tool invocation, execution, and failure diagnosis. We will provide more detailed statistics on API usage and wall-clock time in future versions of our work.

Reviewer_sB1HOpenReview ↗

maintain my original rating

I would like to thank the authors for providing the supplementary experiments and explanations. I believe the research direction and system design of this paper have some merit, particularly the combination of Object/Task/Plan Memory with code-VLA collaboration.

However, the current experiments are insufficient to support its core claim regarding a general-purpose self-evolving embodied agent. Several key issues remain unresolved. The current memory erasure experiments fail to distinguish the respective contributions of retrieval, revisitation, and VLA-assisted exploration. More importantly, although the authors acknowledge the presence of 9 false positives, they have not quantified how erroneous programs contaminate memory or propagate to subsequent tasks. An increase in memory capacity alone does not prove that such errors can be reliably identified and corrected.

Overall, I appreciate the authors’ efforts and the supplementary evidence regarding memory transfer. However, the new experiments have only partially addressed my concerns, and the core questions regarding the validity and reliability of the proposed self-evolving mechanism remain inadequately supported. Therefore, I maintain my original rating.

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

This paper presents EVORAM, a robotic agent framework that couples a reactive VLA execution loop with a deliberative code-generation loop and stores verified experience in a three-tier memory (Object, Task, and Plan Memory). Attaching executable manipulation functions directly to reconstructed 3D object/part geometries while using VLA rollouts and analytic code to mutually recover from each other's failures is sensible and well-motivated.

Critical strengths
  1. Organizing memory into Object Memory (3D CAD models, part labels, and object-specific Python pose-generation methods), Task Memory, and Plan Memory is a clean abstraction for robot manipulation.
  2. The physical experiments tackle non-trivial manipulation problems (bimanual bottle unscrewing, 1.8 cm cube stacking recovery, and deformable package grasping). In particular, formulating camera intrinsic and hand-eye extrinsic recalibration (Section 3.3) as an executable skill that the robot acquires and runs autonomously to counter calibration drift is a creative, practically meaningful demonstration of physical self-maintenance.
Critical weaknesses
  1. Although the paper positions EVORAM against recent self-improving agents (Table 1), the experiments contain no quantitative baselines or ablations. On LIBERO, only the code loop is evaluated, leaving the core Code–VLA interaction untested on any benchmark. And Second, the reported 121/130 (93.1%) appears to measure whether the agent produced at least one successful exploratory episode before its verifier declared completion, rather than evaluating the repeatability of the final consolidated memory across multiple random seeds/initial states. In the real-world setting, the claim that memory generalizes to novel objects is from a single episode of opening a detergent bottle (~2 hours) followed by a single episode on a mineral water bottle (~40 minutes). Because the two bottles have completely different geometries and mechanical resistances, without measuring how long the mineral water bottle takes from scratch (with empty memory), the speedup is confounded by task difficulty.
  2. n "VLA for Code" (Sections 2.2.2 and 3.2.2), it is unclear how a closed-loop, vision-driven VLA rollout on a deformable tissue pack is algorithmically converted into a deterministic, CAD-grounded Python function that generalizes across 8/10 orientations.
Questions for authors
  1. Does the 121/130 success rate on LIBERO reflect a single successful exploratory trial per task, or multi-seed evaluation of the final consolidated code library? In addition, how many tasks does the code agent solve if given the exact same total exploration budget per task without retaining Object, Task, and Plan Memory across tasks?
  2. When a VLA rollout succeeds on the tissue pack after code attempts fail, what exact data representation (e.g., recorded TCP poses, contact points projected onto the reconstructed mesh, or video frames) is fed to the code agent to synthesize the new Python program, and how many VLA rollouts were required to obtain that successful demonstration?
  3. Were the programs from the 9 false-positive LIBERO episodes consolidated into Object and Task Memory? If a stored function in Object Memory was verified on a false-positive episode and subsequently fails on a later task, how does EVORAM decide whether to overwrite the shared object method versus creating a task-specific workaround?
5 comments
AuthorsOpenReview ↗

Response to Reviewer JbAE

We sincerely thank you for your thoughtful and constructive feedback. We address your concerns point by point below.

W1

(1) Lack of Quantitative Baselines and Ablations

We thank the reviewer for this valuable suggestion. To further evaluate the effectiveness and generalization of our executable memory, we conducted additional experiments on RoboDojo, using memory previously accumulated from LIBERO and real-world robotic experiments.

Due to the limited time available during the rebuttal period, we evaluated the first 10 RoboDojo tasks, with 5 trials per task, using GPT-6.1 sol with High reasoning effort. We compared EvoRAM with and without memory under the same model and experimental settings, and additionally included the reported results of other RoboDojo agents for reference. The results are presented below.

methodavg. acc/scorealign blocksarrange numbersarrange numbers (random)build towerclassify objectsclassify by languagecover blocksdeposit coinfasten screwsfill egg holder
Q0-Preview74.40/78.2492/9288/89.492/93.472/7794/96.486/88.8100/10042/50.478/86.80/8.2
GO-3 Nano Preview69.20/73.3788/8876/82.648/53100/10072/79.766/74.6100/10048/5494/96.40/5.4
PyRUA-Lean63.00/69.6976/7680/83.868/76.44/23.296/97.192/94.6100/10040/4468/80.66/21.2
SenseNova-RoboRSI52.20/62.6388/8880/86.892/95.268/71.870/8236/55.448/52.432/44.84/27.64/22.3
WorldScape-R²SI51.80/60.7196/9672/77.452/64.636/51.690/91.958/66.898/98.60/7.614/35.42/17.2
EvoRAM (w/ Memory)46.00/50.5060/6020/3320/270/060/6380/8080/86100/10020/3620/20
HexaShell-Preview43.60/51.6178/7812/17.832/42.630/4878/85.372/79.4100/10016/26.418/29.80/8.8
JoyAI-VL43.60/51.6178/7812/17.832/42.630/4878/85.372/79.4100/10016/26.418/29.80/8.8
EmbodiedEvo36.20/49.0798/9836/52.628/440/916/35.540/5884/84.622/37.638/55.60/15.8
PhysicalRSI33.93/40.8086/861.33/3.8721.33/32.4728.67/37.1340/55.836/20.93100/10056/62.270/7.60/1.9
GPT-6-Astra32.20/42.6050/5068/7652/61.42/16.456/6930/4646/49.32/16.416/36.40/5.5
EvoRAM (w/o Memory)26.00/30.1060/600/80/10/040/4040/64100/10020/280/00/0
GPT-5.50.00/0.230/00/00/00/00/0.30/0.20/00/1.60/00/0.2

As shown in the table, EvoRAM with memory achieves 46.00% average accuracy and a score of 50.50, outperforming several reported RoboDojo agents, including EmbodiedEvo, PhysicalRSI, and GPT-6-Astra. In contrast, disabling memory reduces performance to 26.00% accuracy and a score of 30.10, representing improvements of 20.00 percentage points in accuracy and 20.40 points in score, demonstrating the effectiveness of accumulated executable experience.

More importantly, all memory used in this experiment was accumulated exclusively on LIBERO and real-world experiments, without any prior exploration or memory accumulation on RoboDojo. Despite the differences between the two benchmarks, the accumulated memory remains useful for solving previously unseen tasks. This provides evidence of the cross-task and cross-benchmark generalization capability of our executable memory, rather than merely reusing solutions for previously encountered task instances.

For transparency and reproducibility, we provide the detailed execution videos of these experiments in our anonymized GitLab repository: EvoRAM Experiment Videos.

We acknowledge that the current evaluation covers only a subset of RoboDojo due to the limited rebuttal period. We plan to extend the evaluation to the full benchmark with 50 trials per task in a future version.

AuthorsOpenReview ↗

Response to Reviewer JbAE (2)

W1

(2) Why Is the VLA Loop Not Evaluated on LIBERO?

We apologize that the motivation for this experimental design was not sufficiently clear.

We deliberately evaluate only the code loop on LIBERO to isolate the self-evolution process driven by executable memory accumulation. Enabling the VLA loop would introduce another source of successful task execution, making it more difficult to distinguish improvements arising from accumulated memory.

Instead, we evaluate Code–VLA collaboration separately in real-world experiments (Section 3.2), demonstrating both Code for VLA (16/20 successful cube-stacking recoveries) and VLA for Code (8/10 successful tissue-pack grasps using the acquired code).

We agree that a larger-scale benchmark evaluation of the complete Code–VLA framework would further strengthen the paper, and We will include additional experiments in future versions of our work. Thank you for your valuable suggestion, which will help us further strengthen our evaluation.

(3) Repeatability of Consolidated Memory

We thank the reviewer for highlighting the importance of memory repeatability. While the reported 121/130 (93.1%) on LIBERO measures successful task discovery during iterative exploration, our real-world cube-stacking experiment (Section 3.2.1) directly evaluates the repeated reuse of previously accumulated Task Memory. Specifically, after VLA placement failures, EvoRAM retrieves and executes the previously verified code through Quick Mode (Appendix D), without additional code exploration, achieving 16/20 successful two-layer stacking trials (80%), with 5 trials further completing three-layer stacking.

To further evaluate the repeatability and generalization of our accumulated memory, we conducted additional experiments on RoboDojo using memory transferred from LIBERO and previous real-world experiments. Specifically, we evaluated the first 10 RoboDojo tasks, with 5 trials under different random seeds for each task. These experiments demonstrate that the accumulated executable memory can be effectively reused across different initial states and task configurations, rather than being limited to a single successful exploratory episode. Moreover, since the memory was accumulated exclusively on LIBERO and previous real-world experiments, these results also provide evidence of its cross-task generalization capability.

(4) Cross-Object Memory Transfer in Bottle Opening

We agree that the approximately two-hour detergent-bottle episode and 40-minute mineral-water-bottle episode do not constitute a strictly controlled speedup comparison, given the differences in object geometry and physical properties.

However, the acquired Task Memory can be directly executed for the same previously explored bottle, completing the opening procedure in approximately 10 minutes without repeating the original exploration process, as supported by the Quick Mode mechanism described in Appendix D. Furthermore, Appendix G provides a detailed analysis of the two bottle-opening episodes, including the executable functions accumulated during the first episode and the specific components reused during the second. In particular, the agent reuses bimanual stabilization, cap-grasp constraints, repeated turning and regrasping, and separation-verification logic, while adapting the geometric parameters to the new bottle.

W2. How Does VLA Exploration Guide Code Generation?

We thank the reviewer for raising this important question and apologize that the VLA-to-Code conversion process was not sufficiently detailed in the original paper.

In the tissue-pack experiment (Section 3.2.2), the code agent had already developed a general grasping strategy that targeted the side edges of the tissue pack. However, due to the deformable nature of the object, determining the appropriate grasping angle and end-effector orientation remained challenging. Initial code-based attempts therefore failed to achieve stable grasps.

To address this, EvoRAM invoked the VLA for additional exploration. The code agent analyzed the successful VLA end-effector grasp pose relative to the tissue-pack pose, together with the grasp configurations and observed failures from previous code-based attempts and VLA rollouts. By comparing successful and unsuccessful interactions, the agent identified more suitable grasping angles and approach orientations, which were then incorporated into the existing parameterized grasp-generation code.

Importantly, the agent does not simply replay the successful VLA trajectory. Instead, it extracts reusable grasping constraints and integrates them into a general program that computes grasp poses based on the current object pose. The resulting code was successfully verified across 8 out of 10 different tissue-pack orientations, demonstrating its ability to generalize beyond the original VLA demonstration.

We appreciate the reviewer's suggestion and will provide a more detailed explanation.

AuthorsOpenReview ↗

Response to Reviewer JbAE (3)

Q1. LIBERO Success Rate and Same-Budget No-Memory Comparison

As clarified in W1 (3), the 121/130 LIBERO result measures exploration-time success, while our real-world cube-stacking experiment demonstrates repeated reuse of previously accumulated Task Memory, achieving 16/20 successful two-layer stacking trials through Quick Mode without additional code exploration. Furthermore, our new RoboDojo experiments evaluate memory transfer across 5 trials per task and compare EvoRAM with and without memory under identical settings. We thank the reviewer for this valuable suggestion, which helped us strengthen the evaluation of memory reuse and generalization.

Q2. How Are Successful VLA Rollouts Converted into Executable Code?

As explained in W2, the code agent analyzes successful VLA grasp poses alongside previous failed attempts to identify suitable grasping angles and approach orientations. These insights are incorporated into a parameterized grasp-generation function rather than directly replaying VLA trajectories, achieving 8/10 successful grasps across different orientations. We appreciate the reviewer's suggestion and will provide further implementation details in a future version of the paper.

Q3. False Positives and Memory Contamination

We thank the reviewer for raising this important concern. As discussed in Appendix F.3, incorrectly verified programs can indeed be incorporated into Object and Task Memory. However, accumulated memory is not immutable. When previously stored implementations fail under new task configurations, EvoRAM analyzes the failures and refines the corresponding code, either by improving reusable object-level functions or adapting task-specific procedures. As illustrated in Appendix F.2, the final four LIBERO tasks required substantial refinement of existing memory, increasing Object Memory from 4,036 to 5,266 lines of code without introducing new object types (Figure 2). This demonstrates how accumulated memory can be progressively improved through subsequent exploration.

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

Related papers

Loading the map…

Discussion (0)

Sign in to comment.