acceptodds
Under review as a conference paper at ICLR 2027

Refining Programmatic Runtime Policies for Efficient Contingency Adaptation

Abstract

Robotic systems operating in dynamic environments require continual adaptation of coordination among reusable perception and control capabilities in response to concurrent events during execution. By bringing general-purpose programming abstractions to physical execution, programmatic policy frameworks provide an executable layer for orchestrating these capabilities into behavior, with an explicit organization that can be reconfigured using execution feedback. However, contingencies can alter runtime coordination among concurrently executing skills, while coordination embedded within task logic makes the refinement target ambiguous between skill behavior and coordination and leads to repeated recovery and validation across task compositions. We propose RaP, a *compile–execute–refine* framework that externalizes runtime coordination from generated task programs as a persistent refinement target and represents uncertainty over skill behavior and coordination as hypotheses. At *compile* time, RaP converts skill invocations into runtime-managed processes and augments the task program with conditional tests of these hypotheses. During *execution*, the runtime enforces coordination relations and records hypothesis-test outcomes, while *refinement* uses this evidence to target revisions to skill behavior or coordination conditions and distills validated repairs into reusable guidance with explicit applicability conditions. On long-horizon multi-arm manipulation tasks under concurrent events that alter coordination requirements, RaP achieves higher mean held-out success than task-program repair after three refinement rounds.

Primary area:
applications to robotics, autonomy, planning
Keywords:
Programmatic Policies, Runtime, Contingency Adaptation

Reviews

Among:
Shape:
1234this paper, Top 15%
Figure 1. Mean review rating of the reviewed papers at ICLR 2027. This paper averages 3.00 over 3 reviews, above 85% of the others.
Reviewer_5zKHOpenReview ↗
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

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.


W1. The results do not sufficiently support the central contributions: gains over guidance-only repair are small and effort-dependent, statistical support is weak, and transfer evidence is limited.

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. †^\dagger Newly added comparison. pp is the Holm-adjusted value of a two-sided exact stratified permutation test against RaP.

AblationsKKCCHHlowmediumhighmaxAveragepp
AS✗✗✗39.9 ± 2.338.4 ± 2.146.4 ± 8.840.6 ± 3.341.3 ± 1.6< 0.001
AS + Event Kernel✓✗✗37.5 ± 12.550.7 ± 13.056.4 ± 9.268.6 ± 7.853.3 ± 8.10.009
AS + Coord Prompt$^\dagger$✗✓✗40.7 ± 2.342.2 ± 5.749.5 ± 7.950.9 ± 7.145.8 ± 2.8< 0.001
AS + Coord Refine✗✓△47.2 ± 7.148.8 ± 8.948.1 ± 12.061.9 ± 6.651.5 ± 3.00.003
RaP w/o hypothesis✓✓✗40.7 ± 11.747.1 ± 10.154.5 ± 11.862.9 ± 6.351.3 ± 6.60.002
RaP✓✓✓48.3 ± 5.157.8 ± 11.865.4 ± 8.473.0 ± 4.661.1 ± 3.5–

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 HH.

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.01p < 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.5 and Appendix D.4 of 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.2 shows 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


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 effortMethodRound 0Round 1Round 2Round 3
lowRaP70.670.676.588.9
lowAS33.359.381.989.0
mediumRaP66.866.881.887.6
mediumAS33.363.178.587.2
AverageRaP68.768.779.288.3
AverageAS33.361.280.288.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 (%)lowmediumhighmax
Round 038.045.645.851.3
Round 351.353.261.869.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.

MethodHaiku 5.5Sonnet 5.5Opus 5.5Fable 5.2
AS33.333.333.333.3
SG2.813.515.631.6
BT18.533.633.232.6
RaP39.845.548.868.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.

Reviewer_cggTOpenReview ↗
Rating
3(+1)
Confidence
1
Informativeness
2
Presentation
1
Soundness
2
Read review
Paper summary

This paper presents RaP, a compile–execute–refine framework for adapting programmatic robot policies to execution-time contingencies. It separates skill behavior from runtime coordination, uses explicit hypotheses and execution traces to guide repairs, and retains coordination rules and applicability-conditioned repair guidance for subsequent use. Experiments examine runtime compilation, incremental contingency adaptation in multi-arm manipulation, and transfer of workspace-occupancy conditions across skills.

