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

Jingwen Bai; Guochao Bai; Canbo Zhang; Shuangqi Li; Minchao Hu; Weichun Huang; Shuang Liu

cs.ROOct 18, 2026

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

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

Abstract

Embodied AI lacks the data-rich pretraining that gave language models their agents and skills, so new manipulation capability costs demonstrations per task or a frontier model in every episode. We study a third route: a strong general model acts only as an offline author that writes, runs, diagnoses and repairs a manipulation skill in simulation until it passes an exam on layouts drawn after freezing; the frozen skill then runs as code alone or under a cheap caller that reads only its description. We call this skill-level recursive self-improvement Skill-RSI and specify a compile protocol (isolated, audited author; hidden validation layouts; no-feedback and inherit-only controls; tamper-evident ledger) and a reuse protocol that runs the identical files with executors from another model family. On 7 RoboTwin 2.0 tasks with cluttered tables, Claude Code compiled 4 tasks into 7 frozen skills, 5 from a first draft needing only qualification, at USD 4.29-8.22 of author cost each (USD 55 per skill counting the 13 failed campaigns). The other three tasks did not compile in 18 campaigns, including five with GPT-6 and a pre-registered 150-layout run: on the hardest task every campaign scored 78-95 of 100 but had 3-16 safety aborts, failing the gate of 95% success with zero aborts; a 100-episode exam bounds an abort rate only to 3.6%. On hidden layouts, repair that inherits the previous version beat from-scratch rewriting in 8 of 8 controlled campaigns (sign test p = 0.004); an inherit-only lineage attributes most of the gap to inheritance, with development feedback adding a little (3 of 3, p = 0.125). Write-once campaigns found no detectable first-draft effect of practice (minimum detectable effect 14 points). The frozen skills kept 148/150 successes on new layouts with no model and 147/150 with a DeepSeek-flash caller at USD 0.00028-0.00054 per episode; no direct-control baseline was run.

Figures & tables

Panel of Figure 1 — Figure 1: Compile once, run cheap. Protocol A lets a strong author generate, repair and qualify a skill offline; an independent gate freezes it as an immutable FrozenSkill . Protocol B runs the same files with executors that never see the skill code, on new layouts. Both protocols share one non-bypassable runtime.

System	Evolving object	Runtime model	Cross-family frozen execution	Exam layouts drawn after freezing	Learning vs. selection control
RoboRSI [ 8 ]	skill tree; code consolidated from stable tool chains	agents remain in loop	–	–	–
Zetta [ 9 ]	critics and recovery skills around a frozen policy	frozen VLA	–	–	–
SHAPER [ 10 ]	skills and context-code harness	same frozen model	–	–	–
ASPIRE [ 11 ]	code-as-policy library	author model	–	–	–
Practice [ 13 ]	skill library via a trained learner	frozen executors	several executors	–	–
FAEA [ 5 ]	per-task policy through test-time iteration	frontier model, per episode	–	–	–

Table 1: Positioning against concurrent self-evolving and harness systems. Entries summarize each work’s stated focus as of October 2026; “–” means not a stated focus, not that the capability is absent. The three right-hand columns are this paper’s evaluation requirements, so the table shows where our evidence differs in kind, not that the other systems are weaker; several of them evaluate on real robots or on more tasks than we do. “Runtime model” is what reasons during deployment.

Task	Rep	Ctrl	R0	Val. base	Rounds	Curve	Cost $	Hours	Wall h	Exam	95% CI	Aborts	$\Delta$	Outcome	Caller	Audit
phone_stand	1	yes	42/42	40/40	0	42	5.46	1.6	6.3	99	94.6–99.8	0	-1.0	frozen	20/20	clean
phone_stand	2	yes	30/42	27/40	2	30 $\to$ 42	8.22	2.9	13.0	96	90.2–98.4	0	+28.5	frozen	20/20	clean
phone_stand	3	–	42/42	39/40	0	42	7.97	1.7	5.8	95	88.8–97.8	1	-2.5	failed exam	–	clean
bowls_two	1	yes	47/47	41/41	0	47	6.75	1.8	10.5	98	93.0–99.4	0	-2.0	frozen	19/19	clean
bowls_two	2	yes	41/47	39/41	1	41 $\to$ 46	9.29	2.6	8.3	95	88.8–97.8	2	-0.1	failed exam	–	clean
bowls_two	3	–	44/47	38/41	4	44 $\to$ 47	25.53	5.3	14.2	96	90.2–98.4	4	+3.3	failed exam	–	clean

