Toward Self-Improving Robotic Agents: From Interaction Experience to Reusable Manipulation Capabilities

1. Introduction

Robot manipulation is expanding beyond static, policy-centric execution toward agent-mediated capability development [1]. While modern Vision–Language–Action (VLA) architectures achieve broad semantic generalization across instructions and objects [2,3,4,5,6], what the robot encounters during deployment (failed grasps, recovered errors, newly observed object properties) is rarely retained in a form that later tasks can reuse. To address this limitation, agent-mediated frameworks coordinate task decomposition, tool use, and verification around physical execution [7,8,9]. Crucially, their role now extends beyond invoking pre-existing behaviors to constructing and revising capabilities themselves—synthesizing control programs, collecting physical experience, and organizing learning experiments [10,11]. Since sustained deployment needs such experience to accumulate rather than be repaired by hand, we ask: How do robot agents convert physical interaction experience into reusable manipulation capabilities for subsequent tasks?

Answering this question requires connecting what computational artifact is updated with how that update alters physical execution. System updates address distinct bottlenecks across the autonomy stack: persistent memory supplies task constraints or guides skill selection; programs structure multi-step control flow and error recovery; harness revisions alter observation filtering and API dispatch; and neural updates adapt motor actuation or spatial representations. Learning resources act indirectly by shaping optimization for subsequent policies. Crucially, these disparate mechanisms can produce identical gains in benchmark success: improvements may reflect more appropriate skill selection, better routine coordination, or more compliant motor execution. An update taxonomy alone does not show how a change reaches behavior, and an execution taxonomy alone does not show how capabilities accumulate. Explaining capability development requires jointly investigating three coupled questions: what changes, how subsequent execution ingests that change, and which dimension of manipulation behavior improves.

This conversion is challenging because physical outcomes depend on tightly coupled perceptual, planning, and control loops. A failed grasp may originate in calibration drift, kinematic misplanning, or unmodeled friction, making the true update target uncertain: diagnosis must causally link observed failures to a modifiable component that can alter behavior. Even when an update is successfully synthesized, localized repairs frequently fail complete tasks: an approach trajectory can satisfy reachability checks yet leave the workspace in a state that renders subsequent grasping infeasible [12]. Moreover, capability updates risk catastrophic regression on previously mastered tasks [13,14]. Evaluating such updates therefore requires keeping two questions apart. The first concerns the update artifact: whether it improves complete-task outcomes, transfers to new tasks, and preserves earlier capabilities. The second concerns the acquisition process: whether independent runs repeatedly produce such effective updates under explicitly stated human-intervention and reset costs.

Prior work examines this space along separate axes: VLA architectures and sensorimotor learning [15], functional components of embodied agents [16], context-conditioned robot learning [17], and update mechanisms in self-evolving digital agents [18]. These lines of work treat models, execution, and updates in depth, but largely separately. Less systematically connected is the full chain from interaction experience, through the update it produces and how subsequent execution uses that update, to the resulting physical effect. Table 1 summarizes these perspectives and the connecting question pursued here.

Our framework couples agent-mediated execution (Track A), which coordinates physical behavior under a fixed capability configuration, with capability acquisition (Track B), which constructs or revises that configuration across deployment cycles (Figure 1). We trace this conversion through a capability lineage, linking originating experience, the acquisition mechanism, the updated component, its downstream invocation, and the resulting physical performance. By systematically auditing 162 primary manipulation studies across hardware and embodied simulation through October 2026, this review delivers three findings, which address in turn which component updates yield gains, whether local updates improve complete tasks, and whether the acquisition process repeatedly produces effective updates:

1.

Capability gains are not limited to action-policy updates. Reported manipulation gains also arise from refined prompt guidance, skill selection, or harness routing while the neural actor remains fixed. Which component is updated therefore matters: locating whether an execution bottleneck lies in semantic reasoning, tool composition, or continuous control should precede the choice of update target.

2.

Locally accepted updates do not guarantee complete-task improvement. Accumulated skills and locally accepted repairs can fail once composed into complete tasks: a reusable capability needs verified entry conditions and must leave physical states that support downstream skill handoffs. Whether an update artifact is effective must therefore be judged by complete-task outcomes, transfer, and retention of earlier capabilities, not by isolated component metrics alone.

3.

Effective updates are documented, but repeatable acquisition on hardware is not yet established. Repeated acquisition, transfer, and retention are jointly demonstrated in bounded simulation streams. On hardware, no examined system shows that independent acquisition runs repeatedly produce effective updates with connected transfer, retention, and explicit accounting of human intervention and reset costs.

Section 2 formalizes our analytical framework, system state tuple, and evidentiary protocol. Section 3, Section 4 and Section 5 examine execution interfaces, update targets, and acquisition processes; Section 6 synthesizes empirical outcomes; Section 7Section 8 outline open challenges and conclude.

2. Problem Formulation and Analytical Framework

This section formalizes the core theoretical substrate connecting physical interaction experience, retained computational updates, and subsequent manipulation performance. We first decouple intra-episode execution from cross-episode capability acquisition, formulate the persistent system configuration tuple, and establish the operational lifecycle governing candidate generation and validation gating. Finally, we formalize the capability lineage and evidentiary audit criteria used to assess claims across the surveyed literature.

2.1. Execution and Capability Acquisition

We formalize robot manipulation across two asynchronous timescales: intra-episode closed-loop control governed by continuous sensorimotor transitions, and cross-episode capability acquisition governed by structural configuration mutations. At execution step $t\in [0,T]$, an underlying policy maps observation–action history $h_t=(o_0,a_0,\dots ,o_t)$ and instruction ℓ to an immediate motor action or trajectory chunk:

$$a_t\sim {\pi }_{\theta }(·\mid h_t,\ell ).$$

(1)

Even under fixed weights $\theta$, recurrent hidden states, feature caching, and reactive feedback loops dynamically modulate control within an episode. Such responsiveness reflects runtime execution resilience rather than retained capability acquisition.

An agentic manipulation system coordinates intermediate deliberative decisions, including task decomposition, tool selection, spatial constraint formulation, and closed-loop verification:

$$\begin{array}{cc}\hfill (u_t,z_{t+1})& ={\mathcal{A}}_{C_k}(o_t,\ell ,z_t,F_t),\hfill \\ \hfill a_t& \sim {\pi }_{\mathrm{actor},C_k}(·\mid u_t,o_t),\hfill \end{array}$$

(2)

where $u_t$ is an intermediate executable decision (such as a parameterized skill invocation, programmatic subroutine, or spatial objective); $z_t$ designates transient belief; $F_t$ represents physical execution feedback; and configuration $C_k$ (defined below) parameterizes the available reasoning, orchestration, and action components. The continuous action chunk $a_t$ is realized by the underlying actor ${\pi }_{\mathrm{actor}}$ conditioned on $u_t$ and immediate observation $o_t$. This functional decomposition applies equally to unified foundation models and modular harnesses. Agency is defined not by the presence of a language model, but by the structural orchestration of intermediate decisions, tool endpoints, and physical feedback loops.

To evaluate capability retention across extended deployments, we define the physical execution context as the temporal state space governing robotic continuity: task progress, timestamped 3D scene estimates, kinematic configurations, capability registries, and execution traces. Crucially, retaining symbolic software state (such as an object prehension flag or estimated bounding box) preserves an internal belief, but guarantees neither physical validity after unobserved slippage nor autonomous workspace recovery. Physical continuity demands renewed sensorimotor verification; maintaining software state and acquiring a transferable manipulation capability represent fundamentally disparate claims.

2.2. Update Targets and Their Effects on Execution

Across successive deployment cycles ($k\in \mathbb{N}$), the system’s persistent operational capacity is parameterized by the architectural configuration tuple:

$$C_k=({\theta }_k,H_k,M_k,S_k,T_k,E_k),$$

(3)

where ${\theta }_k$ contains trainable neural parameters; $H_k$ designates the execution harness and prompt orchestrator; $M_k$ stores declarative knowledge and textual guidance; $S_k$ contains callable skills or programs; $T_k$ specifies callable tool contracts; and $E_k$ records developmental assets including simulation environments, rewards, and training recipes. The first five components govern physical execution, whereas $E_k$ guides downstream learning or evaluation. Artifacts are classified strictly by representation and ingestion: textual planner guidance belongs to $M_k$, executable code to $S_k$, and context orchestration to $H_k$, regardless of source-paper terminology.

The distinction matters because these targets enter execution through fundamentally different routes: retrieved $M_k$ influences constraints, command formulation, or skill selection; invoked $S_k$ supplies reusable behaviors and their composition; revisions to $H_k$ or $T_k$ change context construction, dispatch, monitoring, or recovery; updates to ${\theta }_k$ modify continuous control, reasoning, or verification; and changes to $E_k$ act through subsequent learning cycles. As synthesized in Figure 2, our framework establishes two orthogonal classification axes: the execution interface describes how decisions reach physical control, while the update target identifies which component of $C_k$ changes.

2.3. Acquisition Processes, Capability Lineage, and Agency Boundaries

Candidate capability generation and deployment promotion are governed by:

$${\tilde{C}}_{k+1}=\mathcal{U}(C_k,{\tau }_k,F_k;B_k),C_{k+1}=\mathcal{G}(C_k,{\tilde{C}}_{k+1};\mathcal{V},B_k),$$

(4)

where $\mathcal{U}$ constructs candidate mutation ${\tilde{C}}_{k+1}$ from interaction traces ${\tau }_k$ and feedback $F_k$ under resource budget $B_k$, and promotion gate $\mathcal{G}$ accepts or rejects it using validation evidence $\mathcal{V}$ from development partition ${\mathcal{D}}_{\mathrm{val}}$. Writing this formalization accommodates both automated pre-deployment validation suites and systems lacking explicit gates (where $\mathcal{G}$ acts as a direct adoption rule with $\mathcal{V}=\varnothing$).

Our analytical unit, a capability lineage, links originating experience or supervision, the diagnosis and construction mechanism, the changed component, the adoption decision, the later-use interface, and the comparative physical outcome. Tracing where an update is retrieved, invoked, or learned connects the acquisition process to a testable behavioral effect.

Decision responsibility across Equation 4 is recorded separately from artifact utility. We formalize four operational boundaries of agency: Researcher-selected, where humans curate data, objectives, and promotion rules; Teacher-assisted, where external expert demonstrations or dialogue guide acquisition; Delegated agent improvement, where an agent proposes and tests updates within a static development workflow; and Agent-selected improvement, where the agent autonomously directs diagnosis, exploratory trials, and promotion gates. These categories delineate operational decision authority rather than a hierarchy of measured artifact utility.

2.4. Evidence Criteria and Claim Boundaries

A lineage describes how a change could affect execution; evidence determines which outcomes are established. We distinguish artifact construction, persistence, later use, and comparative benefit. Transfer, earlier-task retention or regression, resource costs, and acquisition repeatability further characterize that benefit. Repeated execution of one artifact measures runtime variance, whereas independent acquisition histories test whether the procedure reliably produces useful artifacts.

Our framework formalizes five progressive evidence levels (Table 4):

L1: 

Execution baseline. Agent-mediated manipulation is documented without established construction of a capability artifact.

L2: 

Capability construction. An artifact is constructed or adapted, but persistence and subsequent execution are not jointly verified.

L3: 

Persistence and later use. The constructed artifact survives episode termination and is actively loaded or invoked by subsequent execution or learning workflows.

L4: 

Measured manipulation gain. A connected artifact lineage supports reported physical gain over a frozen comparator under source-declared separation of acquisition or selection from evaluation.

L5: 

Repeatable physical self-improvement. Independent acquisition histories yield protected-test gains, with cross-task transfer, earlier-task retention, and low human dependence jointly supported under declared intervention criteria and accounting periods.

These levels describe evidence in the inspected corpus, not a universal ranking of system quality. L5 is a review-defined joint criterion; failure to meet it does not negate supported components. Each record receives the highest level supported by one connected experimental chain. Simulation (S), hardware (H), and joint evidence (B) identify the credited endpoint. Offline training and teacher assistance remain eligible for L4 when evaluation separation holds.

2.5. Review Scope and Coding Protocol

Four progressive questions organize the synthesis:

RQ1: 

Execution. Through which interfaces do available capabilities produce physical manipulation, and where does sensory feedback alter decisions?

RQ2: 

Update targets. Which computational components are constructed or revised, and how are they ingested by subsequent execution?

RQ3: 

Acquisition. How do interaction experience and supervision drive update generation, validation, and adoption?

RQ4: 

Evidence. What empirical evidence substantiates subsequent manipulation gains, transfer, retention, and repeatable acquisition under bounded intervention?

The audited corpus comprises 162 primary manipulation studies available through October 2026 across hardware and embodied simulation. Eligible studies investigate goal-directed physical manipulation with inspectable execution or acquisition mechanisms and reported evaluation outcomes. Purely digital software agents, standalone perception modules, navigation-only systems, and ungrounded dialogue are excluded.

For each primary study, our structured ledger cross-verifies seven core dimensions: execution interface, mutated configuration target, persistence and ingestion, comparator baseline and reported gain, acquisition/test separation, acquisition repeatability, and human/reset intervention budgets. Unreported properties are explicitly recorded as unresolved evidence rather than assumed to be absent, preventing negative inferences from missing reporting. Extraction is AI-assisted and cross-validated through deterministic consistency checks, with complete query strings, screening dispositions, and source audit records preserved in the accompanying ledger. Section 6 presents the resulting empirical synthesis without pooling incompatible success metrics.

3. Agent-Mediated Manipulation: Grounding, Coordination, and Control

An execution-stage embodied agent translates high-level task specifications into continuous physical actions by grounding semantic goals into metric spatial frames, coordinating callable actors, and leveraging real-time feedback to arbitrate corrective interventions. Under the execution boundary formalized in Section 2.3, this section addresses RQ1: how agent decisions interface with continuous robot control, which observation structures and intervention points support error recovery, and what operational limitations arise under a given capability configuration $C_k$. This analysis holds the configuration fixed during the examined execution, without excluding acquisition at other stages.

3.1. Physical Grounding and Ephemeral Belief Dynamics

Task grounding projects abstract semantic directives onto concrete physical states: target entities, continuous affordance manifolds, spatial coordinate frames, and contact prerequisites. Representations optimized strictly for semantic object categorization frequently prove inadequate for contact stability, compliance regulation, or force-closure grasp verification. Underlying VLA actors can learn visual grounding priors through target-region reconstruction [21] or alignment with pretrained 3D representations [22]. AffordanceVLA [23] further grounds action generation through object selection, interaction localization, and 3D affordance reasoning. A3D [24] adapts support and stabilization locations from interaction feedback during dual-arm assembly.

Scene Continuity and State Tracking Under Dynamic Contact.

Execution harnesses diverge substantially in how they maintain spatial continuity across contact events, frictional slip, and visual occlusions. As established in Section 2.1, a stored prehension flag or 3D bounding volume reflects historical evidence; physical disturbances can invalidate this internal state without generating an inspectable software exception.

Implementations span two distinct tracking paradigms. In ephemeral session tracking, explicit task progress indicators and coordinate frames exist exclusively within the temporal lifecycle of a single trial, re-initializing the internal world model upon episode termination, as in SimpleARM [25]. Conversely, spatio-temporal world-state representations track physical entities across extended interactions: RoboStream [26] preserves object identities and action-triggered transitions across continuous visual occlusions, while MessyMem [27] organizes dynamic 3D scene graphs across long-horizon executions.

