Warm Repair with Clean Replay Overview

• Warm Repair with Clean Replay is a systems pattern that reuses pre-existing execution state to fast-track local error correction while enforcing clean replay for semantic validation.
• It is applied across diverse domains—including LLM agents, quantum RL, and planning—to leverage checkpoints, verified prefixes, and causal subgraph repairs.
• Empirical evidence shows reduced replay actions, enhanced recovery speed, and improved reproducibility, underscoring the balance of efficiency and safety.

Warm Repair with Clean Replay denotes a family of recovery and warm-start procedures that reuse an already constructed execution state, buffer, or partial plan for fast local repair, while imposing an additional replay, admissibility, or cold-start criterion that guards semantic validity, stability, or reproducibility. In the recent literature, the phrase is used in several non-identical but structurally related settings: commitment-sensitive structured tool agents, Program-of-Thought repair, repository bootstrapping, long-horizon planning-graph correction, replay-buffer transfer for noisy quantum RL, and mixed offline–online bandits (Yang et al., 22 May 2026, Mazaheri, 28 May 2026, Fu et al., 15 May 2026, Song et al., 2 Jul 2026, Kundu et al., 23 Apr 2026, Banerjee et al., 2022). A plausible implication is that the term names a recurring systems pattern rather than a single canonical algorithm.

1. Shared pattern across domains

Across the cited works, the warm component is the reuse of pre-existing state: DART restores a checkpoint local to a failed subtask instance; RePoT preserves the maximal verified prefix of a primitive-action plan; BootstrapAgent verifies candidate contracts inside a long-lived Docker container; WM-SAR sends only a compact causal subgraph to the LLM instead of replaying the whole planning graph; the quantum RL scheme copies $B_{\text{clean}}$ into $B_{\text{noisy}}$; and Artificial Replay consumes historical samples only when the base algorithm proposes the corresponding action (Yang et al., 22 May 2026, Mazaheri, 28 May 2026, Fu et al., 15 May 2026, Song et al., 2 Jul 2026, Kundu et al., 23 Apr 2026, Banerjee et al., 2022).

The clean replay component differs by domain. In DART, correctness is enforced by recoverable-boundary certification and an admissibility test that can block local rollback and force whole-task replay (Yang et al., 22 May 2026). In RePoT, replay is deterministic verification against the environment until the first invalid transition, followed by at most one suffix-repair call (Mazaheri, 28 May 2026). In BootstrapAgent, warm-mode validity is insufficient for acceptance; the final contract must also pass fresh-container cold replay (Fu et al., 15 May 2026). In WM-SAR, “clean replay” refers to a compact subgraph that preserves the causal bridge without downstream noise (Song et al., 2 Jul 2026). In the replay-buffer and bandit settings, the clean object is historical or noiseless data that are reused selectively rather than through indiscriminate full warm-start (Kundu et al., 23 Apr 2026, Banerjee et al., 2022).

This cross-domain recurrence suggests a common design objective: accelerate iterative correction without allowing latent state, unsupported commitments, irrelevant context, or spurious historical data to determine the accepted outcome.

2. Semantic recoverability in structured tool agents

DART formalizes warm repair for commitment-sensitive LLM-driven execution by modeling agents as explicit finite-state machines with observable traces,

$G=(S,A,\delta,M,H),$

where each recorded step is

$e_t=(s_t,a_t,s_{t+1},\Delta m_t).$

The runtime also maintains a conservative producer–consumer dependency graph over subtask instances using read/write sets,

$$R(I)=\bigcup_{t:I_t=I}R_t,\qquad W(I)=\bigcup_{t:I_t=I}W_t,$$

and

$$I_p \rightsquigarrow I_q \iff W(I_p)\cap R(I_q)\neq \varnothing.$$

Each subtask skeleton declares entry states $S_{\text{ent}}$, commit predicates $P_{\text{com}}$, exit predicates $P_{\text{exit}}$, input/output interfaces $X_{\text{in}},X_{\text{out}}$, and an effect policy $B_{\text{noisy}}$0. A recoverable boundary $B_{\text{noisy}}$1 for failed instance $B_{\text{noisy}}$2 is defined by

