acceptodds
Under review as a conference paper at ICLR 2027

PhysEvo: Astra Can Act, Let It

11 views

Abstract

Astra can act, yet reliable manipulation depends on the system through which it observes and controls the world. We introduce PhysEvo, a framework for physical recursive self-improvement (RSI) around a single frozen model. A task agent executes robot tasks; a meta-agent uses the resulting trajectories to diagnose failures, revise tools and skills, and test corrections. The meta-agent can also improve its own diagnostic tools, so retained revisions support both later action and later self-improvement. This process develops joint-level control, evidence-seeking observation, and reusable manipulation skills without model-weight updates or a separately trained action policy. Across 42 RoboDojo tasks, held-out-layout evaluation of retained task-specific deployment versions yields a five-dimension average score of 68.14/100 and 62.00% success, compared with 47.17% for RoboDawn's one-shot Astra agent, the strongest published reference in our comparison. On eight manipulation tasks challenging direct Astra, success rises from 1.25% to 55.00%. Deploying the simulation-evolved harness on AgileX PiPER and continuing skill revision yields successful executions of five real-world tasks, adapting pouring and localization to physical discrepancies. PhysEvo turns the consequences of action into persistent, testable changes to how a frozen model acts and improves.

Primary area:
applications to robotics, autonomy, planning
Keywords:
recursive self-improvement, physical intelligence, embodied agents, robot manipulation, agent harness

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 3 reviews, above 27% of the others.
Reviewer_ahEpOpenReview ↗
Rating
2
Confidence
3
Informativeness
2
Presentation
2
Soundness
2
Read review
Paper summary

PhysEvo introduces physical recursive self-improvement (RSI) around a frozen Astra model. A task agent executes robot tasks, while a meta-agent diagnoses failures, revises tools and skills, and tests corrections, including changes to its own diagnostic tools. The evolved framework combines joint-level control, active and retrospective observation, and reusable manipulation skills. Across 42 RoboDojo tasks, retained task-specific deployment versions achieve a five-dimension average success rate of 62% on held-out layouts. Continued skill revision on AgileX PiPER yields successful executions of five real-world tasks.

Critical strengths
  1. Timely implementation and evaluation. The paper studies Astra-based robot manipulation soon after the model’s release. Despite the roughly three-week interval before the submission deadline, it includes an implemented self-improvement loop, simulation evaluation, and real-robot demonstrations.
  2. Reasonably comprehensive evaluation. The evaluation includes comparisons with VLA policies and other Astra-based approaches. It also includes a control-interface comparison, geometric-tool checks, revision case studies, and demonstrations on five real-world tasks.
Critical weaknesses
  1. Unreported self-improvement cost. PhysEvo’s self-improvement cost is unclear. It uses Astra for task execution, failure diagnosis, tool and skill revision, and repeated testing, but reports no token usage, model-call counts, exploration attempts, or wall-clock time. Given Astra’s cost, final success rates alone do not establish practical efficiency or scalability. The authors should report resource consumption across the full self-improvement process and show performance against cumulative cost or exploration time.
  2. Value of recursive self-improvement is not clearly demonstrated. Figure 5 illustrates the reuse of a self-built diagnostic tool, but provides no success-rate comparison before and after the revision. The reported results therefore leave unclear how much benefit comes from improving the improvement mechanism itself.
  3. Limited gains in complex manipulation. Pen-holder filling and laptop/headphone storage remain at 0% success, leaving precise placement under contact and spatial constraints unresolved in these tasks. Compared with RoboDawn, improvements on eight challenging manipulation tasks are confined to two pouring tasks. Generalization success also drops from 50% to 45%, while long-horizon success remains at 45%. These results provide limited evidence that the proposed framework improves the capabilities needed for more demanding manipulation.
Questions for authors
  1. Could the authors provide an example of final task-specific skills, along with evaluation configurations to facilitate reproduction of the reported results?
  2. On a representative task, how does PhysEvo compare with an online RL baseline (such as SimpleVLA-RL) under comparable environment-interaction budgets, in terms of success rate, runtime, and computational cost?
2 comments
AuthorsOpenReview ↗

Response to Reviewer ahEp (1/2): Results, mechanism, and skill

Thank you for focusing on the benefit and cost of recursive self-improvement (RSI). From a shared start, Full PhysEvo reaches 75.56 Score / 72.2% SR versus 61.11 / 55.6% for Fixed Meta, which can already revise Task skills and code. Their recorded post-branch development token counts are similar (~132M per method across six chains). Below we provide checkpoints, a deployed skill, and measured costs.

Q1: How much does improving the improvement mechanism help, including beyond pouring?

  • Direct Answer: Full exceeds Fixed Meta by 14.44 Score points and 16.7 percentage points in SR on average, including a folding gain (86.67 vs. 60.00). On Pour Balls Into Vase, Insert Tubes, and Fold Clothes, we run two development chains per active method and task (6 paired blocks). Within each task–repeat block, the three active methods share identical initial Task/Meta bundles and the exact same recorded initial development rollout. Fixed Meta can inspect images/code, run temporary analysis scripts, and persist Task changes; Full PhysEvo additionally persists changes to Meta knowledge, tools, and workflows.

