---
title: 'Fail2Progress: Adaptive Learning from Failures'
url: https://www.emergentmind.com/topics/fail2progress
type: topic
---

# Fail2Progress: Adaptive Learning from Failures

Searching arXiv for recent 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 provided papers [2509.01746], [2607.01111], [2606.07833], and the related failure-dynamics paper [2607.07650] 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 [2509.01746]. 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 [2607.01111]. 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 [2606.07833]. 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 [2607.07650].

## 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 language models, while adjacent work on authentication systems studies failure accumulation under timing constraints rather than under learning or red-teaming dynamics [2509.01746].

| Work | Domain | Core mechanism |
|---|---|---|
| "Fail2Progress: Learning from Real-World Robot Failures with Stein Variational Inference" [2509.01746] | 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" [2607.01111] | 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" [2606.07833] | 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" [2607.07650] | 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^+$ [2509.01746]. In FAR, failed rollouts are converted into paired preference supervision and later placed into replay buffers for continual finetuning [2607.01111]. In red teaming, each attempt is logged as an event in a campaign rather than collapsed into a single pass/fail label [2606.07833]. 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$, $\sigma_{1:H}$, and $a_{1:H}$, the probability of each symbolic relation $r\in\mathcal R$ after execution, and planning selects $(\sigma_{1:H},a_{1:H})$ to maximize $P(G\mid O_0,\sigma_{1:H},a_{1:H},\mathcal D)$ [2509.01746].

The central failure mode is out-of-distribution behavior. Real deployments encounter scenes $S_{\text{real}}$ not covered by the simulator-generated training set $\mathcal D$. When the executed skill $\kappa_k(a_k)$ produces observed relations $\hat R_k \neq R_k$, the method declares a symbolic-prediction failure. The paper distinguishes this from a Sim2Real-gap failure by reconstructing the simulator from $O_F^-$ and checking whether the simulator reproduces the failure. A single real-world failure snapshot
$$
F=(O_F^-,R_F^-,O_F^+,R_F^+,\kappa_F,a_F)
$$
is explicitly described as insufficient by itself to fine-tune a neural skill-effect model [2509.01746].

The objective is therefore to construct an additional dataset $\mathcal D^+$, all using the failed skill $\kappa_F$, such that retraining on $\mathcal D\cup\mathcal D^+$ most reduces future failure probability. The paper formulates this as
$$
\arg\max_{\mathcal D^+}
D_{\mathrm{KL}}\!\left[
p_{T^+}(r\mid O_F^-,\kappa_F,a_F)
\;\middle\|\;
p_T(r\mid O_F^-,\kappa_F,a_F)
\right]
\quad
\text{s.t.}\quad
(s^+,a^+)\sim P(R_F^-,O_F^-\mid s),
$$
where $T^+$ is the model retrained on $\mathcal D\cup\mathcal D^+$ and the constraint enforces that the pre-skill rendered state matches the observed failure pre-state [2509.01746].

