Fail2Progress: Adaptive Learning from Failures

• Fail2Progress is a framework that treats failures as structured information, enabling adaptive learning across robotics, test-time recovery, and adversarial evaluations.
• It employs methods like Stein variational inference and failure-aware retry loops to generate targeted simulation data and continually improve policy performance.
• Empirical results highlight significant success rate improvements in complex tasks, demonstrating the practical impact of converting failures into actionable insights.

Searching arXiv for papers mentioning Fail2Progress and closely related formulations. {"query":"all:Fail2Progress OR ti:Fail2Progress OR abs:\"Failure-Aware Retry\" OR abs:\"process mining\" red team attacks", "max_results": 10} Received arXiv search results; using the papers on arXiv (Huang et al., 1 Sep 2025, Hao et al., 1 Jul 2026, Topol, 5 Jun 2026), and the related failure-dynamics paper (Mamo et al., 8 Jul 2026) for the article. Fail2Progress is a term used in recent arXiv literature for methods that treat failure as structured information rather than as a terminal binary outcome. In long-horizon robot manipulation, it names a procedure that generates simulation data targeted to an observed real-world failure and then fine-tunes a skill-effect model with Stein variational inference (Huang et al., 1 Sep 2025). In test-time robot recovery, it denotes a failure-aware retry loop that constructs preference-learning data from failed trajectories, adapts the policy, adds lightweight perturbations, and incorporates successful recoveries into continual policy improvement (Hao et al., 1 Jul 2026). In LLM red teaming, it describes a process-centric methodology that augments attack success rate with event logs, Directly-Follows Graphs, state-transition matrices, self-loop ratios, time-to-jailbreak, and mutator asymmetry (Topol, 5 Jun 2026). A related line of work on time-constrained authentication systems formalizes a distinct failure phenomenon, the Success Cliff, which sharpens the broader question of when accumulated complexity pushes a system from gradual degradation into abrupt non-linear collapse (Mamo et al., 8 Jul 2026).

1. Scope and conceptual usage

In the cited literature, Fail2Progress appears in distinct but structurally related formulations. Each formulation preserves sequential information about failures and uses that information for either adaptation, diagnosis, or targeted data generation. The term therefore spans robot learning, robot recovery at test time, and adversarial evaluation of LLMs, while adjacent work on authentication systems studies failure accumulation under timing constraints rather than under learning or red-teaming dynamics (Huang et al., 1 Sep 2025).

Work	Domain	Core mechanism
"Fail2Progress: Learning from Real-World Robot Failures with Stein Variational Inference" (Huang et al., 1 Sep 2025)	Long-horizon manipulation	Generate $\mathcal D^+$ from failure-consistent simulation environments and fine-tune a skill-effect model
"FAR: Failure-Aware Retry for Test-Time Recovery and Continual Policy Improvement" (Hao et al., 1 Jul 2026)	Robot test-time recovery	Failure-Contrastive Preference Adaptation with lightweight action perturbations and continual improvement
"Beyond Pass/Fail: Using Process Mining to Understand How LLMs Resist (and Fail) Red Team Attacks" (Topol, 5 Jun 2026)	LLM red teaming	Process mining over event logs with DFGs, Markovian transition matrices, MTTC, and $D_{KL}$
"Modeling Failure Dynamics in Time-Constrained Authentication Systems: Evidence of a Success Cliff in USSD Workflows" (Mamo et al., 8 Jul 2026)	USSD authentication systems	Simulation-based analysis of session failure dynamics and the Success Cliff

A recurrent theme is that failure is not discarded. In the manipulation setting, a single real-world failure snapshot is used to construct an additional dataset $\mathcal D^+$ (Huang et al., 1 Sep 2025). In FAR, failed rollouts are converted into paired preference supervision and later placed into replay buffers for continual finetuning (Hao et al., 1 Jul 2026). In red teaming, each attempt is logged as an event in a campaign rather than collapsed into a single pass/fail label (Topol, 5 Jun 2026). This suggests a family resemblance across the works even though the underlying mathematical objects differ: simulator states and symbolic relations in one case, trajectory chunks and diffusion-policy losses in another, and event logs and Markovian transitions in a third.