Mean official Score / official SR across protocol checkpoints (evaluated on 3 held-out layouts per task):

MethodCheckpoint 0 (Start)Checkpoint 3 (Mid)Checkpoint 6 (Final)
No evolution (initial harness)28.89 / 22.2%——
Reflexion-style: Task text lessonsshared (28.89 / 22.2%)31.11 / 27.8%35.56 / 27.8%
Fixed Meta: Task skills & codeshared (28.89 / 22.2%)28.89 / 22.2%61.11 / 55.6%
Full PhysEvo: Task + Meta resourcesshared (28.89 / 22.2%)44.44 / 38.9%75.56 / 72.2%
  • Trajectory & Mechanism: The common start includes joint control; this tests continued improvement. Full leads at both measured post-start checkpoints: about 15.6 Score points at checkpoint 3 and 14.44 at checkpoint 6. In our recorded pouring chain, Session 1 builds an event-alignment and visibility-checking resource; a later independent Codex session reuses it to detect continued pouring while the vase opening is occluded, revising observation timing and tilt control. Subsequent sessions inherit projection-assumption and completion-condition checks to refine localization, release, and upright recovery.
  • Beyond Pouring: On Fold Clothes, Full reaches 86.67 Score versus 60.00 for Fixed Meta; on Insert Tubes, Fixed Meta performs better (90.00 vs. 73.33). Across all six paired blocks, Full wins 3, ties 2, and loses 1 (sim pen-holder and laptop/headphone tasks remain unresolved here). Separately, 25 hardware adaptation trials (5 tasks × 5 trials) yield 90.60 Score / 84.0% SR.

Evaluation: All development artifacts were frozen before testing. The reported comparison uses the same three held-out layouts per task.

Q2: What does a final task-specific skill look like, and what configuration was evaluated?

  • Direct Answer: The deployed pour-liquid-into-cup skill coordinates active observation, grasp verification, incremental pouring, and upright recovery through closed-loop feedback rather than a fixed open-loop sequence. Selected excerpts across its six stages are:
    • Arm choice & observed grasp: "Use the robot's workspace, not image left/right: prefer the left arm for a cup on the left and the right arm for a cup on the right. [...] Position the EMPTY arm at a clear oblique view showing the bottle, approaching fingers and cup rim. [...] Confirm retention with a short upright lift, then a small rotation in clear space: the bottle must follow the pads, not pivot inside them."
    • Outlet placement & flow inspection: "Establish the EMPTY arm's pouring view before that tilt. It should expose the mouth, near and far inner rim, landing area and bottle/gripper clearance. [...] Keep the observer still while making short inward rotations. Compensate translation for the mouth's arc around the body grasp. [...] If it hits the rim, an arm or the table, reduce tilt to stop the spill, wait over the cup for residual drops, then correct the mouth position before resuming. Extra tilt is not a correction for a missed landing."
    • Draining & upright verification: "Record whether the empty assessment is direct, indirect or unknown, separately from evidence that liquid entered the cup. [...] Confirm the actual body and neck are upright in world space, not merely vertical in a rolled wrist image, then check native completion."

Continued in Part 2/2: evaluation configuration, costs, and online RL.

AuthorsOpenReview ↗

Response to Reviewer ahEp (2/2): Configuration, costs, and online RL

Continued from Part 1/2: Q2 configuration, followed by Q3 and the summary.

  • Evaluation Configuration: Held-out test layout IDs for the main report are Pour Balls (36/43/30), Insert Tubes (38/49/33), and Fold Clothes (35/38/47). During testing, the Task version is strictly frozen and each episode starts from a fresh state: unlike 1-shot ICL baselines (e.g., RoboDawn), we never provide a task demonstration trajectory in context—prior development experience is passed solely through retained skills and executable tools, while same-episode history remains available for closed-loop control.

Q3: What is the development cost, and how does it compare with online RL?

  • Direct Answer: Below we report exact physical executions, HTTP attempts, and known token usage for the controlled study alongside historical runtime latency. Full PhysEvo and Fixed Meta have similar recorded post-branch development token counts (~132M per method across six chains).
  • 1. Post-Branching Development Cost Per Method (6 chains / 18 Meta sessions per method):