Multi-step state tracking maintains the agent’s task belief $z_t$. If this state is reset without retaining a component for subsequent use, its within-task persistence does not establish cross-task acquisition. Whether a record contributes to later capability depends on its lifetime and use, as defined in Section 2.1. In contrast, learned world representations can encode reusable priors over state transitions [28]. The decisive control-theoretic distinction is whether an internal memory entry denotes raw sensory evidence, an inferred geometric hypothesis, or an actively confirmed physical contact state. Following external preemption or visual occlusion, downstream action dispatch demands renewed physical verification that prerequisite states remain intact.

Active Sensing, Probing, and Epistemic Uncertainty Reduction.

When passive sensory observations leave the state distribution uncalibrated, an embodied agent can actively interrogate the physical environment prior to irreversible actuation. In physical probing, the manipulator executes deliberate, low-energy exploratory motions to infer latent physical parameters: PhysCaP [29] evaluates epistemic uncertainty and commands executable probes to estimate mass and surface stiffness from proprioceptive feedback before executing dynamic tasks. In active viewpoint selection, the agent repositions external or wrist cameras to resolve occlusions: VAP-TAMP [30] couples precondition and effect monitors to camera movements when existing visual perspectives are insufficient for geometric predicate evaluation. In clarification interactions, the system defers action commitment to human supervisors: KNOWNO [31] uses conformal prediction sets over candidate plans, triggering targeted human queries whenever the prediction set contains multiple competing hypotheses. Each exploratory or interactive modality expends physical execution time, joint actuation budgets, or human oversight; their systemic utility must therefore be audited against the operational costs of active probing trajectories, sensor displacement, and human intervention.

3.2. Task Planning, Decomposition, and Multi-Agent Coordination

Task planning maps grounded manipulation goals into sequential subgoals or conditional programs, drawing on semantic and spatial reasoning [32,33]. The operational trade-offs governing deliberative planning center on how alternative representations enforce physical kinematic feasibility, when sensory feedback triggers online replanning, and how multi-embodiment architectures arbitrate shared workspaces. RationalVLA [34] adds a prior check of instruction admissibility, rejecting defective commands before manipulation.

Representations for Manipulation Decomposition.

Across current architectures, three primary planning representations impose fundamentally different structural constraints on physical execution:

• Affordance-Grounded Value Ranking: Semantic action proposals are filtered through learned physical feasibility scores. As pioneered by SayCan [7], an autoregressive language model scores task relevance while a learned value function evaluates the real-time physical feasibility of candidate skills. This approach grounds high-level selection without requiring analytical dynamic world models; however, it remains strictly bounded by the static repertoire of pre-trained skills and greedily evaluates skills step by step rather than searching over continuous geometric state manifolds.
• Symbolic Action Schemas and Predicate TAMP: Task structures are explicitly formalized via rigorous preconditions, continuous parameters, and expected physical transitions. PLanAR [35] enforces formal object predicates and action schemas with observation-based effect verification, whereas SayPlan [36] navigates hierarchical 3D scene graphs and refines proposed plans using scene-graph simulator feedback prior to physical actuation. These formalisms provide verifiable task progression, yet their physical execution fidelity remains vulnerable to grounding noise in continuous state estimation.
• Programmatic Logic and Executable Assertions: Task plans can be represented as structured programs with conditional branches, loops, and explicit execution checks. ProgPrompt [37] generates situated task plans with assertions and recovery routines, while RoboScript [38] translates free-form manipulation instructions into executable scripts using geometric planning and control modules. Such representations make task-level control flow explicit and inspectable, although their effectiveness depends on the available robot APIs and execution feedback.

Replanning Triggers and Closed-Loop Preemption.

Replanning is triggered when empirical feedback violates formal assumptions: an unfulfilled precondition, an unachieved postcondition despite nominal controller termination, or an unreachable kinematic waypoint. Under the Track A paradigm, these events dynamically restructure the sequence of callable actions within the active trial; they alter no persistent capability representations.

Multi-Agent Coordination and Workspace Interference.

In collaborative manipulation settings, spatial allocation couples subtask dispatch with physical interference constraints. RoCo [39] employs multimodal dialogue rounds between heterogeneous manipulators to negotiate task allocations and 3D waypoints, subsequently dispatching agreed coordinates to centralized motion planners that check spatial collision constraints under the represented geometry. In human-robot co-working contexts, MOSAIC [40] integrates interactive planning with probabilistic human trajectory forecasting, dynamically arbitrating subtask assignments during shared culinary assembly. Furthermore, heterogeneous infrastructures such as ABot-Claw [41] coordinate diverse robotic embodiments across unified visual grounding, mobile navigation, and object handovers. RoboOS-NeXT [42] coordinates heterogeneous robots through shared spatio-temporal-embodiment memory. In all collaborative settings, linguistic consensus remains purely declarative; physical feasibility demands continuous geometric validation within the shared contact envelope.

3.3. Skill Selection, Composition, and Policy Handoffs

Skill composition selects a callable actor, binds its continuous arguments to the active scene geometry, and verifies whether its terminal kinematic state satisfies the entry conditions of subsequent primitives. The execution view treats composition as an orchestration problem over an established repertoire.

Skill Interfaces and Compositional Invariants.

Extending procedural abstractions in digital systems [19], physical manipulation skills are governed by five operational boundaries: (i) precondition and feasibility boundaries that verify spatial reachability, collision-free corridors, and prehension states; (ii) scene-grounded bindings that map abstract parameters to 6-DoF grasp poses or tracked surface keypoints; (iii) continuous motion substrates that execute trajectories via feedback controllers, dynamic movement primitives, or learned visuomotor policies; (iv) post-execution invariant monitors confirming that the targeted physical transition occurred; and (v) interruption thresholds on quantities such as torque and velocity, whose effect on stopping behavior and scene stability depends on the controller and task. Compositional feasibility therefore depends on whether the terminal states produced by skill ${\mathcal{S}}_i$ satisfy the initiation conditions of skill ${\mathcal{S}}_{i+1}$.

Delegation to Foundation Actors.

Hierarchical architectures frequently partition decision authority between high-level multimodal deliberators and low-level sensorimotor actors. Hi Robot [43] partitions control hierarchically: a high-level multimodal planner processes user intent and camera frames to emit segmented directives to a low-level VLA executing continuous joint control. Conversely, systems like Pigey [44] and VLAs-as-Tools [45] encapsulate pre-trained foundation policies directly as callable tool endpoints within an orchestration harness, utilizing returning observation streams to arbitrate downstream dispatch. Cortex [46] aligns planner directives with low-level actor interfaces via structured skill descriptors and canonical prompt schemas. OpenHelix [47] uses latent conditioning between a vision-language model and a diffusion actor, while VLA² [48] supplies OpenVLA with retrieved knowledge and object detections.

Handoff Boundaries Between Heterogeneous Policies.

Handoffs across heterogeneous policies (such as transitioning from an analytical trajectory planner to a learned diffusion actor) frequently encounter boundary mismatches in action horizons, coordinate frames, and observation dynamics. RoboHarness [49] explicitly resolves these transition mismatches via a dedicated Memory Bridge, retrieving historical trajectories, learning a local progress ranking, and selecting reachable handoff configurations compatible with the incoming actor. Analogously, 2AM [50] decouples temporal memory from motor execution, maintaining long-horizon context within the high-level reasoner while deploying an episodically stateless action generator conditioned on semantic instructions and spatial guidance hints. To arbitrate dynamic transitions between modular analytical planners and contact-rich end-to-end controllers, RoboAware [51] discretizes skill execution into a five-stage semantic schema ($P^5$) and trains an outcome-aware coordinator via state-locked counterfactual branching, dynamically assigning execution responsibility across policy families at each stage boundary based on anticipated physical returns. These bridging mechanisms help mitigate transition failures; their systemic contribution must be evaluated against unbridged baselines.

3.4. Decision Interfaces for Physical Control

The decision interface establishes the structural contract between high-level agent reasoning and physical robot control. Table 2 and Figure 3 compare five canonical execution patterns, delineating their action representations, motion substrates, feedback timing, and runtime intervention points.

Pattern 1: Integrated Reasoning–Action Interfaces.

A unified sensorimotor model generates intermediate reasoning traces, subgoal images, or spatial heatmaps directly alongside continuous motor commands. In Embodied Chain-of-Thought (ECoT) [52], the network autoregressively emits textual and spatial bounding tokens prior to outputting discretized action tokens. OneTwoVLA [53] incorporates discrete deliberation tokens that alternate dynamically between linguistic reasoning and continuous chunk generation, integrating error-recovery rollouts directly into the policy training distribution. At the actor-model level, related approaches couple visual prediction with action generation through optical-flow intermediates [54], joint image–action denoising [55], unified world–action modeling [56], affordance-aware joint world–action prediction in AffordanceWAM [57], or cross-embodiment curricula with hybrid temporal attention and joint visual–action prediction as in Kairos [58]. Integrated architectures reduce inter-module translation overhead, but their tightly coupled reasoning and control can make failure attribution and targeted correction less transparent.

Pattern 2: Skill and Policy Invocation Interfaces.

This interface represents agent decisions as discrete skill identifiers with scene-grounded continuous arguments. VLAs-as-Tools [45] exposes pre-trained robot policies as callable tools, allowing a high-level reasoner to select and parameterize existing motor capabilities. The selected actor executes under its own control loop, while the agent monitors termination conditions and determines subsequent invocations. This interface separates high-level decision-making from continuous control, but its effectiveness depends on the coverage, reliability, and compatibility of the available skills.

Pattern 3: Programmatic Orchestration and Tool Interfaces.

In this pattern, the agent generates executable programs that compose perception, planning, and control APIs. Code as Policies [8] uses language-model-generated programs to invoke robotic control functions, while AGP [59] incorporates physical execution feedback to iteratively refine generated policies. Programmatic interfaces make control flow, conditional execution, and recovery logic explicit and inspectable. However, their reliability depends on the capabilities exposed by the underlying APIs, while code generation and revision introduce additional latency.

Pattern 4: Spatial Objectives and Optimization Constraints.

The agent translates semantic goals into continuous 3D cost fields, keypoint trajectories, or optimization energy functions. VoxPoser [9] synthesizes language-conditioned 3D value maps from visual observations, defining objectives for model-based trajectory optimizers. ReKep [60] formalizes manipulation tasks as relational 3D keypoint constraints, resolving path and subgoal constraints via sequential quadratic programming. Spatial interfaces delegate trajectory generation to numerical solvers; dynamic stabilization and contact compliance depend on the underlying controller. Related approaches also use explicit geometric inference to translate learned spatial predictions into robot actions [61]. However, the reliability of spatially grounded interfaces remains sensitive to perceptual registration errors, including depth noise, occlusions, and reflective surfaces.

Pattern 5: Incremental Command Interfaces.

The agent deliberator operates as a low-frequency setpoint corrector, emitting continuous Cartesian pose deltas ($\Delta x,\Delta y,\Delta z,\Delta \theta$), directional waypoints, or discrete gripper triggers. Systems like Show-Harness [62], RoboDawn [63], and World Action Agent (WAA) [64] expose incremental control interfaces to vision models for successive corrective steps. Incremental commands offer frequent opportunities for trajectory correction, but recurrent model inference introduces non-negligible latency. Contact stability depends on the underlying controller and physical interaction between successive setpoints; the command interface alone does not specify an impedance-control implementation.

Timescales and the Feedback Latency Hierarchy.

A rigorous claim of closed-loop manipulation must identify which specific loop is closed: low-level joint stabilization, visuomotor chunk generation, or high-level semantic replanning. Their rates depend on the implementation and task. These control loops can operate at different temporal scales. Contact disturbances faster than the high-level feedback cycle require a response from the underlying controller. PD-VLA [65] reduces chunk-decoding latency through training-free parallel fixed-point iterations, addressing one component of sensing-to-action delay. Reporting standards must explicitly state sensing-to-action latency, execution chunk duration, preemption thresholds, and the exact compliance controller governing contact between high-level deliberation cycles.

3.5. Execution Monitoring and the Operational Limits of Track A

Execution monitoring supports state verification, task progress assessment, and reactive recovery under a fixed capability configuration $C_0$.

Sources of Verification Evidence.

Runtime verification relies on four main sources:

• Privileged Simulation Predicates: Physics engine states, joint contact manifolds, and collision meshes are directly queried. However, privileged predicates are generally unavailable on physical hardware without equivalent sensing and state estimation.
• Learned Visual Verifiers: Multimodal foundation models evaluate pre- and post-condition RGB frames, as in Inner Monologue [66] and Agentic Robot [67]. However, vision-based verification remains highly susceptible to perceptual illusions, visual occlusions, and specular reflections where an object appears prehended despite lacking normal contact force.
• Geometric and Programmatic Invariants: Continuous mathematical constraints are verified throughout trajectory execution: Code-as-Monitor [68] executes synthesized monitor scripts checking spatio-temporal invariants among tracked geometric primitives, while DoReMi [69] uses multimodal checks to detect execution deviations and trigger recovery.
• Proprioceptive and Contact-Force Verification: Gripper motor currents, joint torque differentials, and tactile sensor arrays are monitored during motion. Force feedback provides direct physical evidence of prehension; a nominal controller completion status code alone establishes neither contact stability nor grasp retention.

Task Progress Monitoring.

While verification checks whether expected states or transitions have occurred, progress monitoring assesses how a task evolves over time[cite: 14]. GVL [70], Robo-Dopamine [71], and RoboMeter [72] estimate task progress from visual observations, while ViVa [73] and WVM [74] leverage video generation models for progress-related value estimation[cite: 15]. PRM-as-a-Judge [75,76] further uses progress curves for process-level evaluation and failure diagnosis. Complementing process-level auditing, benchmark suites such as WorldFailBench [77] evaluate whether predictive and generative world models can faithfully diagnose and anticipate downstream policy execution failures. Such progress and failure estimates can reveal stagnation and regression beyond individual state checks, providing complementary signals for execution monitoring and potential recovery.

Feedback-Driven Recovery.

Verification failures can trigger corrective interventions, while progress estimates provide complementary signals for identifying stalled execution. Existing recovery mechanisms operate at different levels: Plan-level replanning routes semantic failure diagnostics back to the high-level planner for symbolic re-sequencing (e.g., CoPAL [78]); action-space residual steering adjusts frozen policy proposals through learned local correction offsets, as in CommitFlow [79]; and verifier-triggered prompt modification utilizes offline-trained stage or risk verifiers to re-prompt a frozen VLA (e.g., VLA-Corrector [80]) without modifying underlying neural parameters. Furthermore, SafeHarness [81] arbitrates obstacle-aware routing and contact points, whereas KNOWNO [31] solicits human input when its calibrated confidence sets indicate multi-modal uncertainty.

Limits of Runtime Adaptation.

The five execution interfaces expose different decision and feedback boundaries: integrated policies couple reasoning with motor output, skill interfaces schedule reusable actors, programmatic interfaces organize callable APIs, spatial objectives guide numerical solvers, and incremental commands permit stepwise corrections. Across these interfaces, monitoring and replanning can improve within-episode robustness under a fixed capability configuration. These execution mechanisms also provide feedback and intervention points for later capability acquisition.

A fixed configuration does not preclude new task solutions: agents may solve previously unseen tasks by recomposing available skills, adjusting execution parameters, and leveraging sensory feedback. However, these adaptations do not by themselves establish persistent capability acquisition. When systematic failures arise from missing motor skills, unreliable state estimation, or incompatible execution interfaces, further improvement may require updating persistent components of $C_k$ across episodes. This motivates Track B (Capability Acquisition), examined in Section 4, which connects retained updates to the execution interfaces through which they affect later behavior.

