acceptodds
Under review as a conference paper at ICLR 2027

PLAN AROUND CHANGES, LEARN FROM VIOLATIONS: PERSISTENT TASK STATE FOR LONG-HORIZON VLA AGENTS

Abstract

Failure is not a diagnosis. In a failed long-horizon robot task, the user may have changed the goal, the world may have invalidated a grounding, the planner may be following an obsolete goal occurrence, or the policy may simply have executed poorly. Two common adaptation strategies reconstruct task state from accumulated history or train on failed trajectories. The first can forget commitments that still hold; the second can learn from events for which the agent was never responsible. We introduce CoPE, a two-timescale adaptation framework built around persistent task state. It gives each commitment a stable occurrence identity and tracks whether that occurrence remains authoritative and grounded. At runtime, CoPE revises affected commitments and recompiles the current planning problem. Across episodes, violations of still-valid commitments attach corrective supervision to the same occurrence; legitimate task and world changes remain state transitions rather than training targets. Across complementary controlled, simulator, and learned-policy studies, the same task-side state is exercised through both time scales. In controlled state scaling, local persistent updates remain stable as the state grows from 4 to 16 to 32 commitments, while full-state regeneration falls from 30/36 to 13/36 to 8/36 valid transitions; at 32 commitments, 27/28 full-state errors contain preservation drift. On 1,200 prospective records, occurrence-level responsibility improves the respective routing metrics by 6.67–11.50 percentage points over episode-level, terminal-skill, and flat-trace baselines. We further carry occurrence identity through actual OpenVLA adapter updates and occurrence-gated deployment, where all 18 dynamic runs switch at the designated task occurrence with exact planning and no history corruption or invalid transaction. Persistent commitments therefore tell an agent what to re-plan now and which component—if any—should learn later.

Primary area:
applications to robotics, autonomy, planning
Keywords:
robot learning, vision-language-action models, long-horizon task planning, persistent task state, runtime adaptation, credit assignment, continual learning

Reviews

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

This paper proposes CoPE, a persistent task-state framework for long-horizon vision-language-action (VLA) agents, designed to support runtime replanning and failure responsibility attribution in dynamic environments. CoPE maintains structured task commitments with stable occurrence identities, allowing local state updates while preserving unaffected commitments. By leveraging occurrence-level information, the framework further aims to identify the modules responsible for execution failures and guide policy adaptation through occurrence-gated deployment. The authors evaluate CoPE on controlled state-scaling tasks, a failure attribution benchmark, LIBERO simulations, and OpenVLA post-training experiments. The results demonstrate improvements in task-state consistency, update efficiency, and failure attribution accuracy over the evaluated baselines.

Critical strengths

Well-motivated problem formulation and unified framework. This paper addresses an important challenge in long-horizon VLA agents: distinguishing legitimate task changes from genuine execution failures. By introducing persistent task states with occurrence-level identities, CoPE provides a unified framework for runtime replanning, failure attribution, and policy adaptation. This is a meaningful contribution, as it offers a systematic approach to maintaining task consistency and supporting targeted adaptation in dynamic environments.

Critical weaknesses

Strong dependence on accurate task-state estimation and limitations in failure attribution.

CoPE relies heavily on the accurate interpretation of task and environmental events to maintain its persistent task state. However, in realistic environments, noisy observations, ambiguous instructions, or missing events may lead to incorrect state updates, potentially propagating errors to subsequent replanning and failure attribution. Furthermore, identifying a violated commitment does not necessarily establish which module is responsible for the failure, particularly when failures arise from interactions among multiple components. The paper provides limited discussion or empirical evidence regarding how CoPE handles such uncertainties and complex failure scenarios. This raises concerns about the framework's robustness and reliability in real-world deployments.

Limited downstream performance gains and insufficient experimental validation.

Although CoPE demonstrates improvements in task-state consistency and failure attribution, the benefits for downstream task success remain less convincing. In the LIBERO experiments, CoPE achieves the same success rates as FSR-PC (17/20 in Stage B and 9/15 in Stage C). Similarly, the OpenVLA post-training experiments show only a marginal improvement over the All-Failure baseline (9/18 vs. 8/18). These results make it difficult to assess whether the proposed framework offers meaningful advantages in end-to-end robotic performance.