SettingBranch ExecutionsTask HTTPMeta HTTPTotal HTTPKnown TokensCalls Missing Token Logs
Reflexion-style282,1339263,059131.31M (131,313,347)42
Fixed Meta232,1128702,982132.33M (132,333,166)30
Full PhysEvo222,0368792,915131.78M (131,782,233)21
  • Accounting for the Reported Comparison: The methods have similar recorded post-branch development token counts (~131–132M per method), with Full PhysEvo using the fewest branch executions (22) and HTTP attempts (2,915) (Checkpoints 0/3/6 denote protocol allowances; early-stopped chains carry forward accepted versions). Including the 6 shared initial rollouts (663 HTTP / 13.86M tokens), 4 uninherited screening runs (328 HTTP / 7.90M tokens), 4 infra checks (4 HTTP / 84 tokens), and the 63 unique held-out test evaluations supporting all 117 main-table report slots (6,851 HTTP / 212.96M tokens; pre-outcome caching reuses identical frozen configs at zero extra API cost), the development runs and tests covered by this accounting amount to 146 physical executions (83 dev + 63 test), 16,802 HTTP attempts (including retries/failures), and 630,153,958 known tokens (439 attempts lacked token logs).

  • 2. Historical Episode Runtime Breakdown (15 timestamped episodes, 2,300 HTTP attempts, ~153 attempts/episode):

Timing ComponentMean per Episode
Waiting for cloud API responses (incl. failures; mean 17.5s, P95 27.2s/call)44.76 min (about 85%)
Other startup, robot motion, and local tool execution7.60 min
Local concurrency queuing (0.78s) & logged retry backoff (4.67s)5.45 s
Total elapsed wall-clock time52.45 min
  • 3. Comparison with Online RL: Online RL (e.g., SimpleVLA-RL) updates policy weights via interaction, whereas PhysEvo freezes model weights and revises software resources, requiring no GPU weight-training phase (while still incurring inference and simulation costs). Fixed Meta serves as the exact controlled baseline for our recursive claim under a shared model, starting code, and development-budget rules; while a matched online-RL comparison remains an interesting direction for future work.

Summary

Under matched starting resources and similar recorded post-branch development token counts (~132M per method across six chains), enabling Meta-resource evolution yields an average +14.44 Score (+16.7 percentage points in SR) gain over Task-only refinement and extends to deformable cloth folding. We hope these controlled results, skill excerpts, and cost accounting for the audited batch support raising your score.

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

This paper introduces PhysEvo, a framework for physical recursive self-improvement that employs two agents, each using the same frozen model (Astra) but equipped with different harnesses. The task agent observes and controls the robot using its harness, which supplies observation and action tools, skills, and memory. The meta-agent uses execution trajectories to diagnose failures, refine the task agent's harness, and validate candidate refinements. It also refines its own meta-harness, which supplies tools for code inspection and editing, trajectory review, diagnostic tests and refinement validation checks.

The approach is validated in simulation on a suite of 42 tasks from RoboDojo that test capabilities in generalization, precision, long-horizon execution, memory and open-ended instruction following, against a collection of baselines including LLM-based methods and end-to-end policies such as VLAs. The authors report that PhysEvo achieves the highest overall score and success rate among the compared methods. The paper also includes three case studies analyzing robot behavior under PhysEvo, as well as a demonstration of PhysEvo on five real-world tasks.

Critical strengths
  • With the harness PhysEvo provides, a frozen language model completes manipulation tasks it almost never completes when acting directly. Success rises from 1.25% to 55.00% on the eight-task subset and from 26% to 68% on the ten-task GPT-as-Policy set (Tables 2 and 3). Differences of this magnitude lie well outside the range attributable to chance, even with five attempts per task, and indicate that the interface around the model constitutes a major bottleneck on these tasks.
