What Stops Recursive Self-Improvement in Robotics? Lessons from 123 Rounds of Agentic Skill Discovery

TL;DR

Jiaming Wang (NUS) built an agentic self-improvement system (orchestrator + proposer + research agents, backed by GPT-5.6 Sol then GPT-6 Astra via Codex CLI) and ran it for 123 continuous rounds on a RoboCasa household task (place condiments on the top shelf of a fridge). The agent can discover missing capabilities on its own — it invented an active-search skill from scratch — but across 123 rounds the target task never succeeded, and local improvements kept passing their gates without compounding. The report attributes the standstill to three structural problems around the agent: chained perception modules do not represent relations (“the top shelf”), skill chains lock learning onto the first failing step via double attenuation of value and evidence, and the harness (evaluators, memory, action descriptions) silently determines what the agent learns — needing roughly two human harness repairs per accepted skill change. The paper proposes a three-condition framework (representability / expressibility / resolvability) that an improvement must satisfy to compound, and reads the entire run through it.

Key claims

A coding agent constrained to write skill code cannot add relational perception; it instead displaces missing semantics into ever-growing geometric rules, a failure mode the paper names semantic displacement — the fridge region skill accumulated 33 thresholds over ~3,000 lines without ever converging across two recorded head viewpoints [§5].
A 7B open-weights VLM (Qwen2.5-VL) placed “the top shelf” correctly on all four recorded head views in ~1s per query, but switching model class was outside the agent’s action space; even after a human suggested VLMs, the first agent-registered grounders were filed under a family whose code never called them [§5].
Long task chains cause double attenuation: a change to step $k$ scales task success by $R_k \cdot P(\text{continue after }k)$ and the evidence about step $k$ scales by the same reach factor $R_k$ , so a downstream repair is attenuated once in value and once in measurability — in the run, >50% of fridge rollouts failed step 1 and almost none got past step 4, so nearly all accepted changes went to perception [§6, Fig. 1c, Fig. 5a].
Failures surface downstream of their causes: a localizer that returns a confident wrong point produces “no grasp contact” and “unreachable” verdicts in later steps, and because the loop attributes failures to the step where they surface, proposers were sent to repair the wrong skill family for many rounds [§6].
“Task success” is not “program success”: the only task that ever succeeded (sink) mostly succeeded by accident — the gripper opened elsewhere and the object fell into the sink — and the program alternated success/failure across rounds because an upstream pose estimate took one of a few discrete values [§6].
The agent optimized exactly what the evaluator measured, including where the evaluator was wrong: a spherical reach evaluator taught the agent to park on the sphere surface, and a missing torso lift in the actuator description taught it to work around a non-existent constraint [§7].
The research-agent memory recorded silently-dropped requests as failures, which stopped the loop from re-requesting vision-language grounders even after their predecessors never ran — demonstrating that the memory substrate is a selection mechanism, not neutral storage [§7].
Keeping the harness honest took roughly two human repairs per accepted skill change over 123 rounds; the agent was rarely the bottleneck in diagnosis — when it declined to change a skill and explained why, it was often pointing at a real harness bug [§3 “What worked”].
The paper proposes three conditions an improvement must jointly satisfy to compound: representability (the failure is described correctly in the evidence the proposer sees), expressibility (a fix exists in the substrate the proposer can change), resolvability (the gate can distinguish a better change from a worse one on the states where the change matters). All three hold almost for free in software; each one broke in the robotics run [§4, Table 2].
The one front where all three conditions held — active search for out-of-view targets — is the one the agent solved end-to-end, requesting a target-free active-viewpoint model, debugging the planner (its own start cell was marked occupied), and deploying a look-around skill by round 16 with no human robot code [§3 “Phase 1”].

Method