Critical strengths
  1. Meaningful problem and sensible architectural principle. Failures can arise from inappropriate coordination among otherwise functional skills. Treating coordination as an explicit repair target provides a useful alternative to repeatedly modifying task-specific code.

  2. Structured diagnosis and knowledge retention. Hypothesis-linked observations and execution traces help identify candidate repair targets, while explicit applicability conditions provide a reasonable basis for retaining and reusing repair knowledge.

  3. Useful empirical analysis. The evaluation includes several program-refinement baselines, component ablations, and different reasoning-effort settings, providing evidence about both the benefits and limitations of the proposed framework.

Critical weaknesses
  1. The methodological novelty is primarily architectural. The contribution organizes event-driven execution, coordination rules, and hypothesis-based checks into a refinement framework. The paper does not sufficiently establish why this complete combination is necessary beyond simpler coordination-aware program repair.

  2. The additional benefit over a strong, simple alternative is limited. AS + Coordination Guidance achieves 50.5% mean success, compared with 53.3% for full RaP. Although RaP shows stronger gains at higher reasoning effort, its advantage is not consistent across effort settings, weakening the evidence that the additional machinery delivers a reliable practical improvement.

  3. The evidence for cumulative adaptation and reuse remains preliminary. The principal adaptation results evaluate separate subtask episodes within a representative task, while the transfer study largely applies the same occupancy condition to different skills. The reported 7/10 transfer result comes from a logical evaluator; together, these studies do not yet convincingly demonstrate sustained coordination-knowledge accumulation and reuse across substantially different task compositions.

Questions for authors
  1. Could the authors show how retained coordination knowledge evolves across rounds, including its applicability conditions, interactions with existing rules, and reuse in previously unseen task compositions?

  2. What explains the effort-dependent advantage over AS + Coordination Guidance, and how do the methods compare in refinement cost, execution probes, and success under matched resource budgets?

  3. Could the authors distinguish logical-evaluator results from repeated physical-robot outcomes and provide stronger quantitative evidence of coordination transfer in real execution?

9 comments

We sincerely appreciate the time and effort that the reviewer devoted to this review. We are grateful that the reviewer finds the problem meaningful, the diagnosis and knowledge retention well structured, and the empirical analysis useful. The questions build on each of these points and ask for the evidence that they need. Below we respond to each point with additional analysis and clarifications.


W1. The methodological novelty is primarily architectural, organizing event-driven execution, coordination rules, and hypothesis-based checks into a refinement framework. The paper does not sufficiently establish why this complete combination is necessary beyond simpler coordination-aware program repair.

Design principles To ground programmatic policies for efficient contingency adaptation, we model contingencies as exogenous events in a GSMP. This lets a policy specify when to combine predefined APIs without enumerating every possible combination. As the programming capabilities of frontier models advance, this representation could serve as a common foundation for contingency adaptation across tasks and a bridge from model knowledge to explicit coordination rules that can be inspected and refined.

We keep these rules separate from skill behavior because a contingency can change when a skill should proceed even if the skill itself still works as intended. We handle this timing during execution, in line with approaches that check a manipulation constraint with generated code [A] or interrupt a running policy from visual feedback [B]. We then make the rule itself a target of refinement, so a revision applies to every skill that shares it.

Design choices Each component of RaP reflects the following design choice.

  • Event-driven kernel. The kernel runs skills as the asynchronous events of a GSMP and enforces coordination rules on these events, decoupled from the control flow of the task program. A rule therefore holds wherever its condition arises during execution. In implementation, these rules are close to the runtime rules that are enforced on LLM agents, each with a trigger, a predicate, and an enforcement action [C].
  • Coordination semantics. On the kernel, skills run as concurrent events, so the control flow of the task program no longer decides which combinations of events may proceed together. That decision is stated in the coordination semantics, with one rule for each condition under which the skills in its scope may proceed. A contingency changes such a condition and leaves the skill sequence unchanged, so it is repaired in the rule, which makes the coordination semantics the natural target of refinement.
  • Hypotheses. A coordination rule depends on what the agent infers about the robot and the environment, and many rules are possible for one contingency. A hypothesis records one such inference with a test, which runs on the kernel as a monitoring process beside the skills. While a rule applies, the test observes whether the condition of the rule occurs and whether its recovery resolves the contingency. These observations reduce the uncertainty of the agent about which inference holds [D], so the agent learns more about the environment from the same executions.