Table 2: Every compile campaign. R0 is the better first draft in fallback mode on the usable development layouts; val. base is the same draft on the hidden validation layouts before repair; curve is the development score of the head at the start and end of R1; cost is the author’s reported API-equivalent cost (unobservable for the second product); hours are author session hours; wall is campaign wall-clock including all simulation; exam is fallback successes of 100 on layouts drawn after freezing, with Wilson 95% interval; aborts are safety aborts in the exam;

\Delta

is exam minus validation baseline in points; caller is the post-freeze caller check (author product, 20 layouts); audit is the isolation grade. Above the rule: Claude Code 2.1.284 ( claude-opus-5-5 ); below: Codex CLI 0.160.0 ( gpt-6-astra ).

Run	Rounds	Dev best	Val. base	Cost $ (R / C / I)	Wall h	Exam	95% CI	Aborts	$\Delta$	Outcome	Audit
j1	4	120/128	39/45	26.3 / 16.5 / 18.5	47	88	80.2–93.0	8	+1.3	not compiled	clean
j2	6	122/128	30/45	36.0 / 27.6 / 33.6	62	93	86.3–96.6	5	+26.3	not compiled	review
j3	8	122/128	33/45	41.5 / 34.2 / 44.0	74	94 †	87.5–97.2	3	+20.7	not compiled	clean

Table 3: Pre-registered second experiment (runtime 5.9.0): stack_bowls_three with 150 development seeds (128 usable) and three lineages. Dev best is the repair lineage’s best development score; cost is the author cost of the repair / control / inherit-only lineages; wall is campaign wall-clock in hours; exam is fallback successes of 100 with Wilson interval;

\Delta

is exam minus validation baseline. † j3’s exam was redrawn after a voided round ( Appendix E ).

Campaign	Exam	Aborts	Success /300	95% CI	Aborts	95% CI
phone_stand 3	95	1	290/300	94.0–98.2	0	0.0–1.2
hanging_mug 1	97	1	290/300	94.0–98.2	3	0.2–2.9
bowls_two 3	96	4	288/300	93.1–97.7	8	1.2–5.2
bowls_two 2	95	2	288/300	93.1–97.7	11	1.8–6.5

Table 4: Re-evaluation of the four campaigns nearest the bar on 300 new layouts (report-only). Success carries a Wilson interval, aborts a Clopper–Pearson interval.

Task	Default	Practice only	Write once
phone_stand	88.3 (3)	85.0 (2)	92.5 (1)
bowls_two	95.9 (3)	96.3 (2)	97.6 (1)
can_pot	95.5 (3)	96.6 (2)	95.5 (1)
hanging_mug	83.7 (1)	75.6 (2)	83.7 (1)
dual_shoes	76.9 (3)	–	86.1 (1)
bowls_three	70.4 (6)	–	75.6 (1)

Table 5: Validation baseline of the selected first draft (%, mean over campaigns; count in parentheses) by author condition. Default: practice episodes and own simulator account. Practice only: no account. Write once: the package cannot be run before delivery.

Task	Run	Start	$k$	$R1.k$ / $C.k$	Mean $\Delta$	Best
bowls_three	c7a1f0	33/45	3	36/27, 33/33, 35/43	+0.3	36 / 43
bowls_three	ef1eb1	31/45	5	40/24, 41/38, 34/37, 42/21, 36/23	+10.0	42 / 38
phone_stand	4161b3	28/40	2	34/25, 39/38	+5.0	39 / 38
bowls_two	102fc5	38/41	1	40/34	+6.0	40 / 34
bowls_three	451bca	38/45	7	36/41, 40/26, 38/36, 39/42, 40/39, 39/33, 37/39	+1.9	40 / 42
dual_shoes	320e4b	32/36	3	35/31, 31/25, 32/28	+4.7	35 / 31

Table 6: Per-round held-out comparison. Start is the selected R0 draft on the hidden validation layouts; each pair is repair

R1.k

/ control

C.k

on the same layouts; the last column is each side’s best version.

Panel of Figure 2 — Figure 2: (a) Each point is one repair round of a controlled campaign: the repair version against the control draft of the same round, both on the hidden validation layouts; points above the diagonal favor repair. (b) Exam success against the hidden-validation baseline for all 25 campaigns of both products and the three 150-layout campaigns; the dotted line is the 95% bar.

Run	Start	$R1.k$	$I.k$	$C.k$	R $-$ C	I $-$ C	R $-$ I
j1	39	41, 43, 43, 38	41, 39, 32, 40	29, 4, 34, 35	+15.8	+12.5	+3.2
j2	31	38, 41, 40, 39, 40, 43	40, 40, 39, 37, 39, 40	30, 30, 39, 42, 27, 35	+6.3	+5.3	+1.0
j3	36	38, 39, 43, 42, 43, 39, 40, 40	31, 42, 42, 40, 42, 43, 41, 42	37, 23, 41, 35, 27, 39, 21, 33	+8.5	+8.4	+0.1