The system treats the robot’s software as something an agent can rewrite and lets failures drive the rewrites. A task program is Python that composes skills with declared per-step preconditions and postconditions. A skill has typed I/O and multiple implementations; routing picks among them. Skills call providers — external models behind a contract (SAM 3 for text-prompted segmentation, Florence-2 for referring-expression segmentation, monocular depth, 6-DoF grasp generation, motion planning). All inputs come from head/wrist RGB-D cameras and joint readings, as on a real robot. An orchestrator agent writes task programs; a proposer agent (multimodal, receives RGB keyframes of failed steps as images) writes skill-code changes under a sequence of physical tests (replay the recorded failure, paired old-vs-new trials on fresh scenes, held-out task); a research agent finds and wraps external models when the proposer declares a code change insufficient. All three run as separate Codex CLI sessions in sandboxed containers against GPT-5.6 Sol at max effort (rounds 1–75), then GPT-6 Astra at low (76–84) and medium (85–123) effort. The one layer only humans may change is the harness itself: evaluators, tests, memory, and actuator descriptions.

The author then builds a minimal three-condition compounding model (§4): representability, expressibility, resolvability. The run is read front-by-front through this lens (Table 2) — active search (all three held, agent solved it), relational perception (representability + expressibility both failed, loop displaced semantics into geometry), grasp retention (resolvability failed because fresh tests rarely reached grasp), reachability (resolvability held but the evaluator shape and actuator description were wrong), requested models (resolvability failed via silent request-drop + memory misattribution).

Results

123 rounds over several weeks of continuous operation on three RoboCasa kitchen tasks (Fridge target, Cabinet, Sink) plus a held-out task; a round took 1–3 hours (plus several hours when models were researched) [§2 “Tasks”].
Target task (Fridge: place mustard + mayonnaise on top shelf): never succeeded across 123 rounds. In the last twenty rounds, three of four fridge seeds failed at finding the top shelf every round and the fourth at grasping [§3 “Phase 3”].
Cabinet task: never succeeded [§3].
Sink task: first successes at round 78; “mostly accidental drops” — the gripper opened elsewhere and the object fell in [§3].
Eight agent-introduced external models used in deployment: grasp generation, motion planning, base planning, active viewing, relational localization (categories listed; agent-sourced and installed with no human robot code) [§3 “What worked”].
Active-viewing search skill: invented, requested, debugged (planner bug — robot’s start cell marked occupied — identified and repaired), and deployed by round 16, after which out-of-view failures disappeared [§3 “Phase 1”].
Fridge region skill: accumulated 33 thresholds in ~3,000 lines across 27 attempts; one seed consistently rescued, one never [§5].
Qwen2.5-VL (7B open-weights) tested post-hoc on four recorded head views placed “top shelf” and “shelf below” correctly in all four, ~1s per query [§5].
Human harness repairs per accepted skill change: ~2 [§3 “What did not work”].
First approach skill accepted: round 62; first grasp skill: round 63; first task success (Sink, mostly accidental): round 78 [§3 “Phase 2”].
Grasp improvement in round 118 won reproduced paired comparisons on unseen scenes including the held-out task; the next five rounds produced zero task successes [§3 “Phase 3”, §6].

Why it’s interesting

This is the first filed paper that answers the question Toward Recursive Self-Improvement in Physical AI (Luo et al.’s physical-RSI survey) frames as the open measurement gap — “no reviewed physical study isolates a gain attributable to recursion itself” — with 123 rounds of empirical evidence for why the gap exists. Where ASPIRE — self-evolving sensorimotor skill library that compounds across robots and the sim-to-real gap (Jim Fan / NVIDIA GEAR) / ASPIRE: Agentic /Skills Discovery for Robotics ASPIRE and ENPIRE: Agentic Robot Policy Self-Improvement in the Real World ENPIRE report headline success numbers from their self-improvement loops, this paper runs a close architectural cousin (coding agent + skill library + evolutionary-ish gates + external-model research) with explicit human-only harness editing and reports what breaks. The three-condition framework (representability / expressibility / resolvability) is a sharper diagnostic than the four-gates framing in Luo et al. and maps directly onto the “frontier lock” phenomenon RoboRSI: Stable, Efficient, and Reusable Robot Self-Evolution in Complex Real-World Environments RoboRSI’s iteration-time metric was designed to avoid. The semantic-displacement finding is also the strongest filed challenge to date on the pure-code-rewrite agent recipe: a frontier VLM proposer that could itself see the top shelf correctly in keyframes could not transfer that ability to the robot because its only channel was code — directly relevant to VLM Perception Failures‘s binding-problem thread.