2. Failure-targeted data generation in long-horizon manipulation

The robot-manipulation formulation of Fail2Progress begins with long-horizon manipulation tasks defined by an initial observation $O_0$ and a high-level goal $G$ expressed as a conjunction of symbolic relations. A plan skeleton $\sigma_{1:H}=\{\kappa_1,\ldots,\kappa_H\}$ is a sequence of skill primitives, with each $\kappa_k$ parameterized by continuous parameters $a_k\in\mathbb R^d$. A skill-effect model $I$ predicts, given $O_0$, $D_{KL}$0, and $D_{KL}$1, the probability of each symbolic relation $D_{KL}$2 after execution, and planning selects $D_{KL}$3 to maximize $D_{KL}$4 (Huang et al., 1 Sep 2025).

The central failure mode is out-of-distribution behavior. Real deployments encounter scenes $D_{KL}$5 not covered by the simulator-generated training set $D_{KL}$6. When the executed skill $D_{KL}$7 produces observed relations $D_{KL}$8, the method declares a symbolic-prediction failure. The paper distinguishes this from a Sim2Real-gap failure by reconstructing the simulator from $D_{KL}$9 and checking whether the simulator reproduces the failure. A single real-world failure snapshot

$\mathcal D^+$0

is explicitly described as insufficient by itself to fine-tune a neural skill-effect model (Huang et al., 1 Sep 2025).

The objective is therefore to construct an additional dataset $\mathcal D^+$1, all using the failed skill $\mathcal D^+$2, such that retraining on $\mathcal D^+$3 most reduces future failure probability. The paper formulates this as

$\mathcal D^+$4

where $\mathcal D^+$5 is the model retrained on $\mathcal D^+$6 and the constraint enforces that the pre-skill rendered state matches the observed failure pre-state (Huang et al., 1 Sep 2025).

Operationally, the pipeline proceeds as follows. A real-world execution with $\mathcal D^+$7 detects failure index $\mathcal D^+$8 when $\mathcal D^+$9. If the failure is symbolic-prediction rather than Sim2Real-gap, the method invokes Fail2Progress: it runs parallel simulation environment generation via Stein variational inference to produce $O_0$0 particles $O_0$1, instantiates each $O_0$2 in a fast bounding-box renderer, executes $O_0$3 to collect $O_0$4, augments $O_0$5 with $O_0$6, fine-tunes $O_0$7, and resumes real-world execution with $O_0$8 (Huang et al., 1 Sep 2025).

3. Stein variational inference, dataset construction, and empirical results

The variational component is used because the posterior over simulation states $O_0$9 that reproduce the pre-failure relations $G$0, together with actions $G$1 that most increase epistemic uncertainty, is high-dimensional and often multi-modal. Fail2Progress uses SVGD to transport a set of $G$2 particles in parallel on the GPU, enabling $G$3 environments to be generated efficiently in IsaacGym (Huang et al., 1 Sep 2025). The update is

$G$4

with an RBF kernel

$G$5

and bandwidth $G$6 set by the median heuristic. For state inference, the target density is $G$7, where $G$8 is a uniform prior over feasible object poses. For action inference, generalized Bayesian inference uses the loss $G$9, giving $\sigma_{1:H}=\{\kappa_1,\ldots,\kappa_H\}$0, with $\sigma_{1:H}=\{\kappa_1,\ldots,\kappa_H\}$1 uniform in the robot’s workspace (Huang et al., 1 Sep 2025).

Once the particles approximate the posterior, each simulator rollout yields one sample

$\sigma_{1:H}=\{\kappa_1,\ldots,\kappa_H\}$2

These samples form $\sigma_{1:H}=\{\kappa_1,\ldots,\kappa_H\}$3. Fine-tuning then reuses the same losses as pre-training: a detection loss $\sigma_{1:H}=\{\kappa_1,\ldots,\kappa_H\}$4, a latent-space regularization loss $\sigma_{1:H}=\{\kappa_1,\ldots,\kappa_H\}$5, a position loss $\sigma_{1:H}=\{\kappa_1,\ldots,\kappa_H\}$6, and a prediction loss $\sigma_{1:H}=\{\kappa_1,\ldots,\kappa_H\}$7 (Huang et al., 1 Sep 2025).

