acceptodds
Under review as a conference paper at ICLR 2027

FAULT-AWARE POLICY REUSE VIA SKILL LIBRARIES FOR ADAPTIVE ROBOT LEARNING

Abstract

Recent advances in embodied agent adaptation have largely focused on changes in the task or environmental dynamics. However, a robot's own dynamics can also change mid-deployment due to a hardware failure. Consequently, policies trained under nominal dynamics can degrade significantly, even when the task/environment remains unchanged. Existing fault-tolerant approaches either require fault-specific engineering or training a single monolithic policy to generalize across diverse changes in robot dynamics. Policy reuse offers a more targeted alternative, but existing methods are not explicitly organized around the robot's fault state for subsequent adaptation. We propose Skill Library, a framework that organizes reusable policies by fault condition. We first pretrain a collection of lightweight, fault-indexed policies offline. During deployment, when the detected fault is represented in the library, the matched policy is retrieved for direct reuse; when the fault is unseen, stored policies serve as initialization for online adaptation. Our fault-aware Skill Library focuses on changes in the robot's dynamics with policies indexed by the affected joint and fault severity. We evaluate our framework across four manipulation environments on a 7-DOF Franka Panda in MuJoCo. Our results demonstrate that our framework consistently improves adaptation sample efficiency over both training from scratch and fine-tuning from the nominal policy, reducing the recovery interaction budget and improving final success rates. Moreover, experiments on unseen compound faults show that a library of single-joint policies alone can provide useful initialization for complex, multi-joint failures, extending the fault adaptation beyond the conditions explicitly represented in the offline library.

Primary area:
reinforcement learning
Keywords:
Robot adaptation, Reinforcement learning, Fault-tolerant control, Skill library, Embodied agent

Reviews

Among:
Shape:
1234this paper, Top 49%
Figure 1. Mean review rating of the reviewed papers at ICLR 2027. This paper averages 2.33 over 3 reviews, above 51% of the others.
Reviewer_fmGxOpenReview ↗
Rating
3
Confidence
2
Informativeness
2
Presentation
3
Soundness
2
Read review
Paper summary

This paper focus on the problem that hardware failures (e.g., actuator lockups or loss of range of motion) abruptly alter robot dynamics mid-deployment, causing policies trained under nominal dynamics to fail. Existing fault-tolerant methods either rely on fault-specific engineering, require monolithic policies to generalize across wide dynamics distributions, or optimize skill libraries for task variations rather than physical bodily faults.

The authors propose a fault-indexed skill library framework to enable sample-efficient recovery with 2 steps. First of all, specialist policies are trained via PPO for representative single-joint faults across tasks, indexed by fault descriptor (joint index and severity), producing a structured library of 60 policies across four manipulation tasks. When an upstream fault alarm identifies active joint damage, the matched fault-specific policy is retrieved. Known faults are deployed directly or fine-tuned; unseen or compound faults use candidate library policies as warm-start initializations for targeted RL fine-tuning rather than learning from scratch.

Findings in the experiments:

(1) Tested on a 7-DOF Franka Panda arm across four tasks (8-Bin Sort, Shelf Placement, and Horizontal/Vertical Wall Pick-and-Place), Joint 1 (shoulder pitch) and Joint 3 (elbow) emerge as universally critical (70%–99% failure rate drops), whereas distal joints (J0, J2, J4, J6) are consistently non-critical.

(2) Single-joint libraries generalize to unseen compound double/triple faults. Half-severity compound failures remain largely solvable (up to 100% success), while full freezing across multiple critical joints exposes severe kinematic bottlenecks. Cross-task transfer succeeds when source libraries are trained on kinematically diverse workspaces (e.g., 8-Bin transferring to Shelf).

Critical strengths

(1) The problem of fault-aware policy is interesting and practical for robotics deployment.

(2) Different from existing fault-tolerant methods, this paper propose to pre-train a library of fault-indexed skills and re-use the library during deployment, which is reasonable for the task.

