A Controlled Study of Models, Skills, Feedback, and Curriculum in Agentic Robotics

Kaiyuan Chen; Xinyue Zhu; Shuangyu Xie; Uksang Yoo; Thi Thu Phuong Luong; Marcus Gualtieri; Christian Juette; Liu Ren

cs.RONov 6, 2026

A Controlled Study of Models, Skills, Feedback, and Curriculum in Agentic Robotics

Authors: Kaiyuan Chen, Xinyue Zhu, Shuangyu Xie, Uksang Yoo, Thi Thu Phuong Luong, Marcus Gualtieri, Christian Juette, Liu Ren,

Organizations: UC Berkeley · Bosch · NVIDIA

Abstract

Agentic robotics asks coding agents to implement and iteratively improve robot policies from simulated and real-world physical interactions. We study the self-learning loop of agentic robotics through a controlled simulation study spanning nine manipulation tasks, 631 different experiment configurations, and 28K coding agent rollouts, systematically varying model capability, skill priors, feedback structure, and curriculum. The experiment data suggests that the bottleneck is often not the access to sufficient information, but interpreting it into the right policy update. Across these factors, a successful self-learning loop depends on how effectively agents attribute failures, reason task-relevant spatial and geometric structure, and selectively restructure code to improve policies.

Figures & tables

Figure 1: Representative failure modes in Agentic Robotics. Left: Manipulation planning fails to select a grasp and approach strategy compatible with the downstream placement. Center: Motion planning fails to jointly reason about held-object geometry, obstacles, and clearance to produce a collision-free trajectory. Right: Deformable manipulation requires reasoning over object configuration and contact that is difficult to capture through local motion decisions.

Figure 2: Overview of our controlled study of agentic robot self-learning of model, skill, feedback, and curriculum design. A coding agent initializes a policy $\pi_{0}$ , executes the current policy $\pi_{k}$ in simulation, receives feedback $f_{k}$ , and iteratively edits its policy as $\pi_{k+1}=A\!\left(\pi_{k},f_{k},\{(\pi_{j},f_{j})\}_{j<k}\right)$ . We evaluate zero-shot and self-learning performance, and final task success across VABAR and MimicGen manipulation tasks.

Panel of Figure 3 — Figure 3: Five VABAR tasks (Left) and four MimicGen tasks (Right) used for this study.

Figure 4: Outcomes of edits targeting a reported failing skill.

Model	Overall			$\Delta$ Overall		Tool Hanging			Syringe Packing			Gear Meshing			USB-C Insertion			Cable Routing
	@0	@1	@2	1	2	@0	@1	@2	@0	@1	@2	@0	@1	@2	@0	@1	@2	@0	@1	@2
Human	82			–		87			90			100			87			47
Opus 5, xhigh	45	64	74	$+19$	$+10$	22	62	60	28	38	35	100	100	100	0	50	100	73	72	73
Opus 5, high	41	62	81	$\mathbf{+21}$	$\mathbf{+19}$	25	72	97	40	30	45	67	100	100	0	33	87	75	76	76
Opus 5, low	57	67	74	$+10$	$+7$	0	30	57	51	50	60	100	100	100	60	80	80	73	76	76
DeepSeek V4	38	43	44	$+5$	$+1$	0	0	0	20	29	30	100	100	100	0	10	12	70	77	77

Table 1: Self-learning on VABAR by model. Held-out per-object success (%) reached within 0, 1, and 2 rounds of feedback (@

k

) reported by mean over the runs scored at each round.

\Delta_{k}

denotes the gain in overall success from the

k

-th round of feedback, i.e. @

k

-

(k{-}1)

Figure 5: Zero-shot policy composition and attribution by code source.

Figure 6: Number of skills traced back from the observed failing skill before each post-failure policy edit. Finer-grained and semantic feedback leads agents to trace failures further upstream.

Feedback	Overall	Tool Hanging	Syringe Packing	Gear Meshing	USB-C Insertion	Cable Routing
Initial policy	3	0	0	0	0	17
Per episode	25	7	90	10	0	17
Per motion	36	45	55	80	0	0
Per skill	52	90	50	70	20	27

Table 2: Effect of temporal feedback structure on held-out success (%). Per motion reports the outcome of each robot motion that is not aligned with the policy’s semantic skills, Per skill reports the outcome of each semantic skills.

Spatial representation	Overall	Tool Hanging	Syringe Packing	Gear Meshing	USB-C Insertion	Cable Routing
Outcome only	19	15	45	0	0	33
State + relations, world frame	30	25	60	50	0	13
State + relations, object frames	40	63	50	60	0	27
+ part annotations	52	90	50	70	20	27

Table 3: Effect of spatial representation on held-out success (%). World-frame and object-frame reports describe the same underlying scene state at different levels of relational organization, while part annotations add task-relevant functional geometry.

Figure 7: Spatial representations of the feedback report on one failed. The same execution state expressed at different levels of spatial organization.

Figure 8: Policy structure by human(H), Astra(A), and Fable(F).

Figure 9: Human motion plan (blue) considers a collision free spot (B) to reorientate gripper, while agent plan (red) has limited room to reorientate.