4. Capability Acquisition Targets: Artifacts and Ingestion Contracts

Capability acquisition (Track B) constructs or revises components of the retained configuration $C_k$ defined in Equation (3) for subsequent use. It can occur before deployment or interleave with execution; its defining feature is the retained change rather than an episode boundary. This section addresses RQ2: which computational artifacts change, how they enter subsequent execution or learning, and which behaviors and failure modes these changes affect (Figure 4). We examine five groups of update targets in $C_k$, grouping harnesses and tools together, through their functional representations, ingestion contracts, and effects on manipulation.

4.1. Declarative Memory and Relational Schemas ($M_k$)

Memory updates revise the persistent record of operational guidance $M_k\to M_{k+1}$ and can influence later decisions without modifying underlying neural parameters $\theta$ or executable harness scripts H. Retained rules, body estimates, and examples guide skill selection, parameter binding, or program synthesis. Their utility depends on how records are indexed, whether they remain applicable as physical conditions change, and how relevant information reaches the decision process within its available context budget.

Retained Knowledge Representations.

Across the surveyed literature, declarative memory acquisitions populate three primary structural paradigms: Distilled symbolic rules and preference models abstract task constraints and user specifications from supplied examples or interaction feedback. TidyBot [82] summarizes user-provided textual placement examples into generalized semantic preference rules across object categories, demonstrating that declarative induction can steer future task executions without weight adaptation. DROC [83] distills language corrections into task-indexed records containing constraints, preferences, object information, and reusable skill parameters, such as gripper poses and pull distances. These records are retrieved using task semantics and object-level visual similarity to guide subsequent planning and code generation. Queryable body estimates and conditional action-effect schemas formalize the robot’s physical capabilities and morphological constraints. KnowBody [84] maintains an inspectable physical body model alongside condition-dependent action predictors whose applicability is dynamically gated by kinematic body estimates. Candidate body revisions and action-effect schemas are frozen and validated across independent physical trials prior to deployment activation, ensuring that transient tool attachments remain isolated within episodic state. Procedural playbooks and execution-grounded exemplars preserve granular behavioral recipes derived from successful execution traces. ARCHITECT [85] distills human corrections and execution-grounded program patches into an expanding exemplar library ingested in full during subsequent program synthesis cycles. Similarly, Recursive Harness Distillation (RHD) [86] extracts intervention heuristics from a frontier teacher model into a structured operational playbook, selectively steering lightweight edge models on when to request verification and when to dispatch autonomous motion primitives.

Epistemic Drift, Invalidation, and Retrieval Trade-Offs.

Retained knowledge structures are acutely vulnerable to epistemic drift: physical parameters recorded during episode k (such as joint friction estimates, surface contact compliance, or suction seal thresholds) frequently cease to hold following mechanical wear, temperature variations, or payload alterations. Ingestion of uncalibrated memory entries directly injects erroneous inductive biases into downstream reasoning.

RoboHarn-Evo [87] associates knowledge versions with execution evidence labeled as support, opposition, or unverified. Applicable entries are eligible for retrieval when supported without opposing evidence; counter-evidence withdraws the challenged version, while revised content must satisfy the same evidence criterion before reuse. Similarly, Real2Gym [88] extracts reusable procedural packages post-execution to bootstrap subsequent context construction. However, scaling the volume of $M_k$ introduces severe retrieval-capacity tensions: unrestricted retrieval consumes bounded context windows, while selective top-k filtering risks omitting critical geometric invariants or safety preconditions.

4.2. Executable Skill Repositories and Policy Graphs ($S_k$)

Skill acquisition constructs or refactors callable computational procedures ($S_k\to S_{k+1}$), encompassing parameterized motion functions, abstract syntax tree (AST) patches, and executable policy graphs. These artifacts preserve explicit control flow and callable operations for later execution. Their nodes or function calls may invoke learned models, planners, or controllers, so retaining a program does not imply deterministic reasoning or eliminate runtime model calls.

Structural Representations of Programmatic Skills.

The synthesis of executable manipulation procedures manifests across four architectural representations:

• Parameterized Functional Primitives and Clustering: Continuous execution traces are segmented and abstracted into generalized, callable subroutines. As established by LRLL [89], multi-task rollout traces are abstracted via wake-sleep program clustering into parameterized Python functions, replacing ad-hoc script synthesis with reusable subroutines. CaP-X [90] extracts modular helper primitives from successful execution rollouts, while RATs [91] organizes newly discovered exploratory controllers into a permanent, queryable skill registry.
• AST Refactoring and Cross-Trial Controller Rewriting: The agent iteratively modifies the underlying perception, kinematic transforms, or feedback loops of an existing controller script across trial boundaries. Act–Observe–Rewrite (AOR) [92] operationalizes this paradigm by analyzing failure tracebacks and keyframe imagery post-trial, prompting a code-generation model to refactor controller ASTs for the subsequent attempt. ASPIRE [93] extracts reusable repair snippets and execution guards from failure traces to harden brittle manipulation code.
• Executable Policy Graphs: Programmatic policies can make data flow and execution logic explicit through modular graphs. Graph-as-Policy (GaP) [10] synthesizes directed computation graphs with perception, planning, and control nodes, and refines candidate graphs through simulation before repeated deployment. An edge interpreter executes the resulting graph, whose perception nodes may still invoke foundation models at runtime. ENCORE [13] uses structured demonstration packages to synthesize modular robot programs, while Generalized Coding TAMP [94] leverages simulation rollouts to synthesize and freeze executable task programs evaluated across unseen task instances.
• Multimodal Procedural Contracts: In World Action Agent (WAA) [64], acquired skills are encapsulated as multimodal procedural packages containing explicit precondition bounds, visual anchor images of valid initial states, and verifiable postcondition checks. An offline Editor reconciles new demonstration trajectories with the pre-existing skill library, adding, pruning, or retiring skill modules based on empirical verification evidence.

The Synthesis–Execution Latency Asymmetry.

Programmatic skill acquisition can decouple development synthesis from runtime execution. Compiling a policy graph or refactoring a complex controller script (as in GaP or RAPID [95]) involves model calls, program checks, and verification, with system-dependent computational and temporal costs. Once retained, the artifact can reuse synthesized execution logic, but its execution rate depends on the perception, planning, control, and model calls it invokes.

Yet, retaining an inspectable program does not entirely eliminate runtime reliance on foundation models: Astra-Sim2Real [96] retains refactored feedback loops where an agent selects continuous motion arguments online, while visual routines provide real-time stopping checks. System evaluations must rigorously distinguish deployment execution latency from the amortized computational cost of offline program synthesis.

4.3. Orchestration Harnesses, Tool APIs, and Context Builders ($H_k,T_k$)

Harness and tool updates modify the operational scaffolding that mediates between foundation models, sensory observation streams, and physical actors ($H_k\to H_{k+1},T_k\to T_{k+1}$). Retained changes to prompt construction, tool schemas, or error recovery wrappers can alter later execution even when neural parameters $\theta$ and base primitives S remain fixed. They change the information available to a decision, how capabilities are invoked, or when recovery is triggered; they may also accompany updates to other components.

Harness and Tool Mutation Targets.

Across the literature, harness mutations target three distinct operational mechanisms: Context builders and prompt orchestration code optimize the procedural functions that format sensory inputs, filter perceptual history, and construct reasoning contexts. SHAPER [97] optimizes context-building code alongside textual skill descriptors, iteratively refining which sensory features, action histories, and failure diagnostics enter the planner’s prompt. AdaHVLA [98] adapts the orchestration code governing retained runtime state, multi-camera visual context, progress commitments, and recovery decisions around a frozen VLA. Tool interface contracts and dynamic capability routing ($T_k$) alter callable API signatures, argument typing, and execution schemas. RACaP [99] executes a two-phase developmental curriculum: the first phase expands typed policy APIs and experience memory, while the second phase autonomously diagnoses task failures to mutate ReAct harness wrappers. Zetta [100] refines dynamic critic modules, recovery tools, and error-filtering routines wrapped around frozen manipulation actors, expanding functional capability without weight retraining. Repair and execution orchestration changes how the harness handles failures and coordinates calls. RoboFoundry [101] refines task repair routines and general harness logic using recorded pre-repair states and system-policy verifier scores. Here, verifier feedback guides harness revision; its use does not by itself establish that the verifier or acceptance gate is updated. HarnessPAI [102] and HexaAnything [103] synthesize generalized execution wrappers and multi-agent dispatch pipelines, respectively, targeting how available capabilities are coordinated.

Combinatorial Interface Regression and Upward Compatibility.

Mutating $H_k$ or $T_k$ introduces severe risks of combinatorial regression. Because the execution harness serves as the universal mediation layer across all system components, modifying an observation formatter or altering an API signature can silently violate implicit invariants relied upon by pre-existing skills $S_k$ or memory entries $M_k$.

As an illustrative failure mode, expanding a prompt to resolve an insertion failure could displace spatial information needed by another task when the context budget is fixed. While RACaP [99] mitigates this risk via paired candidate rollouts under identical initial seeds, and RoboFoundry [101] enforces historical trace replay, these development-time checks do not guarantee the absence of regressions. Checks used for candidate selection should be distinguished from subsequent evaluation: a selection score cannot also serve as an independent final-test endpoint. Claims of later gain should follow the evaluation boundary defined in Section 6.1.2, without imposing an additional Level 4 requirement.

4.4. Neural Parameters: Policies, Representations, and Evaluators (${\theta }_k$)

Neural weight mutations (${\theta }_k\to {\theta }_{k+1}$) alter the continuous function approximators governing motor control, visual perception, high-level reasoning, or execution monitoring. Updating an actor changes action generation, updating a reasoner changes task interpretation or tool selection, and updating a verifier changes the signals used to assess progress and trigger intervention. The behavioral effect therefore depends on which subnetwork changes and where its outputs enter execution.

Functional Loci of Neural Adaptation.

Reviewed systems target three distinct neural substrates: Continuous motor actors and specialized action experts update the weights governing low-level robot control chunks. RoboCat [104] fine-tunes generalist action transformers on self-generated physical rollouts, demonstrating progressive multi-task skill acquisition. RoboClaw [105] integrates automated hardware collection with automated reset mechanisms to support continuous policy training. Learning while Deploying (LWD) [106] interleaves fleet-wide autonomous rollouts with targeted human interventions, freezing the vision-language backbone while continuously updating a specialized action expert alongside value and critic networks. SOAR [107] fine-tunes goal-conditioned behavioral-cloning policies on retained autonomous rollouts while holding the high-level VLM task proposer and success detector strictly frozen. Under researcher-selected training, CapVector [108] provides a complementary parameter-transfer mechanism by merging capability vectors extracted from matched fine-tuned checkpoints into pretrained weights. SUGAR [109] instead refines human-video motion priors through physics-based learning and distills the resulting skills into a hierarchical humanoid loco-manipulation policy. Distillation of high-level deliberation and tool routing compresses frontier reasoning capabilities into compact edge models. Guava [110] collects interaction traces generated by proprietary foundation models, filtering and distilling tool-use trajectories into a compact, localized VLM capable of autonomous tool dispatch without cloud connectivity. Analogously, WAA [64] and Robo-Harness K1 [111] fine-tune student vision models on historical execution logs to internalize complex tool-calling syntaxes and affordance parsing, preserving underlying analytical controllers while eliminating high-latency API dependencies. Learned execution monitors and outcome verifiers train neural evaluators rather than motor actors. VLA-Corrector [80] trains a neural stage and risk verifier offline using privileged simulation labels, subsequently deploying the frozen verifier to trigger runtime prompt steering around a frozen VLA actor.

Feedback Compounding and Evaluator Exploitation.

Neural self-improvement architectures that couple autonomous data collection with learned success detectors face risks of feedback compounding. False-positive verifier outputs may admit unsuccessful rollouts into subsequent training data or distort optimization feedback. Depending on the training method, these errors can affect supervised policy fitting or reinforcement-learning updates. Optimization against an imperfect evaluator may also favor behavior that satisfies the detector without achieving physical task completion; whether this exploitation occurs requires empirical assessment. Evaluating neural self-improvement requires independent auditing of verifier calibration separate from policy success, combined with longitudinal evaluations across sequential update cycles to detect catastrophic forgetting of legacy capabilities.

4.5. Environmental Assets and Learning Procedures ($E_k$)

Updates to $E_k$ modify the developmental infrastructure that guides future capability acquisition: physics simulation assets, executable reward functions, curriculum schedulers, and interactive pedagogical protocols ($E_k\to E_{k+1}$). Rather than directly producing an operational manipulation policy, mutating $E_k$ alters the optimization landscape within which new policies are synthesized.

Environmental Mutation Paradigms.

Systems targeting $E_k$ operate across three generative mechanisms: Autonomous evolution of executable reward code resolves the fragility of manual reward engineering for complex manipulation. As demonstrated by Eureka [112], an agentic language model analyzes raw environment code and policy evaluation metrics to iteratively synthesize, benchmark, and mutate executable Python reward functions within massively parallelized physics simulations. By searching directly over reward code space, Eureka discovers novel shaping terms that train robust continuous policies for dexterous manipulation tasks such as pen spinning. HARBOR [113] scales this paradigm to full environment generation, synthesizing training configurations, domain randomization ranges, and reward formulations concurrently. Generative digital twins and asset reconstruction automate simulation construction from raw perceptual inputs. DexAgent [114] reconstructs interactive digital twins directly from monocular human demonstration videos, synthesizing metric CAD meshes, kinematic articulation joints, and physical verification bounds. HARBOR [113] similarly automates simulation asset creation, enforcing physical sanity checks on generated models prior to policy training. Adaptive teaching and pedagogical model optimization targets the communication protocols through which external human feedback is interpreted. Language Model Predictive Control (LMPC) [115] fine-tunes an interactive language model on historical human–robot teaching interactions, improving its responses to feedback and its generation of reward code for MuJoCo Model Predictive Control (MJPC). The trained model is a neural update target (${\theta }_k$), while its role in reward-code generation contributes to the developmental workflow ($E_k$), consistent with the joint N/E classification in this review.

Distinguishing Learning Resources from the Acquisition Algorithm.

A fixed acquisition algorithm can still produce updates to $E_k$. In Eureka, for example, retaining a revised reward function changes a resource used in subsequent policy learning even if the reward-search algorithm remains fixed. Conversely, running policy training with unchanged rewards and training procedures may update ${\theta }_k$ without changing $E_k$. For agent-guided development workflows such as ENPIRE [11], the relevant question is which resources or procedures are revised and retained. Updating a reward, curriculum, or training recipe does not by itself establish that the algorithm producing those updates also evolves.

Evaluating a retained learning procedure or simulation asset $E_k$ requires identifying how it changes subsequent learning and manipulation outcomes. L4 requires a retained-artifact lineage and a reported manipulation gain over a frozen comparator under a source-declared independent evaluation boundary. Reductions in human effort, sample complexity, or compute are additional outcomes whose uncertainty and accounting scope should be reported; they do not replace evidence of manipulation gain.

4.6. Cross-Target Ingestion Realities and the RSI Case Analysis

The five groups of acquisition targets affect physical behavior through fundamentally different points of use (Table 3). Memory $M_k$ supplies operational constraints or relational guidance to reasoning and planning; skills $S_k$ provide callable procedures and compositional execution logic; harnesses and tools $H_k,T_k$ shape visual context formatting, capability routing, and recovery thresholds; neural parameters ${\theta }_k$ determine learned continuous mappings for actors, representations, or verifiers; and learning resources $E_k$ alter the optimization landscape for subsequent policy acquisition.

