Conditional Multistage Failure Recovery

• The paper introduces a framework where recovery is conditional, staged, and integrated with nominal operations, employing explicit detection and corrective stages.
• It leverages methodologies such as behavior trees, VLM-driven failure detection, and parameter adaptation, with reported success rates improving up to 81.3% in experimental setups.
• The framework emphasizes modular recovery, balancing local corrective actions with global reassessment to efficiently handle failures in various domains.

Searching arXiv for the specified paper and closely related work on conditional multistage failure recovery. A conditional multistage failure recovery framework is an architectural pattern in which nominal execution remains primary, recovery is activated only when failure conditions or violated preconditions are detected, and corrective behavior is decomposed into ordered stages whose later stages are invoked only when earlier ones are insufficient. In recent arXiv work, this pattern appears in collaborative robotics, vision-language-action control, embodied-agent prompting, FPGA-based fault tolerance, automated adaptive configuration, multimodal software repair, decentralized signal recovery, and distributionally robust multistage optimization. Across these settings, the unifying idea is not a single algorithm but a common control logic: detect or infer an off-nominal state, condition recovery on that diagnosis, execute stage-appropriate correction, and reassess the system before returning to nominal behavior (Ahmad et al., 2024, Hu et al., 8 Jun 2026, Farag et al., 8 Jul 2025, Fuchs et al., 2019, Stoller et al., 12 Jun 2025, Ma et al., 18 Mar 2026, Pichler et al., 2021).

1. Defining characteristics

The term denotes three coupled properties. “Conditional” means recovery is not always on: it is triggered by failure, unmet preconditions, or recognized off-nominal states. “Multistage” means recovery proceeds through a structured sequence such as task attempt, failure detection, diagnosis, corrective action, retry, and possibly reflection or relearning. “Failure recovery” means the corrective stages are explicitly designed to restore the system to a state from which task completion remains possible.

A canonical robotic formulation appears in the Behavior Trees and Motion Generators framework, where recovery behaviors are encoded as specialized skills with preconditions, postconditions, and parameters inside the same execution policy as the production task. In that setting, policy execution is written as

$$\mathbf{u} = \pi(\mathbf{x}\mid \boldsymbol{\theta}),$$

with intrinsic parameters covering tree structure, number and type of nodes, and motion generator choice, and extrinsic parameters covering force, offsets, velocities, stiffness, and related quantities. Recovery is therefore not an external exception handler but a parameterized skill that can be selected and adapted per failure case (Ahmad et al., 2024).

This same structural definition recurs in other domains. ReCoVLA keeps a pretrained VLA frozen and activates a residual recovery policy only when an external VLM recognizes a known failure category and the detector is confident; CMFR activates later prompting stages only if earlier prompts judge them necessary; FAR updates the retry policy only after a failed rollout; FailureMem injects failure memories only when they are relevant to the current repair case; adaptive configuration work defines resilience recursively over future failure states rather than as a single static deployment (Hu et al., 8 Jun 2026, Farag et al., 8 Jul 2025, Hao et al., 1 Jul 2026, Ma et al., 18 Mar 2026, Stoller et al., 12 Jun 2025).

2. Conditional control logic and stage structure

In robotics, explicit control flow is often the mechanism that makes recovery conditional. Behavior Trees provide modularity, interpretability, reactivity, and explicit branching through nodes that return Success, Failure, or Running. Standard control nodes include Sequence, Selector, Condition nodes, Action nodes, and Decorators. In the peg-in-a-hole formulation, the execution pattern is: attempt the production skill, detect failure or a violated precondition, branch to a recovery skill, and then reattempt the production skill if needed. Planning is triggered only when preconditions are not met, which makes the system reactive rather than uniformly plan-first (Ahmad et al., 2024).

Other systems realize the same logic through different interfaces. ReCoVLA makes recovery conditional with a binary gate $\beta_t\in\{0,1\}$: if the VLM does not recognize a trained failure category, recovery is inactive and the frozen base policy continues. Its multistage character comes from recovery-stage labels and stage-aware reward gates that keep later objectives inactive until prerequisite conditions hold; the paper’s example is that a placing term is withheld until the object has been re-grasped (Hu et al., 8 Jun 2026). B2FF uses a different conditional interface: before execution, it constructs a bank $B=\{v_1,\dots,v_M\}$ of imagined future milestones; when recovery begins at index $f$, it selects from the local candidate set

$$C_f = \{v_{f+\delta} \mid \delta \in A,\; 1 \le f+\delta \le M\},$$