Following these design choices, the extended ablation in our response to W2 shows the contribution of each component. For clarity, we also revised Figure 1 and added Figure 2 to the method section, so that the task, a contingency, and the refinements made between rounds are shown explicitly.

Updated part : Figure 1, Figure 2


W2. The additional benefit over a strong, simple alternative is limited, with 50.5% mean success for AS + Coordination Guidance against 53.3% for full RaP. Although RaP shows stronger gains at higher reasoning effort, its advantage is not consistent across effort settings, which weakens the evidence of a reliable practical improvement.

Q2. What explains the effort-dependent advantage over AS + Coordination Guidance, and how do the methods compare in refinement cost, execution probes, and success under matched resource budgets?

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. †^\dagger Newly added comparison. pp is the Holm-adjusted value of a two-sided exact stratified permutation test against RaP.

AblationsKKCCHHlowmediumhighmaxAveragepp
AS✗✗✗39.9 ± 2.338.4 ± 2.146.4 ± 8.840.6 ± 3.341.3 ± 1.6< 0.001
AS + Event Kernel✓✗✗37.5 ± 12.550.7 ± 13.056.4 ± 9.268.6 ± 7.853.3 ± 8.10.009
AS + Coord Prompt$^\dagger$✗✓✗40.7 ± 2.342.2 ± 5.749.5 ± 7.950.9 ± 7.145.8 ± 2.8< 0.001
AS + Coord Refine✗✓△47.2 ± 7.148.8 ± 8.948.1 ± 12.061.9 ± 6.651.5 ± 3.00.003
RaP w/o hypothesis✓✓✗40.7 ± 11.747.1 ± 10.154.5 ± 11.862.9 ± 6.351.3 ± 6.60.002
RaP✓✓✓48.3 ± 5.157.8 ± 11.865.4 ± 8.473.0 ± 4.661.1 ± 3.5–

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 HH.

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.01p < 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.5 and Appendix D.4 of 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.2 shows 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.

Updated part : Section 4.5, Appendix D.4, Appendix D.5


Refinement budget Refinement in our experiments has two budgets, environment executions and coding-agent cost.

For environment executions, each round introduces new contingency conditions with one development episode for each, which gives 11, 10, and 6 episodes in Rounds 1, 2, and 3. Every method refines on these episodes and on three validation episodes that both the current program and the candidate execute.

For coding-agent cost, the table below reports the model cost in USD of each run, from initial compilation through the three refinement rounds. We estimate it from the token usage reported by Codex, with separate rates for uncached input, cached input, and output tokens. As in the ablation table above, each effort column averages five seeds and two event-information settings.

AblationsKKCCHHlowmediumhighmax
AS✗✗✗3.154.245.417.68
AS + Event Kernel✓✗✗2.003.576.4810.72
AS + Coord Prompt$^\dagger$✗✓✗3.214.505.878.80
AS + Coord Refine✗✓△3.024.185.9910.86
RaP w/o hypothesis✓✓✗2.053.725.8811.85
RaP✓✓✓3.325.298.9419.87

At a matched cost, RaP reaches a higher SR than AS + Coord Refine, with 65.4% for 8.94 USD at high effort against 61.9% for 10.86 USD at max effort.

Updated part : Appendix D.2

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

This paper presents the RaP framework, which explicitly represents runtime coordination as maintainable objects. It asks how execution feedback can be used to improve control programs and thus better prepare a robot for unforeseen situations. RaP turns skill invocations into processes executed at runtime, where the assumptions about the underlying skill and coordination are checked and logged. After execution, an agent consuming the observed data can apply changes to skill implementations, task code, or coordination rules. In some cases, the fixes can be packaged as recommendations with a defined scope of applicability, acting as references for later tasks. While this enables simultaneous motion in the BiCoord dual-arm task setting, it may come with a lower success rate due to possible compilation errors. In the Quadmanual four-arm environment, RaP outperforms leading baselines in terms of average success rate, and evaluations against a logic-based assessor provide the first evidence for cross-skill transfer.

Critical strengths
  1. Transforming knowledge of coordination relationships into explicit, maintainable, and updatable objects, and applying these within the processes of robot execution and program repair—also provides a reusable infrastructure.

  2. The paper provides a detailed and comprehensive description of the various runtime mechanisms, making it easier for the reader to understand how the coordination definitions are concretely translated into robot behaviors.

  3. The RaP framework achieved higher average performance in most major experiments designed to assess adaptability to unforeseen situations.