Diagnostic Trade-Offs: What Should Be Updated When Manipulation Fails?

Because these targets operate across distinct functional layers, selecting an update target requires diagnosing the root operational cause of a physical failure:

• Semantic and Preference Misalignment → Update $M_k$: When failures arise from ambiguous task specifications, uncalibrated object spatial relations, or shifting user preferences, declarative guidance revision provides the lowest-cost remediation. Updating memory alters command formulation without incurring code compilation latency or neural fine-tuning risks.
• Compositional and Algorithmic Breakdowns → Update $S_k$ or $H_k$: When failure stems from missing temporal branches, unhandled intermediate transitions, or brittle error-recovery logic, programmatic skill synthesis or harness restructuring provides inspectable, modular repairs. However, this assumes that the underlying perception and motion APIs possess sufficient fidelity to execute the revised logic.
• Contact Instability and Fine-Motor Deficits → Update ${\theta }_k$: When failure is caused by frictional slip, unmodeled compliance dynamics, or force-closure grasp collapse, updating prompts ($M_k$) or program logic ($S_k$) is fundamentally ineffective. Overcoming dynamic contact failures strictly demands adapting continuous parameter weights (${\theta }_k$) through physical interaction or demonstration fine-tuning.
• Distribution Shifts and Sparse Capabilities → Update $E_k$: When the system lacks broad training data or encounters novel physical domains, modifying simulation environments, curriculum schedules, or synthetic reward code ($E_k$) establishes the prerequisite foundation for downstream policy learning.

As summarized in Table 3, each target presents distinct ingestion contracts and primary failure modes. In full-system deployments, a comparison of complete configuration packages supports a package-level result; attributing gains to an individual component requires a controlled ablation that isolates that specific target.

Deconstructing RSI: Local Skill Acquisition versus Complete-Task Failure.

The fundamental tension between local artifact synthesis and task-level physical self-improvement is vividly demonstrated by the Robot Self-Improvement (RSI) campaign [12]. Tasked with acquiring an autonomous, long-horizon refrigerator-stocking capability through trial-and-error exploration in RoboCasa simulation, RSI achieved prolific local skill acquisition, persistently synthesizing, registering, and reusing modular manipulation primitives in its skill library (satisfying Level 3 persistence criteria). Yet, the reported refrigerator-stocking rollouts yielded zero end-to-end task successes.

The RSI campaign demonstrates why constructing, retaining, and reusing local skills does not guarantee complete-task improvement. A synthesized primitive can satisfy its own local acceptance check while leaving the physical environment in a kinematic or geometric configuration that renders subsequent operations impossible. The mechanistic lesson is that local acceptance criteria must be explicitly coupled to downstream initiation conditions, verifying whether the resulting sequence successfully executes in composition. Complete-task failure does not negate the utility of acquired local primitives; it delineates the operational boundary supported by their composition.

5. Capability Revision, Testing, and Retention

Section 4 identified the artifacts that can change. This section addresses RQ3: how interaction evidence guides their construction, evaluation, and retention. Expanding the update model in Equation 4, we distinguish four stages:

$${\tau }_{1:N}{\displaystyle \underset{\mathrm{Sourcing}}{\overset{\mathrm{Experience}}{\to }}}{\mathcal{D}}_{\exp }\stackrel{\mathrm{Diagnosis}}{\to }{\Delta }_{\mathrm{diag}}{\displaystyle \underset{\mathcal{U}}{\overset{\mathrm{Synthesis}}{\to }}}{\tilde{C}}_{k+1}{\displaystyle \underset{\mathcal{G}}{\overset{\mathrm{Gating}}{\to }}}{C}_{k+1},$$

(5)

where traces supply an experience dataset, diagnosis proposes a change, $\mathcal{U}$ constructs a candidate, and $\mathcal{G}$ determines its adoption. This decomposition does not imply that every system implements every stage or deploys the result on hardware. Successful traces, demonstrations, or corrections may support construction without explicit failure diagnosis. Stages can also recur: an unaccepted candidate may prompt further collection, diagnosis, or revision while the current configuration remains available.

5.1. Experience Sourcing and Active Exploration

Experience sourcing determines which situations and outcomes become available for subsequent diagnosis and construction. Failure-focused collection concentrates on exposed weaknesses, while active task proposal can broaden coverage beyond repeatedly encountered situations. Physical interaction incurs execution time, wear, and safety costs, whereas simulation offers different reset and observation privileges; the value of a collection strategy therefore depends on both the information it supplies and the resources it requires.

Reactive Collection and Task Proposal.

Two recurring experience-sourcing mechanisms are: First, reactive failure ingestion uses unsuccessful or corrected executions to initiate revision. Zero2Skill [116] and SkillWeaver [117] illustrate how feedback and exploration traces can support subsequent artifact construction. Failure-focused sampling can reveal weaknesses, but attribution benefits from successful reference executions: an observed failure alone may not identify which component should change. Second, active task orchestration and curriculum proposal delegates task generation directly to the agent. In fleet-scale infrastructures such as AutoRT [118], foundation models propose diverse manipulation goals across multi-robot deployments, using VLM scene descriptions and task-selection rules, including safety criteria, to filter candidate interactions. ENPIRE [11] logs trajectories, videos, and reward signals for code-revision experiments; construction of revised learning recipes is discussed in Section 5.3.

These mechanisms shape the distribution of experience supplied to acquisition: task proposal determines which goals are attempted, while exploration determines which object–skill combinations and states are encountered. Revising this selection process changes the acquisition procedure; simply executing a fixed collection schedule need not do so.

Exploration Choice and Reset Costs.

RATs [91] [Table 4] reports an exploration ablation in LIBERO-PRO simulation using CaP-Agent0 as the test-time execution configuration. When task exploration is directed by an intrinsic curiosity reward—favoring novel object–skill combinations at intermediate estimated difficulty—50 exploration iterations yield a post-synthesis task success rate of 32.3%, compared to 24.7% under unguided random play and 23.2% in the baseline without play. This comparison connects exploration choice to the utility of the subsequently synthesized capabilities. Its matched iteration budget does not equate physical costs or isolate which induced state differences explain the gain.

Table 4. Five-Level Evidence Framework for Robotic Self-Improvement. Levels describe supported claim endpoints; L5 adds a review-defined joint criterion rather than a universal system ranking.

Level	Evidence Endpoint	Mandatory Evidentiary Requirement	Exclusionary Criterion (Insufficient Alone)	Corpus Count
L1	Execution Baseline	Agent-mediated manipulation without established construction of a capability artifact.	Within-episode reactive recovery, prompt retries, or transient state updates.	9
L2	Capability Construction	A capability artifact is constructed or adapted; persistence and later use are not both established.	Code compilation, AST generation, or mock simulation without deployed execution.	18
L3	Persistence and Later Use	An artifact is retained beyond its originating episode or acquisition stage and used in later execution or learning. Learning uses connect to the resulting capability and its later execution.	Ephemeral cache, un-ingested database expansion, or state cleared upon system reset.	70
L4	Measured Manipulation Gain	A retained artifact yields subsequent manipulation gain over a frozen comparator under a source-declared separation of acquisition or selection from evaluation.	Unchecked library accumulation, search peak on development seeds (${\mathcal{D}}_{\mathrm{val}}$), or evaluations lacking baseline isolation.	65
L5	Repeatable Self-Improvement	Independent acquisition histories yield protected-test gains, transfer, earlier-task performance assessed for retention and regression, and documented low human dependence under stated intervention criteria and accounting periods.	Single acquisition history, training-task evaluations lacking cross-task transfer, unverified earlier-task retention, or undocumented manual resets.	0
Total Audited Studies Across Corpus: 162

Table 4. Five-Level Evidence Framework for Robotic Self-Improvement. Levels describe supported claim endpoints; L5 adds a review-defined joint criterion rather than a universal system ranking.

Level	Evidence Endpoint	Mandatory Evidentiary Requirement	Exclusionary Criterion (Insufficient Alone)	Corpus Count
L1	Execution Baseline	Agent-mediated manipulation without established construction of a capability artifact.	Within-episode reactive recovery, prompt retries, or transient state updates.	9
L2	Capability Construction	A capability artifact is constructed or adapted; persistence and later use are not both established.	Code compilation, AST generation, or mock simulation without deployed execution.	18
L3	Persistence and Later Use	An artifact is retained beyond its originating episode or acquisition stage and used in later execution or learning. Learning uses connect to the resulting capability and its later execution.	Ephemeral cache, un-ingested database expansion, or state cleared upon system reset.	70
L4	Measured Manipulation Gain	A retained artifact yields subsequent manipulation gain over a frozen comparator under a source-declared separation of acquisition or selection from evaluation.	Unchecked library accumulation, search peak on development seeds (${\mathcal{D}}_{\mathrm{val}}$), or evaluations lacking baseline isolation.	65
L5	Repeatable Self-Improvement	Independent acquisition histories yield protected-test gains, transfer, earlier-task performance assessed for retention and regression, and documented low human dependence under stated intervention criteria and accounting periods.	Single acquisition history, training-task evaluations lacking cross-task transfer, unverified earlier-task retention, or undocumented manual resets.	0
Total Audited Studies Across Corpus: 162

Physical experience sourcing also faces a reset constraint: a simulator can restore a specified initial state, while a robot may need additional hardware, recovery policies, or an operator to reposition objects. RoboClaw [105] develops reset behavior within its collection infrastructure. Reset behavior determines whether another useful trial can begin from the resulting physical state. Reset and rescue dependencies therefore belong to the lifecycle accounting in Section 5.5.

5.2. Failure Diagnosis and Update Attribution

An observed failure can admit several explanations, including task grounding, perception, control, memory, or verifier errors. Diagnosis connects this observation to a component that can be changed. We represent proposed targets and their supporting evidence as:

$$\begin{array}{cc}\hfill {\delta }_{\mathrm{diag}}^{\left(r\right)}& =\left(j_r,{\mathcal{E}}_{\mathrm{diag}}^{\left(r\right)}\right),j_r\in \{\theta ,H,M,S,T,E\},\hfill \\ \hfill {\Delta }_{\mathrm{diag}}& ={\left\{{\delta }_{\mathrm{diag}}^{\left(r\right)}\right\}}_{r=1}^R,R\ge 1.\hfill \end{array}$$

(6)

Each record pairs a proposed target $j_r$ with diagnostic evidence ${\mathcal{E}}_{\mathrm{diag}}^{\left(r\right)}$. The collection ${\Delta }_{\mathrm{diag}}$ gathers R records for one candidate update; these records may address the same target or different targets. These records are an analytical representation, not a data structure required of every surveyed system. A causal hypothesis inferred from a trace is distinct from intervention evidence showing that changing the proposed cause alters the outcome.

Trajectory Summaries and Entry-Level Evidence.

Diagnosis can be organized at different levels: First, trajectory-level holistic summarization processes multimodal rollouts. SHAPER [97] uses episode summaries to guide revision of textual skills and context code. A summary combines observations across steps, allowing the proposed revision to address dependencies between planner guidance and the context supplied to it. Second, claim-level evidentiary ledgers attach evidence to individual guidance entries. RoboHarn-Evo [87] distinguishes task-level and action-level knowledge and reconciles supporting, opposing, and unverified observations. Linking observations to particular entries and their applicability conditions localizes which knowledge should be retained, withdrawn, or revised. Trajectory summaries thus support broader revision proposals, while entry-level evidence supports targeted knowledge maintenance.

Testing Diagnostic Hypotheses.

A diagnosis can target the wrong component: changing a perception threshold, for example, may leave a contact-control failure unresolved. This is a design risk rather than an inevitable consequence of a particular diagnostic representation.

AHA [119] uses FailGen to perturb successful simulated trajectories and produce labeled failure examples for training a failure-reasoning model. Controlled perturbations support those training labels; a model’s explanation of a new failure does not itself verify a causal repair. Lifecycle reports should distinguish generated failure labels, inferred hypotheses, and interventions that test whether a proposed repair restores task progression.

5.3. Candidate Construction

Candidate construction converts experience and proposed diagnoses into a concrete artifact. It may aggregate the records in ${\Delta }_{\mathrm{diag}}$ to revise one component or several together, or construct candidates directly from demonstrations and successful traces. The central mechanism is the transformation from feedback or training data into revised guidance, code, parameters, or learning resources.

Update Operators.

The target representation determines the available update operations; the following examples illustrate representative families rather than an exhaustive list. As in Section 4.3, tool-contract revisions ($T_k$) are discussed alongside harness changes ($H_k$), while remaining distinct targets in $C_k$. Edits to callable signatures, schemas, or API bindings construct ${\tilde{T}}_{k+1}$ candidates.

First, two-stage textual-guidance and harness optimization ($\mathcal{U}\to {\tilde{M}}_{k+1},{\tilde{H}}_{k+1}$) separates revision of planner guidance from revision of context-building code. SHAPER [97] calls the former “skill evolution”: it first revises textual procedural guidance with the seed harness fixed, then revises context code with the selected guidance fixed. Under our artifact taxonomy, these updates target $M_k$ and $H_k$, respectively. The staged procedure uses a fixed counterpart at each step, first changing the guidance available to the planner and then changing how execution information is presented to it. Second, knowledge-entry revision and ledger reconciliation ($\mathcal{U}\to {\tilde{M}}_{k+1}$) revises stored conditions and strategies rather than executable code. RoboHarn-Evo [87] constructs Task and Action Knowledge, merges equivalent entries, associates evidence with content versions, and withdraws challenged versions from retrieval. Revised strategies remain candidates until applicable executions support them without opposing evidence. Construction and evidence maintenance are coupled: a revision changes the stored strategy, while its version-specific evidence determines whether it becomes available for retrieval. Third, data aggregation and policy-checkpoint training ($\mathcal{U}\to {\tilde{\theta }}_{k+1}$) updates parametric actors through gradient-based training. Systems such as RoboClaw [105] pair forward task executions with autonomous physical resets, synthesizing candidate policy checkpoints ${\tilde{\theta }}_{k+1}$ using a conditional flow-matching objective on collected action trajectories. Here, collected trajectories influence later actions through fitted policy parameters rather than through a retrieved instruction or an explicit program edit.

Fourth, revision of developmental assets and learning procedures ($\mathcal{U}\to {\tilde{E}}_{k+1}$) constructs proposed reward code, simulation configurations, curricula, or training implementations. Eureka [112] uses environment code and policy-training statistics to generate and refine reward programs. ENPIRE [11] uses rollout trajectories, videos, and reward feedback to modify training implementations and recipes, sharing successful revisions across parallel agent–robot experiments. These revisions produce ${\tilde{E}}_{k+1}$ candidates; collecting data or fitting policy weights under a fixed recipe does not revise that recipe. Policy checkpoints trained using this developmental candidate are separate neural artifacts ($\theta$).

Synthesis Interfaces and Validation.

Executable skill synthesis ($\mathcal{U}\to {\tilde{S}}_{k+1}$) generates or revises program implementations around domain-specific interfaces. CaP-X [90], ASPIRE [93], and GaP [10] use supplied robot or simulator APIs for these constructions. The supplied interfaces define the operations a candidate can call and the arguments it must provide. Syntax checks assess program form, simulation execution tests behavior under modeled conditions, and physical validation examines behavior on the robot; none substitutes for the others. Interface-constrained synthesis therefore does not by itself certify all generated programs or guarantee physical safety. Across these update operators, construction produces a candidate whose adoption is considered next. Component comparisons are needed to distinguish the contribution of one target from the effect of a combined update.