(3) The extensive experiment reveals various conclusion about the proposed method.

Critical weaknesses

(1) There lacks experiments on real-world robots. Could the author provide some experiments on real ones?

(2) For the compound fault part, fine-tuning the existing policy one-by-one seems too expensive. The distance between the fault index of the learned policies and the new fault in the "fault-space" might serve as a cue to combine/select existing policy when a new fault appears.

Questions for authors

Please refer to the weakness part.

1 comment

Thank you for your kind suggestions. We have answered your questions in the comments below.

1. Real-world robots

We agree that real-robot validation matters. However, our focus is simulation, and we cannot inject faults into real robot to validate sim-to-real transfer of the library due to the hardware limitations. We will state real-robot deployment as a limitation of our paper and a future work direction

2. Distance in fault space as a cue for compound faults

Following the comment, we ran a cheap test.On the Wall-H task, we fine-tuned from each of the 15 library policies on 7 compound faults (10 seeds, final checkpoint), and asked whether fault-space distance between the source policy and the compound fault predicts which source works best.

  • Distance is probably not a useful cue. Across all (compound fault, source policy) pairs, success and distance are essentially uncorrelated (Spearman ρ ≈ 0.11, p ≈ 0.3). Mean success at distances 0/1/2/3 is 0.55/0.42/0.65/0.67, which is not monotonic.
  • Even perfect selection gains very little. The source policy closest to the compound’s components reaches 0.57 success after fine-tuning, below the healthy policy at 0.67. The oracle (the best of all 15 sources per compound) reaches 0.69.
  • Selection cannot solve the hard cases. Two of the compounds (J0-full+J1-full and J0-half+J1-full) get 0% from all 15 sources even after fine-tuning. Our reachability check (see our answer to Q3) shows they are kinematically infeasible, so no selection or adaptation strategy could succeed on them. For the other five, the best source reaches 68% to 100%, and in many cases the healthy policy is already quite close.
  • This test also suggests adding the reachability check as a precondition, so we avoid spending fine-tuning on physically infeasible faults.

We therefore keep fine-tuning from a retrieved single-fault policy as our approach for compound faults. This test covers selecting a source policy by distance. It does not cover combining policies (for example, weight merging), which we agree is a promising direction and will list as future work. Our next step is a smarter, structured retrieval method, which will be the main focus of future work.

Reviewer_YvVWOpenReview ↗
Rating
1
Confidence
4
Informativeness
1
Presentation
2
Soundness
1
Read review
Paper summary

The paper studies recovery of a manipulation policy after a hardware fault changes the robot’s own dynamics while the task stays fixed. It proposes Skill Library. The approach trains a PPO policy for every (task, fault) pair, where a fault is one of 7 joints at half or full severity (15 conditions including healthy), across 4 tasks, giving 60 policies. Given an oracle fault descriptor (exact joint and severity), the matching policy is deployed directly or fine-tuned. For unseen faults (compound faults, other tasks), every library policy is fine-tuned for 1M steps and the best one is kept. Experiments on a simulated Franka Panda (four pick-and-place variants, 10 seeds) report that full freezes of J1 and J3 are mostly catastrophic for the healthy policy, that fault-matched initialization improves early sample efficiency for some of these faults, that an 8-Bin library transfers to Shelf but not the reverse, and that single-fault policies give some benefit on double and triple faults.

Critical strengths

Interesting Problem Setting. Most works on policy adaptation focus on external changes (task or environment), while recovery from changes in the robot’s own dynamics, such as a hardware failure, is underexplored compared to the external changes. The paper frames this setting clearly.

Critical weaknesses