Operationally, the pipeline proceeds as follows. A real-world execution with $I$ detects failure index $k$ when $\hat R_k\neq R_k$. 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 $20$ particles $\{(s_i,a_i)\}$, instantiates each $s_i$ in a fast bounding-box renderer, executes $\kappa_F(a_i)$ to collect $(s_i,\kappa_F,a_i,s_i',O_i',R_i')$, augments $\mathcal D$ with $\mathcal D^+$, fine-tunes $I\rightarrow T^+$, and resumes real-world execution with $T^+$ [2509.01746].

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

The variational component is used because the posterior over simulation states $s$ that reproduce the pre-failure relations $R_F^-$, together with actions $a$ that most increase epistemic uncertainty, is high-dimensional and often multi-modal. Fail2Progress uses SVGD to transport a set of $N$ particles in parallel on the GPU, enabling $N\approx 20$ environments to be generated efficiently in IsaacGym [2509.01746]. The update is
$$
\theta_i \leftarrow \theta_i + \epsilon\,\widehat\phi(\theta_i),
\qquad
\widehat\phi(\theta)
=
\frac{1}{N}\sum_{j=1}^N
\Bigl[
k(\theta_j,\theta)\,\nabla_{\theta_j}\log p(\theta_j)
+
\nabla_{\theta_j}k(\theta_j,\theta)
\Bigr],
$$
with an RBF kernel
$$
k(x,y)=\exp\!\bigl(-\|x-y\|^2/(2h^2)\bigr),
$$
and bandwidth $h$ set by the median heuristic. For state inference, the target density is $p_s(s)\propto P(R_F^-\mid s)P(s)$, where $P(s)$ is a uniform prior over feasible object poses. For action inference, generalized Bayesian inference uses the loss $C(a;s)=H(I(r\mid s,O_F^-,\kappa_F,a))$, giving $\log p_a(a)\propto -C(a;s)+\log P(a)$, with $P(a)$ uniform in the robot’s workspace [2509.01746].

Once the particles approximate the posterior, each simulator rollout yields one sample
$$
d_i=(s_i,O_{F,i}^-,\kappa_F,a_i,s_i',O_i',R_i').
$$
These samples form $\mathcal D^+$. Fine-tuning then reuses the same losses as pre-training: a detection loss $L_{\mathrm{det}}=\mathrm{CE}(I(r\mid O_t),R_t)$, a latent-space regularization loss $L_{\mathrm{reg}}=\|z_{t+1}-\hat z_{t+1}\|_2^2$, a position loss $L_{\mathrm{pos}}=\|\Delta p_t-(\hat p_{t+1}-p_t)\|_1$, and a prediction loss $L_{\mathrm{pred}}=\mathrm{CE}(I(r\mid O_{t+1}),R_{t+1})$ [2509.01746].

The evaluation covers multi-object transport, constrained shelf packing, and hierarchical tabletop organization. Metrics are execution success rate, $F_1$ of relation detection, and generalization to novel object counts and viewpoints. Baselines are Original, Small, Large, Replanning, Sampling, and Gradient [2509.01746]. On hierarchical tabletop organization, success rates over $300$ trials each are reported as follows: with $3$ objects, Fail2Progress reaches $86\%$ versus $72\%$ for Gradient and $53\%$ for Replanning; with $5$ objects, it reaches $87\%$ versus $80\%$ for Gradient; with $7$ objects, it reaches $82\%$ versus $82\%$ for Gradient [2509.01746]. On multi-object transport, it reports $87\%$ for seen $3$-object scenarios, $81\%$ for unseen $5$-object scenarios, $71\%$ for unseen $7$-object scenarios, and $83\%$ and $85\%$ on two unseen viewpoints, outperforming Sampling and Gradient in each listed case [2509.01746]. Real-world hierarchical tabletop experiments are summarized as approximately $80$–$90\%$ success for Fail2Progress versus $40$–$50\%$ for baselines, and an ablation states that $N=20$ particles balances fine-tuning gain versus simulation time [2509.01746].

The stated limitations are also important for encyclopedic scope. The paper reports approximately $80$–$90\%$ 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 [2509.01746].

## 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 [2607.01111].

FCPA begins with credit assignment by value drops. A conservative critic is trained offline using demonstrations $\mathcal D_{\text{exp}}$ with an IQL-style value loss
$$
L_V=\mathbb E_{(s,a)\sim\mathcal D}\!\left[L_2^\tau(Q_\phi(s,a)-V_\psi(s))\right]
$$
and Q-loss
$$
L_Q=\mathbb E_{(s,a,s')\sim\mathcal D}\!\left[(r(s,\hat g(a))+\gamma V_\psi(s')-Q_\phi(s,a))^2\right].
$$
A failed rollout $\tau=\{(s_t,a_t)\}_t$ is broken into overlapping chunks $a_{t:(t+H-1)}$, and for each chunk the method computes
$$
\Delta V_t = V_\psi(s_{t+H}) - V_\psi(s_t).
$$
The lowest $\rho$-percentile of the $\{\Delta V_t\}$ are taken as negative samples,
$$
\tau^-=\{(s_t,a_t^-)\mid \Delta V_t \le \mathrm{percentile}_\rho(\{\Delta V\})\},
$$
so that dramatic value drops mark failure-inducing behavior [2607.01111].

Positive candidates are then mined from the current policy. For each failure state $s_t$ and negative chunk $a_t^-$, the method samples $M$ alternative chunks
$$
\mathcal C(s_t)=\{a^i\sim \pi_\theta(\cdot\mid s_t)\}_{i=1\ldots M},
$$
retains only those satisfying
$$
d_{\min}\le \|a-a_t^-\| \le d_{\max},
$$
and ranks the survivors by $Q_\phi(s_t,a)$, keeping the top $K$ as positives. The preference objective is
$$
L_{\mathrm{FCPA}} \equiv L_{\mathrm{pref}}
=
-\sum_{(a^+,a^-)}
\log \sigma\!\left[
\beta\cdot(\ell_{\mathrm{diff}}(a_t^-,s_t;\theta)-\ell_{\mathrm{diff}}(a_t^+,s_t;\theta))
\right],
$$
which encourages the diffusion policy to assign lower denoising error, and hence higher likelihood, to good chunks than to failure chunks [2607.01111].

To avoid repeated failures after adaptation, FAR adds small, temporally smoothed perturbations at execution. With probability $\epsilon_{\mathrm{explore}}$, it picks a fresh Gaussian target $\delta^*\sim\mathcal N(0,\Sigma)$; otherwise $\delta^*=0$. The perturbation evolves by
$$
\delta_t=\alpha\cdot\delta_{t-1}+(1-\alpha)\cdot\delta^*,
$$
and the executed control is
$$
\tilde a_t=\hat g(a_t)+\delta_t.
$$
The continual improvement loop then stores original demonstrations, successful online trajectories, and failed trajectories in $\mathcal D_{\text{exp}}$, $\mathcal D_{\text{succ}}$, and $\mathcal D_{\text{fail}}$, retrains $Q_\phi$ and $V_\psi$ on the aggregate set, and updates the actor with the advantage-weighted denoising loss
$$
L_\pi
=
\mathbb E_{(s,a)\sim\cdots;k,\epsilon}
\left[
w(s,a)\cdot \|\epsilon-\epsilon_\theta(a_k,s,k)\|^2
\right],
$$
where $A(s,a)=Q_\phi(s,a)-V_\psi(s)$ and $w(s,a)=\exp(A/\eta)$ [2607.01111].

Empirically, FAR improves average success from $47.0\%$ to $63.4\%$ in simulation relative to the base diffusion policy, and from $52.2\%$ to $70.9\%$ on RoboMimic. In the real world, across Drawer, Pot, and Tea tasks, it yields an $11.7\%$ average lift in success rate over standard diffusion policy and is $5$–$10$ percentage points above DP-NR and DP-BGR. Under continual improvement, it outpaces baselines by $10$–$20$ 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 $5$–$10$ percentage points [2607.01111].

## 5. Process-centric Fail2Progress in LLM red teaming

The red-teaming formulation replaces robot trajectories with event logs. A campaign $c$ 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 $s\in\{L0,L1,L2,L3,L4\}$ assigned by an LLM-as-judge, with $L3/L4$ denoting jailbreak. The attack mutation is $a\in\{0,\ldots,10\}$, where $0$ is verbatim and $10$ is SuffixDAN. Each event is recorded as a 4-tuple $e_k=(c_k,a_k,t_k,s_k)$, and the full log is $L=\{(e_k)_k\}$. The dataset contains $8{,}575$ scored events across $60$ prompts $\times 2$ models, with each campaign stopping early on first jailbreak or after up to $110$ attempts [2606.07833].

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 $i\rightarrow j$. The weighted edges are $w_{ij}=\mathrm{count}[i,j]$. The same counts produce a row-stochastic state-transition matrix
$$
P_{ij}
=
\Pr(s_{n+1}=j\mid s_n=i)
=
\frac{\mathrm{count}[i,j]}{\sum_z \mathrm{count}[i,z]},
$$
which defines a discrete-time Markov chain over the five severity levels. The self-loop ratio is
$$
R_i \equiv \frac{\mathrm{count}[i,i]}{\sum_z \mathrm{count}[i,z]}.
$$
If $R_i\approx 1$, the state behaves like a near-absorbing trap [2606.07833].

Applying this analysis yields two defense archetypes. GPT-OSS 120B is characterized as an “Absorbing Wall,” with refusal state $L1$ having
$$
R_{L1}=\frac{4\,187}{4\,187+394+7+9}\approx 0.911,
$$
and $P_{1,3}\approx 9/4\,597\approx 0.002$. The DFG is dominated by a thick self-loop at $L1$, with only two leak edges toward jailbreak. Llama 3.3 70B is characterized as a “Porous Gate,” with
$$
R_{L1}=\frac{1\,214}{1\,214+213+15+26}\approx 0.827,
$$
$$
P_{1,3}=26/1\,468\approx 0.018,\qquad P_{1,2}=15/1\,468\approx 0.010,
$$
and additional non-zero escape routes $L1\rightarrow L2$, $L1\rightarrow L3$, $L2\rightarrow L3$, and $L2\rightarrow L4$ [2606.07833].

The framework then adds quantitative progress metrics that go beyond attack success rate. Time-to-jailbreak for a campaign $c$ is
$$
T(c)=\text{smallest } t \text{ such that } s(c,t)\in\{L3,L4\},
$$
or $\infty$ if no jailbreak occurs, and mean time to compromise is
$$
\mathrm{MTTC}=E[T\mid T<\infty].
$$
Empirically, $\mathrm{MTTC}_{\mathrm{GPT}}\approx 57.0$ attempts with median $73$, whereas $\mathrm{MTTC}_{\mathrm{Llama}}\approx 23.9$ with median $21$. Mutator asymmetry is measured by per-converter state distributions and the Kullback–Leibler divergence
$$
D_{KL}(p_v\|q_v)=\sum_s p_v(s)\log\frac{p_v(s)}{q_v(s)}.
$$
Concrete examples include ROT13, which has $p_{\mathrm{ROT13}}(L3+)=0.7\%$ on GPT-OSS and $0\%$ on Llama, and Base64, which has $p_{\mathrm{BASE64}}(L3+)=6.3\%$ on Llama versus $0.4\%$ on GPT-OSS [2606.07833].

The paper summarizes these quantities in a practical scorecard,
$$
\mathrm{Score}(M)=\langle \mathrm{ASR}, \mathrm{MTTC}, R_{L1}, \sum_{v\in \mathrm{live}} w_v D_{KL}(p_v^M\|p_v^{\mathrm{baseline}})\rangle,
$$
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 [2606.07833].

## 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 [2607.01111]. In LLM red teaming, a single ASR value omits the campaign structure that reveals near-absorbing refusal or porous escape routes [2606.07833]. In long-horizon manipulation, a single real-world failure snapshot is insufficient by itself; the method instead generates a targeted simulated dataset $\mathcal D^+$ and fine-tunes the model before resuming execution [2509.01746].

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 [2509.01746]. 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 [2607.01111]. 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 [2606.07833].

A related but distinct strand of work models failure accumulation in time-constrained USSD authentication systems and formalizes the Success Cliff [2607.07650]. There, overall authentication complexity is defined by the normalized sum of per-step complexities, with
$$
C_j = E[U_j]/E[U_{\text{baseline}}],
$$
and the session success probability is
$$
S(C,T_r,T_n)=P[\text{session completes all }N\text{ steps without violation of any timeout or abandonment}],
$$
with discrete drop and acceleration
$$
\Delta(C)=P_{\text{success}}(C)-P_{\text{success}}(C+1),\qquad
\Gamma(C)=\Delta(C)-\Delta(C-1).
$$
The Success Cliff $Q$ is the smallest complexity level at which both $\Delta(C)\ge \delta$ and $\Gamma(C)\ge \gamma$ hold, with default thresholds $\delta=0.02$ and $\gamma=0.02$ [2607.07650].

The model specifies per-step elapsed time
$$
t_k = U_k + R_k + D_k + H_k,
$$
where $U_k=t_{\text{read},k}+t_{\text{input},k}+t_{\text{context},k}$, $R_k\sim\mathrm{Gamma}(\alpha,\beta)$, $D_k$ is retry delay after an input error, and $H_k=W_{\mathrm{SMS}}\sim \mathrm{Uniform}(5,30)\,\mathrm{s}$ for out-of-band SMS OTP steps. Termination occurs if $T_{\text{session}}>\tau_s$ with $\tau_s=120\,\mathrm{s}$, if $U_k+H_k>\tau_u$ with $\tau_u=30\,\mathrm{s}$, if $R_k>\tau_a$ with $\tau_a=15\,\mathrm{s}$, or if the user abandons according to one of the specified models [2607.07650].

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 $99.1\%$ at $C1$ to approximately $95.2\%$ at $C4$, with no cliff detected. With blocking delay inserted at $C4$ for SMS OTP, the cliff is detected at the $C3\rightarrow C4$ transition, and $P_{\text{success}}$ at $C4$ collapses to approximately $88.7\%$ under medium RTT and approximately $74.9\%$ under high RTT, yielding $Q=C4$ or normalized $C\approx 3.99$ [2607.07650]. 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 [2509.01746], test-time preference adaptation and continual policy improvement [2607.01111], and process mining of adversarial traces beyond binary ASR [2606.07833], while adjacent failure-dynamics research specifies when time-constrained workflows cross a critical threshold into abrupt collapse [2607.07650].

Source: https://www.emergentmind.com/topics/fail2progress