5.4. Promotion, Regression Checks, and Rollback

The promotion rule in Equation 4 may combine admissibility checks with a candidate–current comparison on validation data. Its metric, threshold, and any risk penalties should be explicit. As specified in Section 2.3, validation can guide refinement; it is distinct from a protected final test.

Complementary Validation Safeguards.

Three complementary safeguards organize the gating mechanisms and deployment requirements. Their presence and empirical coverage must be established separately for each system: First, static contract and sandbox admissibility is a proposed pre-execution safeguard. Syntax and API checks, restricted I/O, resource limits, and timeouts can reject inadmissible candidates within a specified interface. SHAPER [97] reports a required context-function interface, restrictions on imports, file I/O, and dynamic execution, and a runtime timeout before rollout. A timeout does not prove termination of arbitrary generated programs, and a configured memory limit does not establish a program-level bound. RoboFoundry [101] reports trace-based edit evaluation and promotion, without establishing these static or sandbox guarantees. Second, historical trace replay and regression assessment examines broader effects of a candidate. In RoboFoundry [101], recorded pre-repair states from other tasks are replayed to propose task-level edits; a system-policy verifier compares their capability-gap scores with recorded successful repairs, and a general edit is promoted when the average score difference is nonnegative. This is a trace-based proxy, distinct from rerunning prior manipulation tasks to measure regression. RACaP [99] instead uses paired parent–candidate evaluations under matched task and seed conditions to assess the effect of a retained update. Third, execution-grounded evidence checks whether a proposed update is supported by relevant interaction outcomes. In RoboHarn-Evo [87], a knowledge entry becomes eligible for retrieval when applicable executions provide support without opposing evidence; a challenged entry is withdrawn, and an untested revision remains a candidate. This internal admission rule is distinct from final independent evaluation. The source reports repeated acquisition with frozen held-out tests in simulation, alongside a separate real-robot knowledge-update experiment.

Rejected Candidates and Rollback.

Candidate rejection preserves the current configuration before adoption; rollback restores an earlier version after an update has been adopted. The latter requires keeping the relevant artifacts and their compatible dependencies available. Restoring software or model parameters does not restore the physical scene: a displaced object, occupied gripper, or changed contact state may require separate recovery before execution can resume.

Incomplete reporting of rejected candidates and rollback events limits assessment of an update process. Published checkpoint curves, including collection-and-training results in RoboClaw [105], describe the evaluated trajectory; they do not by themselves reveal all unsuccessful candidates or the cost of selecting the reported checkpoints. Missing rejection logs cannot establish concealed human debugging or prove that the underlying task distribution was artificially restricted.

Physical deployment requires fail-safe rollback protocols as a design objective. AgenticRobotics [120] reports evidence-gated promotion and transaction recovery in LIBERO-10 simulation, and identifies independent safety interlocks as necessary for real-robot deployment. Its study does not demonstrate rollback following joint vibration or physical safety stops. Workflow recovery therefore supplies evidence about software coordination, while controller safety and physical recovery require separate hardware evaluation.

Deployment and Return to Development.

Adoption connects the retained artifact to a point of use. Runtime artifacts enter execution through retrieval, skill invocation, orchestration, or model inference (Section 3). Learning resources $E_k$ instead enter subsequent acquisition through the retained asset or procedure. Their effect on manipulation is mediated by the resulting capability, such as a trained policy checkpoint, and its later execution (Section 4.5).

When hardware wear, sensor drift, or novel objects produce persistent deployment failures, a system may return to development. Evaluating repeated self-improvement requires tracing this transition and its interventions. Engineer-led recalibration or reward revision can support capability acquisition, but its contribution and cost must be included when judging the autonomy of the complete cycle.

5.5. Supervision and Resource Budgets

Acquisition mechanisms draw on different forms of supervision and resources. Automated candidate generation may still depend on supplied demonstrations, operator resets, or engineer-led repairs elsewhere in the lifecycle. These dependencies affect which mechanisms can be repeated under a given deployment budget. Table 5 compares protocol outcomes and dependencies; the supplement preserves their detailed lineages.

Budget Components.

We organize resource accounting along four dimensions:

$${\mathbf{B}}_k=(B_{\mathrm{human}},B_{\mathrm{oracle}},B_{\mathrm{wear}},B_{\mathrm{compute}}).$$

These dimensions form an accounting profile rather than a sum in common units. Relevant quantities depend on the acquisition mechanism; privileged access may require a description of supervision and permissions rather than a scalar cost. First, Human mechanical and communicative labor ($B_{\mathrm{human}}$) encompasses all external interventions across the learning loop, including initial teleoperation demonstrations, mid-rollout policy rescues, manual workspace resets, and out-of-band code refactoring. Operator-dependent sample efficiency should be reported together with its reset budget when judging autonomy. Second, Privileged sensory and simulation access ($B_{\mathrm{oracle}}$) accounts for the provenance of ground-truth supervision; simulation-based development [112,113] can provide state variables, reward signals, and reset operations that are unavailable under the corresponding robot interface. The relevant distinction is which privileges are available during acquisition and which remain available during later execution. Third, Physical wear and hardware interaction budgets ($B_{\mathrm{wear}}$) describe interaction exposure and hardware demands. Depending on the platform and available instrumentation, relevant records may include contact time, joint torque saturation events, or emergency safety trips; these are indicators of exposure and operating conditions rather than interchangeable measures of wear. Finally, Computational and token expenditure ($B_{\mathrm{compute}}$) describes resources consumed across candidate construction, reflection, training, and selection. Suitable measures may include model calls or API tokens, training compute, and elapsed time, with the accounting scope stated for the reported process.

Lifecycle Synthesis.

Experience selection, diagnostic evidence, candidate construction, and promotion determine different parts of the acquisition process. RATs changes the exploration supplying later synthesis; SHAPER separates guidance and context-code revision; RoboHarn-Evo couples knowledge maintenance to entry-level evidence; and RoboFoundry screens edits with trace-based scores. The same update target can therefore be reached through different acquisition processes, and similar retained artifacts need not imply similar costs, reliability, or conditions of reuse. Connecting how an artifact was obtained to how it is later used supports the comparison of outcomes and evidence gaps in Section 6.

6. Empirical Realities: Capability Lineage and the Evidence Ledger

This section addresses RQ4: which reported experiments support retained capability gains, and what further evidence is needed for repeatable acquisition? Across the 162-record corpus, we distinguish execution robustness from persistent artifact utility and procedural repeatability. Each credited chain links an artifact to its acquisition process, later use, comparator, and reported evaluation boundary. The strength of that boundary and the scope of the resulting claim are assessed separately.

6.1. Evaluation Designs and Attribution Boundaries

We distinguish three evaluation questions: execution performance under a given configuration, the utility of retained artifacts in later use, and the repeatability of the acquisition procedure (Figure 5).

6.1.1. Auditing Agent-Mediated Execution (Track A)

An execution evaluation assesses whether an embodied agent completes goal-directed physical tasks through its active decision and control interface under a given configuration $C_k$. Metrics including nominal task success rate, human intervention frequency, completion latency, and execution energy must be audited alongside physical reset dependencies, retry limits, and available tool repertoires.

A successful runtime recovery demonstrates a response to the current task, but does not by itself establish a retained capability. If the correction is preserved for subsequent use, that additional process belongs to acquisition analysis. RoboMemArena [121] evaluates memory-dependent long-horizon tasks in simulation and the real world, where within-episode memory use remains distinct from cross-episode retention. Comparisons intended to isolate the execution architecture should control the actor, observations, initial conditions, and retry budgets as appropriate to the claim. Broader system comparisons can establish package-level effects without attributing the gain to one execution component.

6.1.2. Auditing Retained Capability Gains (Track B)

An acquisition evaluation identifies which constituent of $C_k=({\theta }_k,H_k,M_k,S_k,T_k,E_k)$ changes, how the resulting artifact is retained and used, and whether later manipulation improves over a frozen comparator under declared test conditions. A comparison of complete configuration packages supports a package-level result; attribution to an individual component requires a comparison that isolates that component.

To qualify for Level 4 (Measured Manipulation Gain), one experimental chain must establish artifact construction, persistence, later use, a reported manipulation gain, and a source-declared separation between acquisition or selection and the credited evaluation. Held-out instances, acquisition/test seed partitions, fixed cross-domain transfer, or explicitly separated stages with declared evaluation conditions can establish this minimum boundary. Mere chronology—collecting data, training, and then reporting a score—does not suffice. A score used to construct or select the credited artifact cannot also serve as its independent final-test endpoint.

This source-report classification is distinct from the stricter requirement that every final-test channel be explicitly excluded from construction and selection. The boundary audit reports both criteria separately. Statistical significance is not a universal L4 threshold: sample size, uncertainty, experimental scope, and component attribution qualify the strength of each reported gain. Incomplete documentation remains unresolved evidence rather than proof of leakage.

6.1.3. Auditing Acquisition as a Repeatable Procedure

Evaluating repeated execution rollouts measures the runtime variance of a single static artifact; evaluating independent acquisition histories measures whether the underlying self-improvement mechanism $\mathcal{U}$ reliably produces useful capabilities from declared initial resources. These may include shared pretrained models, source archives, or skill libraries; the restarted and retained components must be identified.

Procedural comparisons should identify the initial resources, independent acquisition histories, and rules for selecting or rejecting updates. Acquisition repeatability and human dependence are separate properties: repeated runs can still rely on demonstrations, resets, or engineering support. Their joint assessment uses the intervention criteria and accounting periods defined in Section 2.4.

6.2. Evidence Levels in the Reviewed Corpus

Applying our cumulative evidentiary criteria across the 162 primary studies assigns 9 records to Level 1 (Execution Baseline), 18 to Level 2 (Capability Construction), 70 to Level 3 (Persistence and Later Use), and 65 to Level 4 (Measured Manipulation Gain). Crucially, zero inspected experimental chains satisfy the joint Level 5 criterion under this review’s intervention-accounting requirement (Table 4).

These mutual distributions reveal three profound empirical realities across current self-improvement research: First, the Level 3 bottleneck (70 records): Nearly half of the surveyed literature successfully synthesizes persistent computational artifacts and demonstrates their later invocation, yet stops short of Level 4. This is predominantly caused by evaluation methodology rather than system failure: many studies evaluate self-evolving frameworks without an explicit frozen-comparator baseline, report adaptive multi-turn evaluations that obscure causal attribution, or mutate multiple components simultaneously. L3 status confirms that capability persistence is technically established, while highlighting the absence of isolated causal attribution.

Second, the simulation-to-hardware disparity in Level 4 (65 records): Among the 65 records establishing measured capability gains under declared evaluation boundaries, 36 have credited simulation endpoints, 22 report hardware endpoints, and 7 demonstrate gains in both environments. As analyzed below, hardware gains are heavily concentrated in modular skill additions or prompt tuning around frozen foundation models, whereas neural parameter updates dominate simulation benchmarks.

Third, the Level 5 hardware frontier (0 records): The absence of Level 5 hardware credentials is not an indictment of existing algorithms, but an exposure of physical reset constraints. While repeated acquisition, out-of-distribution transfer, and earlier-task retention occur jointly within bounded simulation streams (such as Conquer [122]), sustaining an autonomous self-improvement loop on physical hardware inevitably encounters manual human resets, safety interventions, and physical workcell wear. Because literature routinely omits quantified human labor accounting ($B_{\mathrm{human}}$), true autonomous self-improvement on real-world robots remains an unestablished scientific frontier.

6.3. Diagnostic Case Analysis and Attribution Boundaries

To interrogate attribution boundaries, experience dependencies, and adverse failure modes across diverse execution interfaces, we examine eleven diagnostic protocols (Table 5). Rather than representing an exhaustive catalog, these diagnostic cases provide critical contrasts across acquired artifacts, candidate generation mechanisms, and evaluation protections.

The boundary audit covers all 65 L4 records and 58 L3 records with a reported-gain field, for 123 records in total. Sixty-five meet the minimum declared-separation rule used for L4, while 17 explicitly document the stricter exclusion of the final test from both construction and selection. This difference is a reporting sensitivity, not evidence that the remaining gains are absent or necessarily affected by leakage. L3 gain-bearing records lack a complete credited artifact-to-evaluation chain because of unresolved boundaries, adaptive evaluation, or package-level attribution limits.

For instance, KnowBody [84] establishes a robust physical hardware gain (12/16 versus 4/16 successes) by deploying an offline-curated package of body models and harness wrappers with cross-episode updates disabled; this confirms the utility of the static package, but does not isolate the independent causal contribution of body memory. Similarly, SOAR [107] demonstrates substantial empirical improvements (28% to 57% success), but its reported experimental lineage presents a continuous collection–training–evaluation sequence lacking an explicit, pre-isolated evaluation boundary. CaP-X [90] demonstrates notable physical hardware transfer, yet its simulation interface distinctions do not satisfy a formal held-out instance partition.

6.4. Cross-Mechanism Empirical Synthesis

Retained Knowledge and Programmatic Skills ($M_k,S_k$).

When underlying continuous motor actors remain strictly frozen, mutating declarative memory or programmatic skill libraries regularly yields substantial manipulation improvements. RATs [91] provides a canonical plug-in contrast: injecting an autonomously discovered skill library into a frozen CaP-Agent0 baseline raises LIBERO-PRO simulation success from 23.2% to 32.3%, with physical hardware performance increasing from 30.0% to 38.8%. However, because the complete RATs pipeline concurrently refines harness routing, the holistic gain cannot be causally attributed to the skill library alone.

Recursive Harness Distillation (RHD) [86] isolates the impact of retained textual guidance: deploying its refined operational playbook to an identical lightweight agent elevates success on 48 held-out instances from 43.8% to 66.7%, whereas deploying an unrefined initial playbook collapses performance to 31.3%. This stark contrast demonstrates the extreme sensitivity of frozen actors to prompt quality, yet leaves the causal contribution of individual heuristic rules un-isolated.

SHAPER [97] provides an exemplary component-level dissection across update targets. Its textual skills represent procedural planner guidance ($M_k$), while its context-building code belongs to the harness ($H_k$). On an isolated 800-episode VLABench test partition, the baseline seed, skill-only evolution, harness-only evolution, and joint skill-harness evolution achieve success rates of 28.25%, 33.50%, 30.50%, and 34.50%, respectively. Crucially, textual-guidance revision yields the primary performance delta (+5.25%), while compounding the evolved harness confers an incremental +1.00 percentage point gain. These findings substantiate our first major insight: in agentic manipulation, optimizing high-level command formulation and discrete skill selection frequently produces the dominant share of task gains, even while low-level motor execution remains completely static.

Neural Adaptation and Supervision Lineages (${\theta }_k$).

While programmatic systems update symbolic syntax, neural self-improvement updates continuous tensor representations. RoboCat [104] isolates experience mechanisms by holding model capacity and an initial 500-demonstration budget fixed: incorporating autonomously generated rollouts yields consistent performance gains across four physical hardware task variants. Its Level 4 hardware credential derives from an isolated fine-tuning chain, where real-world success rises from 0% to 82% and 88% with 100 and 500 demonstrations, respectively, under rigorous checkpoint-selection boundaries. However, because earlier evaluation trajectories are cyclically recycled into subsequent training pools, evaluation isolation remains phase-dependent rather than structurally permanent. EmbodiRSI [123] verifies the benefits of adaptive data collection over static rollouts under matched simulation budgets prior to human-in-the-loop refinement.