Table 7: Second experiment, per-round held-out comparison on the 45 hidden validation layouts: successes of the repair (

R1.k

), inherit-only (

I.k

) and rewrite (

C.k

) versions of each round, and the campaign-mean differences repair

-

control (R

-

C), inherit

-

control (I

-

C) and repair

-

inherit (R

-

I). With three campaigns the one-sided sign test cannot go below

p=0.125

( Table 8 ).

Difference	Measures	Per campaign	Mean	Rounds	Camp.	$p$
repair $-$ control	inheritance and feedback together	+15.8, +6.3, +8.5	+10.2	16/1/1	3/0	0.125
inherit $-$ control	inheritance alone	+12.5, +5.3, +8.4	+8.7	14/3/1	3/0	0.125
repair $-$ inherit	feedback alone	+3.2, +1.0, +0.1	+1.5	11/6/1	3/0	0.125

Table 8: Second experiment, the three pre-registered differences: per-campaign means (layouts of 45), their mean, per-round counts (better/worse/tied; descriptive only) and the campaign-level sign test. “Feedback” is the runtime’s development-layout evaluation; all three lineages keep their practice runs.

Panel of Figure 3 — Figure 3: Second experiment: successes of each round’s repair, inherit-only and rewrite versions on the 45 hidden validation layouts; the dashed line is the starting version. Inherit-only and repair rarely fall below the start; rewrites vary from 4 to 42.

Skill	Compile $	Exam	Arm	Success	Wilson 95% (%)	Aborts	Decisions	Model cost / episode $	At 100 $	At 1000 $
can_pot	7.99	100/100	F	50/50	92.9–100.0	0	0.0	0	0.080	0.0080
			O-ds	50/50	92.9–100.0	0	1.0	0.00028	0.080	0.0083
phone_stand	5.46	99/100	F	49/50	89.5–99.6	0	0.0	0	0.055	0.0055
			O-ds	49/50	89.5–99.6	0	2.0	0.00054	0.055	0.0060
bowls_two	6.75	98/100	F	49/50	89.5–99.6	1	0.0	0	0.068	0.0068
			O-ds	48/50	86.5–98.9	2	1.0	0.00029	0.068	0.0070

Table 9: Protocol B on three frozen skills, 50 new layouts per skill, both arms on the same layouts. Compile is the author cost from the manifest; exam is the skill’s own qualification score; cost is the caller’s model cost per episode from provider usage and the captured price; amortized columns are

C/N+c_{X}

N{=}100

and

N{=}1000

deployments.

Panel of Figure 4 — Figure 4: (a) Success of each frozen skill in its exam and under the two Protocol B executors. (b) Per-episode cost with compilation amortized over $N$ deployments; the dotted lines at $4.77 and$ 0.039 are the strong model and DeepSeek controlling the robot without a skill in the runtime self-test (two episodes per arm), an order-of-magnitude reference and not a measured baseline.

	Published in RoboTwin 2.0 (not measured in this paper; success %)												This paper, clutter tier (measured)
	Demonstration-trained policies (their Table 10)										LLM code	Expert	Expert, ours	Exam, of 100: Claude Code formal (frozen/campaigns);
	Easy					Hard					(their Table 9)	(their Table 11)	(of 10)	GPT-6; 150 development layouts
Task	RDT	$\pi_{0}$	ACT	DP	DP3	RDT	$\pi_{0}$	ACT	DP	DP3
place_phone_stand	15	35	2	13	44	6	7	0	0	2	0	66	8 (6)	99, 96, 95 (2/3)
stack_bowls_two	76	91	82	61	83	30	41	0	0	6	30	78	6–8 (6)	98, 95, 96 (1/3)
move_can_pot	25	58	22	39	70	12	21	4	0	6	30	93	9 (6)	98, 99, 100 (3/3)

