Compile Once, Run Cheap: Frozen, Portable Skills for Embodied Agents, and What Recursive Self-Improvement Adds

Authors: Jingwen Bai, Guochao Bai, Canbo Zhang, Shuangqi Li, Minchao Hu, Weichun Huang, Shuang Liu

Affiliation: Beijing Ou Rui Ling Shi Technology Co., Ltd., ChangingTek Robotics Technology (Suzhou) Co., Ltd., Shanghai Yunfan Intelligent Control Robot Technology Co., Ltd.

Status: arXiv preprint, manuscript version 3.6, 17 October 2026

---

Summary (Overview)

• Core contribution: The paper introduces Skill-RSI (Skill-level Recursive Self-Improvement), a protocol that separates skill authoring from skill execution: a strong general model acts only as an offline author that writes, executes, diagnoses, and repairs manipulation skills in simulation until they pass a qualification exam on layouts drawn after freezing. The frozen skill then runs with no model at all or with a cheap caller from another model family.

• Key results: On 7 RoboTwin 2.0 tasks with cluttered tables, 4 tasks were compiled into 7 frozen skills by Claude Code at $4.29–8.22 per skill in author cost (or$55 per frozen skill when failed campaigns are counted). The frozen skills retained 148/150 successes with no model and 147/150 with a DeepSeek-flash caller at $0.00028–0.00054 of model cost per episode.

• Three unexpected findings: (1) Most frozen skills came from first drafts—the protocol's measured contribution on compiling tasks was qualification and freezing; (2) the qualification gate binds on rare safety aborts (not task completion), and more development layouts did not change that; (3) most of the per-round advantage of repair over rewriting comes from inheriting the previous version rather than from the runtime's development-layout feedback.

• Controlled experiments: On hidden layouts, repair beat from-scratch rewriting in 8 of 8 controlled campaigns (sign test $p = 0.004$); an inherit-only lineage showed most of that gap comes from inheritance, with development feedback adding a smaller increment (3 of 3 campaigns, $p = 0.125$).

• Cost accounting: The paper provides a full ledger of authoring costs including failed candidates. Compilation amortized over deployments yields per-episode costs below one cent at 1000 deployments.

---

Introduction and Theoretical Foundation

Background and Motivation

The authors observe that language models acquired agentic capabilities in a fixed order: web-scale pretraining produced a strong base model first, and only then did agent loops, tool harnesses, and reusable skills emerge on top. Embodied intelligence has no comparable corpus, so current routes to new manipulation capability face a dilemma:

1. Demonstration route: Collect demonstrations for every task or perform post-training (e.g., OpenVLA, $\pi_0$).
2. Per-episode reasoning route: Keep a frontier multimodal model in the control loop for every episode (e.g., GPT-6 Astra as a policy, reaching 22.5% success over 2,100 trials on 42 RoboDojo tasks).

The paper studies a third route: a strong general model acts only as an offline author that writes, executes, diagnoses, and repairs a manipulation skill in simulation until it passes a qualification exam on layouts drawn only after freezing. The frozen skill is then executed by code alone or by an inexpensive caller that reads nothing but its description.

Theoretical Foundation

The central hypothesis is that the order of the language-model history can be inverted for robots: skills can come before the strong embodied base model, be compiled by a strong general model that already exists, and let robots start working in specific scenes now.

The paper defines the setting as target-task weight-update-free: neither author nor executor parameters change for the target task; no new human teleoperation or expert trajectories are collected; simulation rollouts, environment predicates, structured traces, and the declared primitive API may be used; the external skill may change during compilation and never afterward.

What Is and Is Not Called RSI

The paper carefully delineates four stages:

• R0 (generate): Independent drafts of the package from the task card
• R1 (repair): Recursive refinement of a persistent package, where version $k+1$ is written from version $k$ and its execution evidence on development layouts
• R2 (qualify): An exam on layouts drawn after the package is frozen
• R3 (reuse): Execution of the frozen package by executors that did not author it