The evaluation covers multi-object transport, constrained shelf packing, and hierarchical tabletop organization. Metrics are execution success rate, $\sigma_{1:H}=\{\kappa_1,\ldots,\kappa_H\}$8 of relation detection, and generalization to novel object counts and viewpoints. Baselines are Original, Small, Large, Replanning, Sampling, and Gradient (Huang et al., 1 Sep 2025). On hierarchical tabletop organization, success rates over $\sigma_{1:H}=\{\kappa_1,\ldots,\kappa_H\}$9 trials each are reported as follows: with $\kappa_k$0 objects, Fail2Progress reaches $\kappa_k$1 versus $\kappa_k$2 for Gradient and $\kappa_k$3 for Replanning; with $\kappa_k$4 objects, it reaches $\kappa_k$5 versus $\kappa_k$6 for Gradient; with $\kappa_k$7 objects, it reaches $\kappa_k$8 versus $\kappa_k$9 for Gradient (Huang et al., 1 Sep 2025). On multi-object transport, it reports $a_k\in\mathbb R^d$0 for seen $a_k\in\mathbb R^d$1-object scenarios, $a_k\in\mathbb R^d$2 for unseen $a_k\in\mathbb R^d$3-object scenarios, $a_k\in\mathbb R^d$4 for unseen $a_k\in\mathbb R^d$5-object scenarios, and $a_k\in\mathbb R^d$6 and $a_k\in\mathbb R^d$7 on two unseen viewpoints, outperforming Sampling and Gradient in each listed case (Huang et al., 1 Sep 2025). Real-world hierarchical tabletop experiments are summarized as approximately $a_k\in\mathbb R^d$8–$a_k\in\mathbb R^d$9 success for Fail2Progress versus $I$0–$I$1 for baselines, and an ablation states that $I$2 particles balances fine-tuning gain versus simulation time (Huang et al., 1 Sep 2025).

The stated limitations are also important for encyclopedic scope. The paper reports approximately $I$3–$I$4 real-world reliability rather than full elimination of failure, does not address Sim2Real gap directly, relies on a simplistic bounding-box Real2Sim stage, and assumes a fixed set of relations and skills. It proposes lifelong deployment, joint inference over physical parameters and symbolic states, and integration with scene graphs for building-scale mobile manipulation as extensions (Huang et al., 1 Sep 2025).

4. Failure-aware retry and continual policy improvement

FAR presents a distinct but closely related formulation in which failures are exploited online at test time rather than through targeted simulator dataset generation. The paper contrasts three modes. Naïve Retry, denoted DP-NR, simply runs the pretrained policy multiple times from the same failure state and often repeats the same mistake. Human-in-the-Loop methods solicit corrective demonstrations or feedback after each failure. FAR instead performs a lightweight, automated test-time update—Failure-Contrastive Preference Adaptation, or FCPA—to steer the policy away from failure-inducing actions, and then injects small randomized perturbations to encourage local exploration (Hao et al., 1 Jul 2026).

FCPA begins with credit assignment by value drops. A conservative critic is trained offline using demonstrations $I$5 with an IQL-style value loss

$I$6

and Q-loss

$I$7

A failed rollout $I$8 is broken into overlapping chunks $I$9, and for each chunk the method computes

$O_0$0

The lowest $O_0$1-percentile of the $O_0$2 are taken as negative samples,

$O_0$3

so that dramatic value drops mark failure-inducing behavior (Hao et al., 1 Jul 2026).

Positive candidates are then mined from the current policy. For each failure state $O_0$4 and negative chunk $O_0$5, the method samples $O_0$6 alternative chunks

$O_0$7

retains only those satisfying

$O_0$8

and ranks the survivors by $O_0$9, keeping the top $D_{KL}$00 as positives. The preference objective is

$D_{KL}$01

which encourages the diffusion policy to assign lower denoising error, and hence higher likelihood, to good chunks than to failure chunks (Hao et al., 1 Jul 2026).

