cs.ROOct 13, 2026
SaveEmbodiedEvo: Self-Evolving Coding Agent For Physical Intelligence
Organizations: Navers Lab, Einsia.AI, Tsinghua University
Abstract
Coding agents can construct executable programs and revise them through feedback, offering a foundation for embodied control without target-task fine-tuning. Through a programmatic robot interface, the agent observes the scene, executes control programs, and adapts them to the resulting physical state, serving as the closed-loop policy. However, this within-episode adaptation does not automatically preserve experience across scenes. Our trajectory analysis shows that agents spend interaction and inference budgets establishing effective operations and identifying their preconditions, while fresh agents cannot reuse these discoveries. This motivates EmbodiedEvo, a self-evolving coding agent that distills physical feedback into reusable code Skills and diagnostic Lessons. Experience is acquired on one Playground scene per task, then frozen for independent agents in unseen scenes, without updating model weights. On RoboDojo-Sim, EmbodiedEvo achieves an average score of 44.48 and a success rate of 37.82%, surpassing all officially verified results. Paired tests show the largest gains on memory-dependent tasks and successful reuse of coordinated procedures, while fine contact control remains difficult. Experience from stronger models also improves weaker executors: Astra's experience raises Sol and Luna's success rates by 8.86 and 5.50 percentage points over no experience. Compared with raw interaction history, Skills and Lessons achieve comparable task performance at 53.0% lower execution cost.
Figures & tables
Figure 1: Overview of EmbodiedEvo. During task-specific Playground interaction, a coding agent develops control programs and revises reusable Skills and Lessons through physical feedback. The resulting harness is frozen and inherited by fresh Test agents on new scenes.
Figure 2: Comparison of embodied control paradigms. (a) A VLA policy emits native action chunks. (b) An agent orchestrates a VLA policy while retaining its action-generation role. (c) A single-turn LLM/VLM produces a structured action specification for an adapter. (d) A coding agent develops and revises executable programs through environmental feedback, composing primitive calls (L1) into evolved procedures (L2). The dashed loop shows execution feedback for program revision.
| Primitive | Function |
|---|---|
| get_instruction() | Returns the current task and goal. |
| get_observation() | Returns camera images and robot state without advancing physics. |
| step(action) | Executes a native action and returns the resulting observation, completion signal, and termination status. |
| reset() | Restores the same scene for another exploration attempt and renews its native action allowance. |
Table 1: Native environment interface. The first three primitives are available in both phases; reset is restricted to Playground phase.
Figure 3: Code-to-task mapping through a unified simulation interface. The agent develops submission/solution.py within its workspace and submits it to an adapter. The adapter executes the program and issues native step(action) calls through the unified interface to the selected benchmark backend.
| Component | Role and access |
|---|---|
| instruction.md | Fixed task delegation, phase rules, and budgets. |
| primitives/primitives.md | Fixed documentation of the robot interface. |
| submission/solution.py | Editable Python source for the next control segment. |
| scripts/env.py | Fixed client for execution, status queries, and session completion. |
| observations/ | Host-written history of submitted source, observations, video, and execution logs. |
| scratch/ | Writable plans, calculations, and temporary analyses. |
Table 2: Software-engineering workspace. Paths are relative to the agent’s workspace root. Protocol files and execution records are read-only to the agent.
Figure 4: Two failure trajectories of Astra. (a) Two empty lifts precede the first retained grasp; the episode later exhausts its budget without completion. (b) Observation switches to manipulation during an unfinished demonstration, followed by termination. Boxes identify relevant objects. The table reports Astra’s averages over all tested scenes of each task.
Figure 5: EmbodiedEvo framework. Left: on one Playground scene, the agent edits and executes code, uses feedback to revise Skills and Lessons, and reuses them in subsequent attempts. The Freeze arrow transfers these artifacts to Test. Right: each unseen scene starts with a fresh agent and runtime; code adapts through feedback while the harness stays read-only. Robot scenes are schematic.
| Model | Type | Average | Generalization | Precision | Long-horizon | Memory | Open |
|---|---|---|---|---|---|---|---|
| Score SR (%) | Score SR (%) | Score SR (%) | Score SR (%) | Score SR (%) | Score SR (%) | ||
| GPT-6-Astra | Agent | 28.97 22.48 | 33.36 30.50 | 12.65 4.00 | 21.45 8.25 | 43.04 38.67 | 34.36 31.00 |
| InternW0- | WAM | 30.77 23.91 | 30.09 22.78 | 31.98 23.25 | 46.29 29.33 | 34.67 34.00 | 10.84 10.17 |
| Simate-beta | VLA | 33.95 27.96 | 35.09 27.95 | 34.35 26.92 | 57.84 43.42 | 33.33 33.00 | 9.12 8.50 |
| Awomo-0.5 | WAM | 35.34 29.64 | 30.31 23.84 | 39.65 33.50 | 40.36 26.75 | 42.27 41.22 | 24.09 22.92 |
| PhysicalRSI | Agent + VLA | 36.27 31.38 | 21.30 15.62 | 38.05 32.50 | 46.37 37.33 | 46.74 46.56 | 28.88 24.92 |
Table 3: Full RoboDojo simulation evaluation. EmbodiedEvo alongside selected systems from the October 9, 2026 leaderboard snapshot, ordered by increasing Average Score. Score and success rate (SR, %) are higher-is-better; bold marks the best value in each metric column.
| Method | Input | Average | Generalization | Memory | Precision | Long-horizon | Open |
|---|---|---|---|---|---|---|---|
| Score SR (%) | Score SR (%) | Score SR (%) | Score SR (%) | Score SR (%) | Score SR (%) | ||
| Astra | Task description | 14.77 8.50 | 3.19 0.00 | 12.67 10.00 | 11.38 5.00 | 18.12 0.00 | 28.50 27.50 |
| EmbodiedEvo (Astra) | Task description | 38.64 30.17 | 22.36 16.67 | 59.33 56.67 | 29.88 15.00 | 29.50 12.50 | 52.12 50.00 |
| Astra | Task description + wiki | 20.67 13.36 | 12.33 7.64 | 39.67 36.67 | 15.00 7.50 | 19.38 0.00 | 17.00 15.00 |
| EmbodiedEvo (Astra) | Task description + wiki | 42.42 35.08 | 36.15 31.25 | 70.33 66.67 | 23.12 12.50 | 33.75 20.00 | 48.75 45.00 |
Table 4: Task knowledge and inherited experience. All rows use Astra/xhigh on matched scenes. Each cell reports Score / SR (%).
Figure 6: Effect of EmbodiedEvo with and without wiki. Score (points) and SR (percentage points) gains over Astra/xhigh on matched scenes and inputs: (a) task description only; (b) task description + wiki.
| Task | Category | Astra | EmbodiedEvo (Astra) | SR (pp) | ||
|---|---|---|---|---|---|---|
| Score | SR (%) | Score | SR (%) | |||
| (1) Successful before evolution | ||||||
| Align blocks | Open | 60 | 60 | 80 | 80 | |
| Conveyor matching | Memory | 60 | 60 | 100 | 100 | |
| (2) Successful only after evolution | ||||||
| Stack blocks | Generalization | 10 | 0 | 100 | 100 | |
Table 5: Task performance before and after harness evolution. Selected tasks with the same Astra/xhigh executor and matched dev scenes. Bold marks the higher value within each before/after pair; SR is the change in percentage points. Groups describe observed success in these scenes.
Figure 7: New capability: changes at the decisive operation or phase. Each row compares Astra and EmbodiedEvo on the same task and scene. (a) Tic-tac-toe, layout 27: empty pickup versus an inherited rim grasp and completed board. The first pickups use different rings and arms. (b) Imitation sorting, layout 4: early motion versus observing the complete new order before executing it. Both timing and motion differ; the baseline feedback does not identify the termination cause. Frames show selected decision points, not synchronized times.
Figure 8: Remaining limit: unsuccessful contact transfer. EmbodiedEvo, insert key, layout 44. The donor retains the key, but the receiver closes without grasping the shaft (highlighted); the final release loses the key (highlighted). Wrist observations and gripper feedback locate the failure at handover, before insertion. This episode scores 15 with no success, matching the task’s dev-set mean.
| Executor | Average | Generalization | Precision | Long-horizon | Memory | Open |
|---|---|---|---|---|---|---|
| Score SR (%) | Score SR (%) | Score SR (%) | Score SR (%) | Score SR (%) | Score SR (%) | |
| No Experience (No Evolution) | ||||||
| Astra / xhigh | 14.77 8.50 | 3.19 0.00 | 11.38 5.00 | 18.12 0.00 | 12.67 10.00 | 28.50 27.50 |
| Astra / medium | 6.58 4.33 | 1.81 0.00 | 2.88 0.00 | 5.88 0.00 | 7.33 6.67 | 15.00 15.00 |
| Sol / xhigh | 4.10 3.17 | 0.56 0.00 | 3.00 2.50 | 3.12 0.00 | 3.33 3.33 | 10.50 10.00 |
| Luna / xhigh | 0.08 0.00 | 0.42 0.00 | 0.00 0.00 | 0.00 0.00 | 0.00 0.00 | 0.00 0.00 |
Table 6: Performance under three experience conditions. Score and success rate (SR, %) are higher-is-better. Each executor uses matched scenes across conditions. Self-evolved harnesses are acquired by the listed executor; the final group reuses frozen experience from Astra/xhigh.
Figure 9: Experience transfer to weaker executors. Each executor is evaluated on the same scenes under the three conditions used in Table 6 : No Experience (No Evolution), Self-Evolved Harness, and Harness from Astra/xhigh. The latter reuses frozen experience without additional exploration. Astra/medium compares source reasoning strengths within the same model; Sol/xhigh and Luna/xhigh test cross-model reuse.
Figure 10: Performance gains from experience across tasks. Each bar is the change from No Experience on the same target scenes, with Astra/xhigh fixed. Score uses points and SR uses percentage points; zero denotes the No Experience reference. Gains weight the twelve targets equally after combining Generalization variants. Related-task and mismatched-task harnesses require no new target-task exploration; the same-task harness is shown as a reference.
Figure 11: Comparable performance with lower token use. The executor, source Playground, and Test scenes are fixed. (a–b) Raw History and Skills/Lessons achieve similar observed Score and SR. (c) Skills/Lessons reduce total Test tokens by 11.3%. (d) The reduction comes from input usage, while output increases. Tokens are cumulative per episode, with cache reads included in input.
| Exploration | Observed progress and retained knowledge |
|---|---|
| Task outcome | No task success across 100 code executions. |
| Local progress | Execution 74: tracked grasp and 6 cm lift in 31 native actions. |
| Skills | Track a moving target through closure; monitor contact during transport. |
| Lessons | Anticipate conveyor motion; verify object retention after a short lift. |
| Test condition | Score / SR (%) |
| No experience | 0 / 0 |
Table 7: Useful experience without Playground task success. Astra/xhigh on image-conditioned conveyor pickup; frozen experience is evaluated on new scenes.
Figure 12: A correction retained with an execution check. Left: Playground execution 16 records a dropped load. Center: the frozen lesson distinguishes reached pose from retained load, and the controller limits motion using the observed pose. Test execution 9 calls it with an 8 mm bound. Right: the later successful stack at execution 15. The controller is abridged pseudocode; the lesson excerpt and call parameter come from the retained artifacts and Test program.
| Experience | Score | SR (%) | Cost (USD) | Code executions | Native actions |
|---|---|---|---|---|---|
| No Experience | 14.77 | 8.50 | 4.058 | 22.3 | 723.0 |
| Raw History | 36.41 | 29.78 | 12.203 | 23.7 | 705.1 |
| Skills/Lessons | 38.64 | 30.17 | 5.732 | 29.0 | 722.6 |
Table 8: Performance and execution expense at a fixed executor. Astra/xhigh on matched dev scenes. Costs and interaction counts are per-episode means, including failures. Raw History and Skills/Lessons use the same Playground source.
Appendix figures & tables7 assets
Supplementary material from the paper’s appendix.
Appendix
| Task | Task description | Task description + wiki | ||
|---|---|---|---|---|
| Astra | EmbodiedEvo | Astra | EmbodiedEvo | |
| Generalization | 3.19 / 0.00 | 22.36 / 16.67 | 12.33 / 7.64 | 36.15 / 31.25 |
| arrange_largest_number | 3.75 / 0.00 | 13.75 / 0.00 | 8.33 / 0.00 | 49.17 / 41.67 |
| fold_clothes | 11.67 / 0.00 | 13.33 / 0.00 | 33.33 / 16.67 | 70.00 / 66.67 |
| hang_mugs | 0.00 / 0.00 | 10.00 / 0.00 | 0.00 / 0.00 | 8.75 / 0.00 |
| make_toast | 0.00 / 0.00 | 0.00 / 0.00 | 0.00 / 0.00 | 0.00 / 0.00 |
Table 9: Per-task dev-set results. Each cell is Score / SR (%); all four conditions use Astra/xhigh on matched scenes. Shaded category rows report means; the final row reports the overall Average.
| Task / category | Score | SR (%) |
|---|---|---|
| Generalization | 34.12 | 29.67 |
| arrange_largest_number | 58.20 | 46.00 |
| fold_clothes | 66.80 | 60.00 |
| hang_mugs | 5.40 | 0.00 |
| make_toast | 1.50 | 0.00 |
| pack_objects_into_box | 20.30 | 4.00 |
Table 10: Per-task full-set results for EmbodiedEvo (Astra/xhigh). Task description + wiki, from the completed evaluation in Table 3 . Shaded category rows report means; the final row reports the overall Average.
| Target | Related source | Mismatched source | B | D | Related | Mismatched |
|---|---|---|---|---|---|---|
| Score SR (%) | Score SR (%) | Score SR (%) | Score SR (%) | |||
| stack bowls | stack blocks | swap blocks | 6.25 0.00 | 25.42 16.67 | 25.42 16.67 | 15.00 0.00 |
| stack blocks | stack bowls | swap T | 10.00 0.00 | 100.00 100.00 | 100.00 100.00 | 83.33 83.33 |
| insert tubes | plug in charger | classify objects | 4.00 0.00 | 36.00 0.00 | 60.00 40.00 | 4.00 0.00 |
| plug in charger | insert tubes | classify objects by language | 0.00 0.00 | 40.00 40.00 | 0.00 0.00 | 0.00 0.00 |
| fill pen holder | fill egg holder | pour liquid into cup | 15.00 0.00 | 5.00 0.00 | 2.00 0.00 | 17.00 0.00 |
Table 11: Cross-task sources and target outcomes. Each outcome is Score / SR (%). Related and mismatched sources are fixed before these transfer runs; B and D reuse the same target-scene results.
| Task / layout | Key execution evidence |
|---|---|
| Tic-tac-toe / 27 | Astra first retains a ring at action 367 and ends with Score 50 at the 1,100-action limit. EmbodiedEvo includes rim_pick.py , retains a ring at action 38, and succeeds at action 919. First rings and arms differ. |
| Imitation sorting / 4 | Astra moves before the demonstration finishes and terminates at action 256 with Score 0; feedback does not identify the cause. EmbodiedEvo observes the new order through action 455 and succeeds at action 1,585. |
| Insert key / 44 | EmbodiedEvo’s receiver closes empty in execution 14 and remains unsecured through execution 21. Donor release reaches the 300-action limit with Score 15. Failure occurs during handover, before insertion. |
Table 12: Execution evidence for the capability analysis. Action counts refer to native simulator actions; layout IDs identify the matched scenes.
Figure 13: Success, transfer, and regression on matched scenes. (a) Language stacking, Astra/xhigh, layout 37: the self-harness completes the stack. (b) Cover/uncover, Sol/xhigh, layout 38: Astra’s harness succeeds where Sol’s own harness fails. (c) Elephant pickup, Astra/xhigh, layout 15: Astra succeeds without experience but loses the object with its self-harness. Frames are original observations from independent runs, with identical crops. Labels show official Scores and execution indices.
Figure 14: A retained Skill and two Lessons in actual reuse. (a) The complete frozen pick_from_above function composes the measured-pose move_ee controller into descent, closure, and lifting. It checks alignment and the action budget, then returns for visual retention verification. The same source is included verbatim in Test execution 2 and called for orange, blue, and yellow in executions 4, 8, and 12. (b–c) The lesson descriptions paraphrase the frozen downward_approach.md ; the highlighted Test snippets are verbatim. The complete episode is shown in Appendix F .
Figure 15: Endpoints of the complete stacking episode. The initial head view is opened by the agent; the terminal image is recorded by the environment. After execution 15, the agent receives the success feedback and ends without a further image-opening call. The required final order is orange–blue–yellow from bottom to top.