The recursion is over the artifact, not over the author. The paper explicitly states it does not claim meta-level improvement of the improver (level 5 in Duan et al.'s ordering).

---

Methodology

System Components

• Author $A$: A strong model product used only offline (Claude Code 2.1.284 with claude-opus-5-5, or Codex CLI 0.160.0 with gpt-6-astra)
• Executor $E$: A code-only runner or a caller model (deepseek-flash)
• Skill package $K$: Four files (SKILL.md, skills.py, perception.py, rationale.md) plus MANIFEST.json
• Kernel $D$: A fixed runtime exposing six primitives: observe, ee_pose, gripper_state, move_pose, gripper, wait
• Evaluator: Reads privileged simulator state to decide success (never seen by the author)

Protocol A: Compiling a Skill

The compile protocol includes:

• Preparation and lock: Task card with instruction, roles, success predicate source; a phase-0 health check calibrates the gripper and fixes the speed bar
• R0: Two independent author sessions write first drafts; the better draft becomes the lineage head
• R1: Repair rounds (max 10, or 3 without improvement, or $150 cost cap). Each round starts a fresh author session that sees the previous version, its per-layout outcomes, and comparison verdicts
• R2: Qualification exam on 100 seeds drawn after freezing, with gate: ≥95/100 success, zero safety aborts, speed ≤2× expert median, no regression on development layouts
• Control lineages: No-feedback rewrites (fresh drafts with no history) and inherit-only lineages (revise previous version but without runtime's development-layout feedback)

The learning-vs-selection comparison uses the formula:

$$\operatorname{Learn}(k) = \max\left(R_0 \cup \{r_1..r_k\}\right) - \max\left(R_0 \cup \{c_1..c_k\}\right) \tag{1}$$

Protocol B: Measuring Reuse

• Verifies file hashes against the manifest
• Draws 50 seeds disjoint from all compile-time seeds
• Two arms: F (fallback, no model) and O-ds (orchestrated with deepseek-flash caller reading only SKILL.md)

Author Isolation and Audit

The author runs in an OS sandbox restricted to its own directories. Every campaign ends with an automatic audit grading it: clean, metadata, review, contaminated, or unaudited. The last two invalidate the campaign. An earlier version without isolation found 5 of 58 campaigns where the author had read other campaigns' work—none of those campaigns are reported.

---

Empirical Validation / Results

Q1: Compiling to the Qualification Bar

Key findings:

• 7 of 20 primary-author campaigns produced a FrozenSkill on 4 of 7 tasks
• 5 of 7 frozen skills needed zero repair rounds (first drafts already met targets)
• The RSI delta (exam minus validation baseline) averaged +13.3 points on campaigns with ≥1 repair round

The Gate Binds on Rare Safety Aborts

• 12 of 20 campaigns scored ≥95 on the exam, but 5 of those failed due to safety aborts alone (1–4 aborts per 100)
• A 100-episode exam with zero aborts bounds the abort rate only to 3.6% (Clopper–Pearson 95%)
• A skill with a true 1% abort rate passes a zero-abort rule with probability only 37%
• Re-evaluation on 300 layouts showed abort rates separated into tiers: ~0%, ~1%, and 3–4%

Q2: What Recursive Self-Improvement Contributes

Per-round held-out comparison (8 controlled campaigns, 34 rounds):

• Repair was better in 26 of 34 rounds (sign test $p = 0.004$)
• Mean advantage: +6.4 layouts (+15.0 points) per round
• Relative to each campaign's own starting point: repair averaged above start in 8/8 campaigns (+4.3 layouts); control drafts averaged below in 6/8 (−1.3)

Selection-matched best-of-$k$ comparison: Much closer—positive in 5 campaigns, zero in 2, negative in 1 on development layouts.

Second experiment (pre-registered, 3 campaigns on stack_bowls_three with 150 development seeds):

Conclusion: Most of the advantage comes from inheriting the previous version; development feedback adds a smaller increment.

In-session self-testing: The write-once ablation found no detectable effect (task-stratified difference −3.4 points on validation baseline, permutation $p = 0.77$), within a design that cannot exclude effects below ~14 points.

Q3: Reuse by Executors That Did Not Author the Skill

The caller made 200 decisions over 150 episodes, none invalid, at median latency 2.0s (90th percentile 2.8s).

Q4: Cost per Episode

• Program-level cost: **$55 per frozen skill** ($384 over 20 campaigns for 7 skills)
• 150 caller episodes cost $0.055 total
• Direct-control self-test (2 episodes): strong model $4.77/episode (0/2 success), DeepSeek$0.039/episode (0/2 success)—an order-of-magnitude reference, not a formal baseline

Comparison with Published Results

The paper transcribes RoboTwin 2.0 published results for context (not comparison): demonstration-trained policies score 0–91% on Easy and 0–41% on Hard settings; the official expert program scored 4–6/10 on stack_bowls_three under the paper's clutter tier, while compiled skills scored 78–95 on the exam.

---

Theoretical and Practical Implications

What Recursion Bought (and Did Not)

• On easy tasks: First drafts already met the bar; the protocol's contribution was qualification and freezing, not improvement
• On hard tasks: Recursion mattered, and the controlled experiments show the improvement lives in inheriting the artifact across sessions, with development feedback adding a smaller increment
• On the hardest task (stack_bowls_three): Recursion did not carry it over the gate—all 9 campaigns failed on safety aborts, even with 128 usable development layouts. The bottleneck is more plausibly the strategies the author finds and the kernel they run on than the amount of feedback

Where the Capability Lives

The executor crossings answer a question success rates alone cannot: the capability resides in the package, not the runtime model. An executor with no model matches the author's exam, and a cheap caller from another family adds nothing and loses nothing—because the descriptions rarely need interpretation (one plan per episode, or one recovery branch).

Gate Design for Rare Events

A zero-abort rule over 100 episodes is a coin flip for skills with ~1% abort rates. The paper recommends:

• Upper confidence bounds on the abort rate as the safety requirement
• Sequential tests that stop early on clearly safe or clearly unsafe skills
• Reporting intervals beside every verdict

Strategy Substitution vs. Perception Completion

Skills can encode strategies that avoid needing missing modalities (e.g., supporting a fragile object from below rather than estimating a safe grip force). However, tasks requiring identifying the property itself (e.g., sorting real from artificial eggs) cannot be solved by substitution.

Economics of Authoring

• Successful campaigns: $4.29–8.22 per skill
• Failed campaigns: $10.97–119.7 each
• Program cost is dominated by the tasks that fail: $55 per frozen skill vs.$6.69 median for successful campaigns

---

Conclusion

The paper separated the authoring of robot skills from their execution and measured the separation. A strong general model, used only offline, produced 7 immutable skill packages on 4 of 7 RoboTwin 2.0 tasks that passed qualification exams on layouts drawn after freezing, most from first drafts needing only qualification, at $4.29–8.22 each and$55 per skill when failed campaigns are counted. The three tasks that did not compile were stopped by rare safety aborts that a 100-episode exam can barely resolve and that a larger development block did not remove. On hidden layouts, revising the previous version beat rewriting from scratch in every controlled campaign, with most of that advantage located in the inherited artifact. The frozen skills ran at 98.7% with no model and 98.0% with a cross-family caller at a fraction of a cent per episode.

Future directions: Whether the data these skills produce while working can in turn train the embodied models that do not yet exist is the question the next study should ask. The protocols, ledgers, and seeds are released for replication with other authors, executors, and tasks.

---

Data and code available at: https://github.com/Orillusion/embodied-skill-rsi (release v1.0, Apache-2.0 for code, CC BY 4.0 for data)