Novelty. The work exhibits minimal to no novelty. The approach is a hand-indexed table of policies retrieved by an oracle. The core of the method is just training N x M policies, one for each predefined task and fault, and selecting one using privileged knowledge of the fault, with an optional fine-tuning step. On the privileged information aspect, even though the authors state ‘no privileged information at deployment beyond fault identity,’ this is exactly what privileged information is in this setting. When the fault is unseen, the approach falls back to brute force by fine-tuning every policy in the library. This offers little practical gain while the Skill Library is not actually exploited in some insightful way. Additionally, the important and interesting parts of the problem (fault detection, similarity-based retrieval for unseen faults, and a learned fault representation) are deferred to future work. One of the main findings in the paper, that freezing J1 or J3 breaks a policy, is also expected and not informative on its own. Lastly, the approach is very similar to IT&E/MAP-Elites, SRSA and classical policy reuse, and the paper argues it differs from them by fine-tuning with RL and indexing by fault rather than task, but these are minor variations.

Evidence does not support the claims, and multiple inconsistencies in the results. First and foremost, the same-fault comparison in Table 2 is mostly continued training, because the same-fault library policy was fine-tuned on the fault it was trained on, continuing from its original training point. So, the comparison is basically more vs. fewer total training steps. Then a single fault-conditioned policy comparison is missing, which might remove the need and computational cost for one policy per fault. Moreover, on the Wall-H J1 full experiment, the healthy policy is a much better source than the same-fault policy (AUC 0.974 vs 0.298), but the text states that fault-matched retrieval is essential across tasks. Lastly, one of my major concerns is that in Table 3 (shelf → 8-bin), the ‘best’ library sources (j0_half, j6_half, j0_full) have values identical to the healthy source on every metric, including standard deviations. While the above-mentioned ones are the most critical points, below I list some other inconsistencies I noticed:

  • The “best source” is the maximum over 15 noisy candidates, compared against a single healthy source, which favors the library. Moreover, for unseen faults, all 15 library policies are fine-tuned for 1M steps each (15M steps total), yet they are compared against a single 1M-step healthy run, which is not a fair comparison.
  • For the scratch baseline in Table 2, the AUC, PDE or budget is not reported, and it is often comparable or better than the library (Shelf J1 full: 88.4% vs 21.4% final SR).
  • The headline gain of +91.7 points is the success rate at 200k steps on a single cell, whose final success rate is only 21.4%.
  • The abstract states that the method ‘consistently improves’ over both baselines, which several rows of Table 2 contradict.
  • The SR@20% is defined at 200k steps, implying a 1M budget, yet several PDE values exceed 1M.
  • Statements about changes in the robot’s dynamics and about generalization to unseen faults are not supported, since all the experiments use one robot, one simulator, and four pick-and-place variants that share the same interface, and the faults are limited to joint freezes and range/stiffness reductions.
  • In Section 6.1 it is stated that J0 is “consistently non-critical across all tasks” and J1 is “universally critical,” but Table 1 shows a 35.7% drop for J0 on Wall-H and only 0.8% for J1 on Wall-V.

Additional Feedback. There are a few problems with the presentation of the paper. For example, Section 4.2 is practically empty, Appendix A references Section 3, which is not correct, and there are several typos, such as in Figure 1 and Figure 2, where the word deploy is written as “depoly” in the boxes. Lastly, the PDE acronym is never expanded and can be easily confused with partial differential equations.

Questions for authors
  1. Could the authors address the contradictions in the paper that are described in the weaknesses?
  2. Could the authors report the AUC, PDE, and SR@20% for the policy from scratch in Table 2?
  3. What is the training wall time for the 60 policies?
  4. What success rate does a fault-conditioned policy or a policy with domain randomization over faults achieve?
4 comments

Thank you for your comments; your suggestions are very meaningful to us. We will fix all bugs in the camera-ready version. Thank you again for the time and effort you put into reviewing this paper.

1. Could the authors address the contradictions in the paper that are described in the weaknesses?

Thank you for pointing these out. We found and fixed a source-loading error: Shelf-sourced runs in Table 3 had silently trained from scratch, which invalidated the Shelf→8-Bin half of the table. We reran them all and will report the corrected table. We are also correcting the Section 6.1 criticality claims, the abstract’s “consistently improves”, the headline cell, and the definition of the evaluation budget (the 1M-step fine-tuning budget, with seeds that never reach 80% counted at 2M steps in PDE).