$B_{\text{noisy}}$3

DART then restricts actual restore decisions to checkpoints satisfying admissible local recovery: $B_{\text{noisy}}$4 If the admissible set $B_{\text{noisy}}$5 is nonempty, DART selects the most recent admissible checkpoint,

$B_{\text{noisy}}$6

and otherwise rejects local rollback and falls back to whole-task replay (Yang et al., 22 May 2026).

The operational workflow is five-stage: failed-instance localization; recoverable-boundary certification; instance-aligned checkpointing at $B_{\text{noisy}}$7; admissible-rollback selection; and warm repair plus replay from the latest admissible checkpoint. The alignment is instance-specific: snapshots are indexed as $B_{\text{noisy}}$8, and restore searches only within $B_{\text{noisy}}$9, which avoids reopening unrelated work. In the scheduling-assistant example, DART restores from a commit checkpoint of Subtask 1, re-queries calendars, and resumes Subtask 2, while keeping downstream committed work intact because $G=(S,A,\delta,M,H),$0 has already been checked (Yang et al., 22 May 2026).

The empirical claims are correspondingly narrow and strong. In commitment-sensitive cases, Retry-Only always succeeds but replays 14–29 actions; “Entry-only” local restore fails with 0% success; DART’s Comp-Frozen succeeds 100% with replay $G=(S,A,\delta,M,H),$1–$G=(S,A,\delta,M,H),$2 actions, zero upstream replay, and preserved committed progress. On a LangGraph substrate, built-in checkpoint-restore fails the schedule-form commitment-sensitive case with 0% success, whereas DART succeeds with a one-step replay. A five-domain safety audit reports 54 comparable rows with 100% safe-equivalent outcomes, and blocking calibration on 47 evaluated events yields 35 admitted with 0 unsafe admissions and 12 blocked with 0 false blocks. The paper’s central corrective claim is explicit: controller legality does not imply semantic validity, and sound local recovery requires an explicit admissibility check (Yang et al., 22 May 2026).

3. Verified-prefix repair in Program-of-Thought planning

RePoT treats warm repair as deterministic replay plus suffix repair for one-shot Program-of-Thought plans. The environment is deterministic, with

$G=(S,A,\delta,M,H),$3

and a plan is a sequence $G=(S,A,\delta,M,H),$4 of primitive actions. Let

$G=(S,A,\delta,M,H),$5

or $G=(S,A,\delta,M,H),$6 if all steps are valid. The verified prefix is then

$G=(S,A,\delta,M,H),$7

and $G=(S,A,\delta,M,H),$8 is the last valid state. RePoT runs one-shot PoT, replays until the first invalid transition, and if the goal has not yet been reached, makes at most one additional LLM call to repair the suffix from the verified state. The budgeted loop therefore costs at most one extra LLM call relative to PoT on the subset of problems where PoT fails (Mazaheri, 28 May 2026).

Its evaluation isolates the effect of checkpointed replay under a matched budget of at most two calls. On PuzzleZoo-775, RePoT peaks at 96.9% versus 86.3% for PoT on GPT-5.4-mini-medium; against the matched-budget PoT-retry baseline, RePoT is +3.6 percentage points on Gemini 3.5 Flash with 95% CI $G=(S,A,\delta,M,H),$9, is statistically a tie on GPT-medium and Claude, and loses on GPT-mini. On PlanBench Blocksworld, the no-thinking variants show gains of +9.3 pp for GPT-5.4-mini, +11.4 pp for Claude Sonnet 4.6, and +1.1 pp for Gemini 3.5 Flash. The paper also introduces Adaptive RePoT, which measures

$e_t=(s_t,a_t,s_{t+1},\Delta m_t).$0

and if $e_t=(s_t,a_t,s_{t+1},\Delta m_t).$1 with $e_t=(s_t,a_t,s_{t+1},\Delta m_t).$2, or if $e_t=(s_t,a_t,s_{t+1},\Delta m_t).$3, abandons suffix repair and performs a fresh PoT retry instead (Mazaheri, 28 May 2026).