Task	w/ curr.	w/o curr.	w/ curr.	w/o curr.
	# Skills		Success (%)
Tool Hanging	19.3	28.0	16	63
Gear Meshing	18.3	21.7	33	40
USB-C Insertion	18.0	10.7	31	16
Kitchen	13.0	13.3	33	62
Coffee	5.0	11.7	76	64

Table 4: Policy size (# Skills, final policy) and held-out success (mean over the last three iterations) with (w/ curr.) and without (w/o curr.) the privileged-to-perception curriculum; mean over three runs.

Figure 10: Held-out success (top) and stage reward (bottom) for the privileged-to-perception curriculum and perception-only control on MimicGen (left) and VABAR tasks (right), evaluated on 10 fixed held-out layouts per task. Lines show means over three seed replicates and bands show

\pm 1

standard error. The dotted line marks transfer to perception; shading indicates the privileged phase, during which only the curriculum experiment has access to privileged geometry.

Figure 11: What closes the gap to human-written policies? For VABAR Level-1 test cases solved by the human policy with Opus 5, improvements come progressively with the earlier findings, while a small fraction unsolved.

Appendix figures & tables29 assets

Supplementary material from the paper’s appendix.

Appendix

	Tool Hanging	Syringe Packing	Gear Meshing	USB-C Insertion	Cable Routing
Instruction	hang the wrench on the hook	pick up each syringe from the instrument tray, one at a time, and drop it through the hole in the top of the yellow sharps disposal box, until both are in the box	put the gear on its peg so it meshes with the pinion, then press the red button at the near end of the board to start it	insert the USB-C plug into the receptacle	weave the cable through the two pegs and route its free end into the port
Robot	bimanual I2RT YAM; prompted with one arm	Franka Panda	Franka Panda with Robotiq 2F-85	bimanual I2RT YAM; prompted with one arm	bimanual I2RT YAM; prompted with both arms
Objects	wrench (260 mm); hook on a pegboard	two identical syringes 90 mm apart in an instrument tray; sharps box with a top aperture	spur gear (16, 20 or 24 teeth) on a mat; board with a peg, a driven pinion and a start button	USB-C plug ( $2\times$ scale) on an attached 240 mm cable; receptacle bolted to the bench, 0.15 mm clearance per side	600 mm cable, one end welded in an anchor bracket; two pegs; a port
Success trials per episode	1: the goal	2: each syringe in the box	1: the goal	1: the goal	3: seated at peg 1, at peg 2, in the port with its free end
Partial-credit reward (floor)	share of the 3 goal clauses (1/3: a wrench at rest meets the speed clause)	share of the 2 syringes in the box (0)	turning fraction of its one gear, so 0 or 1 (0)	insertion depth / 10.4 mm, capped at 1; 0 while the lateral offset exceeds 8.8 mm (0)	lower of the shares of the 4 containment and the 2 release clauses (0)
Step cap	8,500	22,800	6,000	9,000	13,000

Appendix

Table 5: The five tasks. The instruction is the task document’s, verbatim, and is the task description the agent receives. Success is scored per trial (object); the reward is partial credit, logged but never reported as success. Step caps are in control steps.

Task	Base document, sampler and randomized quantities	Documents: 4 train, 5 val., 10 held-out	Seed
Tool Hanging	wrenches_level1 , layout:LEVEL1 : wrench $x,y$ each $\mathcal{U}(\pm 20)$ mm; hook fixed	train: 001, 012–014 val.: 015–019 held-out: 002–011	doc $n$ : seed $4n{-}3$
Syringe Packing	tray_pair_both , 30-trial layout sweep: tray arrangement yaw $\mathcal{U}(\pm 25^{\circ})$ about the first syringe, shift $x,y$ each $\mathcal{U}(\pm 60)$ mm, shifts $\geq$ 10 mm apart; sharps box $x,y$ each $\mathcal{U}(\pm 30)$ mm	train: t00, t11–t13 val.: t14–t18 held-out: t01–t10	trial $n$ of one sweep at seed 0
Gear Meshing	40 drawn single-station boards, draw_layout : tooth count 16/20/24 (balanced); plate center $x,y$ each $\mathcal{U}(\pm 30)$ mm; chain yaw $\mathcal{U}(\pm 10^{\circ})$ ; gear dropped uniformly on the mat ( $\geq$ 15 mm from the plate), clocked $\mathcal{U}[0,2\pi)$	train: 01, 12–14 val.: 15–19 held-out: 02–11	doc $n$ : 31-bit SHA-256 of $(0,n)$ ; teeth: one balanced draw
USB-C Insertion	insert_easy , staging:USBC_EASY : plug yaw $\mathcal{U}(\pm 8^{\circ})$ , $x,y$ each $\mathcal{U}(\pm 12)$ mm; receptacle $\mathcal{U}(\pm 5)$ mm across, $\mathcal{U}(\pm 1.5)$ mm along, yaw $\mathcal{U}(\pm 5^{\circ})$ , redrawn until it clears the bench	train: 01, 12–14 val.: 15–19 held-out: 02–11	doc $n$ : seed $9999{+}n$
Cable Routing	port_easy , staging:PORT_BOARD : cable bow $\pm 20$ mm, shift $\pm 15$ mm, yaw $\pm 4^{\circ}$ , wave $\pm 30$ mm (fractions $\mathcal{U}(-1,1)$ ), anchor follows the cable; port $x,y$ each $\mathcal{U}(\pm 6)$ mm, yaw $\mathcal{U}(\pm 3^{\circ})$ ; peg gap $\mathcal{U}(0.7,1.3)\times$ the 240 mm pitch within the anchor–port corridor, lateral wobble $\pm 5$ mm, board yaw $\mathcal{U}(\pm 5.7^{\circ})$ , board position uniform in the corridor, rejected unless turning, wrap and route length stay near the declared board’s values	train: 01, 12–14 val.: 15–19 held-out: 02–11	doc $n$ : seed $9999{+}n$

Appendix

Table 6: Scene generation and splits. Each instance is one task document, its base document drawn once as the last column states.

Figure 12: Main randomized quantities of every instance by split, recomputed from the samplers; the segment through each Syringe Packing point shows the tray’s yaw, and dashed boxes are the sampling ranges (Table 6 ).

Figure 13: Held-out success per instance: the share of programs that succeed on each held-out object at

k{=}0

(hollow) and at the kept iterate (filled), pooled over the runs of all three tables, against one randomized quantity. Diamonds are the second syringe and the mean of the two peg seats; the band spans the training draws.

Namespace	Tools
robot (23)	close_gripper , describe_arm , describe_gripper , describe_workspace , execute_trajectory , forward_kinematics , get_camera_pose , get_ee_pose , get_gripper , get_gripper_pose , get_observation , go_home , go_to_pose , go_to_pose_cartesian , grasp_frame , instruction , move_cartesian_until_contact , move_to_joints , open_gripper , set_grip , solve_ik , stream_dual , wait_steps
motion (5/8)	describe_planner , get_robot_collision_spheres , plan_joint , plan_linear , plan_support_disengagement ; with cuRobo also build_world_tsdf , plan_to_pose , solve_ik_batch
curobo (9)	cloud_to_attachment , plan_directed_linear , plan_grasp_motion , plan_linear , plan_to_grasp_poses , plan_to_pose , plan_with_grasped_object , validate_joint_trajectory_grasped , validate_joint_trajectory_robot
curve (2)	fit_centerline , track_centerline
geometry (22)	build_world_config , cloud_to_attachment , compute_drop_position , compute_feature_mate , compute_obb , compute_xy_distance , depth_to_point_cloud , exclude_robot_points , filter_and_compute_obb , filter_noise , fit_linear_feature , fit_planar_feature , front_grasp_from_obb , iou , mask_to_world_points , pixel_to_world_point , pose_distance , rotate_quat_z90 , select_top_down_grasp , top_down_grasp_candidates , top_down_grasp_from_obb , transform_points
grounding-dino (1)	detect

Appendix

Table 7: The tool surface

\mathcal{S}_{0}

(the none privilege tier every run uses), by namespace. Each task gets the 23 robot tools, the motion tools of its backend (8 with cuRobo on Tool Hanging and Syringe Packing, 5 with OSC on the other tasks) and the 42 tools of the six bundles that ship with open-robot-skills; USB-C Insertion and Cable Routing add 5 and 8 of their own tools, admitted after an audit found they read no privileged state. Totals from Tool Hanging to Cable Routing: 73, 73, 70, 75 and 78 tools.

Skill	Scripts	cuRobo	OSC	What it does
Perception (11)
perceiving-deformable-linear-objects	1	✓	✓	Ordered 3D cable centerline from RGB-D, kept current across a task
perceiving-functional-features	6	✓	✓	Fits a described part (loop, shaft, tip, aperture) from RGB-D
perceiving-next-item	3			Container and next remaining item from one view, or done
perceiving-object-parts	1	✓	✓	Detects the parent object, then segments a named subpart in its crop
perceiving-objects	1	✓	✓	DINO detection, VLM crop tournament, SAM3 mask, world-frame box

Appendix

Table 8: The general skills

\mathcal{S}_{g}

(open-robot-skills) by the category their SKILL.md declares, with their Python scripts ( tracking-objects runs from a tool module) and whether each is callable on the cuRobo tasks (Tool Hanging, Syringe Packing) and the OSC tasks (Gear Meshing, USB-C Insertion, Cable Routing), i.e. whether that task’s

\mathcal{S}_{0}

holds every tool its scripts call.

Task, human graph	Bundle	Scripts
Tool Hanging	glue (1)	choose_placement_mode
gap_perception	from $\mathcal{S}_{g}$ (15)	compute_mate , execute_placement_plan , release_and_retract , execute_approach_only , execute_reorientation , compute_align_pose , execute_grasp_align , perceive_fixture_feature , perceive_object_feature , select_next_source , plan_clearance_motion , plan_feature_engagement , build_collision_world , register_held , descend_release_linear (of 10 skills)
Syringe Packing	perception (8)	build_collision_world , count_remaining , map_syringe_to_hand , perceive_fixture , perceive_target , verify_grasp , verify_placement , verify_seated
gap_perception_v2	motion (9)	compute_grasp , execute_insertion , execute_reorientation , grasp_checked , lift_held , plan_clearance_motion , plan_visual_insert , release_and_retract , unjam_aperture
	helpers	motion_checks , perception_checks
	from $\mathcal{S}_{g}$ (1)	compute_mate (of computing-feature-mating-poses )

Appendix

Table 9: Expert skills

\mathcal{S}_{\tau}

: the entry scripts of each task’s human VABAR vision policy, bundled by the tools they call (count in parentheses), without the graph that wires them. Helpers are modules the entry scripts import; scripts taken from

\mathcal{S}_{g}

ship there, and scripts that call a tool outside

\mathcal{S}_{0}

are omitted.

	Table 1 , every setting	Feedback study; full library	Tools only	Docs callable
Library	$\mathcal{S}_{0}+\mathcal{S}_{g}+\mathcal{S}_{\tau}$	$\mathcal{S}_{0}+\mathcal{S}_{g}$	$\mathcal{S}_{0}$	$\mathcal{S}_{0}$ + docs of $\mathcal{S}_{g}$
$\mathcal{S}_{g}$ skills callable	27 / 25	27 / 25	0	27 / 25
$\mathcal{S}_{g}$ source readable	✓	✓	–	–
$\mathcal{S}_{\tau}$ expert scripts	✓	–	–	–
SKILLS.md	✓	✓	✓	✓
SKILL_LIBRARY.md	$\mathcal{S}_{g}$ , $\mathcal{S}_{\tau}$	$\mathcal{S}_{g}$	notice only	$\mathcal{S}_{g}$

Appendix

Table 10: Skill availability per experiment. Callable counts are for the cuRobo / OSC tasks; the middle rows are the workspace files that carry each part ( SKILLS.md documents

\mathcal{S}_{0}

, SKILL_LIBRARY.md lists the callable skills, skills/ holds their source).

Panel of Figure 14 — Figure 14: The self-learning loop. Blue states and the preflight’s fix sessions run an agent session; the harness runs everything else. No validation or held-out reading reaches the agent.

	Table 1 (models)	Feedback and skill-library studies
Iterations	3 ( $k{=}0,1,2$ )	6 ( $k{=}0,\dots,5$ )
Training	4 instances per iteration	4 instances per iteration
Validation	5 instances per iteration	5 instances per iteration
Held-out	10 instances per iteration	10 instances at $k{=}0$ and on the kept iterate
Initial policy $\pi_{0}$	written by the agent	written by the agent; in the feedback study every arm reuses the reference run’s $\pi_{0}$ with its training batch and held-out reading, and runs its own validation
Kept iterate	first iterate with the highest validation success

Appendix

Table 11: Evaluation schedule. Every instance is one episode, scored per object; an unscored preflight episode precedes each training batch. The Opus 5, xhigh row of Table 1 runs the right column’s schedule and reports @

k

(Appendix C.2 ).

Event (per 100 agent sessions)	Table 1	Feedback	Skill library	All
Guard rejections	5.5	6.3	4.3	5.7
non-literal tool name (%)	100	100	100	100
Crashed preflights	3.6	0.5	7.4	2.7
repaired by fix sessions (%)	82	100	100	88
run unrepaired (%)	18	0	0	12
Reverts	8.7	16.7	3.2	11.6

Appendix

Table 12: Harness events per 100 agent sessions (zero-shot generation, improvement and preflight-fix sessions), with the studies split as in Table 20 ; indented rows give the share (%) of the event above. The Opus 5, xhigh runs of Table 1 count all six rounds.

Slot	In	Value in the study
{{instruction}}	G, I	the task’s instruction, verbatim (Table 5 )
{{perception}}	G, I	vision
{{privileged}}	G, I	none
{{update_mode}}	G	freeform
{{layout_note}}	G, I	every task: “- Each training episode is a DIFFERENT layout of this task, and the policy is scored afterwards on ten further layouts it never sees, where the objects (and possibly the fixtures) sit elsewhere. Locate everything that can move with perception at run time: a coordinate read off this feedback fits the one layout it was measured in, and a policy built on such coordinates fails the rest.” The Opus 5, xhigh runs of Table 1 that train on one layout (Appendix C.2 ): “- Every training episode replays ONE fixed layout, but the policy is scored afterwards on layouts it never sees, where the objects (and possibly the fixtures) sit elsewhere. Locate everything that can move with perception at run time: a coordinate read off this feedback fits the training layout only, and a policy built on one fails every held-out layout.”
{{bimanual_note}}	G, I	Cable Routing: “This robot has 2 arms. Every robot./motion. verb takes arm_id (0 is the work arm, 1 the support arm); an omitted arm_id drives arm 0. Sequence the arms deliberately — SKILLS.md states each tool’s arm semantics.” Other tasks: empty.

Appendix

Table 13: Template slots and their values. In: the template that uses the slot (G generate, I improve, V fix-validation, P fix-preflight, M workspace block). Quoted values are verbatim; the workspace block and the primer are those of every snapshot after the first, whose earlier wording the text quotes.

Condition	Run arm	Form	Spatial	Granularity
Reference (Table 1 ; Per skill , + part annotations )	reference	state, relations	parts	semantic
Spatial representation (Table 3 )
Outcome only	success_only	--	(parts)	(semantic)
State + relations, world frame	positions	state, relations	positions	semantic
State + relations, object frames	frames	state, relations	frames	semantic
Temporal resolution (Table 2 )

Appendix

Table 14: The feedback conditions as configuration ( feedback.design ), grouped by the table that reports them. Every non-reference condition changes one axis of the reference and continues from the reference run’s initial policy. Parenthesized values select nothing: the spatial representation applies to state and relations, the granularity to any form beyond the outcome. Run arm: the condition’s name in the released configurations.

		Form				Spatial		Temporal
Rendered	Refer- ence	Outcome only	Outcome + stills	Outcome + state	Outcome + relations	World frame	Object frames	Per episode	Per motion
Outcome: episode table, per-object goals, abort, budget and stage banners, raised errors	✓	✓	✓	✓	✓	✓	✓	✓	✓
Node names (one unit per node, with status and time)	✓	$\circ^{a}$	$\circ^{b}$	✓	✓	✓	✓	$\circ^{a}$	$\circ^{a}$
Up to 16 stills (two cameras) around the nodes nearest the first failure	–	–	✓	–	–	–	–	–	–
Tool names, commanded vs. achieved targets	✓	–	–	✓	–	✓	✓	–	✓
Node outputs ( returned key=value )	✓	–	–	✓	–	$\circ^{c}$	✓	–	–

Appendix

Table 15: What each feedback condition renders (✓ whenever the batch has the item,

\circ

partly, – never): the reference, then the conditions that change its form, its spatial representation or its temporal granularity (Table 14 ). a only the node the graph raised at, in the outcome block; b only the nodes that carry stills; c orientation-valued outputs dropped; d part names and kinds only, no geometry; e events between start and end only, not what the close met; f object-level (containment) goals only; g median distance at the end only; h held at the end only. The stills arm’s first report has none: the reference batch it re-renders was recorded without video. Syringe Packing declares no parts, so there the reference differs from object frames only in its legend and goal lines.

Figure 15: Length of the feedback report per condition, in characters: median (bar) and interquartile range (whiskers) over the distinct reports the improve sessions read. The gray bar pools every run of Table 1 , all of which use the reference condition.

	Tool Hanging	Syringe Packing	Gear Meshing	USB-C Insertion	Cable Routing
Validation target (success)	1	0.83	1	1	0.67
in objects	5/5	9/10	5/5	5/5	11/15
Revert margin (train success)	0.5	0.25	0.5	0.5	0.25
in objects	2/4	2/8	2/4	2/4	3/12
Episode wall budget (s)	1500 + 4200	1500 + 12000	1500 + 7200	1500 + 7200	1500 + 14000
Unchanged streak	3 iterations without an accepted edit

Appendix

Table 16: Stopping conditions per task and common to all tasks, and what they did: how the runs stopped, how often they kept the zero-shot program

\pi_{0}

, and how often the revert rule undid an edit. Success rates are per object: the validation target over the five validation instances, the revert margin over the four training instances.

			Sessions	Harness	Effort	Thinking tokens
Setting	Model id	Listed	(UTC)	control	xhigh	Generate	Improve
Opus 5, xhigh	claude-opus-5	07-24	09-18–22	–	64%	30.8k	16.5k
Opus 5, high	claude-opus-5	07-24	09-22–24	budget 32k	13%	17.8k	21.2k
Opus 5, low	claude-opus-5	07-24	09-22–25	budget 4k	12%	18.6k	15.4k
DeepSeek V4	deepseek/deepseek-v4-pro-0813	08-12	09-22–25	–	22%	75.1k	69.2k
Sonnet 5	claude-sonnet-5	06-30	09-22–25	–	21%	46.2k	20.2k

Appendix

Table 17: Agent settings of Table 1 (Opus 5, xhigh: rounds

k\leq 2

). Listed: first OpenRouter listing of the model id in 2026 (the DeepSeek V4 family: 04-24). Sessions: first and last session date. Harness control: the reasoning setting the harness passes (Table 18 ). Effort xhigh: share of sessions whose CLI logged effort level xhigh. Thinking tokens: median per session as the CLI reports them.

Claude Code call	claude -p "Follow INSTRUCTIONS.md in this directory." --output-format json --max-turns 80 --allowedTools "Read,Edit,Write,Grep,Glob,Bash(./validate.sh:),Bash(echo:),Bash(mkdir:*)" --model <id> ; Kimi K3 and DeepSeek V4 set ANTHROPIC_BASE_URL to OpenRouter’s Anthropic-compatible endpoint.
Codex call	codex exec --json --skip-git-repo-check -s danger-full-access -C <workspace> -o <transcript>/last_message.txt -m <id> -c model_reasoning_effort="xhigh" "Follow INSTRUCTIONS.md in this directory. AGENTS.md states the rules."
Reasoning	Opus 5, high and low add MAX_THINKING_TOKENS =32000/4000 to the environment; Codex gets model_reasoning_effort in the call. Claude Code’s effort level is not set: the local machine’s CLI settings pin effortLevel to xhigh, and the remote machines did not record it.
Session limits	2 h wall clock per session; turn cap --max-turns 80 for Claude Code, none for Codex.
Sampling	temperature and top- $p$ not set (provider default).
Context and output	as the CLI reports them. Context: 1M tokens for the Claude models, 200k for Kimi K3, DeepSeek V4 and the sessions rerun through OpenRouter (the CLI’s default for a model outside its catalog). Maximum output per response: 64k or 128k (Opus 5, Sonnet 5), 128k (Opus 5.5), 64k (Fable 5.1, the reruns), 32k (Kimi K3, DeepSeek V4). Codex reports neither.
Rate limits	from 2026-09-22, a Claude session refused with HTTP 429 on the subscription login is rerun at once with the same model through OpenRouter; before that, and for Kimi K3 and DeepSeek V4, it is retried after the limit resets when that is within 1 h (at most 4 attempts). A later reset, or a Codex usage limit, defers the round, and the run resumes it.

Appendix

Table 18: Inference parameters of every agent session of the VABAR studies (the curriculum study’s are in Appendix J ). <id> is the model id of Table 17 ; the working directory is the session’s workspace.

	Fix	Per session		Lines	Gain
Setting	sessions	Turns	Minutes	per edit	@0 $\to$ @2
Opus 5, xhigh	7%	37	8.1	113	$+29$
Opus 5, high	10%	42	8.1	156	$+40$
Opus 5, low	14%	38	8.5	150	$+17$
DeepSeek V4	4%	47	29.0	30	$+6$
Sonnet 5	6%	31	8.7	27	$+1$

Appendix

Table 19: Agent sessions of the settings of Table 1 (Opus 5, xhigh: rounds

k\leq 2

): the share of fix sessions (repairing a rejected proposal or a crashing preflight), median turns (Codex: commands and file edits), minutes and lines added plus removed per accepted edit, and the change in Overall success from @0 to @2 in Table 1 .

		Agent	Tokens (M)		Cost	Simulator	Policy
Setting	Runs	sessions	Input	Output	(USD)	hours	episodes
Opus 5, xhigh	25	62	194	3.4	292	669	1,000
Opus 5, high	25	47	138	2.3	193	520	718
Opus 5, low	25	49	148	2.3	199	641	714
DeepSeek V4	25	56	165	6.0	33	599	996
Sonnet 5	25	56	199	3.7	112	806	978

Appendix

Table 20: Compute and cost per setting of Table 1 and per study. Agent sessions are the coding-agent calls (initial program, feedback rounds, preflight repairs); input tokens include cache reads and writes; cost is repriced at the rates of Table 21 ; simulator hours sum the wall time of every train, validation and held-out episode. Opus 5, xhigh counts rounds

k\leq 2

of its six-round runs and the row of superseded passes and dropped arms its later rounds; the skill library’s full-library arm is the feedback study’s reference.

Model	Input	Cache read	Cache write	Output
Opus 5	5	0.5	10	25
Opus 5.5	4	0.2	8	20
Sonnet 5	2	0.2	4	10
Fable 5.1	10	0.25	20	50
Haiku 4.5 (CLI background model)	1	0.1	1.25	5
Kimi K3	3	0.3	–	15

Appendix

Table 21: Token prices (USD per million tokens) used to reprice every agent session: the list rates at which Claude Code prices the Claude models, and OpenRouter’s list rates of 2026-09-24, during the runs, for the others (DeepSeek V4’s fell to 0.264/0.0088/0.792 by 2026-09-26). Claude Code writes a one-hour prompt cache at twice the input rate; the background model and the sessions rerun through OpenRouter write a five-minute cache at 1.25

\times

; Kimi K3 and DeepSeek V4 wrote no cache.

Component	Source	Cost (USD)
Table 1	Table 20	1,700.03
Feedback study	Table 20	3,186.60
Skill library	Table 20	747.42
Superseded passes and dropped arms	Table 20	1,923.12
Pilot study	ccusage , harness transcripts	22,462.13
Curriculum study	reported by its authors	6,436.83

Appendix

Table 22: Total LLM spend of the paper’s coding agents. The first four rows are the study rows of Table 20 . The pilot study covers the other Claude Code and Codex sessions on our development workstation from 2026-08-18 to 2026-09-26 (Appendix H.3 ), priced by ccusage from the session logs (models it does not price at the rates of Table 21 ) or, for harness sessions whose logs had been deleted, at the cost their transcripts record. The curriculum study’s spend is reported by its authors.

	Category	Rule	Example message
P	Perception	A perception node raises: the target, part or region is not found or not localized.	SAM3 could not localize 'ring'
G	Grasp miss/loss	The jaws close on nothing, or grasp verification finds the object gone from the hand.	the jaws closed on nothing (gap 8.00 mm, lag 0.00 mm)
K	Planning/IK refusal	The planner or IK returns no feasible grasp, orientation, path or approach.	plan_grasp: 0/1 candidate grasps had a feasible CuRobo plan …
T	Reach/tracking/transport	The hand stops short of, or tracks off, a commanded pose.	the hand stopped 23 mm from the grasp pose
A	Placement/insertion misalignment	The graph finishes with the object’s placement clause unmet, or a placement or insertion check raises.	encloses/wrench_1.ring/wrench_hook_1.shank: False
R	Release/goal-clause	The graph finishes with placement met but a rest, release or turning clause unmet.	speed/wrench_1: False

Appendix

Table 23: Failure categories of held-out objects. A failed object takes its episode’s category, assigned by outcome first, then by the error text of the node that raised, then by the goal clause left unmet; examples are verbatim from held-out episode records: the error message, or for A and R an unmet goal predicate and for U the close kind.

	Final programs, by task						Table 1
Category	Tool Hanging	Syringe Packing	Gear Meshing	USB-C Insertion	Cable Routing	All	@0	@2	Feedback	Skill library
P Perception	1	15	17	1	7	8	11	7	6	25
G Grasp	$<$ 1	14	0	17	0	6	13	11	0	1
K Planning/IK	45	1	0	18	0	13	16	16	10	0
T Reach/tracking	13	6	0	2	0	5	9	5	5	4
A Placement	36	43	67	36	69	49	31	39	63	69

Appendix

Table 24: Share (%) of the failed held-out objects in each category: per task and in All over the final programs of the three studies (Table 1 @2, and the kept programs of every feedback arm, including the Outcome + object state and Outcome + relations rows of Table 14 , and of the two restricted skill-library arms), each held-out batch once; then per study, split as in Table 20 , with Table 1 at its zero-shot (@0) and @2 programs. Bold marks each column’s largest category.

Figure 16: Category shares (%) of the failed held-out objects per Table 1 setting, for the zero-shot program (left) and the program @2 reads (right). Letters follow Table 23 ; rows follow Table 1 .

Model	Overall			Tool Hanging			Syringe Packing
	@0	@1	@2	@0	@1	@2	@0	@1	@2
Human	82			87			90
Opus 5, xhigh	45 $\pm$ 7	64 $\pm$ 9	74 $\pm$ 4	22 $\pm$ 33	62 $\pm$ 26	60 $\pm$ 19	28 $\pm$ 4	38 $\pm$ 2	35 $\pm$ 0
Opus 5, high	41 $\pm$ 12	62 $\pm$ 12	81 $\pm$ 4	25 $\pm$ 43	72 $\pm$ 42	97 $\pm$ 4	40 $\pm$ 9	30 $\pm$ 0	45 $\pm$ 0
Opus 5, low	57 $\pm$ 6	67 $\pm$ 8	74 $\pm$ 7	0 $\pm$ 0	30 $\pm$ 37	57 $\pm$ 35	51 $\pm$ 6	50 $\pm$ 4	60 $\pm$ 0
DeepSeek V4	38 $\pm$ 4	43 $\pm$ 4	44 $\pm$ 4	0 $\pm$ 0	0 $\pm$ 0	0 $\pm$ 0	20 $\pm$ 14	29 $\pm$ 12	30 $\pm$ 12

Appendix

Table 25: Table 1 with run-to-run variation: mean

\pm

standard deviation (percentage points) over the five runs of each entry; Human is VABAR’s Level-1 result, without runs.

Suite	Task	Instruction	Stages	Episode
MimicGen	Coffee (D1)	Insert the coffee pod into the coffee machine and close the lid.	7	1500 steps
	Kitchen (D1)	Cook the bread in the pot on the stove, serve the pot with the bread retained, and finish with the stove off.	7	1500 steps
	Mug Cleanup (D1)	Open the target drawer, pick up the mug, place it upright inside the drawer, release it, close the drawer.	7	1500 steps
	Threading (D1)	Pick up the needle by its handle, align its shaft with the tripod ring, and thread it through the ring.	5	1500 steps
VABAR	Tool Hanging (Level 2)	Hang both wrenches on the two hooks.	7	task budget
	Gear Meshing (Level 2)	Put each gear on its own peg so they mesh, then press the red button at the near end of the board.	5	task budget

Appendix

Table 26: Tasks used in the curriculum study. “Stages” denotes the number of ordered reference stages used for stage feedback and stage reward, including the final success stage.

	MimicGen	VABAR
Tasks	Coffee, Kitchen, Mug Cleanup, Threading (D1)	Tool Hanging, Gear Meshing (Level 2); USB-C Insertion (Level 1)
Model	Claude Fable 5.1	Claude Opus 5
Iterations (privileged + perception)	8 + 8	5 + 5
Iterations (perception only)	16	10
Training episodes per iteration	10	4
Training layouts	10 new every iteration (seeds 0–159 over 16 iterations)	same 4 every iteration

Appendix

Table 27: Configuration differences between MimicGen and VABAR curriculum runs. Both settings (privileged

\rightarrow

perception and perception only) use the same configuration within a suite. The conversion session uses the suite’s turn limit with no time limit.

Figure 17: Representative failures of privileged-to-perception learning. (a) Policies learned with exact geometry can rely on geometric precision that perception cannot reliably recover after transfer. In Kitchen, the narrow handle tab is difficult to localize precisely; in Gear Meshing, the short pegs are difficult to detect. (b) Exact geometry alone may be insufficient for learning robust manipulation strategies. In Tool Hanging, the policy learns an unstable wrench grasp; in USB-C Insertion, it aligns the plug but fails during contact. Purple borders indicate privileged policies, and blue borders indicate perception policies.

Agentic AI for Robotics

See all 60 papers

Aug 2, 2026

You Don't Need To Stay in The Loop: An Agentic Robotics Loop for Robot-Policy Improvement

Coding agents such as Claude Code and Codex close the software loop: a main agent manages the loop, subagents analyze and execute, tools do the work. We port this architecture to robot-policy improvement, where one difference dominates the design: robotic tools---trained policies, training pipelines, data collection---fail routinely, so a tool's quality must be measured, recorded at every call, and expired when the artifact behind it changes. AgenticRobotics is a backend-independent control plane in which an LLM controller drives disposable workers through durable train--evaluate--improve transactions: an immutable objective, controller-owned measurement, commit-keyed crash recovery, an evidence-graded skill library, and a tool registry with a standardized, recorded call surface. The title is an operational claim, not a selection claim: the operator can leave because promotion is evidence-gated, state is recoverable, and capability quality is derived from records---not because the loop picks better checkpoints than a human; on the one lineage we measured, it does not. The gates measurably buy false-promotion control (0.001 per run hardened versus 0.005--0.021 shipped), anytime-valid decisions under optional stopping, zero lost or duplicate effects under kill injection, and six of six artifact-tampering classes caught by a signed verifier.

Hang Yu

Independent Researcher, United States.

Robot Policy Adaptation Agentic AI for Robotics Robotic Policy Evaluation Robotics AI Agent Governance LLM Agent Reliability

Ask PDF

Sep 23, 2026

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

Can a robot improve itself the way coding agents now improve software? We built an agentic system to find out. It watches a robot fail, works out which capability is missing, writes new skills or finds and installs external models, tests every change in simulation, and repeats, with no human writing robot code. We ran it for 123 improvement rounds on household manipulation tasks. This report describes what we learned. The good news is that the agent can discover capabilities on its own: noticing that its targets were out of view, it asked for an active-viewing model, debugged it, and deployed a working search skill. The bad news is that its improvements did not add up. Changes kept passing their tests, yet the target task, putting condiments on the top shelf of a fridge, never succeeded. We found that the agent was rarely the bottleneck. Three things around it were. First, chained perception modules do not understand relations. Segmenters such as SAM 3 find shelves but not "the top shelf", so the agent filled the gap with ever more geometric rules that never converged, when what it needed was a different kind of model. Second, skill chains lock learning onto the first step. Long tasks mostly fail early, so evidence and fixes pile up there, and later skills are rarely reached, tested, or improved. Third, what the agent learns is decided by the harness. The agent optimized exactly what the evaluator measured, including where it was wrong, and weak tests and misleading memory turned activity into a standstill. We distill these lessons into concrete recommendations for building robot systems that improve themselves, each paired with an experiment that could prove it wrong.

Jiaming Wang

National University of Singapore

Self-Improving Agents Robot Skill Learning Long-Horizon Robotic Manipulation

Ask PDF

Jun 17, 2026

Playful Agentic Robot Learning

Current agentic robot systems can write executable Code-as-Policy programs, observe feedback, and revise behavior across multiple attempts, but they remain largely task-driven: reusable skills are acquired only after explicit instructions. We study Playful Agentic Robot Learning, where an embodied coding agent uses self-directed play as a continual skill-learning stage before downstream tasks arrive. We introduce RATs, Robotics Agent Teams designed for play-time skill acquisition. During play, RATs proposes novel yet learnable exploratory tasks, plans and executes robot-code policies, verifies intermediate progress, diagnoses failures, retries with dense, step-level feedback, and distills successful executions into a persistent code skill library. At test time, the agent reuses relevant skills from this frozen library to help solve new tasks. Experiments in LIBERO-PRO and MolmoSpaces show that play-learned skills improve held-out downstream tasks over no-play and random-play baselines, with 20.6 and 17.0 percentage-point gains over CaP-Agent0 on LIBERO-PRO and MolmoSpaces, respectively. Moreover, the learned skills can be plugged into other inference-time Code-as-Policy agents by simply retrieving them into the context, improving RoboSuite and real-world transfer by 8.9 and 8.8 points, respectively, without finetuning the underlying model.

Junyi Zhang, Jiaxin Ge, Hanjun Yoo +17

University of California, Berkeley · Impossible Research

Robot Policy Learning Robot Skill Learning Agent Skill Learning Robot Learning

Ask PDF

Abstract

Agentic AI for Robotics

Explore similar work

You Don't Need To Stay in The Loop: An Agentic Robotics Loop for Robot-Policy Improvement

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

Playful Agentic Robot Learning