On the novelty, we would agree the method is straightforward; the constituent parts are not new (policies indexed by fault, retrieved via known fault identity and then fine-tuned with RL). We're not claiming a new learning algorithm, and we treat the oracle fault identity as an assumption rather than a solution to the fault detection problem.

Our contribution is an empirical study of how much help fault-matched prior policies can give in recovery and when they do so, across four tasks and 15 fault conditions. Two findings go beyond the expected result that freezing J1 or J3 breaks a policy:

Retrieval at intermediate severities. For faults in between the library’s half and full levels (30% and 70%) the nearest severity source is of help in several cases (e.g., 8-Bin J3 at 70%: AUC 0.979 vs 0.780 from the healthy source) but not in all. This is the first measurement of similarity-based retrieval for faults outside the library.

We agree fault detection, learned fault representations and retrieval for unseen faults are all important, and we list those as limitations and future work. The paper is different from IT&E/MAP-Elites, SRSA and policy reuse in RL fine-tuning and indexing by fault, and that's all we claim.

2. Could the authors report the AUC, PDE, and SR@20% for the policy from scratch in Table 2?

Yes. We trained from random initialization on each fault under the same 1M-step budget and hyperparameters (10 seeds). Here are the results next to the same-fault library source:

EnvFaultScratch AUCPDESR@20%Final SRLibrary AUC
Wall-HJ1 full0.2211744k23.2 ± 4.625.0 ± 32.30.298
Wall-HJ3 full0.000>2000k0.00.00.000
8-BinJ1 full0.168>2000k5.5 ± 3.729.6 ± 3.60.702
8-BinJ3 full0.037>2000k3.3 ± 1.55.2 ± 2.80.227
8-BinJ5 full0.162>2000k11.8 ± 3.827.5 ± 5.70.930
ShelfJ1 full0.2631890k2.7 ± 2.955.5 ± 21.20.609
ShelfJ3 full0.000>2000k0.00.00.000

Scratch is far below the library on 8-Bin. J3_full is unsolved by every method. On Shelf J1 full, scratch ends with a higher final success than the library (55.5% vs 21.4%), although it is much slower early on. The library policy reaches 99.4% within 200k steps, where under deployment will be suggested to stop there, and then degrades during continued fine-tuning, which we believe reflects PPO instability. We will report both the peak and the final success rate.

3. What is the training wall time for the 60 policies?

One policy takes about 1.0 hour (mean 1.03 h over 140 completed Wall-H runs; 2.5M PPO steps, 4 CPU cores, no GPU). One seed of all 60 policies is therefore about 60 job-hours, or about 1 hour of wall time if run in parallel. This extrapolates the Wall-H figure to the other three tasks, which we have not measured; 8-Bin policies use more steps (about 4M), so they take longer. Our Wall-H library with 10 seeds per condition cost 144 job-hours.

4. What success rate does a fault-conditioned policy or a policy with domain randomization over faults achieve?

We added such a comparison, and here are our new observations:

Implementation. We train one PPO policy per task for up to 10M steps.The fault descriptor z, a one-hot vector over the 15 conditions (healthy plus J0 to J6 at half and full severity), is appended to the observation, and each training episode samples one condition uniformly. We use the same PPO hyperparameters as the library policies and no fine-tuning at test time. For a compound fault, z is the sum of the two component one-hot vectors.

Single faults. On Wall-H (one seed, 50 episodes per condition), the conditioned policy scores 93.2% on average over the 15 conditions: healthy 98% and 100% on every fault except J3-full (0%). The library also scores 0% on J3-full. On J1-full, the conditioned policy reaches 100%, while the library’s same-fault source reaches 29.9% and its healthy source 99.2%. On Wall-V, it scores 93.3% on average, with 13 of 14 faults at 100% and J3-full at 0%. The library’s matched source reaches AUC 0.987 to 0.999 on the same 13 faults, and no library source solves J3-full. On the faults both methods solve, they are within about 2 points.