The controlled-recovery benchmark Derail-550 addresses a common misconception: that an error message alone is an adequate recovery signal. The reported condition is the opposite. On Gemini and GPT-medium, checkpointed methods clear at least 78% and at least 37%, respectively, while error_only remains at 20.7% and 3.1%, and no_feedback at 3.8% and 1.6%. RePoT_full scores 80.7% on Gemini and 59.6% on GPT-medium; RePoT_restart from $e_t=(s_t,a_t,s_{t+1},\Delta m_t).$4 scores 82.4% on Gemini and 94.5% on GPT-medium. The paper’s stated takeaway is that checkpoint information, not the specific verified-prefix tail, is the load-bearing recovery signal (Mazaheri, 28 May 2026).

4. Cold-start reproducibility in repository bootstrapping

BootstrapAgent uses Warm Repair with Clean Replay inside a Docker-based, trace-driven repair loop for generating a reusable .bootstrap contract. The formal distinction is between warm verification inside a long-lived container,

$e_t=(s_t,a_t,s_{t+1},\Delta m_t).$5

and clean replay in a fresh container from the minimal base image,

$e_t=(s_t,a_t,s_{t+1},\Delta m_t).$6

For either mode $e_t=(s_t,a_t,s_{t+1},\Delta m_t).$7, validity is

$e_t=(s_t,a_t,s_{t+1},\Delta m_t).$8

iff setup, diagnostics, and minimal verification all pass: $e_t=(s_t,a_t,s_{t+1},\Delta m_t).$9 Acceptance requires both predicates: $$R(I)=\bigcup_{t:I_t=I}R_t,\qquad W(I)=\bigcup_{t:I_t=I}W_t,$$0 The repair loop therefore performs repeated warm verification for fast feedback, but invokes fresh-container replay only once warm-mode tests pass (Fu et al., 15 May 2026).

The loop begins with $$R(I)=\bigcup_{t:I_t=I}R_t,\qquad W(I)=\bigcup_{t:I_t=I}W_t,$$1, launches one Docker container for warm iterations, verifies $$R(I)=\bigcup_{t:I_t=I}R_t,\qquad W(I)=\bigcup_{t:I_t=I}W_t,$$2 in warm mode, and, if warm validity holds, runs a cold-start replay in a new container. Otherwise it computes a trace-driven repair delta $$R(I)=\bigcup_{t:I_t=I}R_t,\qquad W(I)=\bigcup_{t:I_t=I}W_t,$$3, filters it through

$$R(I)=\bigcup_{t:I_t=I}R_t,\qquad W(I)=\bigcup_{t:I_t=I}W_t,$$4

and applies it via $$R(I)=\bigcup_{t:I_t=I}R_t,\qquad W(I)=\bigcup_{t:I_t=I}W_t,$$5. The sanity condition forbids removal or weakening of any command in the original minimal verification $$R(I)=\bigcup_{t:I_t=I}R_t,\qquad W(I)=\bigcup_{t:I_t=I}W_t,$$6 or any evidence-justified command in $$R(I)=\bigcup_{t:I_t=I}R_t,\qquad W(I)=\bigcup_{t:I_t=I}W_t,$$7, and requires provenance support in $$R(I)=\bigcup_{t:I_t=I}R_t,\qquad W(I)=\bigcup_{t:I_t=I}W_t,$$8 without contradiction of plan $$R(I)=\bigcup_{t:I_t=I}R_t,\qquad W(I)=\bigcup_{t:I_t=I}W_t,$$9. In practice, repairs may insert_commands, remove_commands, or replace_commands at specific zero-based indices (Fu et al., 15 May 2026).