VLA-Corrector [80] updates neural verifiers rather than the primary actor, training an offline stage/risk verifier to trigger runtime prompt steering around a frozen VLA, achieving an 88.3% versus 82.5% hardware success rate. This comparison locates the acquired change in an offline-trained verifier whose outputs guide later execution around the frozen actor.

Robo-COP [124] explicitly tests when neural weight adaptation confers benefits beyond memory adaptation. Post-deployment evaluation across held-out physical initializations demonstrates mean success of 50.0% versus 38.3% for the memory-only baseline, confirming the distinct value of parameter adaptation. Its evaluation also supports candidate rejection as a safeguard against harmful updates in the tested setting.

EmbodiedRSI [125] illustrates how target utility interacts with task structure: in component ablations holding actor capacity and interaction budgets fixed, the relative ranking of code-only and skill-only adaptation completely reverses between atomic manipulation tasks and unseen composite tasks. Furthermore, its simulation-evolved harness elevates physical hardware success from 46.0% to 71.3% with a frozen SmolVLA recipient. However, because the base recipient required 50 human demonstrations per task, zero-shot harness transfer must not be conflated with zero human engineering investment.

Continual Retention and Parameter Interference.

Memory Anchors [127] selects replay experiences using latent-state overlap and disagreement between old and new actions. Its reported 63% reduction in forgetting concerns selected high-conflict task pairs. Negative backward transfer measures earlier-task performance loss, so a smaller value indicates less forgetting. These findings support conflict-aware replay under the evaluated tasks and budgets, rather than a claim that memory expansion alone guarantees retention.

COLADA [128] limits direct overwriting of existing adapters through modular parameter isolation, learning task-specific ACT-LoRA adapters from dialogue-guided demonstrations while freezing the shared base model. On real-world sandwich assembly, it completes 13/16 multi-step trials, with legacy skills succeeding in 44/48 trials, compared with 47/48 during the interaction phase. These results document reuse of earlier skills under modular parameter isolation, while the reported 44/48 and 47/48 outcomes should remain visible when assessing retention. Human teaching remains part of the acquisition process.

Autonomous Data Collection versus Physical Reset Realities.

AquaBot [129] optimizes speed parameters over demonstration-trained policies, reducing real-world sorting times from 37.47 to 31.34 seconds. In contrast, VaPRL [130] and MEDAL++ [131] synthesize autonomous reset policies that restore physical workcells between manipulation trials. Reset mechanisms can reduce externally supplied assistance between trials. Their net lifecycle savings depend on setup, teaching, maintenance, and residual interventions; the mechanism alone does not establish whether total human effort increases or decreases.

6.5. Repeated Acquisition, Transfer, and Retention

To separate demonstrated components from their joint support, we compare six diagnostic protocols across acquisition repetition, final-test separation, transfer, retention, and intervention reporting (Table 6).

Conquer [122] combines repeated acquisition, protected evaluation, future-task transfer, and earlier-task retention in a simulated object-pushing stream. Three independent training runs traverse 14 tasks, with stage-wise evaluations excluded from training and library updates. Final success is $95.6\pm 0.6\%$, compared with $89.2\pm 0.6\%$ for the Scratch comparison; reported forward transfer is 11.3%, and backward transfer is approximately zero. The source specifies an automated retrieval–training–update procedure and interaction budgets. This supports repeatable simulated self-improvement when procedural automation and stated interaction costs suffice. L5 remains unresolved under this review’s additional requirement for a measured in-run intervention criterion and accounting period. This is a documentation boundary, not evidence of high human dependence. Separate hardware demonstrations do not inherit the simulation acquisition histories.

RoboHarn-Evo [87] evaluates three independent simulation acquisition histories starting from empty knowledge stores ($M_0=\varnothing$), with 80 acquisition rollouts per history and read-only evaluation on 20 held-out configurations. Success rises from 48.3% to 75.0% for one model and from 70.0% to 88.3% for another. Frozen RMBench knowledge also transfers to RoboDojo tasks in simulation. Its separate hardware comparison reports 41.7% versus 62.5% success, but does not inherit the simulation experiment’s three acquisition histories. Knowledge-entry retention does not substitute for re-evaluating earlier manipulation tasks after successive updates.

Continual Language-to-Skill (CLS) [126] executes three independent target-skill acquisition histories conditioned on a pre-existing source archive, reporting $57.0\pm 7.8\%$ target success compared to $45.2\pm 10.3\%$ without source conditioning. Generalized Coding TAMP [94] reports five independent program synthesis histories per environment evaluated on hidden states, while LRLL [89] executes three complete developmental curricula under varying teacher seeds, achieving 93.5% backward-transfer retention.

These protocols provide evidence for repeated acquisition under different initial resources and restart scopes. Some retain a pre-existing source archive, while others restart training or program synthesis within supplied environments. Their positive simulation results do not jointly establish independently repeated hardware acquisition, transfer, earlier-task retention, and low human dependence under a declared intervention criterion.

6.6. Observed Losses and Unresolved Evaluation Boundaries

Aggregate gains can coexist with condition-specific losses or failed complete tasks (Table 7). These comparisons identify different limitations and should not be pooled into a single estimate of regression or autonomy.

Condition-Specific Losses and Update Trade-offs.

ENCORE [13] reports an aggregate simulation gain alongside a plate-condition decrease from 50/50 to 0/50 under a tested perturbation. SkillWeaver [117] reports 89.4% success for its augmented-data policy versus 97.8% for the original-data policy under the language-plus-object perturbation, alongside benefits under other perturbations. This is a condition-specific training-mixture comparison, not evidence of a general nominal-performance decline or sequential forgetting.

Policy-Level RSI [14] repairs 19 baseline failures while introducing eight regressions in its reported RoboTwin comparison. Such results motivate testing both repaired and previously successful cases. They do not establish that all specialization causes forgetting or identify one universal cause of update-induced loss.

Local Acceptance and Complete-Task Outcomes.

The RSI campaign [12] reports a locally accepted approach that satisfies a spherical reachability check but leaves the subsequent grasp unable to reach. This identifies a mismatch between an acceptance criterion and the next skill’s requirements. Separately, a later local grasp improvement is followed by 0/60 whole-task successes. The latter result establishes that a local repair is insufficient for complete-task success; it does not establish a decline from a previously successful whole-task baseline or isolate the cause of every failed rollout.

Documented Human Dependence and Missing Cost Measurements.

RSI explicitly reports 113 human harness repairs [12]. These document an external engineering dependency rather than concealed assistance, and should be distinguished from physical hardware resets. Real2Gym’s reported execution savings do not quantify the complete cost of constructing the simulator and extracting skills [88]. Such accounting boundaries prevent an end-to-end cost conclusion; missing measurements remain unresolved rather than being treated as zero or as evidence of hidden labor.

These findings motivate separate measurements of task transfer, update-induced loss, sequential old-task retention, complete-task success, and acquisition costs. Each interpretation should remain tied to the specific comparison and experimental setting that supports it.

Table 8. Comparative Overview of the 162 Reviewed Studies.

G.	Study	Agent interface	Capability artifact	Setting	Acquisition	Level
A. Agent-Mediated Manipulation (53 records)
A	2AM [50]	Skills	N: action model	Sim	Offline training	L3
A	ABot-Claw [41]	Mixed	M: scene/trace memory	HW	Interaction	L3
A	Agentic Robot [67]	Skills	N: verifier LoRA	Sim	Offline training	L3
A	AGP [59]	Code	S/M: code/experience	HW	Demo + feedback	L4(H)
A	CAM [68]	Skills	N/S: verifier/monitor	Sim+HW	Train + synthesize	L3
A	CaP-X [90]	Code	S/N: utilities/policy	Sim+HW	Synthesis + RL	L4(H)
A	Code as Policies [8]	Code	S: policy functions	Sim+HW	Task-time synthesis	L2
A	CoPAL [78]	Skills	State: episode plans	Sim+HW	Task-time planning	L1
A	Cortex [46]	Skills	N: planner/actor	Sim+HW	Offline training	L3
A	DoReMi [69]	Skills	N: detector LoRA	Sim+HW	Offline training	L4(B)
A	DRAE [132]	Integrated	M+N: experts	Sim+HW	Routing + RL	L3
A	Goal2Skill [133]	Skills	N: skill policies	NR	Offline training	L3
A	GPT Policy [134]	Commands	M: supplied demos	HW	External demos	L3
A	HarnessVLA [135]	Mixed	M/S: memory/cards	Sim+HW	Explore + compile	L4(S)
A	HERO [136]	Skills	M+N: skill library	HW	Orchestrated RL	L3
A	Hi Robot [43]	Skills	N: hierarchy weights	HW	Labels + training	L4(H)
A	Inner Monologue [66]	Skills	N: success predictor	Sim+HW	Offline training	L3
A	K1 [111]	Commands	N: command LoRA	Sim	Teacher distillation	L4(S)
A	KnowNo [31]	Skills	H: decision threshold	Sim+HW	Calibration + help	L3
A	Local Coding [137]	Code	S/M: code/history	HW	Task feedback	L3
A	MessyMem [27]	Mixed	M: scene graph	Sim+HW	Interaction	L3
A	MOKA [138]	Spatial	M/N: demos/policy	HW	Demo + distillation	L3
A	MOSAIC [40]	Mixed	N: actor/forecaster	HW	Offline training	L4(H)
A	MotorMind [139]	Mixed	State: task monitoring	Sim+HW	Task-time reasoning	L2
A	OntoPlan [140]	Skills	State	Sim	None established	L1
A	PhyAgentOS [141]	Skills	M/S: records/procedures	Sim+HW	Task feedback	L1
A	PhysCaP [29]	Code	S: transient code	HW	Task-time synthesis	L2
A	PiGeY [44]	Skills	State: execution state	Sim+HW	Task-time control	L1
A	PIVOT [142]	Commands	State: action search	Sim+HW	Task-time search	L1
A	PlanAR [35]	Skills	S: task plans	HW	Task-time planning	L2
A	PROC3S [143]	Code	S: code/search bounds	Sim+HW	Simulation feedback	L2
A	ProgPrompt [37]	Code	S: task plans	Sim+HW	Task-time synthesis	L2
A	REFLECT [144]	Skills	State: failure summary	Sim+HW	Task-time reflection	L2
A	ReKep [60]	Spatial	S: constraints	HW	Task-time synthesis	L2
A	ReMAC [145]	Skills	State	Sim	None established	L1
A	RoboDawn [63]	Commands	M/S: supplied demos	Sim+HW	External demos	L4(S)
A	RoboHarness [49]	Skills	M/H/E: cards/harness	Sim+HW	Rollout adaptation	L3
A	RoboPro [146]	Code	N: code generator	Sim+HW	Video2Code data	L3
A	RoboScript [38]	Code	S: task scripts	Sim+HW	Task-time synthesis	L2
A	RoboStream [26]	Mixed	M: rolling event graph	Sim+HW	Runtime accumulation	L2
A	RoboTool [147]	Code	S: task programs	Sim+HW	Task-time planning	L2
A	RoCo [39]	Mixed	S: subtask plans	Sim+HW	Dialogue + checks	L2
A	SafeHarness [81]	Mixed	H: fixed safety wrapper	Sim	Author design	L2
A	SayCan [7]	Skills	N: skills/affordances	HW	Offline BC/RL	L3
A	SayPlan [36]	Mixed	S: task plans	Sim+HW	Task-time planning	L2
A	Shared-KV BT [148]	Skills	State	Sim	None established	L1
A	ShowHarness [62]	Commands	N/M: model/demos	HW	Demo + training	L3
A	SimpleArm [25]	Skills	State: schema/memory	NR	Task-time synthesis	L2
A	Thea [149]	Mixed	M: session/tool memory	HW	Task consolidation	L2
A	VAP-TAMP [30]	Mixed	S/M: plans/scene graph	Sim+HW	Task-time planning	L2
A	VIA [150]	Mixed	H: fixed prompts	Sim+HW	Task-time control	L1
A	VLAs with Tools [45]	Mixed	N: tool-aligned policy	Sim	Offline training	L4(S)
A	VoxPoser [9]	Spatial	S/N: maps/dynamics	Sim+HW	Synthesis + interaction	L3
B. Capability Acquisition (91 records)
B	AdaHVLA [98]	Mixed	H: coordination code	Sim+HW	Feedback revision	L4(S)
B	Agentic Robotics [120]	Indirect	N/E: policy/experiments	Sim	Experiment cycles	L3
B	Agentic RSR [151]	Integrated	M+N: policy/notes	Sim+HW	Sim curriculum	L3
B	AOR [92]	Code	S/H/M: code/memory	Sim	Explore + revise	L3
B	AquaBot [129]	Integrated	H: speed scales	HW	Surrogate search	L4(H)
B	Arcadia [152]	Integrated	E+N: data/policy	Sim+HW	Feedback + data	L3
B	ARCHITECT [85]	Code	S/M: skills/rules	HW	Human corrections	L4(H)
B	ASPIRE [93]	Code	S/M: repair library	Sim+HW	Debug + adaptation	L4(S)
B	AstraSim [96]	Mixed	S/M: code/experience	Sim+HW	Demo + revision	L4(S)
B	AtlasVA [153]	Integrated	M+N: memory/policy	Sim	Memory + PPO	L4(S)
B	AtomicVLA [154]	Integrated	N: skill experts	Sim+HW	Expert expansion	L3
B	AutoRT [118]	Skills	N: trained policy/data	HW	Collect + train	L3
B	CLS [126]	Code	S: policy archive	Sim	Demo + search	L4(S)
B	CodingTAMP [94]	Code	S/E: policies/tests	Sim	Test-driven search	L4(S)
B	COLADA [128]	Skills	S+N: adapters	Sim+HW	Dialogue + demos	L4(H)
B	Conquer [122]	Skills	M+N: skill bank	Sim+HW	Retrieval + RL	L4(S)
B	DAAG [155]	Integrated	E+N: data/reward	Sim	Video augmentation	L3
B	DexAgent [114]	Mixed	S/E/N: tools/policy	Sim+HW	Generate + train	L4(H)
B	DexFlywheel [156]	Integrated	E+N: data/policy	Sim+HW	Residual RL	L4(S)
B	DGAC [157]	Integrated	N: action/value	HW	Corrections	L3
B	DROC [83]	Code	M/S: rules/code	HW	Human feedback	L3
B	EmbodiedRSI [125]	Mixed	H + S + M + N	Sim+HW	Code/skill evolution	L4(B)
B	EmbodiedSmith [158]	Integrated	E+N: scenes/policy	Sim	Scene refinement	L3
B	EmbodiRSI [123]	Skills	N: policy/data	Sim+HW	Correct + recollect	L4(B)
B	ENCORE [13]	Code	S/M: programs/demos	Sim+HW	Demo + feedback	L4(S)
B	ENPIRE [11]	Mixed	N/E: policies/recipes	Sim+HW	Setup + experiments	L3
B	Eureka [112]	Indirect	E/N: reward/policy	Sim	Reward search + RL	L3
B	EvoHIL [159]	Integrated	N: actor/critic	HW	Human feedback	L3
B. Capability Acquisition (91 records; continued)
B	EvoVLA [160]	Integrated	M+N: policy	Sim+HW	Stages + PPO	L4(S)
B	GAP [10]	Mixed	S/H: skill graph	Sim+HW	Graph refinement	L3
B	GEAR [161]	Integrated	N: goal/distance	Sim	Human feedback	L3
B	Guava [110]	Mixed	N: actor weights	Sim+HW	Offline SFT/RL	L4(H)
B	HALP [162]	Skills	S+N: new skills	Sim+HW	Human demos	L3
B	HARBOR [113]	Indirect	E/N: tasks/recipes	Sim+HW	Generation + RL	L3
B	HarnessPAI [102]	Mixed	S/M/N: code/policy	Sim+HW	Repair + training	L3
B	HexaAnything [103]	Mixed	H/N: tools/model	Sim+HW	Revise + training	L3
B	InterMimicGen [163]	Integrated	E+N: data/tracker	Sim+HW	Iterative imitation	L3
B	KnowBody [84]	Mixed	M/H: body guidance	HW	Seed + interaction	L4(H)
B	LACY [164]	Integrated	N: action/language	Sim+HW	Consistency filtering	L4(S)
B	LMPC [115]	Spatial	N/E: teaching model	Sim+HW	Teaching + training	L4(B)
B	LOTUS [165]	Skills	S+N: skill bank	Sim+HW	Skill discovery	L3
B	LRLL [89]	Code	S/M/E: skills/tests	Sim+HW	Teacher + exploration	L4(S)
B	LYRA [166]	Code	M+S: code bank	Sim+HW	Human feedback	L3
B	MEDAL++ [131]	Integrated	N: forward/reset	Sim+HW	Autonomous RL	L4(S)
B	MobiAgent [167]	Skills	N: skills/data	Sim+HW	Curate + train	L3
B	MTRF [168]	Skills	N: task policies	Sim+HW	Reset-free RL	L3
B	OmniVIC [169]	Integrated	M+H: impedance	Sim+HW	Rollout retrieval	L4(S)
B	PhysEvo [170]	Code	S+H: tools/skills	Sim+HW	Meta-agent revision	L3
B	Plan-Seq-Learn [171]	Mixed	N: interaction policy	Sim	Plan-guided RL	L4(S)
B	PLD [172]	Integrated	N: generalist	Sim+HW	Residual distillation	L4(S)
B	Policy-Level RSI [14]	Integrated	N+H: experts/gate	Sim+HW	Risk-guided training	L4(B)
B	Q-Planning [173]	Skills	N: Q-function	Sim+HW	Deployment RL	L3
B	RACaP [99]	Skills	S/H/M: APIs/harness	Sim	Curriculum + revision	L4(S)
B	RAPID [95]	Mixed	S/E: strategies/scenes	Sim+HW	Simulation synthesis	L4(S)
B	RATs [91]	Code	S/M: helpers/lessons	Sim+HW	Play + consolidation	L4(B)
B	Real2Gym [88]	Code	E/S/M: sim/skills	Sim+HW	Reconstruct + practice	L3
B	Reflective-VLA [174]	Integrated	E+N: reward/policy	Sim	Reflection + RL	L3
B	ReLMM [175]	Skills	N: grasp/nav	Sim+HW	Autonomous RL	L3
B	Retaining Experiences [176]	Integrated	M+N: replay/policy	Sim+HW	Sequential RL	L4(S)
B	RHD [86]	Mixed	M: text playbooks	Sim+HW	Teacher refinement	L4(S)
B	RISE [177]	Integrated	N: world/policy	HW	Imagined rollouts	L3
B	Robo-COP [124]	Mixed	N + M	Sim+HW	Verified policy updates	L4(B)
B	RoboCat [104]	Integrated	N: policy/data	Sim+HW	Demos + self-data	L4(H)
B	RoboClaw [105]	Skills	N: policies/data	HW	Collect + training	L3
B	RoboFoundry [101]	Mixed	H/M/S: code/rules	Sim+HW	Feedback revision	L4(H)
B	RoboFuME [178]	Integrated	N: reward/policy	Sim+HW	Online RL	L4(H)
B	RoboHarn-Evo [87]	Skills	M: task/action rules	Sim+HW	Interaction + revise	L4(S)
B	RoboSkill [179]	Mixed	S/M: skill packages	Sim+HW	Explore + package	L4(S)
B	RSI [12]	Indirect	S/H/M: code/history	Sim	Explore + human repair	L3
B	RWLA [180]	Integrated	M+N: local policy	Sim	Retrieval + repair	L4(S)
B	SAS-Prompt [181]	Integrated	M+H: parameters	Sim+HW	Outcome summaries	L3
B	SECURE [182]	Skills	M: concept beliefs	Sim+HW	Human feedback	L3
B	SEES [183]	Integrated	N: family policies	Sim	Bottleneck RL	L4(S)
B	Self-Improving EFM [184]	Integrated	N: reward/policy	Sim+HW	Online RL	L3
B	SHAPER [97]	Skills	M/H: guidance/context	Sim	Feedback revision	L4(S)
B	SILVR [185]	Integrated	N: video/action	Sim+HW	Rollout fine-tuning	L3
B	SInViG [186]	Integrated	N: dialogue/grasp	HW	Generated dialogue	L4(H)
B	Skill-effect models [187]	Skills	N: effect model	Sim+HW	Sim transitions	L4(S)
B	SkillsCrafter [188]	Integrated	M+N: adapters	Sim+HW	Sequential demos	L4(H)
B	SkillWeaver [117]	Mixed	M/N: rules/policy	Sim+HW	Search + training	L3
B	SMART [189]	Integrated	E+N: configs/policy	Sim+HW	Generated demos	L4(H)
B	SOAR [107]	Skills	N: policy/data	HW	Explore + training	L3
B	SOE [190]	Integrated	N: latent policy	Sim+HW	Latent exploration	L3
B	Teach-and-Grow [191]	Code	S: skill blocks	Sim	Teacher traces	L4(S)
B	TidyBot [82]	Skills	M: preference rules	HW	Human examples	L2
B	Uni-Skill [192]	Skills	M+S: repository	Sim+HW	Offline demos	L4(S)
B	VaPRL [130]	Integrated	N: goal policy	Sim	Value curriculum	L4(S)
B	VideoAgent [193]	Integrated	N: video policy	Sim+HW	Online fine-tuning	L3
B	WAA [64]	Mixed	M/N: guidance/pilot	Sim	Demo + GUI correction	L4(S)
B	Zero2Skill [116]	Mixed	M/N: rules/policy	HW	Human + training	L4(H)
B	Zetta [100]	Skills	H: critic/recovery	Sim	Feedback revision	L4(S)
C. Mechanism-Focused Studies (18 records)
C	AHA [119]	Indirect	N: diagnosis model	Sim+HW	Offline + feedback	L3
C	ARCHIE [194]	Skills	E+N: skills/rewards	Sim+HW	Reward code + RL	L3
C	ART [195]	Mixed	N: tool-use policy	Sim+HW	Offline training	L3
C	ECoT [52]	Integrated	N: reasoning policy	HW	Offline training	L4(H)
C	Embodied Skills [196]	Mixed	N: planner/skills	Sim+HW	Offline training	L3
C	FRAMES [197]	Mixed	H: fixed monitor	Sim	Fixed setup	L1
C	GVCCI [198]	Spatial	M+N: grounding	HW	Synthetic labels	L4(H)
C	HiVLA Study [199]	Mixed	M/N: memory/policy	Sim+HW	Summaries + training	L3
C	Leave No Trace [200]	Integrated	N: forward/reset	Sim	Joint RL	L3
C	Memory Anchors [127]	Integrated	M+N: replay/policy	Sim+HW	Replay curation	L4(H)
C	Object-model reuse [201]	Spatial	M: object models	HW	Reconstruction	L3
C	OneTwoVLA [53]	Integrated	N: reasoning policy	HW	Offline co-training	L4(H)
C	PACT [202]	Integrated	N: diffusion policy	Sim+HW	Safety curriculum	L3
C	PAINT [203]	Integrated	N: reversibility	Sim	Human labels + RL	L3
C	RETRIEVER [204]	Code	N: skill policies	Sim	Offline training	L3
C	SARM2 [205]	Integrated	N: reward/policy	HW	Autonomous data	L3
C	SRSA [206]	Skills	S+N: retrieval	Sim+HW	Prior skill transfer	L4(S)
C	VLA-Corrector [80]	Mixed	N: failure verifier	Sim+HW	Offline training	L4(H)