Compound faults (Wall-H, zero-shot). For J0-half+J1-half, the conditioned policy scores 100%, against 98% for the best of the 15 library policies. For J2-full+J1-half, it scores 95%, against 97%. The two kinematically infeasible combinations are 0% for both methods. The exception is J0-full+J1-half: the conditioned policy scores 0%, the best library policy 58% zero-shot, and library sources fine-tuned on this compound reach 0.68 to 0.86. We did not fine-tune the conditioned policy on compounds.

Conclusion. On the faults we tested, a single fault-conditioned policy is as good as the library, and we will add it to the paper as a baseline. The library’s advantages are different: a new fault costs one new policy without retraining the others, a close source can be fine-tuned when a shared policy fails (J0-full+J1-half), and each policy is easy to inspect. Our conditioned results are from one seed per task so far, and we will report additional seeds and tasks in the paper.owever, the library does have its own advantages. A new fault costs one new policy, and the existing policies are untouched. A single conditioned network has to be updated when the fault set changes, and our concern is that fine-tuning it on a new fault could make it forget the faults it already handles.

I would like to thank the authors for their response.

Setting aside the limited novelty of the paper, which the authors acknowledge, the rebuttal confirms that a main result (Table 3) was invalid. However, the authors provided neither the updated table nor a revised PDF with the new results, so the corrections cannot be verified. Moreover, the new scratch results in the response do not match the scratch column of Table 2 in the paper, which raises concerns. For example, Shelf J1 full has 88.4% in the paper vs. 55.5% final SR in the response. Even if the new results come from new training runs, such large difference should be explained. Lastly, the authors state that a single fault-conditioned policy performs as well as the library, which removes the main motivation of this work.

Given the above, I will keep my original score.

Thank you for your additional comments and for taking the time to review our work. We have now uploaded the revised PDF, which includes the corrected Table 3 and updated experimental results. We have also incorporated the corresponding clarifications into the paper to make the corrections and results easier to verify.

Regarding the numerical differences, the Scratch column in Table 2 and the scratch table in our response measure different quantities. Table 2’s Scratch column is the final success of the random-initialization policy at the library training budget, which is what the revised caption now states. Our response reported fresh random-initialization runs under the same protocol and metrics as the transfer runs (1M steps, 10 seeds; AUC, PDE, SR@20%, Final SR). The budgets and sets of runs differ, so the two are not expected to match. For Shelf J1_full, final success from scratch is high-variance (55.5 ± 21.2% across seeds in the fresh runs), so a value from one set of runs is not directly comparable to a mean from another. We will add the same-protocol 1M-step scratch metrics to Table 2 so that the scratch comparison uses the same budget and metrics as the transfer columns. The transfer columns are unchanged.

We hope the revised version addresses your concerns, and we appreciate your time and consideration.

Reviewer_WGMdOpenReview ↗
Rating
3
Confidence
2
Informativeness
3
Presentation
2
Soundness
2
Read review
Paper summary

This paper proposes Skill Library, a policy-reuse framework for fault-adaptive robot learning. The framework addresses the performance degradation of control policies following joint failures, as well as the substantial interaction cost required to retrain policies from scratch. During the offline phase, specialized reinforcement learning (RL) policies are trained for different task–fault combinations and stored in a library indexed by the task, affected joint, and fault severity. During online deployment, a policy is retrieved according to the detected fault condition. For known faults that are represented in the library, the corresponding fault-specific policy can be directly reused; for unseen or compound multi-joint faults, existing policies are used as initializations for further RL-based adaptation.

The authors evaluate the proposed framework in MuJoCo using a 7-DOF Franka Panda manipulator across four manipulation tasks: 8-Bin Sort, Shelf Placement, Horizontal Wall Pick-Place, and Vertical Wall Pick-Place. The experimental results show that fault-specific policy initialization can substantially improve adaptation efficiency in several critical fault scenarios, reducing the number of environment interactions required for recovery and, in some cases, achieving considerably higher success rates than initialization from the healthy policy or training from scratch.