Critical weaknesses
  • The paper's central claim of physical recursive self-improvement is not substantiated by the evidence. The underlying method, an LLM agent that diagnoses failures from trajectories and edits its own tools and skills, is incremental over prior work. The contribution therefore depends on showing that this loop, and its recursive part in particular, produces the performance gains, but the paper does not convincingly show this.

    • Incremental relative to prior work. Each component is established: retaining executable skills from interaction (Voyager), diagnosing failures from execution traces (REFLECT, Reflexion), and agents that modify their own implementation or improvement procedure (ADAS, DGM, STOP). The combination is reasonable but not a significant methodological contribution in its own right.
    • Gains are not attributed to the evolution process. The initial harness is never evaluated on the 42 tasks, and there is no curve of performance against improvement rounds. The contributions of the authors' harness design and of self-improvement therefore cannot be separated. The paper also does not record which components the agent produced and which the authors engineered. For example, the abstract states that the process "develops joint-level control", but Appendix C.1 does not say whether the meta-agent or the authors introduced the joint interface and ran the comparison that selected it. Section 5.5 also draws a general conclusion, that a larger tool menu alone is not sufficient, from a comparison with only two episodes per interface (Appendix C.1).
    • The recursive component is supported only by a single anecdote (Figure 5). This is the component that distinguishes PhysEvo from ordinary skill and tool refinement, yet there is no ablation with the meta harness frozen.
    • No self-improving baseline. Every comparison is against a method that does not improve itself. A Reflexion-style retry loop or a Voyager-style skill library, given the same tasks and development budget, would show whether the proposed loop adds anything over simpler alternatives.
    • Only one proprietary model is evaluated with PhysEvo. The framework is presented as general, but nothing shows that it works with any model other than Astra. GPT-5.5 and DeepSeek-Flash already appear in Table 1 at below 2% SR, so testing whether PhysEvo lifts a weaker model would be both feasible and informative.
  • The empirical comparisons do not convincingly support the headline claims of superior performance over the baselines. The comparisons are unequal and unreplicated, and the aggregate margin is concentrated in a single capability dimension (memory). Since the method is incremental, the case for acceptance rests on these results.

    • Unequal comparison. The 42-task result aggregates 42 task-specific deployment versions of PhysEvo, each developed on the task it is scored on, with only the layouts held out (Section 5.1). Meanwhile, the baselines are single generalist policies, or RoboDawn with one in-context demonstration. The development and deployment budget or cost is never quantified, whether as episodes, model calls, tokens or wall-clock time per task. Therefore, neither the fairness of the comparison nor the practical cost of the method can be judged.
    • No measure of variance. Each task is scored from five attempts in a single run, with no repeated runs or confidence intervals. The paper itself notes that one changed outcome moves the eight-task mean by 2.5 percentage points (Appendix B.1).
    • The headline performance margin is concentrated in the memory capability dimension. The reported dimension SRs imply 12/8/8/6/8 tasks across generalization, precision, long-horizon, memory, and open-ended (the five RoboDojo dimensions). On the six memory tasks, PhysEvo succeeds on 30/30 attempts against RoboDawn’s 16/30. Excluding memory, PhysEvo succeeds on 93/180 attempts (51.7%) and RoboDawn on 83/180 (46.1%); a 5.6-percentage-point gap at this sample size is well within chance variation (using a two-proportion test treating attempts as independent, I get p$\approx$0.3). The perfect memory result plausibly reflects the review_frames tool and the explicit episode-memory field, which may sidestep what this dimension is intended to test.
    • Results outside memory are mixed. PhysEvo trails RoboDawn on generalization SR (45.00 vs 50.00), and on long-horizon it ties on SR with a lower score (Table 1). On the eight-task subset (Table 3), it leads Simate-beta on four tasks but trails on another four, it leads RoboDawn on two tasks but ties on five and loses on one, and it has no full successes on two tasks.
    • The real-world results are only demonstrations. Skills are revised between attempts on the same hardware task, and Section 5.6 reports no held-out attempts, success rates, counts of attempts, or counts of revision cycles. In simulation, adoption decisions rely on the simulator's ground-truth evaluator (Section 3.3), which has no counterpart on hardware. The paper also does not say what feedback signal drove the hardware revisions. Thus, the claim that the approach transfers to physical settings is limited.
Questions for authors
  • Development budget (clarification): For each task, how many development episodes, model calls and tokens did self-improvement use before the deployment version was fixed, and what was the wall-clock time? What is the per-episode cost at deployment, in model calls and latency? These figures determine whether the comparison with generalist policies and one-shot RoboDawn is on comparable footing.
  • Attribution to self-improvement (clarification): How does the initial harness (TCP interface with local IK, before any revisions) perform on the 42 tasks, or at least on the 16-task union in Tables 2 and 3? Which components of the final harness did the meta-agent introduce and which did the authors, in particular the joint control interface? Are there any results with the meta harness frozen? Without these, the gains cannot be separated from the authors’ harness design, and the recursive component cannot be assessed.
  • Information access (clarification): Does RoboDojo’s protocol for memory tasks permit retrieving earlier frames within an episode, as review_frames does, and did RoboDawn have equivalent access to episode history? The memory dimension accounts for most of the headline margin, so this bears directly on how the 30/30 result should be read.
5 comments
AuthorsOpenReview ↗

Response to Reviewer 8aK7 (1/2): Controlled results and recursive mechanism

Thank you for distinguishing a strong final interface from evidence for recursive self-improvement (RSI). We test whether a developer already able to revise Task code and skills (Fixed Meta) benefits from persistent Meta-resource updates (Full). From the same harness and initial rollout, Full reaches 75.56 Score / 72.2% SR, versus 61.11 / 55.6% for Fixed Meta and 35.56 / 27.8% for Reflexion-style, with similar recorded post-branch token counts (~132M per method across six chains).

Q1: What do the common starting point, self-improving baseline, and frozen-Meta control show?

  • Direct Answer: From the shared joint-control start (22.2% SR), Full reaches 72.2%: +16.7 percentage points over Fixed Meta and +44.4 over Reflexion-style. On Pour Balls Into Vase, Insert Tubes, and Fold Clothes (all outside the Memory dimension), we run two development chains per active method and task (6 paired blocks). Within each block, the three active methods receive identical initial Task/Meta bundles and the exact same recorded initial development rollout, under identical frozen model configs and budget rules. Fixed Meta retains image/code inspection and temporary analysis scripts and can persist Task skills and code; Full additionally persists changes to Meta knowledge, tools, and workflows.

Mean official Score / official SR across protocol checkpoints (evaluated on 3 held-out layouts per task):