The theoretical motivation is explicitly tied to reproducibility. The paper states that Docker image builds are deterministic modulo external network calls; residual-state speed-ups such as caches, installed packages, and generated compiled artifacts do not alter the semantic requirement that $$I_p \rightsquigarrow I_q \iff W(I_p)\cap R(I_q)\neq \varnothing.$$0 specify all necessary setup commands; and the final cold replay prevents transient warm-state fixes from masking missing steps. Under the paper’s assumptions, if a cold-valid contract exists in the reachable contract space $$I_p \rightsquigarrow I_q \iff W(I_p)\cap R(I_q)\neq \varnothing.$$1, the loop will discover it within $$I_p \rightsquigarrow I_q \iff W(I_p)\cap R(I_q)\neq \varnothing.$$2 iterations assuming a complete LLM repair oracle (Fu et al., 15 May 2026).

The quantitative effects are large. Disabling warm-state repair and forcing every iteration to start from a fresh container adds an extra 4,839.9 minutes on Repo2Run, 851.6 minutes on ExecutionAgent, and 421.9 minutes on Installamatic. The per-repo median wall-clock reduction due to warm repair is 42.9 percent on Repo2Run, 30.2 percent on ExecutionAgent, and 32.2 percent on Installamatic. When a Claude Code agent reuses the generated .bootstrap, ExecutionAgent shifts from 285.2 s to 112.0 s and from 597.9K to 115.7K total tokens; Installamatic shifts from 337.8 s to 282.3 s and from 594.4K to 312.6K total tokens; Repo2Run shifts from 391.9 s to 309.8 s and from 797.8K to 526.9K total tokens. Across 212 repositories, the combined mechanism cuts downstream build time by 22.3 percent and total token usage by 25.9 percent, while BootstrapAgent reports a 92.9% success rate overall (Fu et al., 15 May 2026).

5. Clean replay as causal-subgraph repair in long-horizon rollouts

In "Repair the Amplifier, Not the Symptom" (Song et al., 2 Jul 2026), warm repair with clean replay is reformulated for long planning graphs. A failure graph is

$$I_p \rightsquigarrow I_q \iff W(I_p)\cap R(I_q)\neq \varnothing.$$3

where nodes are planning or tool calls and edges encode causal or dependency relations. Each node $$I_p \rightsquigarrow I_q \iff W(I_p)\cap R(I_q)\neq \varnothing.$$4 carries observed error magnitude $$I_p \rightsquigarrow I_q \iff W(I_p)\cap R(I_q)\neq \varnothing.$$5, uncertainty $$I_p \rightsquigarrow I_q \iff W(I_p)\cap R(I_q)\neq \varnothing.$$6, repair cost $$I_p \rightsquigarrow I_q \iff W(I_p)\cap R(I_q)\neq \varnothing.$$7, and a node type. With budget $$I_p \rightsquigarrow I_q \iff W(I_p)\cap R(I_q)\neq \varnothing.$$8, the repair objective is to find the smallest connected region $$I_p \rightsquigarrow I_q \iff W(I_p)\cap R(I_q)\neq \varnothing.$$9, $S_{\text{ent}}$0, whose removal makes the residual world-model operator stable: $S_{\text{ent}}$1 The operator $S_{\text{ent}}$2 is the coupled node-edge error propagation operator. Under the coupled node-edge setting, the paper states that $S_{\text{ent}}$3 fully characterizes future error growth and enters the planning-regret bound through $S_{\text{ent}}$4 (Song et al., 2 Jul 2026).

WM-SAR operationalizes this objective through subgraph amplification analysis. It computes a GEAF score

$S_{\text{ent}}$5

a coupling factor

$S_{\text{ent}}$6

and a seed score

$S_{\text{ent}}$7

Region growth then uses marginal spectral relief

$S_{\text{ent}}$8

and adds frontier nodes maximizing

$S_{\text{ent}}$9

followed by pruning of any node whose removal does not raise the residual spectral radius. The returned region $P_{\text{com}}$0 is the compact causal subgraph to serialize and send to the LLM (Song et al., 2 Jul 2026).

The contrast with other repair strategies is explicit. Full-graph replay re-serializes all $P_{\text{com}}$1 nodes, can consume up to approximately 2,000 tokens, and floods the LLM with irrelevant symptoms. Local symptom scanning methods such as TopK, sliding window, and $P_{\text{com}}$2-hop may repair the visible worst node while missing upstream amplifiers, or may include many harmless neighbours. WM-SAR’s clean replay shows only the compact subgraph $P_{\text{com}}$3, typically 6–10 nodes or approximately 800 tokens, which the paper states preserves the causal bridge without downstream noise (Song et al., 2 Jul 2026).

