Imagine a new insurance adjuster who starts from zero every single day. Yesterday he figured out he needed to retake photos he'd missed; today, on a new case, that experience doesn't come with him. He repeats the same detours in every case, spending budget that should close claims on rediscovering that 'you should look at the scene first.'
This is exactly the situation of today's robot agents. Frontier coding agents can already control robots through programmatic APIs: observe a scene, write control code, revise it based on physical feedback. Their zero-shot success rates are starting to approach VLA and world-action-model systems trained on similar scenarios. The problem is not that they can't learn within a single task — it's that experience accumulated in each task is not automatically inherited by the next agent (per the EmbodiedEvo abstract).
EmbodiedEvo, uploaded to arXiv on October 13 (paper 2610.18867, revised v2 the next day), offers a solution: let the agent practice in training scenarios first, distill the experience into reusable code skills and diagnostic lessons, freeze them, and hand everything to a brand-new agent entering the exam. Without touching model weights, experience is inherited anyway.
🧬 One harness, three phases of life
The entire mechanism of this system lies in the form experience takes.
The agent controls the robot with Python programs. The workspace contains a fixed task description, an interface document, editable control source code, plus an execution client. Programs are submitted through an adapter that translates code actions into the robot's native actions, and sends back camera images, robot state, stdout, and completion signals. State, variables, and functions persist across multiple submissions — editing code does not undo already-executed actions, so every new program must adapt to the current physical situation.
The environment exposes only four primitives: read task, view observation, execute action, reset scene. Ground-truth object poses, depth, and camera calibration are never provided. The interface is deliberately thin: the agent can only call what it writes itself.
Skills and lessons have a clear division of labor. Skills answer *how* to do an action — for example, a parameterized lift with verification, callable by later programs. Lessons answer *when* to act and what signals mean one should back off, recording failure modes and recovery guidance. Using the adjuster metaphor: skills are the moves in his hands, lessons are the precepts in his head. One governs execution; the other, judgment.
A telling detail from the paper: one task failed all 100 code executions during the practice phase, yet the agent still distilled two skills from the failures — tracking moving targets and monitoring contact during transport. In the exam, that task went from zero to full marks. Even unfinished problems leave notes.
📊 Where the gains are — and aren't
The exam venue is RoboDojo-Sim, called the Mount Everest of embodied intelligence. 42 tasks in five categories: 12 generalization, 8 precision manipulation, 8 long-horizon, 6 memory, 8 open. Full evaluation uses 50 scenarios per task — 2,100 episodes total. Budget per episode and per practice chain: at most 100 accepted code executions.
RoboDojo-Sim full-set results (paper Table 3)
| System | Type | Avg score | Success rate | Memory success | Open success | |---|---|---|---|---|---| | GPT-6 Astra (bare) | Coding agent | 28.97 | 22.48% | 38.67% | 31.00% | | Simate-beta | VLA | 33.95 | 27.96% | 33.00% | 8.50% | | PhysicalRSI | Agent + VLA | 36.27 | 31.38% | 46.56% | 24.92% | | VPP2 | World action model | 39.26 | 32.26% | 55.56% | 4.08% | | EmbodiedEvo | Coding agent | 44.48 | 37.82% | 69.67% | 53.00% |
44.48 and 37.82% are the paper v2 abstract's numbers, exceeding all officially verified results. Chinese media widely cited 45.08 and 38.95% from an earlier version; where the two figures coexist, the paper takes precedence.
Paired tests put the same executor on the same scenarios: with only task descriptions, average score rose from 14.77 to 38.64 and success rate from 8.50% to 30.17% — a gain of over twenty percentage points, uncontaminated by benchmark differences.
Among the five systems, EmbodiedEvo is the only column that doesn't swap out weights.
The biggest jumps come in memory and open categories. Memory success hits 69.67%, fourteen points above the next-best world action model; open tasks reach 53.00%, twenty-two points above bare Astra. These are precisely the home turf of 'remembering last time' and 'new jobs never seen before' — matching the design goals of this mechanism.
What didn't improve is equally clear. Precision manipulation succeeded only 13.25% of the time, long-horizon 23.50% — lower than Simate-beta's 43.42%. The paper names the typical death: in a key-insertion task, the gripper holding the key hands off to the wrist gripper, which closes on empty air; the key drops to the ground before actions run out. The problem is the handoff, not the insertion. Inaccurate contact geometry, unstable inter-action transitions, and insufficient local program verification are listed by the authors as open issues.
🔁 Experience can even be inherited across models and tasks
A more counterintuitive layer: frozen experience doesn't care which model executes it.
Handing experience accumulated by Astra to a weaker model: Sol's success rate rose from 3.17% to 12.03% (+8.86 points); Luna's from 0% to 5.50%. The same Astra on a medium reasoning tier gained 18.72 points. Strong models scout the path, weak models walk it — a division of labor that previously required distilling weights, now accomplished with a read-only artifact.
Cross-task transfer results are stranger still. Using experience trained on other tasks to test a target task: same-task gains were 21.39 points, semantically related tasks 14.72 points — while completely unrelated tasks yielded 16.67 points, actually higher than related ones. Semantic similarity of task labels does not predict whether experience helps. The paper offers no explanation, so no conclusion is drawn here.
The accounting matters too. Compared with stuffing raw interaction histories into the agent, the skills-plus-lessons representation cut per-episode cost from $12.203 to $5.732 — a 53.0% reduction — at the same performance level. Uncached input tokens dropped 87.9%. But compared with giving no experience at all, using experience raised per-episode cost from $4.058 to $5.732, up 41.3%. Experience is not a free lunch: it shifts cost from repeated trial-and-error to sustained interaction.
🧭 Between the simulation Everest and real hardware
The 44.48 was scored in simulation. The paper contains no real-robot experiments; generalization beyond RoboDojo-Sim and performance under real contact physics are entirely blank. The handoff failures exposed in contact tasks hint at the hardest wall between sim and real: in simulation, a gripper closing on empty air is just a number; on a real robot, the key rolls under the table.
The real appeal of this route is a different kind of economy. Raising robot capability has mostly meant updating weights — more data, more training compute. EmbodiedEvo deposits capability in the harness, the outer structure, touching neither the model nor caring about the robot's embodiment. Roads scouted by strong models can be walked by weak ones; problems practiced today remain usable tomorrow. Whether this road can run from simulation to real hardware — the paper doesn't say. The market will answer.
---
References
- Wenyi Li et al., *EmbodiedEvo: Self-Evolving Coding Agent For Physical Intelligence*, arXiv:2610.18867[v2]. https://arxiv.org/abs/2610.18867
- EmbodiedEvo project page, Einsia AI Navers Lab. https://lab.einsia.ai/embodiedevo/
- EmbodiedEvo code repository. https://github.com/Einsia/EmbodiedEvo