Critical strengths

1.The paper addresses the problem of task recovery following joint failures during robot deployment, moving beyond conventional settings that primarily focus on task execution under nominal conditions or adaptation to environmental variations. This problem formulation broadens the application of reinforcement learning to fault-tolerant and adaptive robotic control and targets a practically relevant deployment scenario.

2.The authors explicitly organize policies according to both task and fault state, resulting in a clear workflow consisting of offline policy training, fault-aware retrieval, and subsequent policy reuse or fine-tuning. This design makes effective use of previously acquired control experience and can reduce the need to retrain a policy entirely from scratch whenever a failure occurs.

3.The experimental evaluation is relatively systematic. The proposed framework is evaluated across four manipulation tasks, with comparisons among training from scratch, initialization from a healthy policy, and initialization from a fault-specific policy.

Critical weaknesses

1.The paper assumes that, once a fault alarm is triggered, both the faulty joint and the severity of the fault are known accurately, effectively relying on oracle fault information for fault-matched policy retrieval. In practical robotic systems, however, fault type and severity typically need to be inferred from sensor observations and may be subject to detection or estimation errors. The current study therefore does not investigate how imperfect fault diagnosis could affect policy retrieval accuracy, adaptation efficiency, or overall recovery performance.

2.The experimental setup involves 60 task–fault policy mappings, corresponding to four tasks and fifteen fault conditions. As the number of tasks, fault types, and severity levels grows, the associated costs of offline policy training, model storage, and library maintenance may increase substantially. The paper does not provide a detailed analysis of the scalability of the library or quantify the trade-off between these offline costs and the benefits obtained during online adaptation.

3.All experiments are conducted in the MuJoCo simulation environment using a 7-DOF Franka Panda manipulator, with the evaluation focusing mainly on single-joint faults and a limited number of compound fault configurations. In real robotic systems, additional factors such as friction variation, sensor noise, actuator degradation, modeling errors, and coupled dynamics may affect adaptation performance. As a result, the current experiments do not yet establish whether the proposed framework can transfer reliably to physical hardware.

Questions for authors

1.How do the authors view the scalability of the proposed framework? Have approaches such as parameter sharing, policy compression, or reducing the number of separately trained policies been considered? 2.Have the authors compared the total cost of searching and fine-tuning multiple candidate policies with the cost of simply training a new policy from scratch? 3.The compound-fault experiments show that mild multi-joint faults can still be adapted to, while severe faults may be nearly unrecoverable. How do the authors distinguish between limitations of the adaptation algorithm and cases in which the robot is physically incapable of completing the task under the given fault configuration? Could additional reachability or kinematic analysis help characterize this performance ceiling? 4.The paper considers only two discrete levels of fault severity: half and full. In real robotic hardware, however, joint degradation is often continuous. How would the current discretely indexed Skill Library handle intermediate fault severities, or faults that gradually worsen over time?

3 comments

We would like to thank the reviewer for the detailed feedback and questions. We provide our point-by-point response below.

For Q1, We separate two costs: offline cost (building the library, one-time) and online cost (retrieval at each fault). The library scales linearly with the number of tasks and fault conditions (4 x 15 = 60 policies here). Storage isn't the cost driver, and the cost that scales is training (approx 37.5M RL steps per task for the 15 library policies on Wall-H). However, parallel training is well supported in GPUs.

We've tried reducing the number of separately trained policies by parameter sharing. We train one policy per task with the fault descriptor z (a one-hot vector over the 15 conditions) tacked on to the observation and sample one condition per episode. It has 12,807 parameters, as opposed to the ~163k for the 15 library policies, and plateaus around 10M steps. On Wall-H, it scores 93.2% on average (98% healthy, 100% on every fault except J3-full at 0%). On Wall-V, it scores 93.3% (13 of 14 faults at 100%, J3-full at 0%), which is within about 2 points of the library’s fault-matched sources on the faults both solve. Both methods fail on J3-full. On Wall-H compound faults, the conditioned policy matches the best library policy zero-shot on the feasible combinations with one exception (J0-full+J1-half).