Critical weaknesses
  1. RaP is only evaluated on subtasks but not on long-horizon task sequences. These tests thus ignore important cross-subtask interactions and accumulated errors that raise many questions about performance in everyday, multistage task settings.

  2. This performance gain is, however, limited to 2.8 percentage points. The drop in performance under low reasoning effort is too dramatic: the success rate falls compared to AS + Coord.

  3. RaP cannot reliably enforce runtime coordination constraints. There is an example in Figure 4 where the cart-entry constraint fails even after imposing explicit coordination rule between robot and cart. Given the rather questionable overall success rate of 53.3%, there are further concerns about the reliability of the proposed approach.

Questions for authors
  1. In this paper, the new experimental evidence on cross-skill transfer is introduced under this idea of a "logic evaluator," so what does it mean in reality? Indeed, in what proportion are the cases that happened in an actual physical world setting?

  2. Are they suitable for evaluating long-run tasks and cross-task reuse? Because there is no direct evidence in this paper that shows any gain from using a knowledge base over independent tasks.

7 comments

We sincerely appreciate the time and effort that the reviewer devoted to providing constructive feedback. We were glad to see our framework examined from the view of everyday, long-horizon tasks, and these questions showed us where this research should connect next. We have made this direction explicit in the revised paper. We are also grateful that the reviewer values explicit coordination knowledge as a reusable infrastructure and finds our description of the runtime mechanisms helpful. Below we respond to each point with clarifications and additional results.


W1. Q2. RaP is evaluated only on subtasks and not on long-horizon task sequences, so cross-subtask interactions and accumulated errors in everyday, multistage task settings remain untested. Is this evaluation suitable for long-run tasks and cross-task reuse, given that there is no direct evidence of a gain from using a knowledge base over independent tasks?

To clarify cross-subtask interactions, we discuss how errors accumulate between subtasks within a longer-horizon episode and provide the scope and an example of knowledge reuse across refinement rounds.

Cross-subtask interactions within an episode Our experiments evaluate the response to contingencies in Quadmanual, a long sorting task in which four arms deliver six bottles and each delivery is one subtask with pick, handover, and place stages. We evaluate each subtask in separate episodes so that each outcome reflects this response, apart from effects accumulated over earlier subtasks. In a full sequence, the task program given before compilation returns the arms to their start poses after each delivery, so an error in robot behavior during one subtask rarely propagates to the next subtask. A state that one subtask leaves in the environment may affect the next subtask, such as the occupancy of a shared workspace or a bottle that shifts in the gripper while an arm waits in response to a contingency. The coordination rules of RaP can read such a state at any stage once a sensor reports it, without a change to the kernel.

In long-horizon task sequences at the level of continuous everyday operation, an accumulated error whose cause lies many stages earlier remains an open problem. Finding such a cause requires a long execution trace, and methods that summarize robot experience as feedback [A] can be combined with RaP, which takes the feedback as input and designs what refinement revises. We have stated this evaluation scope in Section 4.3 and added this direction for multistage tasks under our contingency formulation to the limitation and future direction paragraph.

Cross-subtask knowledge reuse across rounds In RQ2, refinement proceeds per subtask, and what the subtasks share is kept in the task program and in the knowledge K\mathcal{K}. When a development case of one subtask fails, the coding agent revises the part of the program for that subtask. At the end of a round, these revisions update the task program for the next round, and advisory knowledge promoted from admitted repairs is stored in K\mathcal{K}. Each subtask, with its own goal and route and separate evaluation episodes, is our unit of knowledge sharing, in the role that a task has in ASPIRE [B]. Sharing between such related units through a common representation is the setting in which transfer is expected to hold [C, D].

We observe this reuse in both RQ2 and RQ3. In one RaP run of RQ2, an admitted repair solved two failed development cases, one in T3 and one in T4, and RaP promoted it to a knowledge entry in K\mathcal{K} for the next two refinement sessions. In another run, T3 and T4 share one workspace-clearance rule, so its revisions in Rounds 2 and 3 applied to both subtasks, and RaP succeeded in 25, 43, and 58 of the 58 held-out cart cases after Rounds 1, 2, and 3. In RQ3, RaP applied the occupancy condition from one handover case to placement and succeeded in 7 of 10 held-out cases on the physical robot, while AS kept the condition in the handover step and succeeded in 2. We detail these results in our responses to 5zKH Q2 Example, cggT Q1, and 5zKH Q3 Held-out cases and Success count, respectively.