Furthermore, the experimental comparisons are insufficient to establish CoPE's advantages over strong alternative approaches. The evaluation also relies substantially on custom benchmarks, particularly the 1,200-record mixed-event failure attribution benchmark, for which the data construction process, event distribution, and annotation procedures are not described in sufficient detail. These limitations raise concerns about the strength of the empirical evidence, the fairness of the comparisons, and the generalizability of the reported findings.

Questions for authors
  1. End-to-end performance: Given that CoPE achieves the same task success rates as FSR-PC in LIBERO and only marginally outperforms the All-Failure baseline in OpenVLA post-training, could the authors provide more extensive experiments to demonstrate whether the proposed framework yields meaningful improvements in end-to-end task performance?
  2. Benchmark construction and transparency: Could the authors provide additional details about the construction of the 1,200-record mixed-event benchmark, including the data generation process, annotation procedures, and distribution of different event types and failure categories? Such information would help assess the reliability and representativeness of the benchmark.
  3. Robustness to imperfect task states: How does CoPE perform when task states are inaccurate or incomplete due to noisy observations, ambiguous instructions, or missing events? It would be valuable to evaluate the sensitivity of both replanning and failure attribution to these sources of uncertainty.
  4. Component contributions and complex failures: Could the authors provide more detailed ablation studies to disentangle the individual contributions of occurrence identity, lineage, grounding, and provenance to failure attribution performance? Additionally, how does CoPE handle failures arising from interactions among multiple modules, where responsibility cannot be attributed to a single component?
  5. Clarity and organization: The presentation could be improved in terms of clarity and conciseness. Several important methodological and experimental details are deferred to the appendix, making it difficult to fully understand and evaluate the proposed framework based on the main text alone. I encourage the authors to streamline the subsection structure, simplify unnecessarily technical descriptions, and incorporate essential methodological and experimental details into the main text. These revisions would help readers better understand the core contributions and assess the significance of the empirical findings.
3 comments

Thank you for recognizing CoPE's motivation. Our work addresses two costs in long-horizon robot tasks: repeatedly figuring out what remains to be done, and collecting training data without knowing what went wrong.

1. Why maintain task state when task success is similar?

Suppose a user asks for an object in basket A, temporarily changes the destination to B, then cancels B. The robot needs to recover A and its remaining work. Repeatedly reading the full history takes time and can lead to mistakes.

CoPE keeps the current requests, their relationships, and their changes in a persistent state. It updates affected parts while preserving the rest.

Table 2 measures update cost. At 32 commitments, CoPE generates 6,891 output tokens across 36 calls, compared with 191,787 for full-state regeneration. Other local-update methods achieve similar efficiency.

Table 3 measures what earlier information remains available. In LIBERO Stage C, CoPE and FSR-PC both succeed in 9/15 cases. However, CoPE retains occurrence IDs in 15/15 cases and achieves historical audit coverage of 1.000, compared with 0/15 and 0.344 for FSR-PC. Adding provenance to FSR-PC raises coverage to 0.933. The audit measures whether historical information can be retrieved, which matters when restoring requests or examining past failures.

2. How was the 1,200-record benchmark built?

We used controlled fault injection across four held-out-task folds of 300 records. Events include 504 object movements, 333 temporary unavailability cases, 142 new preferences, 103 reissued goals, 72 cancellations, and 46 no-go restrictions.

Reference labels cover 320 policy, 160 editor, 160 planner, 120 verifier, and 80 multi-module failures, plus 240 no-update and 120 abstain cases.

For each record, we compared normal execution with an injected-fault continuation from the same state. A deterministic program checked the component outputs and available counterfactual evidence. Records were accepted only when the measured cause matched the predefined assignment and all required checks passed.

Labels were hidden from the evaluated models. They describe verified controlled interventions, not human annotations of natural failures.

3. What if the stored state is wrong?

CoPE checks proposed changes before saving them, including task references, legal status changes, and relationships between requests. Invalid changes leave the previous state unchanged.

Our validation pipeline rejected all 88 targeted injected faults. This addresses the tested state-update errors. Misunderstood instructions or missed observations may still produce plausible but incorrect updates, which require further evaluation.

4. How do we assign responsibility?

Our second goal is to use expensive robot training data more carefully. A changed goal, a planning mistake, and a failed grasp may require different corrections.