To avoid repeated failures after adaptation, FAR adds small, temporally smoothed perturbations at execution. With probability $D_{KL}$02, it picks a fresh Gaussian target $D_{KL}$03; otherwise $D_{KL}$04. The perturbation evolves by

$D_{KL}$05

and the executed control is

$D_{KL}$06

The continual improvement loop then stores original demonstrations, successful online trajectories, and failed trajectories in $D_{KL}$07, $D_{KL}$08, and $D_{KL}$09, retrains $D_{KL}$10 and $D_{KL}$11 on the aggregate set, and updates the actor with the advantage-weighted denoising loss

$D_{KL}$12

where $D_{KL}$13 and $D_{KL}$14 (Hao et al., 1 Jul 2026).

Empirically, FAR improves average success from $D_{KL}$15 to $D_{KL}$16 in simulation relative to the base diffusion policy, and from $D_{KL}$17 to $D_{KL}$18 on RoboMimic. In the real world, across Drawer, Pot, and Tea tasks, it yields an $D_{KL}$19 average lift in success rate over standard diffusion policy and is $D_{KL}$20–$D_{KL}$21 percentage points above DP-NR and DP-BGR. Under continual improvement, it outpaces baselines by $D_{KL}$22–$D_{KL}$23 percentage points after just a handful of epochs on Lift, Door, and Can. An ablation reports that removing either FCPA or perturbation reduces performance by $D_{KL}$24–$D_{KL}$25 percentage points (Hao et al., 1 Jul 2026).

5. Process-centric Fail2Progress in LLM red teaming

The red-teaming formulation replaces robot trajectories with event logs. A campaign $D_{KL}$26 is one end-to-end run of a single HarmBench prompt against one model. An event is one scored attempt within that campaign. The activity or state is a severity level $D_{KL}$27 assigned by an LLM-as-judge, with $D_{KL}$28 denoting jailbreak. The attack mutation is $D_{KL}$29, where $D_{KL}$30 is verbatim and $D_{KL}$31 is SuffixDAN. Each event is recorded as a 4-tuple $D_{KL}$32, and the full log is $D_{KL}$33. The dataset contains $D_{KL}$34 scored events across $D_{KL}$35 prompts $D_{KL}$36 models, with each campaign stopping early on first jailbreak or after up to $D_{KL}$37 attempts (Topol, 5 Jun 2026).

From this log, the method extracts a Directly-Follows Graph by grouping events by campaign, sorting by attempt index, and incrementing counts for each observed transition $D_{KL}$38. The weighted edges are $D_{KL}$39. The same counts produce a row-stochastic state-transition matrix

$D_{KL}$40

which defines a discrete-time Markov chain over the five severity levels. The self-loop ratio is

$D_{KL}$41

If $D_{KL}$42, the state behaves like a near-absorbing trap (Topol, 5 Jun 2026).

Applying this analysis yields two defense archetypes. GPT-OSS 120B is characterized as an “Absorbing Wall,” with refusal state $D_{KL}$43 having

$D_{KL}$44

and $D_{KL}$45. The DFG is dominated by a thick self-loop at $D_{KL}$46, with only two leak edges toward jailbreak. Llama 3.3 70B is characterized as a “Porous Gate,” with

$D_{KL}$47

$D_{KL}$48

and additional non-zero escape routes $D_{KL}$49, $D_{KL}$50, $D_{KL}$51, and $D_{KL}$52 (Topol, 5 Jun 2026).

The framework then adds quantitative progress metrics that go beyond attack success rate. Time-to-jailbreak for a campaign $D_{KL}$53 is

$D_{KL}$54

or $D_{KL}$55 if no jailbreak occurs, and mean time to compromise is

$D_{KL}$56

Empirically, $D_{KL}$57 attempts with median $D_{KL}$58, whereas $D_{KL}$59 with median $D_{KL}$60. Mutator asymmetry is measured by per-converter state distributions and the Kullback–Leibler divergence

$D_{KL}$61

Concrete examples include ROT13, which has $D_{KL}$62 on GPT-OSS and $D_{KL}$63 on Llama, and Base64, which has $D_{KL}$64 on Llama versus $D_{KL}$65 on GPT-OSS (Topol, 5 Jun 2026).

The paper summarizes these quantities in a practical scorecard,