Codes. M: memory; S: skills/programs; H: harness/tools ($H,T$); N: neural parameters ($\theta$); E: learning environments/rewards/recipes; State: episodic. HW: hardware; Sim: simulation; NR: not reported. L4(H/S/B): gain in hardware/simulation/both.

Table 8. Comparative Overview of the 162 Reviewed Studies.

G.	Study	Agent interface	Capability artifact	Setting	Acquisition	Level
A. Agent-Mediated Manipulation (53 records)
A	2AM [50]	Skills	N: action model	Sim	Offline training	L3
A	ABot-Claw [41]	Mixed	M: scene/trace memory	HW	Interaction	L3
A	Agentic Robot [67]	Skills	N: verifier LoRA	Sim	Offline training	L3
A	AGP [59]	Code	S/M: code/experience	HW	Demo + feedback	L4(H)
A	CAM [68]	Skills	N/S: verifier/monitor	Sim+HW	Train + synthesize	L3
A	CaP-X [90]	Code	S/N: utilities/policy	Sim+HW	Synthesis + RL	L4(H)
A	Code as Policies [8]	Code	S: policy functions	Sim+HW	Task-time synthesis	L2
A	CoPAL [78]	Skills	State: episode plans	Sim+HW	Task-time planning	L1
A	Cortex [46]	Skills	N: planner/actor	Sim+HW	Offline training	L3
A	DoReMi [69]	Skills	N: detector LoRA	Sim+HW	Offline training	L4(B)
A	DRAE [132]	Integrated	M+N: experts	Sim+HW	Routing + RL	L3
A	Goal2Skill [133]	Skills	N: skill policies	NR	Offline training	L3
A	GPT Policy [134]	Commands	M: supplied demos	HW	External demos	L3
A	HarnessVLA [135]	Mixed	M/S: memory/cards	Sim+HW	Explore + compile	L4(S)
A	HERO [136]	Skills	M+N: skill library	HW	Orchestrated RL	L3
A	Hi Robot [43]	Skills	N: hierarchy weights	HW	Labels + training	L4(H)
A	Inner Monologue [66]	Skills	N: success predictor	Sim+HW	Offline training	L3
A	K1 [111]	Commands	N: command LoRA	Sim	Teacher distillation	L4(S)
A	KnowNo [31]	Skills	H: decision threshold	Sim+HW	Calibration + help	L3
A	Local Coding [137]	Code	S/M: code/history	HW	Task feedback	L3
A	MessyMem [27]	Mixed	M: scene graph	Sim+HW	Interaction	L3
A	MOKA [138]	Spatial	M/N: demos/policy	HW	Demo + distillation	L3
A	MOSAIC [40]	Mixed	N: actor/forecaster	HW	Offline training	L4(H)
A	MotorMind [139]	Mixed	State: task monitoring	Sim+HW	Task-time reasoning	L2
A	OntoPlan [140]	Skills	State	Sim	None established	L1
A	PhyAgentOS [141]	Skills	M/S: records/procedures	Sim+HW	Task feedback	L1
A	PhysCaP [29]	Code	S: transient code	HW	Task-time synthesis	L2
A	PiGeY [44]	Skills	State: execution state	Sim+HW	Task-time control	L1
A	PIVOT [142]	Commands	State: action search	Sim+HW	Task-time search	L1
A	PlanAR [35]	Skills	S: task plans	HW	Task-time planning	L2
A	PROC3S [143]	Code	S: code/search bounds	Sim+HW	Simulation feedback	L2
A	ProgPrompt [37]	Code	S: task plans	Sim+HW	Task-time synthesis	L2
A	REFLECT [144]	Skills	State: failure summary	Sim+HW	Task-time reflection	L2
A	ReKep [60]	Spatial	S: constraints	HW	Task-time synthesis	L2
A	ReMAC [145]	Skills	State	Sim	None established	L1
A	RoboDawn [63]	Commands	M/S: supplied demos	Sim+HW	External demos	L4(S)
A	RoboHarness [49]	Skills	M/H/E: cards/harness	Sim+HW	Rollout adaptation	L3
A	RoboPro [146]	Code	N: code generator	Sim+HW	Video2Code data	L3
A	RoboScript [38]	Code	S: task scripts	Sim+HW	Task-time synthesis	L2
A	RoboStream [26]	Mixed	M: rolling event graph	Sim+HW	Runtime accumulation	L2
A	RoboTool [147]	Code	S: task programs	Sim+HW	Task-time planning	L2
A	RoCo [39]	Mixed	S: subtask plans	Sim+HW	Dialogue + checks	L2
A	SafeHarness [81]	Mixed	H: fixed safety wrapper	Sim	Author design	L2
A	SayCan [7]	Skills	N: skills/affordances	HW	Offline BC/RL	L3
A	SayPlan [36]	Mixed	S: task plans	Sim+HW	Task-time planning	L2
A	Shared-KV BT [148]	Skills	State	Sim	None established	L1
A	ShowHarness [62]	Commands	N/M: model/demos	HW	Demo + training	L3
A	SimpleArm [25]	Skills	State: schema/memory	NR	Task-time synthesis	L2
A	Thea [149]	Mixed	M: session/tool memory	HW	Task consolidation	L2
A	VAP-TAMP [30]	Mixed	S/M: plans/scene graph	Sim+HW	Task-time planning	L2
A	VIA [150]	Mixed	H: fixed prompts	Sim+HW	Task-time control	L1
A	VLAs with Tools [45]	Mixed	N: tool-aligned policy	Sim	Offline training	L4(S)
A	VoxPoser [9]	Spatial	S/N: maps/dynamics	Sim+HW	Synthesis + interaction	L3
B. Capability Acquisition (91 records)
B	AdaHVLA [98]	Mixed	H: coordination code	Sim+HW	Feedback revision	L4(S)
B	Agentic Robotics [120]	Indirect	N/E: policy/experiments	Sim	Experiment cycles	L3
B	Agentic RSR [151]	Integrated	M+N: policy/notes	Sim+HW	Sim curriculum	L3
B	AOR [92]	Code	S/H/M: code/memory	Sim	Explore + revise	L3
B	AquaBot [129]	Integrated	H: speed scales	HW	Surrogate search	L4(H)
B	Arcadia [152]	Integrated	E+N: data/policy	Sim+HW	Feedback + data	L3
B	ARCHITECT [85]	Code	S/M: skills/rules	HW	Human corrections	L4(H)
B	ASPIRE [93]	Code	S/M: repair library	Sim+HW	Debug + adaptation	L4(S)
B	AstraSim [96]	Mixed	S/M: code/experience	Sim+HW	Demo + revision	L4(S)
B	AtlasVA [153]	Integrated	M+N: memory/policy	Sim	Memory + PPO	L4(S)
B	AtomicVLA [154]	Integrated	N: skill experts	Sim+HW	Expert expansion	L3
B	AutoRT [118]	Skills	N: trained policy/data	HW	Collect + train	L3
B	CLS [126]	Code	S: policy archive	Sim	Demo + search	L4(S)
B	CodingTAMP [94]	Code	S/E: policies/tests	Sim	Test-driven search	L4(S)
B	COLADA [128]	Skills	S+N: adapters	Sim+HW	Dialogue + demos	L4(H)
B	Conquer [122]	Skills	M+N: skill bank	Sim+HW	Retrieval + RL	L4(S)
B	DAAG [155]	Integrated	E+N: data/reward	Sim	Video augmentation	L3
B	DexAgent [114]	Mixed	S/E/N: tools/policy	Sim+HW	Generate + train	L4(H)
B	DexFlywheel [156]	Integrated	E+N: data/policy	Sim+HW	Residual RL	L4(S)
B	DGAC [157]	Integrated	N: action/value	HW	Corrections	L3
B	DROC [83]	Code	M/S: rules/code	HW	Human feedback	L3
B	EmbodiedRSI [125]	Mixed	H + S + M + N	Sim+HW	Code/skill evolution	L4(B)
B	EmbodiedSmith [158]	Integrated	E+N: scenes/policy	Sim	Scene refinement	L3
B	EmbodiRSI [123]	Skills	N: policy/data	Sim+HW	Correct + recollect	L4(B)
B	ENCORE [13]	Code	S/M: programs/demos	Sim+HW	Demo + feedback	L4(S)
B	ENPIRE [11]	Mixed	N/E: policies/recipes	Sim+HW	Setup + experiments	L3
B	Eureka [112]	Indirect	E/N: reward/policy	Sim	Reward search + RL	L3
B	EvoHIL [159]	Integrated	N: actor/critic	HW	Human feedback	L3
B. Capability Acquisition (91 records; continued)
B	EvoVLA [160]	Integrated	M+N: policy	Sim+HW	Stages + PPO	L4(S)
B	GAP [10]	Mixed	S/H: skill graph	Sim+HW	Graph refinement	L3
B	GEAR [161]	Integrated	N: goal/distance	Sim	Human feedback	L3
B	Guava [110]	Mixed	N: actor weights	Sim+HW	Offline SFT/RL	L4(H)
B	HALP [162]	Skills	S+N: new skills	Sim+HW	Human demos	L3
B	HARBOR [113]	Indirect	E/N: tasks/recipes	Sim+HW	Generation + RL	L3
B	HarnessPAI [102]	Mixed	S/M/N: code/policy	Sim+HW	Repair + training	L3
B	HexaAnything [103]	Mixed	H/N: tools/model	Sim+HW	Revise + training	L3
B	InterMimicGen [163]	Integrated	E+N: data/tracker	Sim+HW	Iterative imitation	L3
B	KnowBody [84]	Mixed	M/H: body guidance	HW	Seed + interaction	L4(H)
B	LACY [164]	Integrated	N: action/language	Sim+HW	Consistency filtering	L4(S)
B	LMPC [115]	Spatial	N/E: teaching model	Sim+HW	Teaching + training	L4(B)
B	LOTUS [165]	Skills	S+N: skill bank	Sim+HW	Skill discovery	L3
B	LRLL [89]	Code	S/M/E: skills/tests	Sim+HW	Teacher + exploration	L4(S)
B	LYRA [166]	Code	M+S: code bank	Sim+HW	Human feedback	L3
B	MEDAL++ [131]	Integrated	N: forward/reset	Sim+HW	Autonomous RL	L4(S)
B	MobiAgent [167]	Skills	N: skills/data	Sim+HW	Curate + train	L3
B	MTRF [168]	Skills	N: task policies	Sim+HW	Reset-free RL	L3
B	OmniVIC [169]	Integrated	M+H: impedance	Sim+HW	Rollout retrieval	L4(S)
B	PhysEvo [170]	Code	S+H: tools/skills	Sim+HW	Meta-agent revision	L3
B	Plan-Seq-Learn [171]	Mixed	N: interaction policy	Sim	Plan-guided RL	L4(S)
B	PLD [172]	Integrated	N: generalist	Sim+HW	Residual distillation	L4(S)
B	Policy-Level RSI [14]	Integrated	N+H: experts/gate	Sim+HW	Risk-guided training	L4(B)
B	Q-Planning [173]	Skills	N: Q-function	Sim+HW	Deployment RL	L3
B	RACaP [99]	Skills	S/H/M: APIs/harness	Sim	Curriculum + revision	L4(S)
B	RAPID [95]	Mixed	S/E: strategies/scenes	Sim+HW	Simulation synthesis	L4(S)
B	RATs [91]	Code	S/M: helpers/lessons	Sim+HW	Play + consolidation	L4(B)
B	Real2Gym [88]	Code	E/S/M: sim/skills	Sim+HW	Reconstruct + practice	L3
B	Reflective-VLA [174]	Integrated	E+N: reward/policy	Sim	Reflection + RL	L3
B	ReLMM [175]	Skills	N: grasp/nav	Sim+HW	Autonomous RL	L3
B	Retaining Experiences [176]	Integrated	M+N: replay/policy	Sim+HW	Sequential RL	L4(S)
B	RHD [86]	Mixed	M: text playbooks	Sim+HW	Teacher refinement	L4(S)
B	RISE [177]	Integrated	N: world/policy	HW	Imagined rollouts	L3
B	Robo-COP [124]	Mixed	N + M	Sim+HW	Verified policy updates	L4(B)
B	RoboCat [104]	Integrated	N: policy/data	Sim+HW	Demos + self-data	L4(H)
B	RoboClaw [105]	Skills	N: policies/data	HW	Collect + training	L3
B	RoboFoundry [101]	Mixed	H/M/S: code/rules	Sim+HW	Feedback revision	L4(H)
B	RoboFuME [178]	Integrated	N: reward/policy	Sim+HW	Online RL	L4(H)
B	RoboHarn-Evo [87]	Skills	M: task/action rules	Sim+HW	Interaction + revise	L4(S)
B	RoboSkill [179]	Mixed	S/M: skill packages	Sim+HW	Explore + package	L4(S)
B	RSI [12]	Indirect	S/H/M: code/history	Sim	Explore + human repair	L3
B	RWLA [180]	Integrated	M+N: local policy	Sim	Retrieval + repair	L4(S)
B	SAS-Prompt [181]	Integrated	M+H: parameters	Sim+HW	Outcome summaries	L3
B	SECURE [182]	Skills	M: concept beliefs	Sim+HW	Human feedback	L3
B	SEES [183]	Integrated	N: family policies	Sim	Bottleneck RL	L4(S)
B	Self-Improving EFM [184]	Integrated	N: reward/policy	Sim+HW	Online RL	L3
B	SHAPER [97]	Skills	M/H: guidance/context	Sim	Feedback revision	L4(S)
B	SILVR [185]	Integrated	N: video/action	Sim+HW	Rollout fine-tuning	L3
B	SInViG [186]	Integrated	N: dialogue/grasp	HW	Generated dialogue	L4(H)
B	Skill-effect models [187]	Skills	N: effect model	Sim+HW	Sim transitions	L4(S)
B	SkillsCrafter [188]	Integrated	M+N: adapters	Sim+HW	Sequential demos	L4(H)
B	SkillWeaver [117]	Mixed	M/N: rules/policy	Sim+HW	Search + training	L3
B	SMART [189]	Integrated	E+N: configs/policy	Sim+HW	Generated demos	L4(H)
B	SOAR [107]	Skills	N: policy/data	HW	Explore + training	L3
B	SOE [190]	Integrated	N: latent policy	Sim+HW	Latent exploration	L3
B	Teach-and-Grow [191]	Code	S: skill blocks	Sim	Teacher traces	L4(S)
B	TidyBot [82]	Skills	M: preference rules	HW	Human examples	L2
B	Uni-Skill [192]	Skills	M+S: repository	Sim+HW	Offline demos	L4(S)
B	VaPRL [130]	Integrated	N: goal policy	Sim	Value curriculum	L4(S)
B	VideoAgent [193]	Integrated	N: video policy	Sim+HW	Online fine-tuning	L3
B	WAA [64]	Mixed	M/N: guidance/pilot	Sim	Demo + GUI correction	L4(S)
B	Zero2Skill [116]	Mixed	M/N: rules/policy	HW	Human + training	L4(H)
B	Zetta [100]	Skills	H: critic/recovery	Sim	Feedback revision	L4(S)
C. Mechanism-Focused Studies (18 records)
C	AHA [119]	Indirect	N: diagnosis model	Sim+HW	Offline + feedback	L3
C	ARCHIE [194]	Skills	E+N: skills/rewards	Sim+HW	Reward code + RL	L3
C	ART [195]	Mixed	N: tool-use policy	Sim+HW	Offline training	L3
C	ECoT [52]	Integrated	N: reasoning policy	HW	Offline training	L4(H)
C	Embodied Skills [196]	Mixed	N: planner/skills	Sim+HW	Offline training	L3
C	FRAMES [197]	Mixed	H: fixed monitor	Sim	Fixed setup	L1
C	GVCCI [198]	Spatial	M+N: grounding	HW	Synthetic labels	L4(H)
C	HiVLA Study [199]	Mixed	M/N: memory/policy	Sim+HW	Summaries + training	L3
C	Leave No Trace [200]	Integrated	N: forward/reset	Sim	Joint RL	L3
C	Memory Anchors [127]	Integrated	M+N: replay/policy	Sim+HW	Replay curation	L4(H)
C	Object-model reuse [201]	Spatial	M: object models	HW	Reconstruction	L3
C	OneTwoVLA [53]	Integrated	N: reasoning policy	HW	Offline co-training	L4(H)
C	PACT [202]	Integrated	N: diffusion policy	Sim+HW	Safety curriculum	L3
C	PAINT [203]	Integrated	N: reversibility	Sim	Human labels + RL	L3
C	RETRIEVER [204]	Code	N: skill policies	Sim	Offline training	L3
C	SARM2 [205]	Integrated	N: reward/policy	HW	Autonomous data	L3
C	SRSA [206]	Skills	S+N: retrieval	Sim+HW	Prior skill transfer	L4(S)
C	VLA-Corrector [80]	Mixed	N: failure verifier	Sim+HW	Offline training	L4(H)