CoPE retrieves the task state at the time of failure to see which request was valid, what was expected, and what actually happened. It can assign several modules or leave the decision unresolved.

On the frozen benchmark, CoPE's F1 for editor/planner/policy/verifier is 0.875/0.923/0.536/0.505, compared with 0.842/0.943/0.528/0.468 for Generic Persistent. Macro F1 is 0.710 versus 0.695. The results are close overall.

Each state component has a role. Occurrence identity separates repeated requests; lineage tracks replacements and restorations; grounding links requests to objects; provenance records accepted changes and evidence. Table 3 examines some of these properties. Their individual effects on responsibility assignment, including complex multi-module failures, need further testing.

5. Does this improve robot learning?

We used responsibility decisions to select correction examples and train actual OpenVLA adapters with matched budgets.

In the full frozen dynamic evaluation, CoPE succeeds in 9/24 runs versus 8/24 for All-Failure. The paper's 9/18 and 8/18 figures came from a later six-state subset. The success difference is small, while the training data selection shows how responsibility information can focus corrections on the relevant task.

CoPE also records which task occurrence an adapter belongs to. In the clean-retention test, all 9/9 cases stayed on the original policy and succeeded because the adapter was inactive.

The same task information supports both goals: helping the robot avoid repeatedly reconstructing earlier requests, and helping us decide what needs correction after a failure. We would make these points and the key experimental details clearer in the main text.

Thank you for your detailed and thoughtful responses. I appreciate the authors' efforts to address my concerns and clarify the motivation, benchmark construction, and experimental results.

After carefully considering the rebuttal, I am sorry that I will maintain my original rating, as my major concerns regarding the empirical validation and overall presentation of the paper remain. Nevertheless, I believe the research problem is meaningful and the proposed framework has potential.

Beyond the technical aspects discussed above, I would encourage the authors to substantially revise the paper's presentation. In particular, I would recommend studying Best Paper Award-winning papers at leading conferences in related research areas, paying attention to:

  • How to establish the research context and clearly articulate the key motivation.
  • How to organize and present the proposed methodology in a coherent and intuitive manner.
  • How to design and present experiments that convincingly demonstrate the necessity and advantages of the proposed approach.
  • How to improve the quality, clarity, and informativeness of figures, which are also important factors in reviewers' assessment of a paper's overall quality.

I sincerely hope the authors will take these suggestions as constructive feedback. I believe that with further experimental validation and substantial improvements to the presentation, this work could become a much stronger contribution.

I wish the authors all the best in revising this work and sincerely hope that an improved version of the paper will find a good home at a leading conference in the future.

Thank you so much for your thoughtful and encouraging response. I really appreciate the time you took to read our work and offer such detailed advice!

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

This paper proposes CoPE, a framework that maintains persistent task state for long-horizon VLA agents. It tracks commitment occurrences, whether they remain authoritative, and their override and restoration history. The same occurrence identity is used for runtime adaptation, responsibility routing, and adapter deployment.

Critical strengths
  1. The paper makes a useful distinction between changes to a task and failures to satisfy requirements that still hold. This is particularly relevant when tasks are repeatedly interrupted or revised.
  2. The paper provides a complete implementation, including local state updates, robot simulation, and actual OpenVLA adapter training and deployment. The state-scaling experiments also clearly demonstrate the reliability of local updates.
Critical weaknesses
  1. The benefit of CoPE’s specific design is still unclear. Table 2 shows that the other local-edit controls also remain stable as the state grows. Neutral Typed shares CoPE’s semantic executor, so this comparison does not isolate what the proposed transition semantics contribute. Table 3 also reports the same task success counts for CoPE and FSR-PC in both Stages B and C. I would like to see clearer evidence of how the proposed transition semantics improve task execution beyond the benefits of local updates.

  2. An important routing baseline is missing. Table 1 omits Generic Persistent, which retains occurrence IDs and is used in the policy-update study. The paper also needs to clarify how responsibility labels were assigned to the 1,200 records. Without this information, it is difficult to judge what the reported routing improvements mean.

  3. The learning benefit remains unclear. CoPE achieves 9/18 dynamic successes versus 8/18 for All-Failure (Appendix B), and 5/9 versus 8/9 on clean states when the adapters are deployed globally. I would like to see stronger evidence that finer responsibility assignment improves policy learning.