$D_{KL}$66

and frames the overall result as a “Fail2Progress” methodology that preserves the sequential structure of attacks, unmasks hidden defense modes, and yields decision guidance for both red teamers and defenders (Topol, 5 Jun 2026).

6. Boundaries, misconceptions, and related failure dynamics

One recurring misconception is to equate failure-aware progress with simple repetition. The cited work rejects that equation in explicit ways. In FAR, DP-NR merely repeats the pretrained policy, whereas failure-aware retry uses FCPA and perturbations to “try something different” without human rescue (Hao et al., 1 Jul 2026). In LLM red teaming, a single ASR value omits the campaign structure that reveals near-absorbing refusal or porous escape routes (Topol, 5 Jun 2026). In long-horizon manipulation, a single real-world failure snapshot is insufficient by itself; the method instead generates a targeted simulated dataset $D_{KL}$67 and fine-tunes the model before resuming execution (Huang et al., 1 Sep 2025).

A second boundary concerns what failure-aware learning does not solve. The original Fail2Progress paper explicitly states that it does not address Sim2Real gap directly and that a simplistic bounding-box Real2Sim stage constrains failure classification and data quality (Huang et al., 1 Sep 2025). FAR demonstrates substantial gains, but those gains are reported relative to standard diffusion policy, DP-NR, and DP-BGR rather than as elimination of deployment failures (Hao et al., 1 Jul 2026). The red-teaming framework is analytical rather than a defense mechanism in itself; it exposes model-specific transition structure and mutator asymmetry but does not claim to convert a porous model into an absorbing one (Topol, 5 Jun 2026).

A related but distinct strand of work models failure accumulation in time-constrained USSD authentication systems and formalizes the Success Cliff (Mamo et al., 8 Jul 2026). There, overall authentication complexity is defined by the normalized sum of per-step complexities, with

$D_{KL}$68

and the session success probability is

$D_{KL}$69

with discrete drop and acceleration

$D_{KL}$70

The Success Cliff $D_{KL}$71 is the smallest complexity level at which both $D_{KL}$72 and $D_{KL}$73 hold, with default thresholds $D_{KL}$74 and $D_{KL}$75 (Mamo et al., 8 Jul 2026).

The model specifies per-step elapsed time

$D_{KL}$76

where $D_{KL}$77, $D_{KL}$78, $D_{KL}$79 is retry delay after an input error, and $D_{KL}$80 for out-of-band SMS OTP steps. Termination occurs if $D_{KL}$81 with $D_{KL}$82, if $D_{KL}$83 with $D_{KL}$84, if $D_{KL}$85 with $D_{KL}$86, or if the user abandons according to one of the specified models (Mamo et al., 8 Jul 2026).

The empirical result is that in-band complexity alone produces gradual degradation, whereas blocking delay can produce a non-linear collapse. Under medium RTT and no blocking delay, success declines from approximately $D_{KL}$87 at $D_{KL}$88 to approximately $D_{KL}$89 at $D_{KL}$90, with no cliff detected. With blocking delay inserted at $D_{KL}$91 for SMS OTP, the cliff is detected at the $D_{KL}$92 transition, and $D_{KL}$93 at $D_{KL}$94 collapses to approximately $D_{KL}$95 under medium RTT and approximately $D_{KL}$96 under high RTT, yielding $D_{KL}$97 or normalized $D_{KL}$98 (Mamo et al., 8 Jul 2026). This related literature does not use the name Fail2Progress, but it clarifies an operational condition under which sequential failure processes become non-linear and workflows become operationally unreliable.

Taken together, these works define Fail2Progress less as a single algorithm than as a recurring research stance: preserve the structure of failure, model it explicitly, and use it to improve future behavior or diagnosis. In the current literature, that stance appears as targeted simulator data generation for symbolic-prediction failures (Huang et al., 1 Sep 2025), test-time preference adaptation and continual policy improvement (Hao et al., 1 Jul 2026), and process mining of adversarial traces beyond binary ASR (Topol, 5 Jun 2026), while adjacent failure-dynamics research specifies when time-constrained workflows cross a critical threshold into abrupt collapse (Mamo et al., 8 Jul 2026).