MethodCheckpoint 0 (Start)Checkpoint 3 (Mid)Checkpoint 6 (Final)
No evolution (initial harness)28.89 / 22.2%——
Reflexion-style: Task text lessonsshared (28.89 / 22.2%)31.11 / 27.8%35.56 / 27.8%
Fixed Meta: Task skills & codeshared (28.89 / 22.2%)28.89 / 22.2%61.11 / 55.6%
Full PhysEvo: Task + Meta resourcesshared (28.89 / 22.2%)44.44 / 38.9%75.56 / 72.2%
  • Breakdown & Heterogeneity: Full's final net increment over Fixed Meta is +14.44 Score / +16.7 percentage points in SR, and it leads at both post-start checkpoints (about 15.6 and 14.44 Score points). Across all 6 paired blocks, Score differences (Full minus Fixed) are: Pour Balls (0, +66.67); Insert Tubes (−53.33, +20.00); Fold Clothes (0, +53.33)—winning 3, tying 2, and losing 1. Task means favor Full on pouring (66.67 vs. 33.33) and folding (86.67 vs. 60.00), but favor Fixed Meta on insertion (90.00 vs. 73.33).
  • Initial Resources & Human Engineering Boundary: In early historical exploration, authors supplied the infrastructure, goals, and initial Meta prompts encouraging exploration of alternative control modes (listing TCP, Joint, etc. as candidate directions without prescribing Joint; the 6-episode TCP/Joint/Both test is only a local interface check, not a general claim about tool-menu size). Crucially, in our new controlled study above, all methods share the exact same joint-control warm-start (Checkpoint 0 = 22.2% SR), so the observed average margin cannot be explained by different starting control interfaces between Full and Fixed Meta.

Evaluation: All development artifacts were frozen before testing. The reported comparison uses the same three held-out layouts per task.

Q2: What is the recursive contribution beyond accumulated skills or a longer conversation?

  • Direct Answer: The core distinction is persisting physical diagnostic tools that enable subsequent Task code revisions across independent sessions, rather than merely retaining a better Task policy or conversation history. In our new pouring trace: (1) Session 1 builds an event-alignment and visibility-checking resource (code aligns multi-view evidence; Codex labels opening visibility); (2) Session 2 invokes this inherited resource to catch blind pouring without landing evidence, revises observation timing and tilt control, and develops new projection-assumption and completion-condition checks; (3) Session 3 reuses those checks to revise localization, release, and upright recovery.
  • No Conversation Carryover: Independent sessions do not share conversation histories or temporary workspaces; they interact solely through approved Meta resources, subsequent calls, and validated Task patches. Building on Voyager, Reflexion, and ADAS/DGM/STOP, our contribution is realizing this loop around a single frozen embodied model and isolating the incremental value of evolving Meta diagnostic resources against a capable Fixed Meta developer.

Continued in Part 2/2: costs, protocol, Memory, and hardware.

AuthorsOpenReview ↗

Response to Reviewer 8aK7 (2/2): Costs, protocol, and clarifications

Continued from Part 1/2; Q1–Q2 contain the controlled results and mechanism.

Q3: What are the resource costs and model limitations?

  • Direct Answer: Full and Fixed Meta have similar recorded post-branch token counts (~132M per method across six chains); Full used 22 branch executions versus 23.
  • 1. Post-Branching Development Cost Per Method (6 chains / 18 Meta sessions per method):
SettingBranch ExecutionsTask HTTPMeta HTTPTotal HTTPKnown Tokens
Reflexion-style282,1339263,059131.31M (131,313,347)
Fixed Meta232,1128702,982132.33M (132,333,166)
Full PhysEvo222,0368792,915131.78M (131,782,233)
  • Reported-Comparison Costs & Scope: This accounting covers 6 shared initial rollouts (663 HTTP / 13.86M tokens), 73 branch runs, 4 screening runs (328 HTTP / 7.90M tokens), 4 infra checks, and 63 unique tests supporting 117 report positions (6,851 HTTP / 212.96M tokens): 146 physical executions (83 dev + 63 test), 16,802 HTTP attempts (including retries/failures), and 630,153,958 known tokens. Checkpoints 0/3/6 are protocol allowances; early stops carry versions forward. All evaluated versions were frozen before testing. The reported comparison uses the same three held-out layouts per task.

  • 2. Per-Episode Runtime Latency: Across 15 fully timestamped historical episodes (2,300 HTTP attempts, ~153 attempts/episode), mean duration is 52.45 min/episode: 44.76 min (about 85%) waiting for cloud API responses (mean 17.5s, median 16.2s, P95 27.2s/attempt), 7.60 min for local startup, motion, and tools, and 5.45s for queuing/backoff.