Questions for authors

Please see the weaknesses.

2 comments

Thank you for your review. We would like to explain the reasoning behind CoPE and what each experiment is trying to show.

1. Why do we maintain task state?

Our first goal is to reduce repeated reasoning and keep task information accurate during long-horizon execution.

As a robot receives more instructions and feedback, its history keeps growing. If the agent repeatedly reads that history to decide what to do next, it spends time understanding things that may have already been established. It may also forget earlier requirements or change information that should have remained the same.

CoPE saves the task state and updates only the affected parts. For example, if a user temporarily changes a destination from A to B and later cancels B, the robot can recover the original request and its remaining work from the saved state.

This motivates two questions in our experiments.

First, can we reduce the cost of updating task information? Table 2 addresses this. At 32 commitments, CoPE generates 6,891 output tokens across 36 calls, compared with 191,787 for full-state regeneration. Neutral Typed achieves similar efficiency because it also uses local updates. The benefit here comes from keeping unchanged information instead of generating it again.

Second, what happens to task information after repeated changes? Table 3 addresses this. CoPE and FSR-PC achieve the same task success counts, but CoPE preserves occurrence IDs in 15/15 Stage C cases and reaches 1.000 historical audit coverage, compared with 0/15 and 0.344 for FSR-PC. Adding stable IDs alone leaves coverage at 0.344, while retaining provenance raises it to 0.933.

The audit checks whether the stored records contain answers to questions about earlier tasks. For example, when a user asks to resume a previous request, the robot needs to know which request it was, why it was interrupted, and what progress remains. These results help explain why we preserve the history connected to each task.

2. Why use this state for learning?

Our second goal is to make better use of expensive robot training data.

When a task fails, we want to understand what happened before deciding what additional data to collect or which component to improve. A changed user request, a planning mistake, and a failed grasp can require different corrections.

CoPE keeps the task state from the time of failure. This lets us examine which request was valid, what the robot was expected to do, and which component may need correction.

We tested this on 1,200 records generated through controlled fault injection. Each record was checked using execution evidence from normal and faulty continuations, and the responsibility labels were fixed before evaluating the methods. These are reference labels for controlled failures.

You also asked about Generic Persistent. We recovered its frozen results on the same 1,200 records. In Exp2B, CoPE achieves 54.0% and Generic Persistent 52.9%. The paired difference is 1.083 percentage points, with a confidence interval that includes zero. Both methods retain task occurrence information and perform similarly in this test. This leaves the additional benefit of CoPE's transition rules as an open question.

We then wanted to see whether responsibility information could help select training data.

Across three training streams, CoPE selects 30/30/33 correction examples directly related to the target task, compared with 9/12/17 for All-Failure. These numbers measure the relevance of selected examples, which is one step toward making corrective training more focused.

3. What happens when we actually train the robot?

We used these selected examples to train real OpenVLA adapters under matched training budgets.

In the full frozen dynamic evaluation, CoPE succeeds in 9/24 runs and All-Failure in 8/24. The 9/18 and 8/18 figures in the paper refer to a later six-state subset, so the full evaluation should be reported as 9/24 and 8/24. The current difference is small, and the effect on learning efficiency needs further evaluation.

There is also the question of when the robot should use an updated policy. An adapter trained for one task may affect unrelated tasks if it is applied everywhere.

CoPE keeps track of which task occurrence the adapter belongs to. In our clean-retention test, all 9/9 evaluation cases used the original policy and succeeded. This shows that the system can leave unrelated tasks on the original policy.

This is why we want to maintain the same task information throughout execution and learning. During execution, it helps the robot avoid repeatedly working out which requests are still valid. After a failure, the recorded state helps us decide which part needs correction, where additional training data would be useful, and when the updated policy should be used.

Thank the authors for their detailed clarifications, which address some of my concerns. Given my limited expertise on this specific topic, and after considering the comments and assessments of other reviewers, I believe it would be appropriate to maintain my original score.

Reviewer_MzobOpenReview ↗
Rating
1
Confidence
3
Informativeness
1
Presentation
1
Soundness
1
Read review
Paper summary

I had a tough time understanding this paper. From what I can piece together, the key idea seems to be to maintain a decomposed latent state that comprises information about the world and the task. These two components are updated as the robot/agent interacts with the world.