Table 10: Published results on the same seven tasks, for reference only. The twelve columns under “published” are transcribed from the RoboTwin 2.0 paper [ 65 ] (arXiv:2506.18088v2): five policies trained from 50 clean demonstrations per task with single-task fine-tuning (RDT and

\pi_{0}

from pretrained weights), evaluated over 100 rollouts in the Easy setting (clean scene) and the Hard setting (cluttered table with randomized lighting, textures and table height), from its Appendix K, Table 10; its LLM-generated task programs (DeepSeek-V3 with multimodal feedback, “R2.0 + MM FB”), which read privileged object poses at run time and whose metric is the mean success rate over candidate programs rather than one 100-episode run, from its Appendix G.3, Table 9; and the official expert program on the Aloha embodiment, from its Appendix L, Table 11 (RoboTwin 2.0 column). Table numbers in the header refer to that paper. None of these were measured in this paper and all were obtained under other conditions: the frozen skills use no demonstrations and no privileged poses, perceive from RGB-D with the camera calibration, run in the clutter tier (clean configuration plus up to ten distractors, fixed lighting, textures and table height; between Easy and Hard), and must also pass the zero-safety-abort gate and the 2 s settle before the predicate. The table is therefore context, not a comparison, and no differences are computed. “Expert, ours” is the official expert program run ten times in phase 0 on the task’s fixed phase-0 layouts (the same ten layouts for every campaign of a task), given as the range over the 43 clutter-tier campaigns in the export (both author products and the second experiment; campaign count in parentheses), not pooled. “Exam” repeats Tables 2 and 3 : Claude Code formal campaigns in table order with the number frozen over the number of campaigns, then the GPT-6 campaigns and the three 150-layout campaigns of the second experiment.

Appendix figures & tables3 assets

Supplementary material from the paper’s appendix.

Appendix

Primitive	Signature	Returns	Cost
task_spec	()	instruction, roles, criterion source	0
observe	()	ok, one component per role, table-height estimate	1
ee_pose	(arm)	$[x,y,z,q_{w},q_{x},q_{y},q_{z}]$	0
gripper_state	(arm)	commanded, measured, open	0
move_pose	(arm, pose7)	bool (planned and executed)	1
gripper	(arm, value in [0,1])	bool	1

Appendix

Table 11: Primitive API exposed by the kernel. “Cost” is the charge against the 90-call episode budget. Every move_pose and gripper call is an independent planning request; the official plan-success latch is reset before each call.

Parameter	Value	Rationale
Scene tier	clutter ( demo_clean + up to 10 distractors; fixed lighting; no table-height randomization)	the fully randomized tier was too easy in a pilot (first drafts above 82%); table-height randomization conflicts with absolute-height success predicates
R0 drafts	2	independent starting points differ more than one lineage’s repairs
Development layouts	50 seeds (70000–70049); 42–47 usable	separates 85% from 95% versions; layouts the generator cannot stabilize are dropped for every version
Validation layouts	50 seeds (71000–71049); 36–46 usable	hidden; used for the baseline, the target check and the held-out re-run; never fed back
Development / validation target	$\geq 96\%$ / $\geq 94\%$ of usable	first integers at or above 95% on 50, one layout of slack against a hidden set
Max repair rounds / patience	10 / 3	budget bound; three consecutive non-improvements ends R1

Appendix

Table 12: Parameters of Protocol A and Protocol B as run. All Protocol A values were fixed before the first campaign; the two report-only evaluations were added during the study at the versions shown.

Model	Provider	Input	Cached input	Output	Note
deepseek-flash (V4.1-Flash), peak	DeepSeek	$0.30	$0.006	$1.20	UTC 01–04 and 06–10, weekdays
deepseek-flash (V4.1-Flash), off-peak	DeepSeek	$0.15	$0.003	$0.60	all other hours; Chinese public holidays are priced at peak (overstates cost)
Author (Claude Code 2.1.284)	Anthropic	product-reported API-equivalent cost			subscription channel; amount as reported by the product per session
Author (Codex CLI 0.160.0)	OpenAI	not observable			subscription channel; recorded as null, never estimated

Appendix

Table 13: Prices per million tokens used for the caller ledger, captured 2026-10-08 from the provider’s pricing page; every decision stores the price applicable at its UTC time.

Robot Skill Learning

Robot skill learning studies how robots acquire, adapt, and combine reusable behaviors from demonstrations, interaction, and other data.

See all 320 papers

Oct 12, 2026

Embodied Skill Bench: Benchmarking How Well Agents with Embodied Skills Perform on Physical Tasks

