Technical Summary: From Patches to Trajectories (P2T)

Problem Statement

The dominant method for instilling investigation and reasoning capabilities into open software-engineering (SWE) agents is Supervised Fine-Tuning (SFT) on long trajectories generated by strong teacher models. However, standard SFT treats every retained response as an imitation target. Consequently, student agents inherit not only successful outcomes but also flaws in intermediate steps, such as ungrounded leaps, redundant loops, and speculative exploration.

Current data construction pipelines rely on outcome-filtered rejection sampling: they retain only trajectories where the final patch passes a test suite. This approach suffers from three critical limitations:

1. Lack of Process Supervision: It provides no feedback on intermediate reasoning steps, only the terminal result.
2. Inefficiency: Retained trajectories often contain redundant file views, uninformative tool calls, and loops, increasing inference costs.
3. Data Waste: It discards instances where the teacher fails to produce a passing patch, even if the teacher's investigation uncovered valuable intermediate facts.
4. Leakage Risk: Simply using the reference patch ($p^\star$) to guide generation risks "solution leakage," where the agent makes edits or claims before gathering the necessary evidence, leading to unjustified leaps that the student then imitates.

The core challenge is to construct training data that is simultaneously effective (each step narrows the epistemic gap to the correct fix with grounded reasoning) and efficient (each step is information-bearing, avoiding redundancy), without exposing the reference patch to the student agent.

Methodology: P2T (Patches-to-Trajectories)

The authors propose P2T, a framework that treats the developer-authored reference patch ($p^\star$) as privileged information during data curation. The student never sees $p^\star$; instead, the curation process distills $p^\star$ into a latent structure to guide trajectory construction.

P2T operates in two phases:

Phase 1: Process Graph Distillation (Reverse Phase)

The reference patch $p^\star$ is converted into a latent process graph $G^\star_i = (V_i, E_i)$.

• Nodes ($V_i$): Represent intermediate contextual facts (e.g., file locations, runtime behaviors) and solution milestones (e.g., reproduction scripts, fix plans, edits) that a competent developer must establish before the fix is derivable.
• Edges ($E_i$): Encode prerequisite relations, ensuring a topological order where a node is only discoverable after its prerequisites are established.
• Construction: An iterative Proposer-Critic loop using LLM agents:
  • Proposer: Identifies missing facts or milestones needed to derive $p^\star$.
  • Critic: Enforces non-leakage, pruning any node whose "unlocker" (the action required to discover it) presupposes knowledge of $p^\star$ itself.
• Result: A graph $G^\star$ that encodes the necessary prerequisites for the fix without revealing the fix itself.

Phase 2: Receding-Horizon Bi-Objective Trajectory Realization (Forward Phase)

Trajectories are constructed by sampling blinded continuations from a teacher model and curating them against $G^\star$.

• Candidate Generation: At each sliding window, the system samples $K$ "blind seeds" from the teacher. It then generates "mutated variants" by applying at most one localized edit to a seed step, redirecting it toward an available node in $G^\star$.
• Bi-Objective Selection: The system selects a segment based on two criteria:
  1. Effectiveness: Measured by a progress score ($Prog_t$) that counts newly established nodes in $G^\star$, penalizing premature claims. A groundedness gate ensures no step references entities or makes claims not yet supported by the visible history.
  2. Efficiency: Measured by trajectory length (token count or step count).
• Commit Rule: The system applies a "shortest-above-floor" rule: among segments that meet a minimum effectiveness threshold, it commits the shortest one. This ensures the trajectory is concise while maintaining rigorous grounding.
• Termination: The process repeats until a patch is generated. Only trajectories where the final patch passes the test suite are admitted to the SFT dataset.

Key Contributions

1. Problem Formulation: The authors frame SWE-agent SFT data construction as a bi-objective optimization problem over per-step effectiveness and trajectory length, demonstrating that standard outcome-filtered rejection sampling fails to provide signals on either axis.
2. P2T Framework: A novel curation framework that utilizes $p^\star$ as privileged information. It distills $p^\star$ into a non-leaky process graph $G^\star$ and realizes trajectories that are short, grounded, and steered by $G^\star$ without exposing the patch to the student.
3. Empirical Validation: Using only 1.8k curated instances from SWE-Gym, P2T achieves simultaneous improvements in effectiveness and efficiency over outcome-filtered baselines.

Experimental Results

The authors evaluated P2T on SWE-bench Verified and SWE-bench Lite using two student models (Qwen2.5-Coder-14B/32B) and two teacher curators (Qwen3-Coder-480B, GLM-5-FP8).

• Performance Gains: On SWE-bench Verified, P2T improved Pass@1 by up to +10.8 points (e.g., from 39.6% to 50.4% for the 32B student) compared to the test-pass rejection sampling baseline.
• Efficiency Gains: P2T reduced per-instance inference costs by ~15% (e.g., from \0.92 to \0.78), demonstrating that the curated trajectories are significantly shorter and less redundant.
• Quality Analysis:
  • Curated trajectories were 9.3% shorter and 31.0% less redundant (in terms of file-viewing actions) than rejected rollouts.
  • These structural improvements transferred to the trained students, who emitted rollouts that were 10.3% shorter and 19.5% less redundant than those from baseline-trained students.
• Ablation Studies:
  • Removing the groundedness check caused a drop of ~7.2 Pass@1 points, confirming the necessity of preventing ungrounded leaps.
  • Removing the shortest-above-floor rule increased trajectory length and token count, reducing Pass@1, indicating that shorter trajectories carry less imitation noise.
  • A value-of-information study confirmed that the gains are driven by the information encoded in $G^\star$ rather than just the curation machinery or data scale.

Significance and Claims

The paper claims that the right unit of supervision for capable agents is not the trajectory or the terminal artifact in isolation, but the structure that links them.

• Privileged Information Factorization: P2T demonstrates that reference patches, often discarded as mere ground truth, can be leveraged as privileged signals to shape high-quality training data without compromising the student's ability to learn genuine investigation skills.
• Simultaneous Optimization: The work challenges the trade-off between exploration (effectiveness) and efficiency. By using a process graph to anchor progress, P2T achieves both higher resolve rates and lower inference costs, proving that "cautious, well-grounded exploration" does not necessarily require "aggressive shortening" that invites unsupported shortcuts.
• Data Quality over Scale: The results suggest that per-trajectory quality, derived from principled process supervision, is a more potent driver of agent performance than simply scaling the volume of outcome-filtered data.

The authors maintain a modest stance, acknowledging limitations such as the reliance on executable test suites and reference patches, and the empirical (rather than formal) nature of the LLM-mediated groundedness checks. They position P2T as a step toward a more structured approach to process supervision in software engineering agents.