To make this scope clearer, we have stated in Section 4.3 and Appendix D.2 that knowledge sharing in our experiments is between subtasks, and we refer to this scope as "cross-subtask".

Updated part : Section 4.3, Section 5, Appendix D.2


W2. In the ablation, the performance gain of RaP over AS + Coord is limited to 2.8 percentage points. Under low reasoning effort, the performance drops sharply, and the success rate of RaP falls below AS + Coord.

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. †^\dagger Newly added comparison. pp is the Holm-adjusted value of a two-sided exact stratified permutation test against RaP.

AblationsKKCCHHlowmediumhighmaxAveragepp
AS✗✗✗39.9 ± 2.338.4 ± 2.146.4 ± 8.840.6 ± 3.341.3 ± 1.6< 0.001
AS + Event Kernel✓✗✗37.5 ± 12.550.7 ± 13.056.4 ± 9.268.6 ± 7.853.3 ± 8.10.009
AS + Coord Prompt$^\dagger$✗✓✗40.7 ± 2.342.2 ± 5.749.5 ± 7.950.9 ± 7.145.8 ± 2.8< 0.001
AS + Coord Refine✗✓△47.2 ± 7.148.8 ± 8.948.1 ± 12.061.9 ± 6.651.5 ± 3.00.003
RaP w/o hypothesis✓✓✗40.7 ± 11.747.1 ± 10.154.5 ± 11.862.9 ± 6.351.3 ± 6.60.002
RaP✓✓✓48.3 ± 5.157.8 ± 11.865.4 ± 8.473.0 ± 4.661.1 ± 3.5–

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 HH.

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.01p < 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.5 and Appendix D.4 of 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.2 shows 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.

Updated part : Section 4.5, Appendix D.4, Appendix D.5


W3. RaP cannot reliably enforce runtime coordination constraints. In Figure 4, the cart-entry constraint fails even after an explicit coordination rule between the robot and the cart is imposed, and the overall success rate of 53.3% raises further concerns about the reliability of the approach.

To address the concern about reliability, we clarify the design principles of RaP and analyze the results of our extended RQ2 evaluation (Appendix D.5.2).

Design principles To ground programmatic policies for efficient contingency adaptation, we model contingencies as exogenous events in a GSMP. This lets a policy specify when to combine predefined APIs without enumerating every possible combination. As the programming capabilities of frontier models advance, this representation could serve as a common foundation for contingency adaptation across tasks and a bridge from model knowledge to explicit coordination rules that can be inspected and refined. This prospect motivated our extended RQ2 evaluation. To test whether a task-independent programming representation could help us draw more effectively on the common knowledge of frontier models, we compared success rates on held-out cases across coding models and reasoning effort levels.

Extended RQ2 With Claude Fable 5.2 as the coding agent, refined programs handled held-out contingencies more reliably than with GPT-5.6 Sol at both low and medium reasoning effort. After Round 3, RaP reached a mean success rate of 88.3%, compared with the 53.3% of the submission with GPT-5.6 Sol, and AS came close at 88.1% by revising its task code.

Mean success rate (%) of Claude Fable 5.2 in the RQ2 experiment, averaged over low and medium reasoning effort.

MethodRound 0Round 1Round 2Round 3
AS33.361.280.288.1
RaP68.768.779.288.3

In this regime, where refining the task code alone is already effective by Round 3, the two methods differ in the early rounds. RaP outperformed AS on held-out cases in Rounds 0 and 1 on average. The initial rules of RaP already covered some cases that AS handled only after refining on the evidence given incrementally in later rounds. For example, one Round 0 RaP program generated by Claude Fable 5.2 combined the reported cart state with current and projected workspace clearance to decide when the arm could enter.

Efficient contingency adaptation should make the best use of the available information to prepare in advance, and should refine well from execution feedback. When the available information includes a known safety requirement, a shield can use its formal specification to restrict actions at runtime [E]. For both, RaP keeps explicit coordination rules as the refinement target. A coding agent writes the given information into these rules in advance, a known requirement can be added to them in the same form, and refinement revises them from feedback. The results above and the rise from 48.3% to 73.0% across the reasoning efforts of GPT-5.6 Sol in our response to W2 suggest that the reliability of RaP improves with the capability of the coding agent.