with $A=\{-1,0,+1,+2,+4\}$, and then clamps the selected milestone as a fixed visual goal for a recovery window $W=5$ (Shin et al., 8 Jun 2026).

Embodied-agent prompting makes the stage structure fully explicit. CMFR consists of four error-handling stages: Subgoal Importance, Preconditions, Workaround, and Post-execution reflection. The first three operate during task execution, while the fourth is a global task-level reflection stage used only after plan execution completes but the task is still unsuccessful. The pipeline is gated: if Stage 1 judges a failed subgoal unimportant, it is skipped; only important failures proceed to Stage 2, and only failures with no missing prerequisites proceed to Stage 3 (Farag et al., 8 Jul 2025).

RACER instantiates a supervisor–actor loop rather than a fixed symbolic controller. The VLM supervisor reads the current image, task goal, previous instruction, and a textual summary of recent proprioceptive change, and then performs a detect-failure, diagnose, and replan step. Recovery is multistage both online, where supervisor and actor interact step by step, and in the data-generation pipeline, which uses one-step recovery for simple alignment errors and two-step recovery for more delicate primitives such as grasping and releasing (Dai et al., 2024).

3. Adaptation mechanisms

A central design choice in these frameworks is how corrective behavior is adapted. One family adapts parameters within a predefined skill structure. In BTMG, reinforcement learning with Bayesian Optimization refines the extrinsic parameters of recovery behaviors and of the PegInsertion skill. The learned peg-insertion parameters are applied force, path velocity, path distance, and radius. Recovery behaviors are built from GripperOpen, GripperClose, GoToLinear, ChangeStiffness, and ApplyForce, and composed into higher-level recoveries such as Pick-Place, Push, and Pick-Exchange (Ahmad et al., 2024).

A second family preserves the nominal controller and learns only residual corrections. ReCoVLA freezes the base VLA, trains a residual policy in simulation with PPO, and uses the VLM not to generate actions directly but to produce a structured descriptor containing failure category, recovery stage, active entities, confidence, and a reward mask. The reward compiler is deterministic: it validates the descriptor, resolves entities, binds reward potentials, retrieves a stage-gate template, and constructs gated residual rewards from distance progress, grasp state, placement progress, and articulation closing progress. This decoupling is intended to preserve nominal competence while narrowing recovery learning to the detected failure mode (Hu et al., 8 Jun 2026).

A third family adapts at test time from the episode’s own failures. FAR stores a failed trajectory, identifies candidate failure-inducing action chunks using value drops, constructs contrastive preference pairs, performs a small number of gradient updates, and retries with lightweight perturbations. The paper reports that this test-time adaptation typically takes 5–10 gradient steps and can complete in seconds. Successful recovery trajectories are then added to replay buffers for continual policy improvement, so the same recovery loop serves both immediate correction and long-term policy refinement (Hao et al., 1 Jul 2026).

A fourth family learns actionable recovery from synthetic or historical failures. Dream2Fix starts from successful real-world demonstrations, perturbs actions in a generative world model to synthesize counterfactual failures, and then filters the generated rollouts with verifiers for task failure validity, visual quality and temporal coherence, dynamics consistency, and kinematic safety. After filtering, 58.1% of synthesized rollouts are retained, producing a dataset of over 120,000 paired failure-correction samples for fine-tuning a VLM to jointly predict result classification, failure type, and a structured corrective trajectory (Li et al., 13 Mar 2026). FailureMem, in a software-repair setting, converts failed repair trajectories into a hierarchical Failure Memory Bank whose entries contain contextual, cognitive, and code layers; retrieval injects negative constraints and “golden” repair principles into later debugging stages (Ma et al., 18 Mar 2026).

A common misconception is that multistage recovery requires end-to-end learned repair. The recent literature does not support that interpretation. CMFR uses zero-shot chain prompting for recovery; FailureMem combines workflow stages with a late agent loop; GMT in signal recovery uses deterministic stage sizes and thresholds; and adaptive configuration synthesizes reconfiguration policies by state-space exploration rather than by policy-gradient learning (Farag et al., 8 Jul 2025, Ma et al., 18 Mar 2026, Xing et al., 2022, Stoller et al., 12 Jun 2025).

4. Representative instantiations and reported outcomes

The framework pattern is especially visible in robotic manipulation, where failures arise from misalignment, obstruction, grasp failure, environment changes, and off-trajectory drift.