The reported results support that framing. In synthetic agent calling-trees of approximately 26 nodes with cascade gain $P_{\text{com}}$4, engineering baselines reduce immediate NodeMSE but leave $P_{\text{com}}$5 high at 0.4–1.0, so post-repair errors re-amplify with GrowthSlope approximately $P_{\text{com}}$6 to $P_{\text{com}}$7. LocalRepair-3Hop covers approximately 99% of nodes, drives $P_{\text{com}}$8 to 0.01, but uses 25 nodes and is therefore near full replay. WM-SAR uses 8.3 nodes on average, achieves $P_{\text{com}}$9-reduction approximately 1.95, with pre 1.97 to post 0.02, NodeMSE@32 approximately 6.3, GrowthSlope approximately $P_{\text{exit}}$0, and LLM Rec-Exact $P_{\text{exit}}$1 on GPT-4o-mini with 855 tokens. Full-graph LLM repair recovers 0.24 exact with 2,157 tokens. The paper further reports that at $P_{\text{exit}}$2 nodes, WM-SAR already recovers more than 1.45 $P_{\text{exit}}$3-reduction versus at most approximately 0.8 for TopK or $P_{\text{exit}}$4-hop, and that over cascade gains $P_{\text{exit}}$5, WM-SAR sustains at least 90% of maximal $P_{\text{exit}}$6-reduction while Greedy-Point stays near zero (Song et al., 2 Jul 2026).

6. Replay-buffer transfer and historical-data replay

The same phrase also appears in data-centric warm-start procedures. In the quantum RL setting, the clean replay buffer $P_{\text{exit}}$7 is copied directly into the noisy target buffer: $P_{\text{exit}}$8 Transitions have the standard off-policy form

$P_{\text{exit}}$9

and, under prioritized replay, each transition is sampled with probability

$X_{\text{in}},X_{\text{out}}$0

The paper specifies vanilla PER,

$X_{\text{in}},X_{\text{out}}$1

and ReaPER,

$X_{\text{in}},X_{\text{out}}$2

For ReaPER$X_{\text{in}},X_{\text{out}}$3, the reliability exponent is annealed as

$X_{\text{in}},X_{\text{out}}$4

with $X_{\text{in}},X_{\text{out}}$5, $X_{\text{in}},X_{\text{out}}$6, $X_{\text{in}},X_{\text{out}}$7 of the training budget, and $X_{\text{in}},X_{\text{out}}$8. In the noisy phase, the same replay rule is used as in the clean phase, so transferred priorities remain valid (Kundu et al., 23 Apr 2026).

The experimental setup pretrains $X_{\text{in}},X_{\text{out}}$9 for a fixed 12 GPU-hour budget on 6-qubit BeH$B_{\text{noisy}}$00, 8-qubit H$B_{\text{noisy}}$01O, and 12-qubit H$B_{\text{noisy}}$02O tasks, then reduces $B_{\text{noisy}}$03 from 1.0 to 0.55 and tightens curriculum thresholds. Reported improvements of clean-to-noisy warm replay versus from-scratch noisy training are 47–58% fewer steps to chemical accuracy on 6 qubits, 50–85% fewer on 8 qubits, and 88.2% fewer on 12 qubits; up to 90% reduction in final energy error on 6 and 12 qubits; 57.6% fewer CNOTs on 12 qubits; and composite score improvements of 19–36%, approximately 28.7%, and approximately 51% on 6-, 8-, and 12-qubit tasks, respectively. The paper’s explanation is that clean and noisy tasks share state/action structure, Bellman targets remain aligned under modest noise, initial coverage improves, and subsequent noisy transitions provide self-correction (Kundu et al., 23 Apr 2026).