Q4: How does RoboDawn's ICL setting differ, and what do the memory and hardware results mean?

  • Within-episode memory and comparison with RoboDawn (Question 3): Source inspection of RoboDawn’s released RoboDojo adapter confirms that each model request contains a task demonstration, current camera images, and textual episode memory: a 12-turn command/outcome history by default and a model-written scratchpad. Previous images from the ongoing episode are neither automatically replayed nor accessible through a historical-image retrieval command. Although control-step video is recorded, it is not exposed to the acting model as a retrieval interface. PhysEvo instead loads frozen tools and skills without a demonstration trajectory and provides indexed retrieval of saved same-episode RGB through review_frames (which retrieves previously captured same-episode images and aligned robot states, including intermediate frames not previously shown to the planner, without advancing physics or returning object/contact ground truth or historical scores). Both systems use history, but their observation-history interfaces are not equivalent. The matched-start Full–Fixed Meta experiment in Q1 (where all active methods share identical initial resources, rollouts, and development-information access rules) separately tests recursive attribution within our framework.
  • Hardware Results: Across 25 trials (5 tasks × 5 trials) on AgileX PiPER, PhysEvo achieves 90.60 mean Score / 84.0% SR (100% SR on Stack blocks, Stack bowls, Place pens; 60% SR on Pour water and Write "PhysEvo"). Trajectory-driven revisions include shifting the pouring offset backward to counter real fluid momentum, and reversing "geometry-first" into "coarse visual approach + close-range geometric localization" to handle physical positioning error.

Summary

With shared starting resources and development rules, Full shows an average +14.44 Score / +16.7-percentage-point SR increment on non-Memory tasks, supported by cross-session provenance traces. We hope this evidence supports reconsideration of your assessment.

Reviewer_8aK7OpenReview ↗

Rebuttal Response

Thank you for the detailed response and the new controlled study. Comparing Full against a Fixed Meta developer from a shared starting harness and initial rollout directly addresses my request for an ablation with the meta harness frozen. The design (identical starting resources, similar token budgets, Fixed Meta still able to write temporary analysis scripts) also seems fair. The cost and latency figures are also helpful. However, I don't think the new evidence is yet enough to support the paper's central claim, and several of my main concerns remain unaddressed.

Controlled study. The study is small. Each method's final result is based on 18 episodes (3 tasks, 2 chains each, 3 layouts), so the gap between Full and Fixed Meta (72.2% vs 55.6% SR) corresponds to 13 versus 10 successful episodes. Across the six paired blocks, the score differences have a mean of +14.4 with a standard error of about 17.6. Full wins 3 blocks, ties 2 and loses 1, and Fixed Meta has the higher mean on insertion. None of this distinguishes the two methods from chance variation (a paired t-test on the score differences gives me p ≈ 0.45, and Fisher's exact test on SR gives me p ≈ 0.49). The clear gap is against the Reflexion-style baseline, but that baseline can only add text lessons and cannot edit code, so it is a weak comparison. I would also like to know:

  • how these three tasks were chosen, and what the four screening runs were used for;
  • how the initial TCP/local-IK harness performs. All methods in the new study start from a Joint-control warm start, so the study does not separate the contribution of self-improvement from that of the authors' harness design in the main 42-task results.

Concerns that remain unaddressed.

  1. The development budget behind the main 42-task results is still not reported; the new cost figures cover only the three-task study. The per-episode latency figures are helpful, though at about 52 minutes per episode they also bear on the method's practical cost.
  2. There are still no repeated runs or confidence intervals for the main results.
  3. On memory, the response confirms that review_frames gives the task agent indexed access to earlier same-episode frames, including frames never shown to the planner, and that RoboDawn has no equivalent. It does not answer whether RoboDojo's protocol for memory tasks permits this kind of access. This matters because the memory dimension accounts for most of the headline margin. Outside it, the success rates I computed in my review (51.7% vs 46.1%) are within chance variation, and the response does not dispute this.
  4. For the new hardware results, it is not stated whether skills were frozen during the 25 trials, or what feedback signal drove adoption of revisions without the simulator's evaluator. There is also no baseline on hardware.
  5. The framework is still evaluated with a single proprietary model.

Clarifications. The response states that the authors' initial Meta prompts listed Joint control as a candidate direction. I think the abstract's claim that the process "develops joint-level control" should be revised to reflect this. In Q2, the trace mentions that "Codex labels opening visibility". Could the authors clarify what role Codex plays? If the meta-agent runs within an existing coding-agent framework, this should be described in the paper, and it may affect the single-frozen-model framing.

Overall, I appreciate the additional work, and the controlled study is a meaningful step towards isolating the recursive component. However, given its scale and the concerns above, I am keeping my score.

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

The paper presents some initial experimentation on physical RSI in the real world. The physical RSI is implemented with frozen GPT6Astra, with a task agent and a meta agent. The main evaluation benchmark is RoboDojo, and a real-world robot demo has been shown.

Critical strengths
  • A timely topic and research
  • Both simulation and real-world robot experiments
  • Like the part on what changes during RSI, including posture changes, remember evidence, and reuse diagnostic tools. Somehow quantifying the effects of these, instead of just showing examples, would make the claims stronger.