Framework	Conditional mechanism	Reported outcome
BTMG (Ahmad et al., 2024)	Behavior-tree branching to skill-based recovery; RL tunes extrinsic parameters	For every scenario and repetition, at least one policy succeeded
ReCoVLA (Hu et al., 8 Jun 2026)	VLM-based failure-category dispatch and stage-gated residual reward compilation	Simulation average success improves from 36.7% to 66.7%; physical zero-shot sim-to-real average success is 61.7%
B2FF (Shin et al., 8 Jun 2026)	Recovery milestone selected from a pre-imagined familiar future bank	Failure-injected LIBERO success improves from 56.3% to 74.0%
FAR (Hao et al., 1 Jul 2026)	Failure-conditioned preference adaptation and perturbed retry	Average gains of 17.6% in simulation and 11.7% in the real world
Dream2Fix (Li et al., 13 Mar 2026)	Counterfactual failure synthesis and structured recovery prediction	Correction accuracy improves from 19.7% to 81.3% over prior baselines

The BTMG study is a compact example of multistage robotic recovery. It evaluates five progressively harder peg-in-a-hole scenarios on a dual-arm KUKA iiwa, including Baseline, Static Recovery, Dynamic Recovery, Static Recovery with Behavior Changes, and Dynamic Recovery with Behavior Changes. The PegInsertion skill activates at the approach pose, lowers stiffness in the z-direction, applies downward force, and superimposes a circular motion resembling an Archimedean spiral toward the hole center. Robustness is increased with domain randomization, hole-position perturbation with Gaussian noise of 8 mm standard deviation, and five different arm starting positions. The protocol uses 40 iterations per scenario, each iteration evaluated 5 times, with each scenario repeated 10 times; a policy counts as successful if it achieves insertion in at least 3 out of 5 evaluations. The reported qualitative conclusions are that recovery behaviors did not reduce task success, that the system remained robust across baseline, static, and dynamic recovery cases, and that Pareto fronts exposed a success–force trade-off (Ahmad et al., 2024).

ReCoVLA extends the same principle to frozen VLAs. Its evaluation spans long-horizon vegetable sorting, short-horizon soda-can disposal, and contact-rich toolbox organization on a Fetch robot, with additional out-of-distribution substitutions and a Behavior-1K transfer study. In simulation, average success rises from 36.7% for the frozen fine-tuned $\pi_{0.5}$ baseline to 66.7% for the full stage-aware method, and Q-score rises from 0.56 to 0.83. On the physical robot, the full system reaches 61.7% average success and 0.75 Q-score, with per-task physical results of 50% toolbox, 60% sorting, and 75% soda-can disposal. The VLM detector reaches about 85.0% macro accuracy, though the paper notes residual confusion between visually similar failure states (Hu et al., 8 Jun 2026).

B2FF addresses a distinct recovery problem: foresight-driven VLAs can be destabilized when asked to re-predict futures from failed states. Its response is to treat recovery as visual conditioning rather than direct action correction. A familiar future bank of size $M=12$ is imagined from the clean initial observation, and a recoverability-aware selector chooses among local candidates at failure time. Under controlled recovery timing aligned with injected failures, the method improves a baseline VLA from 56.3% to 74.0% on failure-injected LIBERO and from 91.3% to 93.7% on standard LIBERO; the online-triggered variant reaches 64.5% on the failure-injected benchmark (Shin et al., 8 Jun 2026).

FAR and Dream2Fix show two different recovery directions after failure. FAR treats a failed attempt as immediate adaptation signal and shows that retries alone are weaker than retries guided by Failure-Contrastive Preference Adaptation plus perturbation-based local exploration. Dream2Fix instead learns a recovery model offline from counterfactual failures synthesized from successful demonstrations, reaching correction accuracy 0.813 on its test set and achieving 46% recovery on real-world benchmark failures and 40% on OpenVLA deployment failures in physical closed-loop trials (Hao et al., 1 Jul 2026, Li et al., 13 Mar 2026).

5. Generalizations beyond robotic manipulation

The same framework logic appears in cyber-physical fault tolerance. In an FPGA-based MPSoC for spacecraft, dynamic fault tolerance is organized as a closed FDIR loop with three stages: Stage 1 performs software-side fault detection, isolation, and short-term recovery via coarse-grain lockstep and time-triggered checkpoints; Stage 2 attempts tile repair and FPGA partial or full reconfiguration; Stage 3 performs mixed-criticality degradation management when spare resources are exhausted. The design is explicitly conditional on fault type, severity, mission phase, and remaining resources, and it relies on spare resource pooling rather than hardwired redundancy (Fuchs et al., 2019).