In stochastic bandits, "Artificial Replay" (Banerjee et al., 2022) defines a mixed offline–online procedure in which historical data $B_{\text{noisy}}$04 are not consumed wholesale. Instead, when the base algorithm $B_{\text{noisy}}$05 proposes action $B_{\text{noisy}}$06, Artificial Replay checks whether an unused historical sample with that action exists. If so, the sample is replayed and fed to $B_{\text{noisy}}$07 without advancing the round; otherwise a genuine online pull occurs. The main theoretical condition is independence of irrelevant data (IIData): for deterministic $B_{\text{noisy}}$08, adding samples from actions different from $B_{\text{noisy}}$09 does not change the next action,

$B_{\text{noisy}}$10

Under IIData, the paper proves a regret coupling to Full Start: $B_{\text{noisy}}$11 and therefore equal regret in distribution (Banerjee et al., 2022).

The data-efficiency result is that Artificial Replay may use only a fraction of the historical data while matching Full Start regret. For arm $B_{\text{noisy}}$12, the expected number of historical pulls used satisfies

$B_{\text{noisy}}$13

In $B_{\text{noisy}}$14-armed experiments with $B_{\text{noisy}}$15 and $B_{\text{noisy}}$16, AR and Full Start coincide up to sampling noise, while AR can leave 60–70% of history unused once $B_{\text{noisy}}$17. In continuous combinatorial bandits, AR maintains identical regret to Full Start while using far fewer regions in the adaptive partition and leaving a large fraction of history unused (Banerjee et al., 2022).

7. Recurring claims, limitations, and common misconceptions

Several misconceptions are directly rejected by the papers. DART shows that local checkpoint legality is not enough: controller legality does not imply semantic validity, because committed downstream work may depend on upstream history that no longer exists (Yang et al., 22 May 2026). RePoT shows that error-only feedback is not the primary recovery signal; checkpoint state is the load-bearing signal (Mazaheri, 28 May 2026). BootstrapAgent shows that a warm pass is not a sufficient acceptance condition; only a contract that also passes cold replay is admitted (Fu et al., 15 May 2026). WM-SAR argues that repairing the most visible symptom is often inferior to repairing the causal amplifier, and that near-full replay can recover stability only by forfeiting compactness (Song et al., 2 Jul 2026). Artificial Replay shows that full warm-start from all historical data can be wasteful even when it is regret-equivalent under IIData (Banerjee et al., 2022).

The limitations are also domain-specific. DART can block local rollback and force whole-task replay when $B_{\text{noisy}}$18, when instance localization fails, or when committed-consumer conflicts exist (Yang et al., 22 May 2026). RePoT’s matched-budget comparison is capability-sensitive: it strictly dominates PoT-retry on Gemini, ties on GPT-medium and Claude, and loses on GPT-mini, which is why Adaptive RePoT routes between suffix repair and fresh retry based on verified-prefix length (Mazaheri, 28 May 2026). BootstrapAgent’s theoretical claim is explicitly conditional on mild assumptions about Docker determinism and on a complete repair oracle (Fu et al., 15 May 2026). WM-SAR requires per-node error estimates and loses advantage in black-box settings without intermediate $B_{\text{noisy}}$19 (Song et al., 2 Jul 2026). The quantum RL warm-replay argument depends on shared state/action structure between clean and noisy tasks and on only mild task shifts (Kundu et al., 23 Apr 2026).

Taken together, these results support a precise but plural understanding of warm repair with clean replay. The warm phase accelerates recovery by reusing valid local state, trusted prefixes, persistent execution environments, compact causal subgraphs, or historical data. The clean replay phase is the mechanism that prevents this reuse from becoming unsound: admissibility checks in commitment-sensitive runtimes, deterministic verified replay in planning environments, fresh-container verification for reproducibility, spectral stabilization of the residual planning graph, or selective rather than exhaustive consumption of prior experience. This suggests that the unifying principle is not simple rollback, but controlled reuse under an explicit criterion that determines when reuse remains valid (Yang et al., 22 May 2026, Mazaheri, 28 May 2026, Fu et al., 15 May 2026, Song et al., 2 Jul 2026, Kundu et al., 23 Apr 2026, Banerjee et al., 2022).