Critical strengths

The idea to maintain a "task state" (when the state is still valid and what parts of the task still remain to perform) seem reasonable to me. Again, I'm not so sure whether this is really what the paper contributes.

Critical weaknesses

The paper is very unclear. I do not understand the main problem this paper is meant to solve nor the key idea. I encourage the authors to please avoid using AI and focus on conveying ideas in a clear manner.

e.g., In the introduction, "Action identity alone does not resolve task occurrence identity" what does this mean? What does it mean for a task commitment to remain authoritative? "A commitment carries occurrence identity, lifecycle, lineage, grounding, restoration conditions, and append-only provenance." What does this mean?

In Sec 3.1. What does it mean that the state is replayable? what does \mathcal{G} represent and what is the "root ancestry"? What does it mean that "an object an move while an obligation survives"; I don't see how an obligation "survives"? What is a "consumer" in the setup's context?

I do not understand the experiments setup nor what exactly the main claims or hypotheses are.

From my read, the paper looks to be AI generated without substantial insights or key novel ideas.

Questions for authors

Please see weaknesses above. I would encourage the authors not to rely on AI to write the paper.

1 comment

Thank you for your review. We would like to explain the main idea of CoPE with a simple example, and clarify what our experiments are testing.

The first problem we address is repeated reasoning during long-horizon robot tasks.

As a robot works, it receives new instructions, observations, and feedback. Its history keeps growing. If the agent relies on this history, it may repeatedly read and interpret earlier events just to figure out what it should do next. This takes extra inference time and can cause the agent to forget or misunderstand requirements that are still valid.

CoPE keeps an explicit task state that is updated over time. When something changes, the model identifies which part of the task is affected and proposes an update. A validator checks the update before saving it. Everything else stays unchanged. The planner then reads the current task state to decide what to do next.

Here is a simple example.

A user asks a robot to put an object in basket A. Later, the user temporarily changes the destination to basket B. After some time, the user cancels this change and asks the robot to continue the original task.

CoPE keeps both requests. The original request is temporarily inactive, while the new request is active. When the temporary change is canceled, CoPE can find the original request and restore it, including the work that remains to be done.

This example explains the terms in Section 3.1:

  • Task occurrence: One specific instance of a task request. Two requests can involve the same action but still be different occurrences.
  • Authority: Whether a request currently applies and should guide the robot's actions.
  • Lifecycle: Whether a request is active, suspended, overridden, or expired.
  • Lineage: How task requests are related when one replaces another. These relationships are stored in the graph G\mathcal G.
  • Root ancestry: The original request at the beginning of a chain of replacements.
  • Grounding: Which objects and world conditions a request refers to. For example, if the object moves, the requirement to put it in basket A may still apply. The robot needs to update its understanding of the object's location, while keeping the original requirement.
  • Restoration conditions: The conditions that must hold before an earlier request can become active again.
  • Provenance: A record of accepted changes and the evidence behind them.

The state is replayable because the system can rebuild it from the initial state and the recorded updates. It does not need to ask the model to interpret the original history again. The consumers mentioned in the paper are simply the planner and learning components that use this maintained state.

The second problem we address is how to decide what a robot should learn from a failure.

Robot training data is expensive to collect. When a task fails, we first need to understand what happened. Did the user change the goal? Did an object move? Did the planner choose the wrong action? Or did the robot fail to execute a valid action?

These situations require different responses. CoPE uses the task state recorded at the time of failure to check which request was valid, which requirement was violated, and which component may need correction. This information helps the system decide where additional training data would be useful.

Our experiments test three parts of this approach.

  1. State maintenance: We increase the number of stored task requirements and test whether the system can update one part without changing unrelated parts. We also measure the cost of these updates.

  2. Responsibility assignment: We evaluate 1,200 records to test whether the stored task information helps identify which task occurrence and component should receive correction. The decision is made before the correct training target is revealed.

  3. Robot execution and learning: We use simulation and OpenVLA to test whether the maintained task state can support task recovery, actual policy updates, and selecting the adapted policy for the relevant task occurrence.

The main idea connecting these experiments is simple: the robot keeps track of which tasks are still valid and what remains to be done. The same information is then reused to understand failures and guide later learning.

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

Related papers

Loading the map…

Discussion (0)

Sign in to comment.