SWE-Replay Framework

• SWE-Replay frameworks are deterministic record-and-replay systems that capture system events and agent trajectories, enabling reproducible debugging and performance optimization.
• They integrate system-level ptrace methods, trajectory branching for LLM scaffolds, and memory-buffered replay for reinforcement learning safety, streamlining both testing and inference.
• Empirical evaluations show improved resolve rates, significant cost reductions, and enhanced reproducibility, with applications extending to debugging, financial simulation, and decentralized systems.

SWE-Replay frameworks encompass a family of deterministic record-and-replay and trajectory branching techniques designed to improve the efficiency, reliability, and reproducibility of agent behavior in software engineering (SWE), reinforcement learning (RL), and symbolic environments. They enable not only efficient debugging through faithful system-level event capture, but also advanced test-time agent scaling and experiment reproducibility through structured experience management, trajectory archiving, and replay-driven sampling schemes. Implementations range from full user-space system reconstructions (notably “rr”) to agent-level trajectory prefix replay for LLM scaffolds, and memory-buffered off-policy experience replay for RL safety.

1. Foundations and Motivations

SWE-Replay frameworks emerged from the need to deterministically capture and reproduce the execution behavior of software artifacts and agents, both for debugging (reverse-execution analysis, forensic traceability) and for algorithmic efficiency (test-time scaling, safe exploration). Early efforts such as Mozilla’s “rr” focused on pure user-space architectures leveraging hardware determinism for OS and application execution (O'Callahan et al., 2016, O'Callahan et al., 2017), while more recent lines (e.g., “SWE-Replay” for LLM agents) target dynamic optimization of agent sampling and inference cost (Ding et al., 29 Jan 2026).

Motivations for SWE-Replay include:

• Eliminating nondeterminism from software execution for debugging and analysis.
• Enabling regression test reproducibility and hard-to-capture bug diagnosis.
• Reducing computational cost of agent scaling by reusing and branching prior experience.
• Structuring agent exploration to encourage safer, more efficient, or more diverse behaviors via controlled replay policies.

2. Architecture and Algorithms

System-Level Replay (e.g. rr)

The “rr” system records all sources of nondeterminism at the user-kernel boundary, employing:

• A ptracing supervisor intercepting system calls and signals.
• A single-threaded scheduler to serialize thread interleavings.
• Deterministic hardware counters (retired conditional branches, RCB) for precise asynchronous event timing.
• Event logs recording syscall metadata and register state (per-thread).

Replay reconstructs address spaces, replays memory and register modifications, and injects asynchronous events at exactly matched (RCB, registers) coordinates (O'Callahan et al., 2016, O'Callahan et al., 2017).

Agent-Level Trajectory Replay (LLMs/Agents)

The “SWE-Replay” algorithm archives full agent trajectories $\tau = (s_1,\dots,s_N)$ and at each trial flips between:

• Exploration: sampling a new trajectory from scratch.
• Exploitation: replaying a prior trajectory prefix up to a critical step $t$, then resampling the suffix from that state.

Critical step selection is performed based on structural “potential” (e.g., file sets explored) and “reasoning significance” (number of reasoning paragraphs) without calling external LLM judges. Only registry diffs, rather than entire states, are stored for efficient environment rollback, and prompt caching optimizes LLM inference cost (Ding et al., 29 Jan 2026).

Experience Replay for RL Safety