These results are from one seed on two tasks. Two limitations remain. First, a single network would have to be updated when the fault set changes, and we haven't tested whether that would lead to forgetting of the original faults (the library circumvents this by having one policy). Second, we haven't tested per-fault adapters or a shared trunk with fault-specific heads, which we leave as future work.

Our approach naturally relies on a lightweight library of fault-specific policies rather than a single large-scale, general-purpose policy (i.e., a single conditional policy π(a | s, z) with z as a learned embedding, so only the embedding table grows with the number of faults). We considered training a minimal set of policies targeting the most frequently occurring faults (i.e., single-joint faults at two severity levels) and reusing them across a wide range of unseen fault conditions (e.g., combined faults).

For Q2, In our setting, we identify the fault first, so retrieving the matching policy is a direct lookup using the fault index and requires no search over candidate policies. We compared fine-tuning from the matched policy with training from scratch under the same 1M step budget (10 seeds). On 8-Bin J5-full, the library gets to 80% success in 11k steps (final SR 89.4%), whereas scratch never gets to 80% (final SR 27.5%). On 8-Bin J1-full, the final SR is 72.9% vs 29.6%. We didn't measure the total wall-clock cost. As a very rough guide, building one task’s library comes in at about 15 scratch-sized training sessions (15 x 2.5M steps), so it pays for itself after about 15 faults.

For Q3, We appreciate you raising such an insightful point, and we ran an additional test. We mark a fault as infeasible when the nearest reachable end-effector position, among 200,000 sampled free-joint configurations, is farther than 0.11 m from the start position or 0.12 m from the goal position. The healthy robot comes within 0.012 m and 0.011 m of them. The test uses hand position only, so it can prove infeasibility but not feasibility.

Of the 7 Wall-H compound faults we looked at, J0-full+J1-full (start 0.128 m, goal 0.413 m from the reachable set) and J0-half+J1-full (goal 0.181 m) are infeasible. After fine-tuning from any of the 15 library policies, both still score 0%, so these failures come from the robot’s physical limits, not the adaptation algorithm. The other 5 are feasible, and on each some library policy achieves 68% to 100% after fine-tuning. The split does not depend on the exact tolerances: any goal cutoff between 0.084 m and 0.181 m separates the two groups.

A feasible fault can still fail for algorithmic reasons: for J1-full+J1-full, fine-tuning from the nearest-fault policy achieves only 30%, whereas the best source achieves 99%.

For Q4,

Thanks for that suggestion. The current discretely indexed Skill Library can handle intermediate fault severities through retrieving the nearest-severity policies (i.e., full or half of the same joint) and fine-tuning. To show this, we ran an initial experiment with 30%/70% severity faults on all 7 joints in 8-Bin and Shelf (10 seeds). We fine-tuned from the nearest library severity (half) and compared that against the healthy policy. The nearest-severity policy performs best on the critical joints. On 8-bin J3 at 70% severity, we get AUC 0.979 and 99.6% final success compared to 0.780 and 89.6% from the healthy policy. On 8-bin J1 at 30% we have 98.7% final success versus 46.3%. It’s not a universal improvement, though: for several joints, the healthy policy is just as good; on Shelf J1, there’s no clear benefit, and J1 at 70% is not solved by any policy. We’ll include those results in the camera-ready.

For continuous joint degradation, we assume we can estimate the degradation rate and so calculating the severity at regular intervals and re-running the retrieval, which could be one direction of future work.

I appreciate the authors’ response and clarifications, which have partially addressed my initial concerns.

From OpenReview, CC BY 4.0. Authors as signed there; shown unedited.

Related papers

Loading the map…

Discussion (0)

Sign in to comment.