Automated adaptive configuration makes the same idea formal. A system state is a pair $(cfg,fs)$, where $\beta_t\in\{0,1\}$0 is the current configuration and $\beta_t\in\{0,1\}$1 is the set of failed hardware components. Resilience is defined recursively: $\beta_t\in\{0,1\}$2 This definition makes recovery multistage in a literal sense: after each allowed future failure set, a new resilient configuration must exist, and that configuration must itself remain recoverable under later failures. The framework synthesizes not only initial resilient configurations but also state-dependent reconfiguration policies, using state-space exploration and quotient reduction based on RS-equivalence (Stoller et al., 12 Jun 2025).

In multimodal software repair, FailureMem separates debugging into three phases—file localization, key element identification, and agentic patch generation—then adds active perception and a Failure Memory Bank so that failed repair attempts become reusable guidance rather than discarded trajectories. On SWE-bench Multimodal, it achieves a 33.1% resolved rate with GPT-5.1 versus 29.4% for GUIRepair, an absolute improvement of 3.7% (Ma et al., 18 Mar 2026).

Statistical decision theory offers a more abstract analogue. The General Multistage Test for decentralized signal recovery allocates error budgets across staged stopping opportunities so that unresolved streams are conditionally retained for later, more informative decisions. It is multistage because accept and reject opportunities occur only at predetermined stage sizes, and conditional because later stages are reached only if earlier thresholds do not stop the test. The paper shows high-dimensional asymptotic optimality without sparsity constraints and without requiring balanced decay rates of the two error probabilities (Xing et al., 2022).

At the mathematical level, distributionally robust multistage optimization supplies a formal language for conditional reassessment after partial failure histories. The static risk functional

$\beta_t\in\{0,1\}$3

acquires a conditional counterpart

$\beta_t\in\{0,1\}$4

which is used to re-evaluate future risk after partial realizations. The paper’s central distinction is that this conditional robust functional is generally different from the nested analogue of a law-invariant risk measure, except in rectangular settings (Pichler et al., 2021).

6. Benefits, limitations, and recurrent design tensions

Across the surveyed work, the principal benefit is robustness without making recovery the default control mode. BTMG emphasizes that recovery behaviors are reusable skills rather than one-off scripts and that planning can be invoked only when preconditions fail. ReCoVLA preserves nominal behavior by freezing the base policy and injecting residual corrections only in recognized off-nominal states. B2FF likewise avoids fine-tuning the action generator and changes only the visual condition supplied to the frozen VLA. CMFR improves TEACH TfD performance over a no-recovery baseline by 11.5% and over the strongest existing model by 19%, while its ablations show that Preconditions and Post-execution reflection are the dominant stages (Ahmad et al., 2024, Hu et al., 8 Jun 2026, Shin et al., 8 Jun 2026, Farag et al., 8 Jul 2025).

The frameworks also reveal recurring limits. ReCoVLA requires each recoverable failure category to be reproducible in simulation before deployment and cannot synthesize a new recovery policy online during a real trial. FAR does not include a principled failure detector and is studied on diffusion policies trained from scratch in single-task settings. B2FF assumes the task remains physically recoverable, relevant objects remain observable and reachable, and the pre-executed milestone bank contains at least one useful recovery guide. Dream2Fix depends on the quality of generated counterfactual failures and structured verification. CMFR uses ground-truth simulator information rather than perception models, and positioning failures remain common even with heuristic adjustments (Hu et al., 8 Jun 2026, Hao et al., 1 Jul 2026, Shin et al., 8 Jun 2026, Li et al., 13 Mar 2026, Farag et al., 8 Jul 2025).

A second tension concerns the level at which recovery should be expressed. Some frameworks repair at the action level through residuals or perturbations; some at the skill level through BT branching; some at the instruction level through language replanning; some at the configuration level through replication and migration; and some at the risk-functional level through conditional worst-case reassessment. This suggests that “conditional multistage failure recovery framework” is best viewed as an organizing abstraction rather than a single method family.

A third tension is between local correction and global reconsideration. Several systems reserve a later stage for broader reevaluation: CMFR has post-execution reflection, FailureMem delays full agentic exploration until late-stage patch generation, and adaptive configuration requires each post-reconfiguration state to remain resilient over future failure sequences. A plausible implication is that multistage recovery is most effective when early stages are cheap and local, while later stages are fewer but more globally informed.

Taken together, these works indicate a stable conceptual core. A conditional multistage failure recovery framework does not merely retry after failure, and it is not equivalent to static redundancy or generic replanning. It is a staged, state-aware recovery architecture in which failure handling is explicitly gated, later recovery effort depends on earlier outcomes, and corrective behavior is represented in a form appropriate to the domain—skills, residual actions, prompts, memories, reconfiguration actions, or conditional risk updates.