- Rating
- 3(+1)
- Confidence
- 3
- Informativeness
- 2
- Presentation
- 3(+1)
- Soundness
- 3(+2)
Read review
Paper summary
To address the need for robotic systems to adapt to contingencies in dynamic environments, this paper proposes Runtime-adaptive Policy refinement (RaP), which compiles supplied task programs into executable adaptive runtime programs composed of primitive skills, and uses an agent to refine these runtime programs over several rounds by maintaining hypotheses about skill behavior and about the coordination rules that determine which skills may proceed concurrently. The approach models the contingency adaptation problem as a generalized semi-Markov process (GSMP) in which exogenous events (e.g., a cart entering the workspace) and the controllable events of skills unfold concurrently, and defines a contingency as a change in which combinations of skill events may proceed together. This problem model provides clear, explicit components for the agent to hypothesize about and refine in order to construct a policy that can adapt to contingencies. Coordination rules are separated from the task program's control flow and kept as a persistent refinement target, so they carry over across refinement rounds and skills.
The approach is validated on three environments, each with multiple manipulator arms and one in the real world. For one environment the approach is also compared against three baseline "compile-execute-refine" approaches at three different agent reasoning efforts, and for another environment it is compared against two of the same baselines at one reasoning effort. The authors report higher average success rates over the baselines and present examples of re-use of adaptive coordination behavior across contingencies and skills.
Critical strengths
-
The problem formulation as a GSMP is nice and the proposed approach makes good use of this formulation. The factorization into skills and an explicit coordination predicate gives the refinement agent well-defined repair targets and makes hypothesis-based localization possible. The ablation suggests the explicit coordination semantics are the most effective component.
-
Well-designed contingency evaluation: each coordination requirement has several observable realizations, and held-out variants are disjoint from those seen during refinement. This directly tests the paper's central claim that refined coordination generalizes beyond the cases it was learned from.
Critical weaknesses
-
The results do not seem to support the paper's central contributions.
- The ablation does not show that the central contribution is responsible for the performance gains. In Table 1, AS + Coord. Guidance (without a kernel or hypotheses) reaches 50.5% vs AS at 41.7%, which is 8.8 of RaP's 11.6 percentage-point gain over AS. Hypotheses do improve results within the kernel variants (46.9% -> 53.3%), but both kernel variants without hypotheses (45.0% and 46.9%) score below guidance-only. At low effort, guidance-only is the best variant (59.0% vs RaP's 39.0%). The ablation therefore does not show that the runtime kernel contributes beyond explicitly maintaining coordination semantics as guidance for program repair. Since the ablation suggests most of the gain comes from a simpler variant, addressing this would likely require reframing the contribution rather than additional experiments.
- The headline performance gains are not statistically supported. Applying Welch's t-test to the per-seed "Avg." results in Tables 24 and 25, averaged across the two observation settings as in Table 1, I arrived at p$\approx$0.11 for RaP vs AS, and p$\approx$0.59 for RaP vs AS + Coord. Guidance (which is consistent with my preceding point regarding the impactfulness of the kernel/hypotheses). RaP demonstrates high variances in Table 1, and with only three seeds, the comparison is underpowered; the authors should report significance tests or confidence intervals. RaP at low reasoning effort (39.0%) also sits below AS (40.8%) in Table 1.
- The evidence for transfer of coordination rules (RQ3) is limited to a single run of 10 held-out cases at one reasoning effort, without the BT baseline.
-
Presentation is unclear at times and requires substantial effort to parse and understand in places, making it difficult to judge the paper's contributions.
- The paper uses a lot of dense jargon without explaining or illustrating clearly what it means upon first introduction. Several terms in the abstract and introduction appear to be synonymous, but the paper never says whether they are: "runtime coordination semantics", "runtime coordination knowledge", "execution knowledge", "runtime coordination rules", and "coordination condition". Other terms without clear plain-language explanation include "persistent refinement target", "applicability conditions", and "task compositions", to name a few, and there is no concrete example of what a hypothesis looks like until the appendix.
- Figure 1 is difficult to follow on its own, despite seemingly being intended as an introductory illustration for the paper. The task is not stated clearly, the mapping of the concurrent events to the execution timeline is not clear, and most importantly, it is not pictorially clear what refinements are being made between rounds and why.
- Section 3 is very dense and would benefit from illustrating examples and explanations throughout. The paper also over-relies on the appendix (often without pointers to it) for key parts of how the approach works; e.g., how coordination rules are actually represented (kernel rules with hold/yield transitions) is described only in Appendix A.2, which the main paper never references.
- No limitations section is given, which makes it difficult to assess the scope of the approach's applicability.
Questions for authors
- BT baseline (clarification): Why is BT omitted from RQ3? More generally, how were the baselines implemented? BT isn't a published method, and SG/BT start at 3--13% after translation (Tables 22–-23), so translation losses may dominate the comparison.
- Cross-task knowledge (clarification): Cross-task knowledge sharing is part of the method, but RQ2 refines a single task program. Is this mechanism evaluated anywhere?
- RQ3 evaluation (clarification): What does "logical evaluator" refer to, and how do the 10 held-out cases relate to the "five cases per state" in Appendix D.3?
8 comments
W2. The presentation requires substantial effort to follow: terminology, Figure 1, and the method need clearer examples and explanations, and an explicit limitations section is missing.
Terminology To resolve the ambiguity in terminology, we reorganized the coordination terminology into two levels. Coordination semantics denotes the whole object that refinement revises, and a coordination rule is a unit that composes the semantics. We introduce both terms in the Introduction, before they are used.
Figures We revised Figure 1 to show the task and the refinement targets explicitly, so that the concept of a contingency is explained alongside a concrete example.
We also added a method overview figure in Section 3 that follows the case in Figure 1 and details what refinements are made between rounds and why.
Broader applicability and limitations To examine the broader applicability of our framework, we present findings from our extended RQ2 evaluation, in which we use additional frontier models as coding agents at varying levels of reasoning effort. For each model, we report success rates averaged over three seeds and two event-information settings. Further details are provided in Appendix D.5.
With a strong coding model such as Claude Fable 5.2, the explicit coordination rules of RaP covered contingencies that AS handled only in later rounds. At both effort levels, RaP had higher success rates in Rounds 0 and 1, and the two methods reached similar success rates by Round 3.
| Reasoning effort | Method | Round 0 | Round 1 | Round 2 | Round 3 |
|---|---|---|---|---|---|
| low | RaP | 70.6 | 70.6 | 76.5 | 88.9 |
| low | AS | 33.3 | 59.3 | 81.9 | 89.0 |
| medium | RaP | 66.8 | 66.8 | 81.8 | 87.6 |
| medium | AS | 33.3 | 63.1 | 78.5 | 87.2 |
| Average | RaP | 68.7 | 68.7 | 79.2 | 88.3 |
| Average | AS | 33.3 | 61.2 | 80.2 | 88.1 |
A similar pattern emerged when we varied reasoning effort. Averaged over the five models tested at all four effort levels (GPT-6 Luna, GPT-6.1 Terra, GPT-5.6 Sol, GPT-6.1 Sol, and GPT-6 Astra), RaP reached a mean success rate of 51.3% at Round 0 with max effort, matching low-effort RaP after three refinement rounds, and improved to 69.1% by Round 3.
| RaP mean SR (%) | low | medium | high | max |
|---|---|---|---|---|
| Round 0 | 38.0 | 45.6 | 45.8 | 51.3 |
| Round 3 | 51.3 | 53.2 | 61.8 | 69.1 |
These trends are consistent with the view that anticipating contingencies in the initial policy, as RaP does, can support efficient contingency adaptation. Observable warning signs of a contingency can allow a robot to intervene before a failure occurs [A]. For example, a Round 0 program generated by Claude Fable 5.2 combined the reported state of the cart with current and projected workspace clearance to decide when an arm could enter the shared workspace.
We added a limitation and future direction paragraph to Section 5 stating that the predefined kernel, which bounds what coordination rules can achieve, remains outside the refinement loop.
Updated part : Section 1, Figure 1, Figure 2, Section 5, Appendix D.5
Q1. Why is BT omitted from RQ3, and how were the baselines implemented? SG and BT start at 3–13% after translation, so translation losses may dominate the comparison.
Baseline implementation We selected baselines whose representations can express runtime coordination, so that the comparison isolates where coordination is retained and refined. All methods use the same source task programs, primitive control and perception interfaces, and environment budget, and the refinement protocol follows ASPIRE [B].
- SG is built on the public GaP repository [C] and revises the computation graph translated from the source program.
- BT shares the refinement loop, the agent, and the budgets of SG and replaces the graph with a behavior tree. The tree is generated from the task program, as in LLM-based behavior-tree planning [D], and is repaired by local expansion at the failing node [E].
Translation loss analysis We translate every method from the same task program, instruction, and API documentation, so that the comparison also reflects how well each representation can be built from them.
Both SG and BT check the translated representation before execution and regenerate it when the check fails. SG keeps the validation of the public GaP implementation [C] with one added type check on subgraph inputs, and BT applies the same procedure to the tree.
SG builds its graph with a skill library and prompts prepared for its target environment, such as LIBERO, which suits its goal of moving from simulation to deployment [C]. A skill graph or a behavior tree fixes the dependencies among skills before execution, and the task program alone does not state them, so part of the source behavior can be lost at translation. The runtime kernel of RaP resolves these dependencies during execution, so a program compiles onto it without such preparation, as noted in Section 5.
This loss depends on the coding model. With Claude Fable 5.2, SG and BT start at 31.6% and 32.6% after translation, close to the 33.3% of the source program that AS repairs.
SR (%) before refinement for the Claude models in the extended RQ2 evaluation, averaged over low and medium reasoning effort.
| Method | Haiku 5.5 | Sonnet 5.5 | Opus 5.5 | Fable 5.2 |
|---|---|---|---|---|
| AS | 33.3 | 33.3 | 33.3 | 33.3 |
| SG | 2.8 | 13.5 | 15.6 | 31.6 |
| BT | 18.5 | 33.6 | 33.2 | 32.6 |
| RaP | 39.8 | 45.5 | 48.8 | 68.7 |
From this nearly equal start, SG and BT still end below AS and RaP after three rounds, which suggests that the difference does not come from translation loss alone.
BT in RQ3 BT was omitted from RQ3 because of the limited budget for real-world evaluation. SG and BT share the refinement loop and showed similar trends in RQ2, so we prioritized SG. The proxy evaluation in our response to Q3 now includes BT.
We sincerely appreciate the time and effort that the reviewer devoted to this review. We are happy to have received substantial feedback on how well our paper supports and presents its contribution. The statistical analysis that the reviewer carried out on our results and the specific suggestions on terminology, figures, and limitations were constructive for us, and they helped us understand the direction in which this research can bring value to the community. We also appreciate that the reviewer finds the GSMP formulation and the contingency evaluation well designed. Below we respond to each point with the extended results and clarifications.
To clarify the contribution of each component of RaP with more complete evidence, we extend the ablation to five seeds per method and reasoning effort, add the max reasoning effort, and compare two levels of coordination guidance for AS.
Extended ablation in Table 1. low, medium, high, and max are reasoning efforts of GPT-5.6 Sol. † Newly added comparison. p is the Holm-adjusted value of a two-sided exact stratified permutation test against RaP.
We implement coordination guidance for AS at two levels, AS + Coord Prompt and AS + Coord Refine (AS + Coord. Guidance in the submission). AS + Coord Prompt adds the guidance with only a prompt. The agent writes coordination definitions in its existing findings step and reads them in the next repair, with no additional stage or trial. AS + Coord Refine adds an explicit refinement stage to each round. It keeps these definitions in a separate store, and the added stage revises them from development traces before task-code repair, which approximates the refinement pipeline of RaP without the kernel representation. Its repair prompt also lets the agent add observations to the program and probe a development case before admission, which gives active observation without explicit hypotheses, so we mark it with a triangle under H.
SR rises with the level of coordination guidance, and no variant that lacks a component of RaP reaches the SR of RaP, which exceeds AS + Coord Refine by 9.6 percentage points on average. All five differences from RaP are significant under a two-sided exact stratified permutation test with Holm adjustment (p<0.01), computed over 40 runs per method (two event-information settings, four reasoning efforts, and five seeds). We have incorporated these results and their analysis into
Section 4.5andAppendix D.4of the revised paper.At low reasoning effort, the margin over the AS variants narrows because compilation loses more of the source behavior when the coding model has less capability to interpret the runtime kernel, as
Section 4.2shows across compiler models and reasoning efforts. The compiled program of RaP starts at 19.4% SR, below the 33.3% of the source program that every AS variant repairs. From this lower start, RaP gains the most from refinement, 28.9 percentage points against 13.9 for AS + Coord Refine. The extended RQ2 evaluation (Appendix D.5) shows the same dependence on the model. At low and medium effort, the compiled program of RaP starts at 39.8%, 45.5%, 48.8%, and 68.7% SR with Claude Haiku 5.5, Sonnet 5.5, Opus 5.5, and Fable 5.2.We also added the max reasoning effort to the RQ2 experiments and provide an additional analysis of RQ3 in our response to
Q3.Updated part : Section 4.5, Appendix D.4, Appendix D.5