LLM agents increasingly control robots using VLA policies, perception models, and procedural knowledge. These modules are difficult to reuse because their interfaces, embodiment assumptions, and conditions of use differ, and their benefits on physical tasks remain unclear. We package them as embodied skills that extend agent skills with explicit embodiment assumptions and conditions of use, building 250 action, perception, and experience skills from 1,052 resources. On this basis we introduce EmbodiedSkillBench, which runs an agent in a closed observation-action loop and records success, actions, tokens, and wall-clock time. It supports three modes: native control, skill-only execution, and Agent-Directed Reuse (ADR), a mode we propose in which the agent keeps its native controls and decides for each skill whether to invoke, modify, or ignore it. Across four agents on 100 perturbed LIBERO-Pro tasks, we find that skills help an agent only as far as they exceed what it can already do. Skill-only execution lifts GPT-5.6-Sol from 11% to 63% and Kimi-K3 and Claude-Opus-5 by about 20 points, while cutting their token usage by 58% to 85%. Yet all four agents then end up between 61% and 64%, and GPT-6-Astra falls from 92% under native control to 61%. This suggests that as agents grow stronger, the role of embodied skills shifts from supplying missing capability to reducing cost: GPT-6-Astra already solves most tasks through native control, so restricting it to skills removes more than it adds. Under ADR, which lets it keep native control and call skills selectively, GPT-6-Astra recovers to 85%, within 7 points of native control, while using 14.1% fewer tokens and 11.9% less time. With Jev as a skill choosing motion directions and gripper actions, it reaches 81% with 50% fewer tokens and 57% less time. The code is available at https://github.com/HanZhi306/EmbodiedSkill-Bench.

Zhi Han, Zihan Guo, Chenxi Zeng +6

Shanghai Jiao Tong University · Shanghai Artificial Intelligence Laboratory · Sun Yat-Sen University +2

Embodied Agent Benchmarks Embodied AI Robot Manipulation Benchmarks

Ask PDF

May 9, 2026

SkillGen: Verified Inference-Time Agent Skill Synthesis

Skills are a promising way to improve LLM agent capabilities without retraining, while keeping the added procedure reusable and controllable. However, high-quality skills are still largely written by hand. We introduce SkillGen, a multi-agent framework that synthesizes a single auditable skill from trajectories generated by a base agent. The output is a human-readable artifact that can be inspected before use. Rather than merely summarizing trajectories, SkillGen leverages contrastive induction over both successful and failed trajectories to identify reusable success patterns, recurring failure modes, and behaviors that appear in nearby successes but are missing from failures. SkillGen then generates candidate skills and iteratively refines the skill. A key novelty in SkillGen is that we model agent skills as interventions to empirically verify the net effect of skills on the overall performance. Specifically, we compare outcomes on the same instances with and without the skill, so that we account for both repairs (cases where the skill fixes a baseline failure) and regressions (cases where the skill breaks a baseline success). Across a broad range of agents and datasets, SkillGen consistently improves held-out performance, outperforms existing skill-generation baselines, and produces skills that transfer across models.

Yuchen Ma, Yue Huang, Han Bao +5

Munich Center for Machine Learning, LMU Munich · University of Notre Dame · Microsoft Research

LLM Agent Self-Improvement LLM Agent Skill Learning LLM Agents

Ask PDF

Oct 26, 2026

Skill $^{\infty}$ : Recursive Self-Improvement for Agent Skill Optimization

Recursive self-improvement (RSI), in which a system also improves the way it improves, is a long-standing aspiration on the path to AGI. Language agents increasingly store procedural knowledge in reusable skills. Optimizing skills offers a direct way to achieve RSI, because the optimization procedure itself can be encoded as a skill. Existing skill optimizers, however, follow a hand-designed procedure. Even methods that evolve a meta-skill confine it to a fixed pipeline and relearn it for each task. We present Skill

^{\infty}

, which makes skill optimization recursively self-improving: a meta agent follows a meta-skill to optimize task skills and optimizes the meta-skill itself using the same procedure. The optimization is agent-led. The meta agent diagnoses execution traces, proposes candidates, requests independent reviews, and allocates the search budget. The meta-skill defines these steps, allowing self-improvement to rewrite them. This meta-skill is also decoupled from task skills, refined on multiple skill optimization tasks and then reused to optimize task skills across diverse domains. As in deployment, skills at both levels are standard packages loaded through native skill discovery. On 83 SkillsBench tasks, Skill

^{\infty}

reaches a pass rate of 60.7%, compared with 56.4% for human-curated skills and 54.5% for SkillEvolver.

Wangcheng Tao, Zhanglu Yan, Han Wu +1

National University of Singapore · City University of Hong Kong

LLM Agent Self-Improvement LLM Agent Skill Learning Recursive Self-Improvement

Ask PDF

Abstract

Robot Skill Learning

Explore similar work

Embodied Skill Bench: Benchmarking How Well Agents with Embodied Skills Perform on Physical Tasks

SkillGen: Verified Inference-Time Agent Skill Synthesis

Skill∞^{\infty}∞: Recursive Self-Improvement for Agent Skill Optimization

Skill $^{\infty}$ : Recursive Self-Improvement for Agent Skill Optimization