Updated part : Appendix D.5

Comments on the paper

1 comment

We sincerely appreciate the time and effort devoted to reviewing our work. Below we summarize the shared strengths, the main concerns, and our responses, with pointers to the reviewer-specific discussions.


Strengths

  • Well-defined and reusable repair targets, from keeping coordination as an explicit, maintainable object. hFtL cggT 5zKH
  • Well-designed contingency evaluation with held-out variants, baselines, and component ablations, and higher performance in adaptability to unforeseen situations. hFtL cggT 5zKH
  • A meaningful problem with a clear definition of a contingency, formulated as a GSMP of which the approach makes good use. cggT 5zKH
  • Structured diagnosis through hypothesis-linked observations and execution traces. cggT 5zKH

Concerns and Responses

  • Contribution and empirical support.

    • Contribution beyond coordination guidance. We clarify the design choice behind the event-driven kernel, the coordination semantics, and the hypotheses, and we extend the ablation to five seeds and four reasoning efforts. RaP reaches a higher success rate than every variant that lacks one of its components, and each difference is statistically significant. hFtL W2 cggT W1 W2 5zKH W1
    • Dependence on reasoning effort. We analyze the margin at low effort and show that RaP gains the most from refinement, even from a lower start after compilation. We also add an evaluation across coding models, in which this start rises with the capability of the model. hFtL W2 cggT Q2 5zKH W1
  • Physical evaluation and runtime reliability.

    • Logical evaluator and physical execution. We clarify that every reported success in RQ3 is measured on the physical robot, and that the logical evaluator screens each program before execution for safety, with a screened-out case counted as a failure. We also examine RQ3 at a larger scale with a proxy evaluation, in which the screening result replaces execution on the robot, over five runs per method at each of four reasoning efforts and with BT included. hFtL Q1 cggT Q3 5zKH Q3
    • Runtime reliability. We report and analyze an extended RQ2 evaluation with further frontier models. The success rate of RaP rises with the capability of the coding agent, and its initial rules already cover contingencies that AS handles only after later rounds. hFtL W3 5zKH W2
  • Long-horizon adaptation and knowledge reuse.

    • Evaluation scope. We clarify that each subtask is evaluated in separate episodes so that each outcome reflects the response to a contingency. We discuss how effects pass between subtasks within an episode, where an error in robot behavior rarely propagates and a state left in the environment can be read by the coordination rules. We state this scope in the revised paper and add the direction for multistage tasks to the limitation and future direction paragraph. hFtL W1 cggT W3
    • Knowledge accumulation and reuse. We clarify that knowledge sharing in our experiments is between subtasks, each of which serves as the unit of sharing. We trace how a shared rule evolves across rounds and show that one revision applies to every subtask that shares it. We also show in RQ3 that a condition learned at one skill applies to another skill. hFtL Q2 cggT Q1 5zKH Q2 Q3

Further Responses

  • Presentation and limitations. We reorganize the coordination terminology into two levels, revise Figure 1 to show the task and the refinement targets, add a method overview figure (Figure 2), and add a limitation and future direction paragraph. 5zKH W2
  • Baseline implementation and translation loss. We describe how SG and BT are built and report the success rate before refinement for the Claude models, where SG and BT start close to the source program with Claude Fable 5.2 and still end below AS and RaP after three rounds. 5zKH Q1
  • Refinement budget. We report the environment executions and the coding-agent cost of every ablation variant. At a matched cost, RaP reaches a higher success rate than AS + Coord Refine. cggT Q2

Revision Index

  • Section 1, Figure 1 Coordination terminology in two levels and the revised overview figure.
  • Figure 2 Method overview figure in Section 3.
  • Section 4.3, Appendix D.2 Evaluation scope and cross-subtask knowledge sharing.
  • Section 4.4, Appendix D.3 Logical evaluator, held-out cases, and proxy evaluation of RQ3.
  • Section 4.5, Appendix D.4 Extended ablation with five seeds and four reasoning efforts.
  • Section 5 Limitation and future direction paragraph.
  • Appendix D.5 Extended RQ2 evaluation across coding models and reasoning efforts.

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

Related papers

Loading the map…

Discussion (0)

Sign in to comment.