Critical weaknesses
  • The evaluation does not isolate self-improvement from harness engineering and per-task tuning, and self-improvement is the claim. e.g., • there is no fixed-harness baseline.
  • Evaluation protocol presentation issues. In general, I found the evaluation ok but due to a lack of control/details, it was hard to parse. e.g., things like budget need to be reported. Baseline numbers are from external resources and reports, right? Shouldn't they be re-run under the same protocols?
  • The eight tasks in Table 2 and 3: my understanding is that these tasks are the ones VLAs are good at but vanilla Astra is bad at, likely these are the tasks harness/skill engineering would be most beneficial.
  • It would be helpful to introduce RoboDojo and its setup, and the current landscape of the leading solutions for people who are not familiar.
  • Not necessarily a critical weakness, but worth considering: real-world experiment quantitative results (like SR), more challenging real-world tasks, the performance gap btw sim and real, and why.
Questions for authors

See above.

3 comments
AuthorsOpenReview ↗

Response to Reviewer 26Qy (1/2): Attribution and mechanism

Thank you for highlighting our control, observation, and diagnostic-reuse examples, and for noting that your concerns are minor or fixable. Your central question is whether a strong final harness demonstrates self-improvement by the system rather than a better human starting design. To answer this directly, we added both a frozen Task-harness baseline (No evolution) and a frozen-Meta baseline (Fixed Meta). Starting from identical initial resources and using similar recorded post-branch development token counts (~132M per method across six chains), Full PhysEvo reaches 75.56 Score / 72.2% SR, outperforming Fixed Meta at 61.11 Score / 55.6% SR—a net gain of +14.44 Score points and +16.7 percentage points in SR.

Q1: Does the evaluation separate self-improvement from initial harness engineering and per-task tuning?

  • Direct Answer: Yes — in our Full vs. Fixed Meta comparison, initial resources, budget rules, and per-task editing permissions are held strictly identical; the sole experimental intervention is whether newly built or revised Meta diagnostic resources persist across sessions. We evaluate Pour Balls Into Vase, Insert Tubes, and Fold Clothes, running two development chains per active method on each task (6 paired blocks). Within each task–repeat block, all three active methods branch from identical Task/Meta code bundles and the exact same recorded initial development rollout. No evolution directly evaluates this shared starting point without development updates.
MethodPermitted Persistent UpdatesMean ScoreSuccess Rate (SR)
No evolutionNone (Task harness stays completely fixed)28.8922.2%
Reflexion-styleTask text lessons only35.5627.8%
Fixed Meta (New)Task skills and executable code implementation61.1155.6%
Full PhysEvoTask resources + Meta knowledge/tools/workflow75.5672.2%
  • Key Attribution Takeaway: Fixed Meta is a capable coding developer (not a restricted text-only agent): it can inspect images and source code, run temporary analysis scripts, and revise Task skills and code for each task; Full PhysEvo differs only in persisting new Meta diagnostic resources into subsequent sessions. Thus, Full receives neither a better starting interface nor exclusive per-task tuning privileges.
  • Across the 6 paired blocks, Full wins 3, ties 2, and loses 1. Notably, Fold Clothes improves from 60.00 under Fixed Meta to 86.67 under Full (whereas Insert Tubes favors Fixed Meta: 90.00 vs. 73.33), confirming that positive gains extend beyond pouring. Because the shared start already includes joint control, this study tests continued improvement rather than reconstructing the historical TCP/local-IK transition.

Evaluation: All development artifacts were frozen before testing. The reported comparison uses the same three held-out layouts per task.

Q2: What changes during RSI, and what is quantified?

  • Direct Answer: The +16.7-percentage-point SR gain in the ablation above quantifies the overall effect of enabling persistent Meta-resource updates, while our logged cross-session trace demonstrates how inherited diagnostic tools drive concrete Task revisions. In our pouring chain: (1) Session 1 builds an event-alignment and visibility-checking resource around the first ball release (code aligns images, actions, and feedback; Codex inspects key frames and labels the vase opening as visible, occluded, or uncertain); (2) Session 2 invokes this inherited resource to detect continued blind pouring without landing evidence, revises observation scheduling and tilt control, and develops projection-assumption and completion-condition checks; (3) Session 3 inherits those checks to revise localization, release verification, and upright recovery. Independent sessions inherit approved tool resources rather than full conversation histories or temporary workspaces.

Continued in Part 2/2: costs, comparisons, and hardware.

AuthorsOpenReview ↗

Response to Reviewer 26Qy (2/2): Costs, comparisons, and hardware

Continued from Part 1/2; Q1–Q2 contain the controlled results and mechanism.

Q3: What are the protocol, compute costs, benchmark context, and external comparison conditions?

  • 1. Independent Development Costs & Reported-Comparison Accounting: Across the 6 development chains (18 Meta sessions) per active method, post-branching physical executions, HTTP attempts, and known token usage are:
SettingBranch ExecutionsTask HTTPMeta HTTPTotal HTTPKnown Tokens
Reflexion-style282,1339263,059131.31M (131,313,347)
Fixed Meta232,1128702,982132.33M (132,333,166)
Full PhysEvo222,0368792,915131.78M (131,782,233)
  • Development Usage & Reported-Comparison Accounting: Full used 22 branch executions and 2,915 HTTP attempts, the fewest in this batch; recorded post-branch token counts were similar across methods. Checkpoints 0/3/6 are protocol allowances, with early-stopped versions carried forward. Combining 83 development runs (6 shared rollouts [663 HTTP / 13.86M tokens] + 73 branch runs + 4 screening runs [328 HTTP / 7.90M tokens]), 63 unique tests supporting 117 report positions (6,851 HTTP / 212.96M tokens; pre-outcome caching of identical frozen configurations), and 4 infra checks, the development runs and tests covered by this accounting amount to 146 physical executions, 16,802 HTTP attempts (including retries/failures), and 630,153,958 known tokens.

  • 2. Historical Runtime Measurements: Across 15 fully timestamped historical episodes (2,300 HTTP attempts), an episode averages ~153 attempts and 52.45 min total elapsed time: 44.76 min (about 85%) waiting for cloud API responses (mean 17.5s/attempt), 7.60 min for startup, motion, and tools, and 5.45s for local queuing and retry backoff.

  • 3. RoboDojo Context & External Baselines: RoboDojo spans 42 tasks across 5 capability dimensions (generalization, precision, long-horizon, memory, open-ended). The 8-task subset follows the external report's criterion (VLA SR >= 20%, direct-Astra SR < 5%) to target manipulation bottlenecks. In the original external comparisons, RoboDawn (1-shot) is an ICL system reference whose released RoboDojo adapter supplies a task demonstration, current camera images, and textual episode memory (a 12-turn command/outcome history and a model-written scratchpad) in each request, whereas PhysEvo loads frozen tools and skills without a demonstration trajectory and provides indexed retrieval of saved same-episode RGB through review_frames. The external comparisons use published records, not same-protocol reruns; Q1 provides internal controls with shared starting resources and development-budget rules to test the improvement mechanism.

Q4: What do the real-world results establish?

  • Direct Answer: We additionally report 25 trials (5 tasks × 5 trials) on AgileX PiPER: 90.60 mean Score and 84.0% SR. Specifically, Stack Blocks, Stack Bowls, and Place Pens each reach 100 Score / 100% SR; Pour Water reaches 60 Score / 60% SR; and Write “PhysEvo” reaches 93 Score / 60% SR.
  • Sim-to-Real Discrepancies & Adaptations: Two concrete adaptations address physical gaps: (1) forward momentum of real liquid streams caused cup overshoot, prompting the Meta-agent to shift the bottle pouring offset backward; and (2) lower positioning accuracy of the physical arm from distant views prompted the Meta-agent to reverse the simulation "geometry-first" sequence into a "coarse visual approach followed by close-range geometric refinement" strategy.

Summary

Under identical starting resources and similar recorded post-branch development token counts (~132M per method across six chains), our new controlled study against a capable Task-revising developer (Fixed Meta) demonstrates a net gain of +14.44 Score points and +16.7 percentage points in SR, backed by explicit cross-session tool-inheritance traces. We hope these additions resolve your concerns and support raising your score.

AuthorsOpenReview ↗

Follow-up on the initial harness baseline and attribution of gains

Dear Reviewer 26Qy,

On November 18, we reported an additional baseline in another thread that speaks directly to your question about the initial harness. We wanted to share it here alongside the controlled comparison from our earlier response.

  • Initial harness. In the historical seed-0 batch, the initial TCP/local-IK harness succeeded on 4 of 42 tasks (9.52% SR, 15.71 mean Score), with one attempt per task, and scored zero on each of the three tasks used in the controlled study—confirming that the starting interface alone does not account for the final gains.

  • Per-task tuning and recursive improvement. In the separate controlled study, Fixed Meta and Full PhysEvo shared the same joint-control starting harness (22.2% SR) and the same initial rollout within each paired block. Both could revise task skills and code. Full could additionally retain revisions to its own diagnostic tools, knowledge, and workflows across sessions. Across six paired blocks, Fixed Meta reached 55.6% SR (61.11 mean Score) and Full reached 72.2% SR (75.56 mean Score), an observed gain of +16.7 percentage points (+14.44 Score) from persisting revised Meta resources.

  • Costs, benchmark context, and hardware. Full and Fixed Meta each used about 132M recorded post-branch development tokens, and historical runtime averaged 52.45 minutes per episode across 15 timestamped runs. Part 2 also explains how the eight-task subset was selected, identifies which baseline results came from published reports, and reports 21 successes in 25 hardware adaptation trials across five tasks (84.0% SR, 90.60 mean Score; execution videos).

Do this initial baseline, the controlled comparison, and the added protocol details address the concerns from your review? We would appreciate hearing if any question remains open while the discussion is active. Thank you for your time!

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

Related papers

Loading the map…

Discussion (0)

Sign in to comment.