In tabular Q-learning, memory buffers archive transitions. The replay sampling weight $w_t(s,a,s',r)$ can be engineered to bias for safety—e.g., upsampling high-variance (risky) actions, and further prioritizing worst-case outcome transitions—to produce a more risk-averse policy. Provided the sampled replay weights $w_t$ converge, tabular Q-learning converges to the fixed point policy for the effective replay-biased Bellman operator (Szlak et al., 2021).

3. Formalization and Performance Implications

Correctness and Convergence Criteria

SWE-Replay at the system level achieves determinism by ensuring: $$t_\mathrm{rep}^j \le t_\mathrm{rec}^j + \delta \quad\text{and}\quad \text{GPRs}_\mathrm{rep}^j = \text{GPRs}_\mathrm{rec}^j$$ for each asynchronous event, where $\delta$ compensates for interrupt imprecision, and only one thread runs at a time.

Agent-level trajectory branching improves the success probability over naive repeated sampling under fixed compute budgets, provided the critical step-selection is non-uniform and more likely to branch along correct trajectories (Ding et al., 29 Jan 2026).

Replay-biased RL policies converge under classical Robbins–Monro and GLIE conditions if the sampling distributions $w_t$ converge, with replay serving to shift the effective induced MDP and thus the optimal policy (Szlak et al., 2021).

Efficiency Metrics

• Overhead for system-level record/replay with syscall buffering can be reduced from ≈8× to ≈2× for I/O-intensive workloads, and overhead remains <10% for compute-bound tasks (O'Callahan et al., 2016, O'Callahan et al., 2017).
• SWE-Replay for LLM agents on SWE-Bench datasets realizes 11–17% cost reduction and up to 3.8 percentage point improvement in resolve rate, with major improvements in multilingual and high-complexity settings (Ding et al., 29 Jan 2026).

4. Implementation Details and Best Practices

Systemic Replay

Critical hardware and OS requirements include:

• Deterministic user-space hardware counters (e.g., RCB on Intel).
• OS support for ptrace, seccomp-bpf filtering, perf events, and block cloning.
• Avoidance of virtualized or nondeterministic instructions (e.g., RDRAND, CPUID).
• Fully user-space solutions to maximize deployability and ease of integration.

Checkpoints, compressed event traces, and in-process syscall interception optimize both trace size and runtime overhead. Only unmodified binaries and stock kernels are required.

Agent/Environment Replay

• Trajectory archives consist of minimal environment diffs and text, supporting efficient rewind and recomputation.
• Step selection for branching employs exponential weighting for rarely-reached (high-potential) states and steps with higher reasoning content.
• Prompt caching and diff-based restoration yield substantial reductions in computational expense.
• Interface APIs restrict agent access to only externally visible, exchange-like or environment-exposed state (no raw event buffers).

RL Replay

• Buffers maintain sufficient statistics (counts, reward moments, reward→successor mappings) per $(s,a)$, supporting weighted sampling over both state-action pairs and outcome realizations.
• Variance-prioritized and reward-minimizing sampling weights can be tuned via parameters $v$ (replay probability) and $\beta$ (reward bias intensity).
• Memory and computation overhead remains constant per update beyond buffer capping.

5. Empirical Evaluations and Limitations

Recorded Empirical Results

System-level frameworks achieve near-native performance on varied benchmarks. For LLM agent scaling:

• On SWE-Bench Verified, cost dropped by 11–17%, with resolve rate gains of up to 3.8 pp.
• On SWE-Bench Pro and Multilingual, cost was reduced (by up to 9%) with up to 22.6% relative improvement in resolve rate (Ding et al., 29 Jan 2026).
• Ablations reveal that architectural choices (e.g., regression-test filtering, file-set abstraction) strongly influence both cost and performance.

Identified Limitations

• State restoration in agent-level replay may fail if intermediate steps alter non-diff-tracked state.
• Trajectory archives can grow large with increased exploration budget, though per-entry footprint remains low.
• RL safety replay guarantees currently hold only in the tabular setting; extension to function approximation and deep RL is not yet theoretically mature (Szlak et al., 2021).
• System-level replay requires hardware and OS features not present on all platforms; high parallelism or incomplete syscall models can diminish deployability.

6. Broader Applications and Generalizations

SWE-Replay framework principles—deterministic event capture, reproducible branching, and targeted replay sampling—permit generalization to order-driven financial simulation (PredictionMarketBench), decentralized finance, black-box forensic debugging, and scalable RL policy shaping (Arora et al., 28 Jan 2026). When coupled with strict self-containment (all episode data and metadata in a single directory), clean agent APIs, and fee or risk-aware modeling, these frameworks enable stable benchmarking, regression testing, and safety/robustness research across domains.

Designing SWE-Replay-inspired frameworks in new domains requires careful attention to determinism, event ordering, and the abstraction level of agent-environment interactions, as well as rigorous logging and checkpointing to enable full run reproducibility and debugging.