Codes. M: memory; S: skills/programs; H: harness/tools ($H,T$); N: neural parameters ($\theta$); E: learning environments/rewards/recipes; State: episodic. HW: hardware; Sim: simulation; NR: not reported. L4(H/S/B): gain in hardware/simulation/both.

7. Discussion and Future Directions

The comparisons in Section 6 identify three linked design problems: locating the component responsible for a failure, making local updates compatible with subsequent execution, and sustaining acquisition under physical and human resource constraints. Retained artifacts already support gains in reported settings, and a bounded simulation stream combines repeated acquisition with transfer and earlier-task retention. The following directions address how such benefits could become more reliable across tasks and update cycles.

7.1. Methodological Reflections: Three Systemic Dilemmas

Observational Underdetermination in Physical Failure.

In contact-rich manipulation, a failed rollout may reflect perception error, task decomposition, contact dynamics, calibration drift, or an inaccurate outcome verifier. A trace alone may not distinguish these explanations. Revising a prompt or policy without testing the proposed diagnosis can leave the failure unresolved or introduce new errors. The relevant question is whether a targeted intervention improves later outcomes under a matched evaluation.

Evaluator Gaming and Invariant Chaining Collapse.

Candidate selection depends on the fidelity of the gate $\mathcal{G}(C_k,{\tilde{C}}_{k+1};\mathcal{V})$. Errors in geometric predicates or learned critics can admit updates that do not improve the required behavior. RSI [12] documents an accepted reachability outcome that leaves the next grasp infeasible. This motivates checking compatibility between a skill’s terminal states and the next skill’s initiation conditions, alongside independently assessed whole-task success. Evaluator exploitation is a risk to test, not an inevitable consequence of using a particular verifier.

The Conflation of Software Rollback and Physical Reset.

Restoring a software configuration ${\tilde{C}}_{k+1}\to C_k$ does not restore displaced objects or repair damaged hardware. Software rollback itself can require loading, dependency reconciliation, and verification. Physical recovery may require robot actions, fixtures, or human support. Reports should separate these operations and measure their time, interventions, and failed recoveries. An unreported labor cost remains unknown rather than evidence of concealed assistance.

7.2. Future Directions: Reliable and Sustained Capability Acquisition

Active Hypothesis-Disambiguating Probing.

A testable direction is to let agents formulate competing failure hypotheses and choose interactions that distinguish them before revising $C_k$. PhysCaP [29] motivates contact-based information gathering. Future comparisons should evaluate targeted probing against untargeted retries under matched interaction and compute budgets, stating the expected diagnostic observation and whether the resulting update improves held-out manipulation.

Connecting Local Acceptance to Task Success.

Candidate checks should examine whether a skill leaves states suitable for subsequent operations, alongside separate measurements of complete-task success. Comparing isolated skill checks with checks that include downstream requirements can test when local acceptance predicts useful composition. The selection rule $\mathcal{G}$ may remain fixed or itself be updated. For fixed rules, a key question is whether their judgments remain reliable as tasks and candidate distributions change. For revised rules, acceptance errors and changes in stringency should be tracked across versions, including harmful updates admitted on earlier tasks.

Autonomous Reset Operators and Labor Accounting.

Reset and recovery policies can reduce externally supplied assistance during data collection [130,131]. Their contribution should be evaluated alongside setup, teaching, engineering, and deployment costs. We propose the following human labor ledger:

$$\begin{array}{cc}\hfill T_{\mathrm{human}}=& T_{\mathrm{demo}}+T_{\mathrm{setup}}+T_{\mathrm{engineering}}+T_{\mathrm{annotation}}\hfill \\ \hfill & +T_{\mathrm{reset}}+T_{\mathrm{rescue}}+T_{\mathrm{eval}}.\hfill \end{array}$$

(7)

Engineering includes harness repair, simulator construction, and training-pipeline configuration. Each person’s time interval should be charged once to its primary purpose, with shared work allocated by a declared rule. Upfront reusable effort and recurring work should be reported separately, together with the accounting period and any amortization rule.

For L5, independent acquisition histories must jointly establish the specified gain, transfer, retention, and low-human-dependence criteria in the credited setting. The intervention threshold and measurement period should be stated before final evaluation, with interventions reported per episode, per successful task, and per acquisition cycle. Zero unscheduled assistance is a useful experimental target, but this review imposes neither a universal zero-human threshold nor an infinite-horizon convergence requirement.

7.3. Limitations of the Review

The findings of this survey are bounded by the following methodological constraints:

1.

Reported Evidence versus Latent Capabilities: Systems are evaluated strictly against their substantiated empirical chains and public code repositories; undocumented validation protections or unverified latent performance claims cannot be credited retroactively.

2.

Conditioned Definition of Level 5: No inspected chain satisfies the joint criteria under this review’s intervention-accounting requirement. Accepting procedural automation and stated interaction budgets supports a narrower positive conclusion for repeatable simulated self-improvement. Changing the conjunction changes the composite label, while the component evidence remains available for other interpretations.

8. Conclusions

This review examines agent-mediated manipulation and capability acquisition across 162 primary studies. Retained programs, playbooks, and memory representations can improve skill selection, command formulation, and execution recovery using fixed underlying actors, while learned policies and verifiers adapt distinct system layers. However, aggregate benchmark gains can coexist with condition-specific losses, and local candidate successes do not ensure end-to-end task completion.

The five-level framework organizes these findings, while component analysis separates demonstrated outcomes from joint criteria. When evaluated against procedural automation and stated interaction budgets, repeatable acquisition, transfer, and earlier-task retention occur jointly within bounded simulation streams. Under the stricter requirement of explicit human labor and physical reset accounting, independently repeated hardware self-improvement remains unresolved across the inspected corpus. Missing cost ledgers represent unmeasured boundaries rather than evidence of absent capability.

Advancing toward repeatable self-improvement requires an accountable experimental agenda: repeating acquisition across declared initial resources, isolating final evaluations from candidate selection, re-evaluating legacy tasks across update cycles, and publishing comprehensive human, reset, and compute ledgers. Grounding capability acquisition in these protocols connects retained artifacts to verifiable developmental autonomy in physical manipulation.