SE-Agent: Self-Evolution Trajectory Optimization in Multi-Step Reasoning with LLM-Based Agents
Authors: Yifu Guo
Jiaye Lin
Huacan Wang
Yuzhen Han
Sen Hu
Ziyi Ni
Licheng Wang
Mingguang Chen
Venue: NeurIPS 2025 poster ()
Keywords: LLM-Based Agents
Self-Evolution
Multi-Step Reasoning
Primary area: applications
TL;DR: A novel approach; Very practical

Abstract: Large Language Model (LLM)-based agents have recently shown impressive capabilities in complex reasoning and tool use via multi-step interactions with their environments. While these agents have the potential to tackle complicated tasks, their problem-solving process—agents' interaction trajectory leading to task completion—remains underexploited. These trajectories contain rich feedback that can navigate agents toward the right directions for solving problems correctly. Although prevailing approaches, such as Monte Carlo Tree Search (MCTS), can effectively balance exploration and exploitation, they ignore the interdependence among various trajectories and lack the diversity of search spaces, which leads to redundant reasoning and suboptimal outcomes. To address these challenges, we propose SE-Agent, a Self-Evolution framework that enables Agents to optimize their reasoning processes iteratively. Our approach revisits and enhances former pilot trajectories through three key operations: revision, recombination, and refinement. This evolutionary mechanism enables two critical advantages: (1) it expands the search space beyond local optima by intelligently exploring diverse solution paths guided by previous trajectories, and (2) it leverages cross-trajectory inspiration to efficiently enhance performance while mitigating the impact of suboptimal reasoning paths. Through these mechanisms, SE-Agent achieves continuous self-evolution that incrementally improves reasoning quality. We evaluate SE-Agent on SWE-bench Verified to resolve real-world GitHub issues. Experimental results across five strong LLMs show that integrating SE-Agent delivers up to 55% relative improvement, achieving state-of-the-art performance among all open-source agents on SWE-bench Verified.

SE-Agent: Self-Evolution Trajectory Optimization in Multi-Step Reasoning with LLM-Based Agents
Yifu Guo 1.2
Jiaye Lin Huacan Wang** Yuzhen Han
Sen Hu
Ziyi Ni4.
Licheng Wang' Mingguang Chen
Sun Yat-sen University, SStepFun, TTinnhua University, University of Chinese Academy of Sciences, University of Toronto, Peking University, 7 Institute of Automation, Chinese Academy of Sciences, UUniversity California, Riverside
quantaalpha.ai @ gmail.com
Code Agent Resolution Rate Comparison (SWE-Bench Verified)
Cluure Sernet
Muelles lods Cluste Sonnic
Agutt
Augment Agentiv
Tock + Chaude 4 Sornet (2022 22-22
TRA Ajert/Ouss)
Opeittands Cousie Semeet
Toubs e Cloude opus 19:512005-55-2
80.0%
75.2%
74.4%
Resolution Rate (%)
72.4%
70.4%
70.4%
70.8%
70-
66.6%
60
55
Command
Abstract
Large Language Model (asM) agents have recently shown impressive capabilities complex reasoning and tool via multi-step interactions with their environments. While these agents have the potential to tackle complicated tasks, their woblem-solving process-agents interaction trajectory leading to task completion completion-remains remains underexploited. These trajectories contain rich feedback that can navigate agents toward the right directions for solving problems correctly. Although prevailing approaches, such Monte Carlo Tree Search (MCTS), effectively balance exploration and exploitation, they ignore the interdependence among various trajectories and lack the diversity of search spaces, which leads redundant reasoning and suboptimal outcomes. To address these challenges, we propose SE-Agent, a Self-Evolution framework that enables Agents to optimize their reasoning processes iteratively. Our approach revisits and enhances former pilot trajectories through three key operations: revision, recombination, and refinement. This evolutionary mechanism enables two critical advantages: (1) expands the search space beyond local optima by intelligently
"Equal Contribution. Corresponding Author.
39th Conference on Neural Information Processing Systems (NcurIPS 2025).

---

exploring diverse solution paths guided by previous trajectories, and (2) it leverages trajectray inspiration to efficiently enhance performance while mitigating the impact of suboptimal reasoning paths. Through these mechanisms, SE--Agent achieves continuous self-evolution that incrementally improves reasoning quality. We evaluate SE-Agent on SWE--bench Verified to resolve real-world GitHub issues. Experimental results across five strong L.MSs show that integrating SE-Agent delivers up to 55% % relative improvement, achieving state-of-the-at performance among all open-source agents on SWE-bench Verified (61.2% with Claude-3.7 3.7noe-,,--Sonet, 80.0% with Claude-4-Sonng
Introduction
Large Language Models (LLMs) have demonstrated remarkable capabilities in various domains, from natural language understanding to code generation [. When equipped with external tools 2 4 and environmental interaction capabilities, these models evolve into autonomous agents that can tackle increasingly complex real-world tasks.
However, completing complex tasks rarely happens in a single step 6 7 practice, most L.L.-- based agents employ multi-turn interactions with their environments, following frameworks like ReAct [8] that iteratively gather information, reason about the current state, and take actions. These interaction processes naturally form trajectories- trajectories-Ssqqeenee sequences of states and actions that encode valuable problem-solving patterns and strategies [9 [0]. Each trajectory represents a complete attempt at solving a given problem, encompassing not just the final solution but also the reasoning path, [3].
environmental feedback, and makiii process that led to the outcome
Despite the wealth of information contained in these interaction trajectories. current approaches to multi-agent reasoning remain fundamentally limited [14 [5]. While methods such as Monte Carlo Tree Search (MCTS) effectively balance exploration and exploitation [16: 17]. they treat trajectories as independent entities, ignoring the rich interdependencies and potential synergies among different solution paths [18]. Moreover, even when employing diverse sampling strategies (e.g., varying temperature parameters or prompts), agents tend to converge on structurally similar trajectories that differ only in surface-level expressions, leading to a critical phenomenon: despite generating multiple trajectories, the final outcomes remain surprisingly homogeneous [19 20 21.. This limitation stems from the inherent nature of probabilistic language models, which naturally gravitate toward high-probabiiity solution patterns, thereby constraining the diversity of the search space [22 23 24).
To overcome these limitations, we propose SE-Agent, a Agents to iteratively optimize their reasoning processes through systematic trajectory manipulation. Our key insight is that by actively intervening at the trajectory sampling parameters- we can guide agents to explore fundamentally different perspectives and solution approaches. Through three core operations (revision, recombination, and refiement), SE- Agent not only generates genuinely diverse trajectories but also produces correspondingly diverse outcomes, significantly expanding the candidate solution space. This trajectory-level intervention enables agents to discover novel problem-solving capabilities that may not emerge from conventional sampling methods, effectively allowing base models to transcend their initial performance boundaries. By strategically combining insights from multiple trajectories, our framework amplifies the likelihood of finding correct solutions to challenging problems that would remain unsolved through traditional multi-sampling approaches. Our contributions are summarized as follows:
framework that enables
than merely adjusting
We introduce a novel self-evolution framework that operates at the trajectory level to enhance agent reasoning capabilities. Importantly, our approach remains effective regardless of improvements in base model capabilities, as long as complex tasks continue to require multi-step reasoning- requirement likely to persist in the foreseeable future. By manipulating trajectories rather than relying on sampling variations, we achieve genuine diversity in solution paths and final outcomes.
We conduct comprehensive experiments on SWE-bench Verified (25), one of the most challenging and widely-adopted benchmarks for code-related tasks. Our results demonstrate significant performance improvements across different LLMs, validating the effectiveness of trajectory-level self-evolution in real-world software engineering scenarios.
'80.0% is achieved with Claude-4- -laune-4-Sonett using the latest SWE-Agent (aligned with the May 22, 2025 SWE-bench Verified leaderboard; baseline 66.6% resolved) together with our SE-Agent.

---

2
Related Works
Code Agents Code agents represent a specialized class of Al systems designed to understand, generate, and manipulate source code autonomously. These agents have evolved to handle increasingly complex software engineering tasks within large-scale codebases. Given repository-Ieve objectives, they identify relevant files and code segments before implementing necessary modifications. In this work, we focus on the SWE-bench task, which involves resolving real-world GitHub issues by automatically applying functional bug fixes.
[26] introduces the concept of agent-computer
interfaces through SWE-agent, while OpenDevin [27] presents a collection of community driven
agents, including CodeAct (28). The Agentless approach (29) achieves competitive performance using streamlined two-step process of localization and repair. AutoCodeRover (30) incorporates advanced code analysis techniques, including abstract syntax trees and spectrum-based fault localization. Alibaba's Lingma Agent [31] proposes a search- based strategy for for repository exploration followed by structured editing. Additionally, several studies [32 33
34 35] demonstrate that repeated trajectory sampling, even under identical agent configurations, can lead significant variance in outcomes. More recently, SWE-search [36] proposes a multi-agent framework integrating Monte Carlo Tree Search (MCTS) with a self-improvement mechanism to enhance performance on such tasks.
Agent Capability Enhancement Recent research has developed diverse approaches enhance intelligent agent performance. Planning frameworks like GoalAct [37] introduce global planning with hierarchical execution, reducing complexity and improving adaptability by 12.22% on LegalA- gentBench [38]. For code generation, the RGD framework [39] leverages multi-agent debugging for iterative optimization, outperforming state-of- tet-hherrr methods by 9.8% on HumanEval and 16.2% on MBPP datasets. Collaborative approaches such as Collaborative Voyager (40] enable agents to communicate and learn from each other, effectively addressing hallucinations while enhancing task completion. Meta-planning optimization through MPO [11 provides high-level guidance and continuously optimizes plans based on execution feedback, significantly improving task efficiency and generalization. Agent augmentation methods like AutoGPT [42] and AgenIGPT 43 integrate tool usage to expand agent capabilities, while retrieval-augmented frameworks such MemGPT [44) and ReAct [8] enhance contextual understanding through memory mechanisms. Self-improvement techniques, including Reflexion [10 and CRITIC (4), enable agents to iteratively refine their reasoning through self-critique. While these methods show promise, our work introduces novel ap- proach within the ReAct paradigm that incorporates strategic reflection and mutation at critical steps. combining multiple trajectories to generate optimized execution paths without requiring extended computation time like Test-Time Scaling (TTS) techniques.
3 Preliminaries and Problem Setup
We consider general class of complex tasks that require multi-step reasoning and execution. These tasks can range from software engineering problems to mathematical problem-solving, strategic planning, or creative content generation. Formally, we model the reasoning environment as a tuple ε = (T,S, P, R), where T represents the space of all possible tasks that require multi-step reasoning S denotes the state space, where each state E S captures the current progress toward solving a task; AA is the action space available to the agent, which may include reasoning steps, information gathering, or direct task execution; P S x A - S defines the transition dynamics that map a state- satteacction pair to a new state; R S x T + R is the reward function that evaluates the quality of a state for given task.
Task-Oriented Reasoning Environment
Reasoning Trajectories Central to SE-Agent is the concept of reasoning trajectory, which repre- sents the sequential progression of states and actions as the agent works toward solving task. Given a task t E T, reasoning trajectory 7 is defined as an ordered sequence: 7 = (su, ag $1, a1,..., 8n) where Su the initial state, a, is the action taken at step i, and s,, is the final state. Each intermediate state is determined by the transition function: $;+1 = P(s;, az). The trajectory is generated by repeatedly applying a policy क x T A, which maps the current state and task to an appropriate action. The policy can incorporate various reasoning strategies, including decomposition, planning, and verification. The quality of a trajectory is measured by the final reward: R(T, () = R(s,. 1),
which evaluates how well the final state s, satisfies the requirements of task t.
3

---

Revision
Trajectory Pool
Recombinstion
Update Trajectry Pool
Agent Retlection
Trajectory Pool
Chotsiatto
Sample Severd Trejechanes
Unilie Tea Trojactories
New Trajactory
Trunsffer
Ref iinementt
Find
RULES
O
Erhanced
Enolatiion by Agent
Reference Trojecteries
traufe"
Trajectory
Rules
Restructio Ture
Sumpping
Plan
Sample Conui denblle Trajectones
New Trujectory
Orig nol Ingur
Apent Original Arseet
Upditte Trojechory
Figure 1: Overview of the proposed SE-Agent self-evolution framework. Starting from an initial pool of diverse pilot trajectories, the agent iteratively performs three trajectory-level opera- tors Resi-Rvinoon,, Recombination, and Refinement- harvest cross-trajectory insights, escape local optima, and converge to a high-reward solution path that robustly solves the target task.
Objective of Agent The objective of our work is to develop agent that generate high-quality reasoning trajectories for complex tasks. Specifically, given a task E T, we aim to find a policy क that maximizes the expected reward: n² arg max, EnT [R(7" (R((T((t)))) t)], where (*()) denotes the trajectory generated by policy ı for task t.
SE-Agent
In this section, we introduce SE-Agent, a novel yet self-evolution paradigm to tackle intricate tasks involving multi-step executions. To derive high-rewarding trajectory, SE-Agent alternatively generates a series of improved trajectories in which the best one chosen. Specifically, we design the trajectory evolution mechanism using pre-collected pilot trajectories, which generate references for imitation learning of the SE-Agent. Our main inspiration is formulate the pilot trajectories as an "improvement operator" applied to the apprentice trajectory, which allows the agent to continuously evolve its reasoning paths through iterative refinement and cross-trajectory learning.
4.1 Overview of SE-Agent
The philosophy of SR-Agent lies in leveraging the collective intelligence embedded within multiple reasoning trajectories to transcend the limitations of isolated reasoning attempts. As illustrated in Figure [ SE-Agent operates through an evolutionary framework that systematically improves trajectory quality across iterations.
Given task T, first generate diverse pool of initial trajectories To (f1, f2. t, through dalli-dimeesional planning and exploration. Each trajectory t; represents a sequence reasoning steps and actions taken by the agent to solve the task T. Rather than selecting the best trajectory from this initial pool and terminating, as traditional approaches do, SE-Agent employs an iterative evolution process to derive increasingly improved solutions.
Our SE-Agent repeats the following three fundamental operations:
Revision: Enhancing individual trajectories through self-reflection and targeted improvement
Recombination: Creating trajectories by combining strengths from existing paths
Refinement: Optimizing trajectories by eliminating redundancies and enhancing efficiency

---

Each iteration à produces a new generation of trajectories Tú, with the quality of solutions progressively improved(See Fig for a detailed case study demonstrating this process on a real Astropy bug fix.). This process continues until the convergence criteria are met or a predetermined number of iterations reached. The final output is the highest-rewarding trajectory t" that most effectively solves the original task. The key innovation of SEE-Agent is its ability to escape local optima by intelligently exploring the solution space guided by previous experiences while simultaneously leveraging cross- trajectory inspiration efficiently enhance performance. This dual mechanism enables continuous self-evolution the agent's reasoning capabilities.
One may interpret SE-Agent as specialized form of genetic algorithm tailored for large lan- guage model reasoning. From such a perspective. our approach shares conceptual similarities with evolutionary computation frameworks where trajectory generation acts as the genotype, and the problem-solving performance represents the phenotype expression. However, unlike traditional genetic algorithms that typically require numerous iterations to converge to acceptable solutions, SE--Agent is designed to achieve high-quality results with remarkably fewer evolutionary cycles. This efficiency stems from targeted operations that leverage the inherent reasoning capabilities of LLMs combined with structured evolution mechanisms. Furthermore, SE-Agent bears resemblance to self-play and expert iteration approaches in reinforcement learning, where each trajectory refine- ment step serves as an improvement operator that guides subsequent reasoning through enhanced exploration and exploitation balance. The key distinction lies in our explicit manipulation of complete reasoning trajectories rather than isolated acteonction pairs, enabling more holistic improvements across the entire problem-solving process.
4.2 Revision Operation
The revision operation forms the foundation of SE-Agent's self-evolution capability, focusing generating and improving individual trajectories through introspection and targeted enhancement.
4.2.1
Generating Initial Trajectories
To establish a diverse starting point for evolution, we employ two complementary approaches.
Planning Exploration We first generate several distinct trajectories for task T by varying planning strategies, prompting techniques, and reasoning approaches. This maximizes the dimen- sional diversity of our initial trajectory pool, ensuring broad coverage of the solution space. Each trajectory t E To is generated as
4 = Plan(T, 0.),
where 0 represents different planning parameters and strategies.
Mutation- Based Diversification We further expand the trajectory pool by applying controlled mutations to existing trajectories, producing M additional paths. These mutations introduce targeted variations in reasoning steps, action selections, intermediate conclusions:
f Mutate(t;, 1,...,M M
where 6, controls the degree and nature of mutations applied.
This dual approach results in an initial pool of ten diverse trajectories To = Taplan U T-mutate that serve the foundation for subsequent evolution.
4.2.2 Reflection and Revision
For each trajectory f; To, perform critical reflection process that analyzes strengths, weak- nesses, and potential improvement areas:
R² = Reflecttt.,.
Based on these reflections, we derive revised trajectories through targeted improvements:
Revise(t, R,).
5

---

The reflection process identifies logical inconsistencies and elaborates on underdeveloped reason- ing steps. The revision process then eliminates redundant or circular reasoning and incorporates alternative perspectives when beneficial.
The revision operation embodies the principle of "planning origin and reflective evolution", where initial plans serve as seeds that evolve through structured self-reflection and targeted improvement.
Recombination Operation
While the revision operation enhances individual trajectories, the recombination operation facilitates collective evolution through cross- trosettrayeytrry learning.
4.3.1 Trajectory Recombination
We implement three complementary recombination strategies to generate superior trajectories.
Crossover We identify peehhhreforing trajectory segments across different paths and combine them to create hybrid trajectories that inherit the strengths of multiple parents:
Crossover(44. (j,
nEW
where a determines the crossover points and combination strategy.
Transfer Learning Knowledge and strategies from successful trajectories are systematically trans- ferred to enhance less developed paths:
tranefer Transfer(ts, tt.,tt,......8.
'new
where 3 controls the transfer mechanism and knowledge adaptation process.
Restructuring Trajectory restructuring based collective insights from the trajectory pool:
restructure Restruccure (7,, 7),
new
where 7 guides the restructuring process using global trajectory analysis.
4.4
Refinement Operation
The refinement phase represents the culmination of our self-evolution approach, focusing trajectory optimization and final selection based on comprehensive evaluation metrics.
4.4.1
Evaluation Function
To effectively guide the evolutionary process and select optimal trajectories, we design a multi- dimensional reward function that evaluates trajectory quality across several critical axes:
Reward TaskCompletion((,1) T) ReasoningQuality(t
Efficiency(t),
where TaskCompletion(t, T) measures how effectively trajectory t solves task T through structural validation (e.g., non-empty patch files, sufficient code-editing steps, reasonable trajectory length), (uasoningQualiit(()) evaluates the logical coherence, depth and robustness of the reasoning process, and Efficiency() (4) quantifies computational efficiency terms of reasoning steps and resource utiliza- tion. The hyperparameters a, B, 7, and å control the relative importance of each evaluation dimension and can adjusted based on task requirements.
We implement this reward function using a combination of automatic metrics and specialized evaluators that analyze both the process and outcome of each trajectory:
TaskCompletion(t, T) AutoEval(t, 7) + X ExpertEval(t, T),
where AutoEval consists of rule-based structural validation metrics, while ExpertEval incorporates LLM-based evaluation of solution quality.

---

Table 1: Performance comparison of our proposed SE-Agent and other frameworks on SWE-bench Verified, evaluated with @ass@1 and P across various LLMs. SWE-Agent CodeAct-based framework, and SWE-Search is MCTS- The best results are highlighted in bold. indicates open-source LLMs, while indicates clored-source LLMs.
SWE-Agent
SWE-Search (MCTS)
SE-Agent (Ours)
LLM
Pass@1
P
Pass@1
Pass@5
Pass@1 1
P
DeepSeek-Van V3-0324
31.6%
35.8%
39.4%
41.8%
54.8%
58.4%
Qwen-2.5-72b-Insttnu
18.8%
20.6%
23.4%
26.2%
38.8%
42.4%
Llama-3.1-70b-Instie
15.4%
17.8%
21.8%
23.6%
32.6% %
35.2%
GPT-4o A
22.4%
25.4%
32.6%
35.8%
40.4%
44.8%
Claude-3.7-Sonnet
40.6%
43.2%
47.4%
50.6%
61.2%
63.6%
4.4.2 Selection and Convergence
Building upon our comprehensive evaluation function, we implement strategic selection mechanism that balances trajectory quality and diversity drive the evolutionary process forward:
T = Select(T, U Ti UTT""" kk),
where k is the number of elite trajectories to maintain. The mechanism employs a hybrid approach to automatically retain the top-performing trajectories based on reward scores. Meanwhile, it ensures representation of distinct reasoning approaches by calculating trajectory dissimilarity metrics.
This selection process continues iteratively until either predefined number of evolution cycles is complcted or convergence criteria are met (e.g.. when the improvement in maximum reward falls below a threshold for consecutive iterations). The final output is the highest- trajectory:
t* = arg max Reward T).
tET,
where Ty is the final trajectory pool after all evolution cycles.
This refined selection and convergence approach embodies the essence of "collective competition and genetic emergence," " where trajectories compete and collaborate through structured evolution. Through this mechanism, SE-Agent achieves two critical advantages: (1) exploring substantially larger solution spaces by systematically navigating beyond local optima and (2) leveraging cross- trajectory inspiration to efficiently enhance performance while minimizing the impact of suboptimal reasoning paths. These advantages enable SE-Agent to tackle complex multi-step reasoning tasks with unprecedented effectiveness and efficiency, demonstrating the power of self-evolution.
5
Experiments
5.1 Experimental Setup
Benchmark In our experiments, we utilize SWE-bench Verified, curated subset of the broader SWE-bench, consisting of 500 real-world GitHub issues. This benchmark meticulously designed to provide self-contained and controlled environment for evaluating framework performance, with specific focus on functional bug fixes. Each instance in the benchmark includes natural language description of GitHub issue and its corresponding code repository, serving as the sole input to the model. To ensure the rigor evaluation, developer- correctness of model-generated patches. This combination of real-world scenarios and systematic validation establishes SWE-bench Verified as robust and consistent benchmark for assessing the effectiveness of automated fug-fixing systems.
unit tests are employed to verify the
Evaluation Metries To evaluate the performance of our proposed SE-Agent, we employ two key
metrics, i.c., the resolve rate (Pass@ I) and Pass @5. Pass@ quantifies the percentage of issues

---

80
SR-ngeet
w/o Revision
w/o Recombination
w/o All
Pass@e) (%)
40
20
DeepSeek-V3 V3
Qwen-2.5- 12--ruu-tttt
Llama-3. 3, 1-700b-nsstrcct Instruct
GPT-4o
Claude-3. Boauee3.7--ommeee 7.S-nneet
Figure 2: Ablation study of SE-Agent on SWE-bench Verified with three variants.
100
100
DeepSesk- V3-0324
GPT-4o
SEvAgent SWE: SWE-echcch
SWE-Agent
80
Qwen-2.5 (eemn-2.-720--nsttee 5-720-Instruct
Clanle-3 7-Sernnt
30
Llamm-33 3.1 I-ntuc-
Pasiit (N)
Pass@i (60
20
20
Candidate Trajectorics
Maximum Cost
Figure 4: Performance of SE-Agent with different numbers of candidate trajectories and different maximum costs of API on SWE-bench Verified.
successfully resolved the first attempt, serving as indicator of the system's 's overall effectiveness in generating accurate solutions without requiring multiple iterations. In contrast, Pass@5 5 assesses the percentage of issues for which correct solution is identified within five attempts, providing insight into the agent's 's search efficiency under constrained iteration budgets. Together, these metrics offer a comprehensive evaluation framework, capturing both the precision of the agent's 's initial predictions and its ability to explore solution spaces efficiently.
Baselines For comprehensive and fair evaluation, we compare the performance of SE-Agent against two widely recognized baselines: SWE-Agent (CodeAct-based) and SWE-Search (MCTS-basedd These baselines represent high-performing, open-souree frameworks frequently uti- lized in recent research on automated software engineer- ing tasks. The comparison is conducted across multi- ple models, encompassing both spen-source and closed- source paradigms. Specifically, we evaluate three leading open-source models (DeepSSek--V3-0324 Qwen-2.5-72b- Instruct, and I.lama-3. 1-7b-----------ttrcu as well as two state- of-the-art closed-source models (GPT-4o and Claude-3.7- 7- Sonnet). Notably, SE-Agent can be integrated into the existing framework as plug-and-pla module. Here we use SWE-Agent as the basis for subsequent experiments.
i-ggae Cleader Eeeraan
Clanlo
10
19
12
12
18
109
10
Figure 3: Venn diagram of resolved is- sues on SWE-bench Verified.
5.2 Experimental Results
Performance Comparison Table presents perfor- mance comparison between our proposed SF--Agent and existing frameworks on SWE-bench Verified. The results indicate that SE-Agent consistently outper-

---

Case: Silkit-leann44629
The study exomines concrete defect in softwore enginsering agents: within scikit learn, MuhhOutpunCiessffce
validatioon.py
to expose top-level classer_ attribute after fitting, even though cross-validation uhilities such os cress_ vol vol_predict that every classifier otheres is the post-fit contract of providing clesses cress, predict invoked method= predict__praee pro.bo"bb"" this mismatch triggers an AttributeErren. halting any pipeline that relies probability estimates. Hence, the issue violated interface contract between the multi-output wrapper and higher-level validation loyer.
Traditional Agent
Trageturr Porl
vallidation.p
Self-Evolve
SE- SE-Agent
multioutput.py
Figure 5: SWE-bench case SCIKIT-LEARN #14629. Top (Traditional Agent). Search paths are highly homogeneous: each rollout edits _vallddaa mallidaioon.po py. yielding near-duplicate "quick-fix" patches that hide the visible error yet fail hidden tests. Bottom (SE-Agent). By mixing and recombining whole trajectories, agent explores diverse regions of the patch space, discovers multioutpe aultioutpu. . py, and adds a one-line write of classes_, providing a root-level repair that passes the full test suite.
forms the baselines across all five evaluated L.LMs. Compared with SWE-Agent baseline, SE-Agent delivers relative improvement of +1 +112% (Llama-3.1-70B) +80% (GPT-4o) and +51% (Claude-3.7) Sonnet), Against the stronger MCTS-based SWE-Scarch, the relative gains are still +30% on average. Notably, all five models demonstrate substantial and consistent performance gains when integrated with our proposed framework, highlighting the generalizability and effectiveness of SE-Agent across diverse model families.
Ablation Study In this part, conduct the ablation study explore the contribution of each designed module in SE-Agent. Therefore, we compare SE-Agent with three different variants: (i) w/o Revision, i.e., the Revision operation is removed, resulting in only multiple homogenized trajectories. (ii) w/o Recombination, where we do not use the Recombination operation for trajectory interaction. (iii) w/o All, which does not use any trajectory optimization operation. The results presented in Figure 2 These results illustrate two facts: (i) All designed modules are important for SE-Agent. If any module is removed, Pass@1 will decrease. (ii) Revision is effective for the performance enhancement of SE-Agent because it provides diverse set of trajectories for subsequent Recombination. As illustrated in Figure 3 we further conduct a detailed analysis of the overlap in successfully resolved issue instances across different frameworks on SWE-bench Verified, using Venn diagram for visualization. The results reveal that our proposed SE-Agent uniquely solves 12 issue instances that none of the other models are able to address. In addition, SE-Agent exhibits substantial overlap with leading baselines in the set resolved issues, further underscoring its competitive overall performance. This analysis highlights two key advantages of SE-Agent: its competitive effectiveness in solving tasks tackled by state-of-the-art models and its distinct capability to address a broader range of difficult or previously unsolved issues, demonstrating robustness and complementary problem-solving strength.
In Figure 4 we investigate the effect of two key hyperparameters on the performance of SE-Agent: the number of candidate trajectories and the maximum API cost. Results show SE-Agent reaches near-optimal performance with just 10 candidate trajectories, demonstrating our trajectory- based search strategy's iss efficiency through tnaje-trajectory interactions. The maximum API cost reflects the depth of SE-Agent's 's exploration. Under the same cost budgets, SE-Agent consistently outperforms baseline methods in Pass @ scores, validating our self-evolution framework's 's effectiveness.
Case Study To better illustrate the concrete implementation of our method, Figure o provides complete case study demonstrating how SE-Agent progressively optimizes trajectories through its three core operations. As shown Figure 5 the crash surfaces inside _validation .y, yet the root cause is that the wrapper in multioutput. py never stores the required classes. field after training. Traditional ReAct/MCTS agents cling to the stack trace: (i) they pose the bug too narrowly, (ii) next-token prediction keeps every edit local, and (iii their roll-outs are near-identical, so each

---

PROTLEM DENTFFCCATIO
3: REF QUALITY DASED FLTERING
Prob Auliso comssc seeddeiii prnscapicedddii su.. Mi.. redrood frow duuppio rnteut retammnn fale when companed with hone, waing sythor compe operations
Asilying iolluation fundtio for quillty fhaingg
endlpe thas devdlp solution mutli stretagy trajectoy optiiiction..
Searing
LLM Scaring Seasoring cuall atian resomable ves uation
Rade lased Scorlags Crde pirteeens sytte encr chicking cnurtut striice
Rmalc hole from 19 papdaaoo high quality repoorko
STEP MULTI-STIN STRATES TRAJECTORY GEVERATIOO
2
Seceratel' S anta buges using officeer larning stotegie
On Destliidnng fex Recondée Opecations
gigeedyy
ignans
Crosoner Prodec Lou didiiin Comprehetiis hollng
P-last-
many fellaes
Tejestor A grap "'rrecgptaedaiii"" SEL ep subeit Nest
X station soans, logic wrrnn
hujestey sylest cnalyce faslanes vioe MSS, ponceet
con enuive out howw thosage
detertive
Try wonchwttoggg renenn
X Ovirtyy broad eccepiin handlngg
enalyse saage pattern targeted comproheratie fix
Oonsovrr Reauth grop torecagriesdest > view beicuantts ay
Tronster Ecuption Handiing Putton Migration
Source tr eecppt Cypetrer Viluttre petters from deferakv sraning tejernay
Ster io RePLECTION & RESTSION OPERATION
Targe Sincle check from credd tejecory
Tranter fome theck muiti-tpor asceptiin catertig grapett degracation
Pastrutture Optiriaaioon
P-greddy
grxp-olennaki tests snratatiens socestiens/oppeas
Comprehantiee de type handlligg with propur cocspiora
Glbal Pattern Recageltors: All tepecioric revabe around "opeoeee competict uperaions"
Reskasdang
Beorganizadton design Compr
P-tet-
tytest-eralgns FatZenmieetor
Text Teoi-diven dowelog Full covelgg
aralysts
frre
COREExCHCING sepr chestiee ecit
Pilme
Clean
Ougast tngestoris latee generttd)
rest restrouctsreegssee
Invaaive Salf- Ronnddleeeeeennddddd
Steppl Stepp
exceptwell bikore lukote
STap e. Fesat SOLUTION SELECTION
Peennima"
ropand aeppendtntaenntt feLL
Completa solution complinity
Endkuding T0TT carakdit and selecting the liglesk-ccorg incedoog
JON Scries
62-TA
75-80
5.8
Figure 6: To better illustrate the concrete implementation our method, we provide a comprehensive case study that demonstrates how SE-Agent progressively optimizes trajectories through its three core operations.
patch merely tweaks .validation..p. Our SE-Agent sidesteps this tunnel vision by iteratively interacting with and evolving entire trajectories; this trajectory-level evolution serves as an implicit regularizer, foreing the search to generate genuinely novel solutions rather than minor variants of the same fix. Figure 7 in the Appendix provides detailed comparison of the trajectories output by SE-Agent before and after optimization. Notably, none of the top three public frameworks on SWE-bench can solve this case.
Conclusion
In this work, we introduced SE-Agent, a self-evolution framework designed to enhance the multi-step reasoning capabilities of LLM-based agents through iterative trajectory optimization. By revisiting, recombining, and refining previously generated trajectories, SE-Agent systematically expands the exploration space and leverages cross- tesjestraectory insights to improve decision-making efficiency. Experimental evaluations on SWE-bench Verified demonstrate that SE-Agent consistently outper- forms strong baselines across multiple LLMs. Our findings highlight the value of incorporating self-evolutionary principles into agent design, paving the way for more robust and adaptable reasoning frameworks in complex environments. Looking forward, we aim to extend the self-evolution paradigm of SE-Agent to wider spectrum of path-search cabblems-iicluding iterative search-reason frame- works such as DeepSearch, eeiforcement-learninn scenarios where agents must reason and act in the physical world.
policy discovery, and embodied -nntlliiddinelllgennee
10

---

References
[I] K. Zhang, J. Li, G. Li, X. Shi, and Z. Jin, "Codeagent: Enhancing code generation with tool-integrated agent systems for real-world repo-level coding challenges." arXiv preprint arXiv:2401.0333, 2024.
[2] C. Qu, S. Dai. X. Wei, H. Cai, S. Wang, D. Yin, J. Xu, and J.-R. Wen, "Tool learning with large language models: A survey," Frontiers of Computer Science, 2025.
[3] Z. Wang, Z. Cheng, H. Zhu, D. Fried, and G. Neubig, "What are tools anyway? a survey from the language model perspective." arXiv preprint arXiv:2403.15452, 2024.
[4] Z. Wang, D. Fried, and G. Neubig, "Trove: Inducing verifiable and efficient toolboxes for solving programmatic tasks," arXiv preprint arXiv:2401.12866 2024.
[5] T. Cai, X. Wang, T. Ma. X. Chen, and D. Zhou, "Large language models tool makers," arXiv preprint arXiv:2305. /7126, 2023.
[6] R. Nakano, Hilton, S. Balaji, J. Wu, L. Ouyang, C. Kim, C. Hesse, S. Jain, V. Kosaraju, W. Saunders et al., "Webgpt: Browser-assisted question-answering with human feedback," arXiv preprint arXiv:21 2021.
[7] J. Wei, X. Wang, D. Schuurmans, M. Bosma, F. Xia, E. Chi, Q. Le, D. Zhou et al., "Chain-of- thought prompting elicits reasoning in large language models," Advances in Neural Information Processing Systems (NeurIPS), 2022.
[8] S. Yao, J. Zhao, D. Yu, N. Du, I. Shafran, K. Narasimhan, and Y. Cao, "React: Synergizing reasoning and acting in language models," in International Conference on Learning Representa- tions (ICLR), 2023.
[9] G. Mialon, R. Dessi, M. Lomeli, C. Nalmpantis, R. Pasunuru, Raileanu, B. Rozière, Schick, J. Dwivedi- Yu, A. Celikyilmaz. et al., "Augmented language models: survey," arXiv preprint arXiv:2302.0788. 078422 2023.
[10] N. Shinn, F. Cassano, A. Gopinath, K. Narasimhan, and S. Yao, "Reflexion: Language agents with verbal reinforcement learning." Advances in Neural Information Processing Systems (NeurIPS), 2023.
[11] M. Renze and E. Guven, "Self-reflection in Ilm agents: Effects problem-solving performance," arXiv preprint 27X6622405.06622, 2024.
[12] L. Gao, A. Madaan, S. Zhou, Alon, P. Liu, Y. Yang. J. Callan, and G. Neubig, "Pal: Program- aided language models," in International Conference on Machine Learning (ICML), 2023.
[13] W. Huang, Abbeel, D. Pathak, and I. Mordatch, "Language models as zero-shot planners: Extracting actionable knowledge for embodied agents," in International Conference on Machine Learning (ICML), 2022.
[14] C. B. Browne, E. Powley, D. Whitehouse, M. Lucas, P. Cowling, P. Rohlfshagen, S. Tavener, D. Perez, S. Samothrakis, and S. Colton, "A survey of monte carlo tree search methods," IEEE Transactions on Computational Intelligence and Al in Games (T- (T-CIAIG), 2012.
[15] Y. Pitanov, A. Skrynnik, A. Andreychuk, K. Yakovlev, and A. Panov, "Monte-carlo tree search for multi- aalti--aentt pathfinding: Preliminary results," " International Conference on Hybrid Artificial Intelligence Systems (HAIS), 2023.
[16] L. Kocsis and C. Szepesvári, "Bandit based monte-carlo planning," in European Conference Machine Learning (ECML), 2006.
[17] D. Silver, J. Schrittwieser, K. Simonyan, I. Antonoglou, A. Huang, A. Guez, T. Hubert, L. Baker, M. Lai, A. Bolton al., "Mastering the game of go without human knowledge," Nature, 2017.
[18] M. Painter, M. Baioumy, N. Hawes, and B. Lacerda, "Monte carlo tree search with boltzmann exploration," Advances in Neural Information Processing Systems (NeurIPS), 2023.

---

[19] A. K. Vijayakumar, M. Cogswell, R. R. Selvaraju, Q. Sun, S. Lee, D. Crandall, and D. Batra, "Diverse beam search: Decoding diverse solutions from neural sequence models," " in AAAI Conference Artificial Intelligence (AAAT), 2018.
[20] A. Holtzman, J. Buys, L. Du, M. Forbes, and Y. Choi, "The curious case of neural text degeneration." International Conference on Learning Representations (ICLR), 2020.
[21] Y. Zhang, H. Diddee, S. Holm, H. Liu, X. Liu, V. Samuel, B. Wang, and D. Ippolito. "Noveltybench: Evaluating creativity and diversity in language models," arXiv preprint ar arXiv:2504.05228, 2025.
[22] A. Kalavasis, A. Mehrotra, and G. Velegkas, "On the limits of language generation: Trade-offs between hallucination and mode collapse," arXiv preprint vrXiv:2411.06642 2024.
[23] Y. Guo, G. Shang, M. Vazirgiannis, and C. Clavel, "The curious decline of linguistic diversity: Training language models on synthetic text," in The Nations of the Americas Chapter of the Association for Computational Linguistics (NAACL), 2024.
[24] S. Murthy, T. Ullman, and J. Hu, "One fish, two fish, but not the whole sea: Alignment reduces language models' conceptual diversity." in The Nations of the Americas Chapter of the Association for Computational Linguisties (NAACL), 2025.
[25] C. E. Jimenez, J. Yang, A. Wettig, S. Yao, K. Pei, O. Press, and K. R. Narasimhan, "Swe- bench: Can language models resolve real-world github issues?" in International Conference on Learning Representations (ICLR), 2024.
[26] Yang, C. Jimenez, A. Wettig, K. Lieret, S. Yao, K. Narasimhan, and O. Press, "Swe-agent: Agent-computer interfaces enable automated software engineering." Advances in Neural Infor- mation Processing Systems (NeurlPS), 2024.
[27] X. Wang, B. Li, Y. Song, F. F. Xu, X. Tang, M. Zhuge, J. Pan, Y. Song, B. Li, J. Singh, H. H. Tran, F. Li, R. Ma, M. Zheng, B. Qian, Y. Shao, N. Muennighoff, Y. Zhang, B. Hui, J. Lin, R. Brennan, H. Peng, H. Ji, and G. Neubig, "Opendevin: An open platform for ai software developers as agents," " in International Conference on Learning Representations (ICLR), 2025.
[28] X. Wang, Y. Chen, L. Yuan, Y. Zhang, Y. Li, H. Peng, and H. Ji, "Executable code actions elicit better I1m agents," in International Conference on Machine Learning (ICML), 2024.
[29] C. S. Xia, Y. Deng, S. Dunn, and L. Zhang, "Agentless: Demystifying lmsedsedd software engineering agents," arXiv preprint arXiv:2407.01-48 2024.
[30] Y. Zhang, H. Ruan, Z. Fan, and A. Roychoudhury, "Autocoderover: Autonomous program improvement," in International Symposium on Software Testing and Analysis (ISSTA), 2024, pp. 1592-1604.
[31] Y. Ma, Q. Yang, R. Cao, B. Li, F. Huang, and Y. Li, "Alibaba lingmaagent: Improving automated issue resolution via comprehensive repository exploration." arXiv preprint arX1v:2406.01422, 2024.
[32] X. Wang, J. Wei, D. Schuurmans, Q. Le, E. Chi, S. Narang, A. Chowdhery, and D. Zhou, "Self-consistency improves chain of thought reasoning in language models," arXiv preprint arXiv:2203.111771 2022.
[33] Y. Xie, A. Goyal, W. Zheng, M.-Y. Kan, T. P. Lillicrap, K. Kawaguchi, and M. Shich, "Monte carlo tree search boosts reasoning via iterative preference learning," arXiv preprint wwXiv:2405.0045. 2024.
[34] M. Besta, N. Blach, A. Kubicek, R. Gerstenberger, M. Podstawski. L. Gianinazzi, J. Gajda, T. Lehmann, H. Niewiadomski, Nyezyk et al., "Graph of thoughts: Solving elaborate problems with large language models." in AAAI Conference on Artificial Intelligence (AAAI), 2024.
[35] S. Yao, D. Yu, J. Zhao, I. Shafran, T. Griffiths, Y. Cao, and K. Narasimhan, "Tree of thoughts: Deliberate problem solving with large language models," Advances in Neural Information Processing Systems (NeurIPS), 2023.
12

---

[36] A. Antoniades, A. Órwall, K. Zhang, Y. Xie, A. Goyal, and W. Wang, "Swe-search: Enhanc- ing software agents with monte carlo tree search and iterative refinement," arXiv preprint urXiv:2410.20288 2024.
[37] J. Chen, H. Li, J. Yang. Y. Liu, and Q. Ai, "Enhancing llmebased agents via global planning and hierarchical execution," arXiv preprint 17525 2025.
[38] H. Li, J. Chen, J. Yang, Q. Ai, W. Jia, Y. Liu, K. Lin, Y. Wu, G. Yuan, Y. Hu et al., "Legalagent- bench: Evaluating IIm agents in legal domain," arXiv preprint arXiv:24/2.17259 2024.
[39] H. Jin, Z. Sun, and H. Chen, "Rgd: Multi-llm based agent debugger via refinement and generation guidance," in International Conference on Agents (ICA), 2024.
[40] G. Wang, Y. Xie, Y. Jiang, A. Mandlekar, C. Xiao, Y. Zhu, L. Fan, and A. Anandkumar, "Voyager: open-ended embodied agent with large language models," arXiv preprint arXiv:2305. 16291, 2023.
[41] W. Xiong, Y. Song, Q. Dong. B. Zhao, E. Song, X. Wang. and S. Li, "Mpo: Boosting Ilm agents with meta plan optimization." arXiv preprint 2rXiv:2003.02662, 2025.
[42] H. Yang. S. Yue, and Y. He, "Auto-gpt for online decision making: Benchmarks and additional opinions," " arXiv preprini arXiv:2306.02224, 2023.
[43] Reworkd, "Agentgpt: Assemble, configure, and deploy autonomous ai agents," https://github com//eworkd/AgeeiGPTT 2023, gitHub repository, accessed May 2025.
[44] C. Packer, V. Fang, S. G. Patil, K. Lin, S. Wooders, and J. E. Gonzalez, "Memgpt: Towards Ilms as operating systems," arXiv preprint 1rX1v:2310.08560, 2023.
[45] Z. Gou, Z. Shao, Gong, Y. Yang, N. Duan, W. Chen et al., "Critic: Large language models self-correct with tool-interactive critiquing," in International Conference Learning Representations (ICLR), 2024.
13

---

NeurIPS Paper Checklist
The checklist is designed to encourage best practices for responsible machine learning research, addressing issues of reproducibility, transparency, research ethics, and societal impact. Do not remove the checklist: The papers not including the checklist will be desk rejected. The checklist should follow the references and follow the (optional) supplemental material. The checklist does NOT count towards the page limit.
Please read the checklist guidelines carefully for information on how to answer these questions. For each question in the checklist:
You should answer [Yes], [No], or [NA].
[NA] means either that the question is Not Applicable for that particular paper or the relevant information is Not Available.
Please provide short (1-2 sentence) justificcton right after your answer (even for NA).
The checklist answers are an integral part of your paper submission. They are visible to the reviewers, area chairs, senior area chairs, and ethics reviewers. You will be asked to also include (after eventual revisions) with the final version of your paper, and its final version will be published with the paper.
The reviewers of your paper will be asked to use the checklist as one of the factors in their evaluation.
While "[Yes] " is generally preferable to "[No]", ", it is perfectly acceptable to answer "[No] provided proper justification is given (e.g., "error bars are not reported because it would be too computationally expensive" or "we were unable to find the license for the dataset we used"). In general, answering "[No] or "[NA] is not grounds for rejection. While the questions are phrased in binary way, we acknowledge that the true answer often more nuanced, so please just use your best judgment and write justification to elaborate. All supporting evidence can appear either in the main paper or the supplemental material, provided in appendix. If you answer [Yes] to a question, in the justification please point to the section(s) where related material for the question can be found.
IMPORTANT, please:
Delete this instruction block, but keep the section heading "NeurIPS Paper Checklist",
Keep the checklist subsection headings, questions/answers and guidelines below.
Do not modify the questions and only use the provided macros for your answers.
1. Claims
Question: Do the main claims made in the abstract and introduction accurately reflect the paper's contributions and scope?
Answer: [Yes]
Justification:
The abstraction and introduction reflect necessary contributions and experi-
ments.
Guidelines:
The answer NA means that the abstract and introduction do not include the claims made the paper.
The abstract and/or introduction should clearly state the claims made, including the contributions made the paper and important assumptions and limitations. A No or
NA answer to this question will not be perceived well by the reviewers.
The claims made should match theoretical and experimental results, and reflect how much the results can be expected to generalize to other settings.
It is fine to include aspirational goals as motivation as long as it is clear that these goals are not attained by the paper.
2. Limitations
Question: Does the paper discuss the limitations of the work performed by the authors? Answer: [Yes]
14

---

Justification:
The potential trade-off is discussed within the paper in a separate Section,
Guidelines:
The answer NA means that the paper has no limitation while the answer No means that the paper has limitations, but those are not discussed in the paper.
The authors are encouraged to create separate "Limitations" section in their paper.
The paper should point out any strong assumptions and how robust the results are to violations of these assumptions (e.g., independence assumptions, noiseless settings, model vell-specification, asymptotic approximations only holding locally). The authors should reflect on how these assumptions might be violated in practice and what the implications would be.
The authors should reflect on the scope of the claims made, e.g., if the approach was only tested few datasets with few runs. In general, empirical results often depend on implicit assumptions, which should be articulated.
The authors should reflect on the factors that influence the performance of the approach. For example, facial recognition algorithm may perform poorly when image resolution is low or images are taken in low lighting. Or speech-to-text system might not be used reliably to provide closed captions for online lectures because it fails handle technical jargon.
The authors should discuss the computational efficiency of the proposed algorithms and how they scale with dataset size.
If applicable, the authors should discuss possible limitations of their approach to address problems of privacy and fairness.
While the authors might fear that complete honesty about limitations might be used by reviewers as grounds for rejection, worse outcome might be that reviewers discover limitations that aren't 't acknowledged in the paper. The authors should use their best judgment and recognize that individual actions in favor of transparency play an impor- tant role in developing norms that preserve the integrity of the community, Reviewers will be specifically instructed to not penalize honesty concerning limitations.
3. Theory assumptions and proofs
Question: For each theoretical result, does the paper provide the full set of assumptions and a complete (and correct) proof?
Answer: [Yes]
Justification:
The necessary assumption and proof are included in the paper.
Guidelines:
The answer NA means that the paper does not include theoretical results.
All the theorems, formulas, and proofs in the paper should be numbered and cross- referenced.
All assumptions should be clearly stated or referenced in the statement of any theorems.
The proofs can either appear in the main paper or the supplemental material, but if they appear in the supplemental material, the authors are encouraged provide short proof sketch to provide intuition.
Inversely, any informal proof provided in the core of the paper should be complemented by formal proofs provided in appendix or supplemental material.
Theorems and Lemmas that the proof relies upon should be properly referenced.
4. Experimental result reproducibility
Question: Does the paper fully disclose all the information needed to reproduce the main ex- perimental results of the paper to the extent that affects the main claims and/or conclusions of the paper (regardless whether the code and data are provided or not)?
Answer: [Yes]
Justification:
We have listed detail configuration of experiments in Section
Guidelines:
The answer NA means that the paper does not include experiments.
15

---

If the paper includes experiments, a No answer to this question will not be perceived well by the reviewers: Making the paper reproducible is important, regardless of whether the code and data are provided or not.
If the contribution is dataset and/or model, the authors should describe the steps taken to make their results reproducible or verifiable.
Depending on the contribution, reproducibility can be accomplished in various ways. For example, if the contribution is a novel architecture, describing the architecture fully might suffice, or if the contribution is specific model and empirical evaluation, it may be necessary to either make possible for others to replicate the model with the same dataset, or provide access to the model. In general. releasing code and data is often one good way to accomplish this, but reproducibility can also be provided via detailed instructions for how to replicate the results, access to a hosted model (e.g., in the case of a large language model), releasing of a model checkpoint, or other means that are appropriate to the research performed.
While NeurIPS does not require releasing code, the conference does require all submis- sions to provide some reasonable avenue for reproducibility, which may depend on the nature of the contribution. For example
(a) the contribution is primarily a new algorithm, the paper should make clear how reproduce that algorithm. (b) If the contribution is primarily new model architecture, the paper should describe the architecture clearly and fully.
(c) If the contribution is new model (e.g., a large language model), then there should either be way to access this model for reproducing the results or way to reproduce the model (e.g.. with an open-source dataset instructions for how to construct the dataset).
(d) We recognize that reproducibility may be tricky in some cases, in which case authors welcome describe the particular way they provide for reproducibilityy In the case of closed-source models, it may be that access to the model is limited in some way (e.g., registered users), but it should be possible for other researchers to have some path to reproducing or verifying the results.
5. Open access to data and code
Question: Does the paper provide open access to the data and code, with sufficient instruc- tions to faithfully reproduce the main experimental results, as described in supplemental material?
Answer: [Yes]
Justification: The code to reproduce the experimental results are provided on anonymous link.
Guidelines:
The answer NA means that paper does not include experiments requiring code.
Please see the NeurlPS code and data submission guidelines (https://nips cc/
for more details.
While we encourage the release of code and data, we understand that this might not be possible, "No" is an acceptable answer. Papers cannot be rejected simply for not including code, unless this is central to the contribution (c.g., for a new open-source benchmark).
The instructions should contain the exact command and environment needed to to reproduce the results. See the NeurIPS code and data submission guidelines (https
//nips.cc/public/eee. httpg//dddeeooeeuumiiieeeeeeeeee ssi ssionyllicy) for more details.
The authors should provide instructions on data access and preparation, including how to access the raw data, preprocessed data, intermediate data, and generated data, etc.
The authors should provide scripts to reproduce all experimental results for the new proposed method and baselines. If only subset of experiments are reproducible, they should state which ones are omitted from the script and why.
At submission time, to preserve anonymity, the authors should release anonymized versions (if applicable).
16

---

Providing as much information as possible in supplemental material (appended to the paper) recommended, but including URLs to data and code permitted.
6. Experimental setting/details
Question: Does the paper specify all the training and test details (e.g., data splits, hyper- parameters, how they were chosen, type of optimizer, etc.) necessary to understand the results?
Answer: [Yes]
Justification: Section specifies all the training and test details.
Guidelines:
The answer NA means that the paper does not include experiments.
The experimental setting should be presented the core the paper to level of detail that is necessary to appreciate the results and make sense of them.
The full details can be provided either with the code, in appendix, supplemental material.
7. Experiment statistical significance
Question: Does the paper report error bars suitably and correctly defined or other appropriate information about the statistical significance of the experiments?
Answer: [Yes]
Justification:
The experiments are conducted many times and report average results.
Guidelines:
The answer NA means that the paper does not include experiments.
The authors should answer "Yes" if the results accompanied by error bars, confi- dence intervals, or statistical significance tests, at least for the experiments that support the main claims of the paper.
The factors of variability that the error bars are capturing should be clearly stated (for example, train/test split, initialization, random drawing of some parameter, or overall run with given experimental conditions).
The method for calculating the error bars should be explained (closed form formula, call to a library function, bootstrap, etc.)
The assumptions made should be given (e.g.. Normally distributed errors).
It should be clear whether the error bar is the standard deviation or the standard error of the mean.
OK to report 1-sigma error bars, but one should state The authors should preferably report a 2-sigma error bar than state that they have 96% CI, if the hypothesis of Normality of errors is not verified.
For asymmetric distributions, the authors should be careful not to show in tables or figures symmetric error bars that would yield results that out of range (e.g. negative error rates).
If error bars reported in tables or plots, The authors should explain in the text how they were calculated and reference the corresponding figures or tables the text.
8. Experiments compute resources
For each experiment, does the paper provide sufficient information on the com- puter resources (type of compute workers, memory, time of execution) needed to reproduce the experiments?
Question:
Answer: [Yes]
Justification:
The specific configurations are included in the Section
Guidelines:
The answer NA means that the paper does include experiments.
The paper should indicate the type of compute workers CPU or GPU, internal cluster, or cloud provider, including relevant memory and storage.
17

---

The paper should provide the amount of compute required for each of the individual experimental runs as well estimate the total compute.
The paper should disclose whether the full research project required more compute than the experiments reported in the paper (e.g., preliminary or failed experiments that didn't make into the paper).
9. Code of ethics
Question: Does the research conducted in the paper conform, in every respect, with the NeurIPS Code of Ethics htttps:/neuurist: http://wwwgg..ccoaaaa....aacccca
Answer:
[Yes]
Justification:
We follow the NeurIPS Code of Ethics.
Guidelines:
The answer NA means that the authors have not reviewed the NeurIPS Code of Ethics.
If the authors answer No, they should explain the special circumstances that require deviation from the Code of Ethics.
The authors should make sure to preserve anonymity (e.g., there a special consid- eration due to laws regulations in their jurisdiction).
10. Broader impacts
Question: Does the paper discuss both potential positive societal impacts and negative societal impacts of the work performed?
Answer: [Yes]
Justification: We discuss the potential positive societal impacts of using SE-Agent in the Conclusion section.
Guidelines:
The answer NA means that there is no societal impact of the work performed.
If the authors answer NA or No, they should explain why their work has socictal impact or why the paper does not address societal impact.
Examples of negative societal impacts include potential malicious or unintended uses (e.g., disinformation, generating fake profiles, surveillance), fairness considerations (e.g., deployment of technologies that could make decisions that unfairly impact specific groups), privacy considerations, and security considerations.
The conference expects that many papers will be foundational research and tied to particular applications, let alone deployments. However, if there is direct path to any negative applications, the authors should point it out. For example, it is legitimate to point out that improvement in the quality of generative models could be used to generate deepfakes for disinformation. On the other hand, it is not needed to point out that generic algorithm for optimizing neural networks could enable people to train models that generate Deepfakes faster.
The authors should consider possible harms that could arise when the technology is being used intended and functioning correctly, harms that could arise when the technology is being used as intended but gives incorrect results, and harms following from (intentional or unintentional) misuse of the technology.
If there are negative societal impacts, the authors could also discuss possible mitigation strategies (e.g., gated release of models, providing defenses in addition attacks, mechanisms for monitoring misuse, mechanisms to monitor how a system learns from feedback over time, improving the efficiency and accessibility of ML).
11. Safeguards
Does the paper describe safeguards that have been put in place for responsible release of data models that have high risk for misuse (e.g., pretrained language models, image generators, or scraped datasets)?
Question:
Answer: [NA]
Justification: The answer NA means that the paper poses such risks.
Guidelines:
18

---

The answer NA means that the paper poses no such risks.
Released models that have high risk for misuse or dual-use should be released with necessary safeguards to allow for controlled use of the model, for example by requiring that users adhere usage guidelines or restrictions to access the model or implementing safety filters.
Datasets that have been scraped from the Internet could pose safety risks. The authors should describe how they avoided releasing unsafe images.
We recognize that providing effective safeguards challenging, and many papers do not require this, but encourage authors to take this into account and make best faith effort.
12. Licenses for existing assets
Are the creators or original owners of assets (e.g., code, data, models), used in the paper, properly credited and are the license and terms of use explicitly mentioned and properly respected?
Question:
Answer: [Yes]
Justification:
We cite the original paper that produced the code package or dataset.
Guidelines:
The answer NA means that the paper does existing assets.
The authors should cite the original paper that produced the code package or dataset.
The authors should state which version of the asset used and, possible, include URL.
The name of the license (e.g., CC-BY 4.0) should be included for each asset.
For scraped data from a particular source (c.g.. website), the copyright and terms of service of that source should be provided.
If assets are released, the license, copyright information, and terms of use in the package should be provided. For popular datasets, paperswi thcode. com datasets has curated licenses for some datasets. Their licensing guide can help determine the license of dataset.
For existing datasets that re- ce-packaged, both the original license and the license of the derived asset (if it has changed) should be provided. If this information is not available online, the authors are encouraged to reach out to the asset's s creators.
13. New assets
Question: Are new assets introduced in the paper well documented and is the documentation provided alongside the assets?
Answer: [NA]
Justification: This paper does not release new assets.
Guidelines:
The answer NA means that the paper does not release new assets.
Researchers should communicate the details the dataset/code/model as part of their submissions via structured templates. This includes details about training, license, limitations, etc.
The paper should discuss whether and how consent was obtained from people whose asset used.
At submission time, remember to anonymize your assets (if applicable). You can either create anonymized URL or include anonymized zip file.
14. Crowdsourcing and research with human subjects
For crowdsourcing experiments and research with human subjects, does the paper include the full text of instructions given to participants and sereenshots, if applicable, as well details about compensation (if any)?
Question:
Answer: [NA]
19

---

Justification:
This paper does not involve crowdsourcing nor research with human subjects.
Guidelines:
The answer NA means that the paper does not involve crowdsourcing nor research with human subjects.
Including this information in the supplemental material is fine, but if the main contribu- tion of the paper involves human subjects, then as much detail as possible should be included in the main paper.
According to the NeurIPS Code of Ethics, workers involved data collection, curation, or other labor should be paid at least the minimum wage in the country of the data collector.
15. Institutional review board (IRB) approvals equivalent for research with human subjects
Question: Does the paper describe potential risks incurred by study participants, whether such risks were disclosed to the subjects, and whether Institutional Review Board (IRB) approvals (or an equivalent approval/review based on the requirements of your country or institution) were obtained?
Answer: [NA]
Justification: This paper does not involve crowdsourcing nor research with human subjects.
Guidelines:
The answer NA means that the paper does not involve crowdsoureing nor research with human subjects.
Depending the country in which research is conducted, IRB approval (or equivalent) may be required for any human subjects research. If you obtained IRB approval, you should clearly state this in the paper.
We recognize that the procedures for this may vary significantly between institutions and locations, and we expect authors to adhere to the NeurIPS Code of Ethics and the guidelines for their institution.
For initial submissions, do not include any information that would break anonymity (if applicable), such the institution conducting the review.
16. Declaration of LLM usage
Question: Does the paper describe the usage of LLMs if it is an important, original, or non-standard component of the core methods in this research? Note that if the LLM is used only for writing, editing, or formatting purposes and does not impact the core methodology. scientific rigorousness, or originality the research, declaration is not required.
Answer: [Yes]
Justification: Our framework conducts a detailed comparison of the use of different LLMs, and the performance of the method does not rely on the LLMMs themselves.
Guidelines:
The answer NA means that the core method development in this research does not involve LLMs as any important, original, or non non-standard components.
Please refer to our LLM policy for what should or should be described.
20

---

A Implementation Details
To ensure fair comparison, we adopt identical prompt formats across all models evaluated this paper. In our proposed SE-Agent framework, we set the number of candidate trajectories to 10 by default, striking balance between exploration diversity and computational efficiency.
We begin by employing five distinct planning strategies, as described in Section [B...] I to generate a diverse set of initial trajectories that reflect varied reasoning patterns. These serve the foundational seeds for further optimization. Next, we apply the reflection and revision operations (Section [. 1.2) each initial trajectory. This process generates up ten revised trajectories by encouraging self-criticism and iterative improvement within the agent's reasoning process.
Following the generation of candidate trajectories, perform the recombination operation (Sec- tion ).2). which enables the agent to integrate complementary insights from different trajectories, promoting information fusion and enhancing reasoning coherence. Subsequently, the refinement operation (Section [ is applied to finalize the optimized trajectories, ensuring logical consistency and code validity when applicable.
For deployment, we run all open-source models locally, including DeepSeek ShepSeek-V3-0324 Qwen-2.5- I2B-Instruct, and LLLMA-3.1 -..---rrr-- using NVIDIA A100 GPUs with 80GB of memory. For closed-source models such as GPT-4o and Glaude-3.-Sonmee we access them via the official APIs provided by OpenAl and Anthropic, respectively. All experiments are conducted under the same evaluation setting on SWE-bench Verified to ensure consistency and reproducibility.
B Prompt
B.1 Revision Operation
B.1.1 Multi-Planning
Planning-1
STRATEGY:
Always start by trying to replicate the bug that the issues discusses. If the issue includes code for reproducing the bug, recommend that you re-implement that in your environment, and run to make sure you can reproduce the bug.
Then start trying to fix it.
the bug reproduction script does not print anything when it successfully runs, we recom- mend adding print(" ("Cnnipt completed successfully, no errors." ") command at the end of the file,
that you be sure that the script indeed fine all the way through.
2. Locate relevant code using the find and search commands. 'open" the file you want to edit. I highly recommend using 'fileshow' command before you locate the relevant code get information about the folder where the target code file resides, this can help you think about what code locate and modify to better solve the problem.
3. Use the 'edit" command to perform edits.
When you think you't ve fixed the bug, re-run the bug reproduction script make sure that the bug has indeed been fixed.
Create additional tests to verify the fix style similar the existing reproduction script.
In particular, make sure to test edge cases.
you find any issues, go back the file you edited and perform further edits.
Planning-2
STRATEGY:
#*prroduee the Issue:*# Execute the provided test case or script to confirm the presence of the bug. If the script lacks output verification, insert validation statement (e.g., 'assert "Expected Behavior" in output") to ensure full execution.
21

---

2. **Code Investigation: Trace the execution flow using logging debugging tools. Identify the exact module, function, or line causing the discrepancy. Cross-refcrence with documentation or API contracts if needed.
3. ** *Modifiication Process:** Apply changes incrementally using version- version-controlled edits. Annotate modifications with comments explaining the rationale behind each adjustment (e.g.. "Fix: Resolved race condition by adding mutex lock").
** V=Vlidatton: Re-run the original test alongside regression tests covering related functionality. Include boundary conditions (e.g., empty inputs, extreme values) and parallel execution scenarios if applicable.
5. *#Documentation:*** Update changelogs or inline documentation to reflect the fix. If the issue reveals a broader architectural weakness, propose follow-up task address systemic improvements.
Planning-3
STRATEGYY:
1. *"Reproduce the Issue:** Execute the provided bug reproduction script or steps in your local environment. the script runs silently, insert confirmation message (e-g.. (eint("Reroouction successful-bae bug observed." ")") to verify execution.
#* **Code Investigation: ** Identify the relevant code sections using search tools or IDE navigation. Open the suspected files and analyze the logic around the reported issue. **[mplemet Fixes:** Use an editor to modify the problematic code, ensuring changes align with the intended behavior. Document adjustments with inline comments explaining the rationale.
4. **Verify the Fix:** Re-run the reproduction script to confirm the bug is resolved. Check for regression by ensuring existing functionality remains intact.
5. **Expand Test Coverage: Develop test cases, including edge scenarios, validate robustness. If failures occur, refine the fix and repeat verification until all tests pass.
6. ** **Final Review:**
changes against project coding standards. Summarize modifications and test results for documentation or version control.
Planning-4
STRATEGY:
Begin by thoroughly analyzing the reported issue to understand its context and expected behavior. If the issue provides a minimal reproducible example, execute in your environment to confirm the bug. Modify the script to include clear success/failure indicator (e.g.. "print("Valldaat Validation passed.")) to ensure full execution.
Systematically trace the codebase using grep, IDE search, debugging tools pinpoint the exact file(s) and logic responsible for the unexpected behavior. Open the relevant files for inspection.
3. Make targeted adjustments using your preferred editor or IDE, ensuring changes align with the project's architecture. Document modifications with inline comments explaining the rationale.
Validate the fix by re-running the original reproduction script and checking for resolved behavior. Confirm regressions occur in related functionality.
Expand test coverage by designing new test cases that stress edge conditions, boundary values, and atypical inputs. Integrate these into the existing test suite. If failures persist, iterate on the fix and retest until all scenarios pass. 6. Finally, review the changes for code style consistency and potential optimizations before submission.
22

---

Planning-5
STRATEGY:
"*Reroducee the Issue:** Begin by carefully executing the steps or code provided in the bug report to confirm the problem. If the reproduction script runs silently, insert confirmation message (e.g., "print(" Drrii("Verifiiation: Initial bug reproduction successful." ")') to ensure full execution.
2. **Code Investigation:** Systematically trace the issue using search tools debugging utilities. Identify the exact file(s) and section(s) involved, then open them for analysis. 3. **Ipplement Changes:** Use precise editing commands to modify the problematic code.
Document each adjustment track potential impacts.
4. Validattonn Re-run the reproduction script after each edit to verify the fix. If the issue persists, refine the changes incrementally.
5. **egressionn Testing:** Expand test coverage by designing new test cases that mirror the original issue's ' context, including edge scenarios. Iterate failures occur.
6. **iinal Confirmation: Ensure the fix doesn't it introduce new issues by running the full test suite or related workflows. Only conclude when all validations pass.
B.1.2 Reflection and Revision
Reflection- the Critical Step
You are an expert in analyzing agent trajectories. Your task to identify the single most influential critical decision point in the trajectory. A critical decision point is the step that has the most significant impact on the entire solution, typically:
1. Finding the location of the problem (such locating specific files functions)
2. Discovering the breakthrough point for the solution 3. Making key modifications or judgments 4. Determining the correct execution path You need to analyze the entire trajectory, identify the single most critical step, and provide: Step number- Why this step the most critical The impact of this step the final solution Output must strictly follow JSON format, containing: cri aritical_step object with fields: step, action, reasoning, impact
The following example demonstrates the expected output format and level of detail for critical point identification:
## Input Example
""json "trajectory": "step": "action": "Search for __cch_ch____________________te__ list wttpllist___sppple _itm func- tion in src directory", "observation": "No matches found" "step": 2, "action": "Exe- cute Is -F view file structure", "observation": "Listed directory structure". "step": 3, "action": "Search for _cchcc__eessseeeee list_ wiss_ddsspll__ttieeeeeseesepp servation": "Found 2 matches in gjangoloottib/ammiincckksss "Open django/contribadmmnncceele
function in django directory". "ob- "step": 4, "action":
file", "observation": "Successfully opened, 1116 lines total" "step": 5, "action": "Search for Check_list list_dissstl__tt_eeeesssssssss_t item function in checks.py", "observation": "Found at lines 714 and 718". "step": 6, "action": "Navigate to line 718 to view function definition", "observation": "Displayed complete implementation of _ccccck list fost__dislayy _i_item item function" "step": 7, "action": "Modify function logic to resolve admin.E108 error", "observation": "Successfully edited code". "step": 8, "ac- tion": "Submit solution", "observation": "Task completed"
.. ## Output Example func-
"critical_step" "step": 3, "action": "Search for _ceckk list iilss_ddspll___t tion in django directory", "reasoning": "This is the most critical breakthrough point in the entire solution process. After the first two search attempts failed, this step correctly located the exact position of the problem function. transitioning from directionless state having clear modification target. Without this step, all subsequent operations would be impossible." "impact": "Determined whether the entire task could be successfully completed. Finding the function location is prerequisite for solving the problem and marks the transition from exploration phase implementation phase."
23

---

Reflection-Conclude Feature
You are an Al assistant specialized in analyzing code patches. will provide a GitHub issue (problem_ statement) and corresponding patch. Your task is to analyze this patch and provide detailed insights that could help develop an alternative solution. Follow these steps:
Analyze the patch file and understand the changes made
2. Determine the core methods and techniques used to solve the problem
3. Identify the main files and sections that were modified
Identify key assumptions and limitations in the current solution
Return your analysis in JSON format with the following fields:
approach summary: Summary the main approach used in the first solution
modified_files: List of files that were modified
key_changes: Description key code changes in the patch
strategy: The core solution strategy at an abstract level
specific seriicttecniqqeee fartnniiuu_ufom____eee_e from_ffrrtttttee wwl.ffisssuuuiinoo Specific technique used that should be avoided in alternative solutions
specifcc_files__e ff_ncctiooo Files or functions that should not be modified in the same way
Assumptions made in the first solution component_not,_ wwwottoouceee_in..tommmom wwt.ffirs_ssouutiioo Components key functions not touched but potentially relevant
assumptions_matt saaee____frsss____uu_e
differents www.eeeeteerrsettiieee A different perspective for looking at the problem
The following examples are provided only for reference illustrate the expected level of detail and abstraction for each field. Your analysis should be based your understanding of the patch and problem:
approach, summary example: "Added conditional check to handle MuliiOutuutlassiffer by accessing classes through the estimators. attribute" podified_files example:
key_changes example: "Added condition to check if estimator has "estimators_ attribute, then uses estimator estimators__ [i_label] classes instead of estimator _laasee_[i__aaaae strategy example: "Component-specffc exception handling" (instead of "Interface extension to provide unified attribute access")
for MultiOutputClassffer
specific, htrpaaficcteccnnuueeeeeee coooofirr_ssouuiioo example: "Direct attribute checking with hasattr() and conditional branching"
specific_ffleesor__fuee fwnctions example: "_fit_ drit_annd_prdictt
function in example: "Assumes that only MultiOutputCla-
-py"
sifier needs special handling for classes_ attribute access"
component_note htttt/notttttcceet.ttt
example: "MultiOutpurClassffee class
in sklcam/mullioutppu..yy which could implement classes_ attribute directly" different_ sereet_perspeccttt example: "API consistency perspective: make MulliOutputClas sifier conform to the same interface as other classifiers instead of modifying the validation module"
Problem: problem_ problem_statemet statement Trajectory: trajectory Patch: model_pated
Revision
Let's develop different approach fix it.
I've analyzed the first solution attempt, and here's what I found:
The first solution approached this problem by approach_ sumnary.. It modified podified_filed and the key changes involved key_ sty__chanes... The core strategy used was "strategy" which may have limitations. Specifically, the solution used specific_ted seaifficctechhiiee que que and focused on changing specific_files,
This approach makes some assumptions: assumptions

---

For our alternative solution, I want you explore completely different approach. Instead of following the same strategy, consider looking at this from a Sdffferent_perspecctee angle.
You might want to investigate component_neg wwwpoonenn_ntttttutuoeoeoo notche as potential area for your solution. Remember, your goal is create patch that:
Solves the same problem but uses fundamentally different approach
Avoids the techniques used in the first solution
3. Challenges the assumptions made in the first solution
4. Still aims generate patch that passes all tests, and use the 'submit' command when you believe your modifications are complete Please analyze the problem again from this new perspective and develop your alternative solution.
B.2
Recombination Operation
CrossOver
You are an expert in analyzing and synthesizing agent trajectories. Your task is to critically analyze two different trajectories and create a new optimized trajectory by combining the best elements from both approaches.
Your fusion process should: Identify the strengths and weaknesses of each trajectory Extract the most effective strategies and techniques from both 3. Creatively integrate these elements into coherent new trajectory Ensure the new trajectory maintains logical flow and consistency 5. Avoid simply concatenating the trajectories create genuine synthesis You need to analyze both trajectories and provide: Analysis of strengths from trajectory A Analysis of strengths from trajectory B A new fused trajectory that combines the best aspects Rationale for the fusion decisions
Output must strictly follow JSON format, containing: trajectory_a sayy__sstrentts: list of strengths from first trajectory trajectory Sacyy_b_staaa_ b_strengths: list of strengths from second trajectory fused_ trajectory: trajectory steps combining best elements fusion_ratione
explanation fusion decisions Trajectory A: trajectory_e
Trajectory B: trajectory_b
The following example demonstrates the expected output format and level of detail for trajectory fusion:
## Input Example Trajectory A: "trajectory": "step": 1, "action": "search _dir for target function". "observation": "found function location quickly". "step": 2, "action": "directly edit function". "observation": "made changes without full analysis". "step": "action": "submit solution", "observation": "task completed"
Trajectory B: "trajectory": "step": "action": "analyze problem statement thoroughly", "oserrvation": "understood the root cause" "step": 2. "action": "search_file to find exact location". "observation": "took longer but found precise location". "step": "action": "review existing code logic", "observation": "identified potential side effects", "step": 4, "action": "implement careful modification". "observation": "made robust changes", "step": 5, "action": "test the solution". "observation": "verified correctness". "step": 6, "action": " "submit solution", "observation": "task completed successfully"
## Output Example "trajectory_a a_tye_gttttttt""" (Effficient search strategy using search_ bearch_dirz dir", "Quick execution with minimal steps". "Direct approach to problem solving" "trajectory "trajectory.b_streeghhee b_strengths": "Thoroughh problem analysis at the beginning". "Careful code review to identify potential issues", "Testing phase to ensure solution robustness". "More comprehensive approach to code modification" J, 'fused_ trajectory": [ "step": 1, "action": "analyze problem statement to understand root cause", "reasoning": "Combined trajectory B's thorough analysis with trajectory A's efficiency goal",, "step": 2, "action": "search_ dir for target function with precise search terms". "reasoning": "Used trajectory A's efficient search method with trajectory B's precision approach". "step": 3, "action": "review existing code logic and identify modifications needed", "reasoning": "Incorporated
25

---

trajectory B's careful review step before making changes", "step": 4, "action": "implement modification with consideration for edge cases", "reasoning": "Combined trajectory A's direct editing with trajectory B's careful consideration". "step": 5, "action": "submit solution after quick validation", "reasoning": "Balanced trajectory A's efficiency with trajectory B' testing approach" "fusion_raed "atrioonnrtiinale" "The fused trajectory combines trajectory A's efficiency and direct approach with trajectory B's thoroughness and careful analysis. maintains streamlined execution path while incorporating critical analysis and validation steps, resulting in solution that is both efficient and robust."
Transfer
You are expert in optimizing agent trajectories through transfer learning. Your task is to enhance target trajectory by transferring effective strategies, insights, and approaches from pool of reference trajectories.
Your transfer learning process should: Analyze the target trajectory to identify areas for improvement 2. Extract valuable patterns, strategies and techniques from the reference trajectories Transfer these elements to enhance the target trajectory 4. Ensure the enhanced trajectory maintains logical coherence and consistency 5. Focus on meaningful knowledge transfer, not simply adding steps
Target Trajectory: trajectory_targe Reference Trajectory Pool: traj_pool
Carefully analyze both the target trajectory and reference pool, then create enhanced version of the target trajectory that incorporates the most valuable elements from the reference trajectories.
Your output should be single JSON object representing the enhanced trajectory, following this exact format: "trajectory": "step": I, "action": "action description", "observation": "ob- servation description", "step": 2, "action": "action description", "observation". "observation description"
Make sure the enhanced trajectory: Addresses weaknesses in the original target trajectory Incorporates valuable insights from reference trajectories Maintains a coherent problem- solving approach Includes specific implementation details Has logical progression between steps Is complete enough to solve the task effectively
Restructure
You are an expert in large-scate scale trajectory restructuring. Your task to synthesize new reasoning trajectory by analyzing the global structure of trajectory population. Unlike Crossover or Transfer that focus on local segment manipulation, this task requires holistic restructuring based global insights across all input trajectories.
Your restructuring process should: 1. Analyze the entire trajectory pool discover abstract patterns, common subgoals, and shared structures 2. Identify redundant reasoning paths and filter out ineffective or repetitive steps Synthesize a completely new trajectory that aligns with the overall problem-solvine objective, but reflects novel and optimized reasoning process Maintain logical consistency, completeness, and step-wise progression of the trajectory
Trajectory Pool: trajectory-pool
You must generate single restructured trajectory that combines the collective strengths and high-level reasoning strategies inferred from the input trajectories. Your output should be single ISON object representing the newly restructured trajectory, following this exact format:
"new_ trajectorj""
"step": 1,
"action": "action description", "observation"; "observation description",
26

---

Make sure the restructured trajectory: Reflects global insights derived from the trajectory pool Avoids redundancy and overly local reasoning Introduces coherent and efficient so- "reasoning": "why this step was chosen and how it contributes"
{
"step": 2,
"action": "action description", "observation": "observation description", "reasoning": "rationale for this step"
}
Make sure the restructured trajectory: Reffects global insights derived from the trajectory pool Avoids redundancy and overly local reasoning- Introduces coherent and efficient so- lution strategy Demonstrates abstract synthesis and long-range planning Forms complete and executable path to solve the task
B.3 Refinement Operation
B.3.1 Evaluation
TaskCompletion
You are an expert in large-scale trajectory restructuring. Your task is to synthesize new reasoning trajectory by analyzing the global structure of trajectory population. Unlike Crossover or Transfer that focus on local segment manipulation, this task requires holistic restructuring based on global insights across all input trajectories.
Your restructuring process should: 1. Analyze the entire trajectory pool to discover abstract patterns, common subgoals, and shared structures 2. Identify redundant reasoning paths and filter out ineffective or repetitive steps 3. Synthesize completely new trajectory that aligns with the overall problem-solving objective, but reflects novel and optimized reasoning process 4. Maintain logical consistency, completeness, and step-wise progression of the trajectory
Trajectory Pool: trajectory_pon pppottrryppool
You must generate a single restructured trajectory that combines the collective strengths and high-level reasoning strategies inferred from the input trajectories. Your output should be a single JSON object representing the newly restructured trajectory, following this exact format:
"new_ trajeccore"t"
"step": "action": "action description", "observation": "observation description", "reasoning": "why this step was chosen and how it contributes"
"step" 2,
"action": "action description", "observation": "observation description", "reasoning": "rationale for this step"
}
27

---

lution strategy Demonstrates abstract synthesis and long- range planning Forms complete and executable path to solve the task
C Case Study
uptredad
heabed Comndeitt
*gr daccppton
catako eneelldllnnneees won't wook to iskelked undorres diia nambeni.
docwning ssleg terrsguce attioree) luy, bereeeeleeeeeeeepc..
kel implenas
reuaitery that nogerenent apaiifidin dousptaeri nat?
with azodie rahantad- meeebon not warcng for iabented arribase (ean. menbera Lefh sant by caplerig the squansoy amautae andeoandie problen.
Thrnght: Eill repleeent the aeceurry
Theughe: Ell inakene
zuedic inleked-
mechher not vodling for issamted atsiianes (dea membero, Letk can by explerig fx repeniary aritee undemmeciuu probiem..
2
Siea
Thenght: sutidies etienatee since iane aradeo..
has beng Actio: dr ratace odttr creas hodled aos speciii anecpy -dlle sett..
Thangle: Perfect
daoigh
the 1s.
Thrnght:
line 190, The eoda choda mendemaand) mimorrace cunca clask munoraas, viaie the air dies consane cnines the has clas aanoppaoo
Theeate: The dhoudd chedk ior aberied san decarentaion lodkra danogh MBO (Metee kensasies Untect santer to bon the pet ain hus creaswet mecled doo
Action squase aditr todbadk splnn catradddaciiiin witoe
Stea
Thenpht: intetiied stribako. sut canze aunopace dlas
Thangte: problas fitering add cxntast mathed, modily
Action editor sxplacc polieciophisoeeeioo. www.aooeeoeodedeeeeeeeoooooo
Actie: at squace odtor az replice Iedeaallgdizaaooaaaaddde isi. weld az
T Thrught: Harc iosel la the abject member fincsen imparae only chedo ike inconos artbetes in curver sonmeoaac (ranequce nd het drean' cheit for inronce pancpppccs
Thanght: Now nead to inylenser the fir Treed to modly toe conter metiod to chokk for inkerted stmbbaac docansriases whan diad bekap fab- Hard' appoaeds 1. Fins, by lhe sbject
autheu smvetaton
Action or sop odhor aepice tncher oeteriitttteeeoooooe -MM -eea
Stradd
Stea.
Thanpht Inxroding
meniorn
Thoqpl: Exsclaat for cosplics
arytting scietegrros
ploa Activs st, Japker siioe view www.wooaallllaeaeeeeooooooooo wwwea//ollllloooooooooooooooooo stoiee inii...p witon, saue 633
<Amee luched
Figure A case analysis comparing the trajectories output by SE-Agent before and after optimization.
28


Reviews:
[{"review_id": "4nDvO6q0n3", "reviewer": "Reviewer_DjBE", "summary": "The paper proposes a self-evolutionary pipeline for constructing better trajectories based on the previous ones. The pipeline consists of 3 steps: revision (revise single trajectory), recombination (combine multiple trajectories) and refinement (enhancing trajectories via rewards). The authors evaluated an agent with this pipeline on SWE-bench Verified, and obtained better performance than the baselines. Ablation study showed that each step contributed to the improvement. Compared to existing approach like MCTS, the proposed method tried to use cross-trajectory information to improve the agent.", "questions": "Please see \"Strengths And Weaknesse\" section.", "limitations": "I did not find discussion on limitations in the paper.", "rating": 4, "confidence": 3, "soundness": null, "presentation": null, "contribution": null, "strengths": "", "weaknesses": "", "quality": 2, "clarity": 1, "significance": 2, "originality": 2, "strengths_and_weaknesses": "Strengths:\n1. The proposed idea is interesting which tries to utilize and improve the previous trajectories.\n2. Experiments and ablation study showed the agent with this method obtained better performance.\n\nWeaknesses:\n1. Many of method descriptions (the 3 steps) are only at high-level and lack specific details. For example, it's not clear what Mutate(), Reflect(), Revise(), Crossover(), Transfer() and Restructure() really do under the hood.\n2. It is not clear whether groundtruth label is being used to select the trajectories. In subsection 4.4.1, the paper mentions auto eval based on test pass rate is being used to compute the reward and select the trajectories. Isn't this a leak of the groundtruth label?\n3. No examples are given for how each step revises / combines / refines the trajectory. Including some examples can help improve explain the methods.", "was_revised": true, "final_justification": "The rebuttal helps clarify the paper significantly and the results on SWE-Bench verified are promising, so I've increased the score slightly. However, I still feel the methodology is missing many details and more benchmarks are necessary to show the approach is generalizable.\n\nUpdate: the authors provide pseudo code of the Transfer process, which makes it much more clear. There are still missing info for understanding the end-to-end process which should be easy to fix by more clarification. Therefore, I increased the score to borderline accept.", "rebuttal": "# Response to Reviewer DjBE\n\nThank you for your detailed feedback. We appreciate your recognition of our interesting idea of leveraging and improving upon previous trajectories, as well as the performance improvements demonstrated through our experiments and ablation studies. We are also grateful for your positive assessment of the advantages our approach offers in **cross-trajectory information utilization** compared to existing MCTS methods. Below, we address each of your main concerns in detail:\n\n\n## **Method Implementation Details (For W1)**\n\nWe acknowledge that the main paper's description is relatively high-level to maintain clarity and space constraints. Appendix B provides detailed implementation specifics, including concrete prompt templates and execution logic for each operation. To better illustrate the concrete implementation of our method, we provide a complete case study demonstrating how SE-Agent progressively optimizes trajectories through its three core operations.\n\n### **Case Study: Fixing UnrecognizedUnit.__eq__ in Astropy**\n\nProblem Description: Astropy's UnrecognizedUnit.__eq__ method throws exceptions instead of returning False when compared with None, violating Python's safety conventions for comparison operations.\n\n**Step 1: Revision Operation - Multi-Strategy Trajectory Generation**\n\nFirst, generate 5 initial trajectories using 5 different planning strategies:\n\n| Prompt Variant | Trajectory Summary | Main Issues |\n|----------------|-------------------|-------------|\n| P-greedy | `grep→view→quick-edit` | Only handles None, ignores other types |\n| P-tests-first | `pytest→search→edit` | Too many test failures |\n| P-linter-aware | `flake8→edit→pytest` | Indentation issues, logic still wrong |\n| P-defensive | `try-catch→comprehensive` | Overly broad exception handling |\n| P-minimal | `single-line→submit` | Incomplete functionality |\n\nThen perform reflection and revision operations on each trajectory to generate corresponding improved versions:\n\n**Example - Evolution of P-greedy trajectory:**\n- **Original trajectory issue**: Overly narrow type checking\n- **Revised trajectory**: `grep → view → add comprehensive tests → edit(improve type annotations, add exception handling) → pytest`\n\nOutput: 10 revised trajectories (original 5 + revised 5) proceed to the next stage.\n\n**Step 2: Refinement.Selection - Quality-Based Trajectory Filtering**\n\nUse evaluation function for quality filtering:\n$$\\text{Reward}(t, T) = \\alpha \\cdot \\text{TaskCompletion}(t,T) + \\beta \\cdot \\text{ReasoningQuality}(t) + \\gamma \\cdot \\text{Efficiency}(t)$$\n\nScoring includes two components:\n- **LLM scoring**: Reasoning quality and solution reasonableness evaluation\n- **Rule-based scoring**: Code completeness, syntax error checking, structural validation\n\nResult: Remove low-quality trajectories, retain 5 for the next step.\n\n**Step 3: Recombination Operation - Cross-Trajectory Knowledge Fusion**\n\nBased on task complexity, orchestrate operator combinations to generate 5 new trajectories:\n- **2× Crossover**: Fuse complementary segments from different trajectories  \n- **2× Transfer Learning**: Transfer successful patterns to target trajectories\n- **1× Restructure**: Global restructuring optimization\n\n**Specific trajectory fusion examples:**\n\n**Crossover #1 - Precise Localization × Comprehensive Testing:**\n- Trajectory A: `grep \"UnrecognizedUnit\" → edit eq → submit` (fast but shallow)\n- Trajectory B: `pytest → analyze failures → view test context → comprehensive edit` (slow but thorough)\n- Crossover Result: `grep \"UnrecognizedUnit\" → view test_units.py → analyze eq usage pattern → targeted comprehensive fix`\n\n**Transfer #1 - Exception Handling Pattern Migration:**\n- Source: try-except (TypeError, ValueError) pattern from defensive programming trajectory\n- Target: Simple None check from greedy trajectory  \n- Transfer Result: `None check + multi-type exception catching + graceful degradation`\n\n**Restructure - Global Optimization:**\n- Global pattern recognition: All trajectories revolve around the core issue of \"type-safe comparison operations\"\n- Redundancy elimination: Merge duplicate search and localization steps\n- Structural reorganization: `Problem understanding → Precise localization → Context analysis → Type-safe design → Comprehensive validation`\n\nOutput: Extended pool contains 10 trajectories (original 5 + newly generated 5)\n\n**Iterative Self-Evolution Support**\n\nSE-Agent supports multi-round iterative optimization, continuing the evolution process based on the current trajectory pool:\n\n**Round 2 Evolution (simplified representation):**\n- **Step2'**: Reflection ⟨5 trajectories⟩ → Revision ⟨...⟩ → `T2'` (10 trajectories)\n- **Step3'**: Quality-Filtering ⟨T2'⟩ → Select ⟨...⟩ → `T3` (5 trajectories)\n- **Step4'**: Recombination ⟨T3⟩ → [Crossover×2, Transfer×2, Restructure×1] → `T4` (10 trajectories)\n\nConvergence condition: Stop when consecutive K rounds of highest reward improvement < ε, or reach preset maximum rounds. This iterative mechanism ensures **SE-Agent** can continuously optimize until finding high-quality solutions or meeting stop conditions.\n\n**Step 4: Final Solution Selection**\n\nSelect the highest-scoring trajectory from candidates as the final solution:\n\n**Core Improvement**: SE-Agent evolved from single-point failure repair to a **type-safe universal solution**, generating entirely new solution methods through **explicit inter-trajectory interactions** (Crossover, Transfer, Restructure), covering all invalid input scenarios.\n\n**Key Innovation**: This trajectory-level collaboration is **unachievable by traditional methods** like MCTS that rely solely on model capabilities for diversified sampling—they can only generate mutually independent trajectories, **unable to achieve collaborative evolution and knowledge transfer** between trajectories.\n\n## **Ground Truth Leakage Concern (For W2)**\n\nOur evaluation function consists of two components: \n\n1. **Rule-based reward**, denoted as AutoEval()\n2. **Model-based reward**, denoted as ExpertEval()\n\n**Important**: Neither component relies on ground-truth labels. \n\nTo elaborate, **AutoEval()** is a rule-based mechanism designed to assess whether a generated trajectory meets minimal submission criteria. These criteria include, but are not limited to: \n- Ensuring the final patch file is non-empty\n- Verifying that the trajectory contains a sufficient proportion of code-editing steps\n- Checking whether the trajectory length falls within a reasonable range\n\nThis procedure **does not require access to ground-truth labels** or test oracles.\n\nWe acknowledge that our use of the term **\"test pass rate\"** may have led to confusion, as it could be misinterpreted as indicating the use of ground-truth tests. In fact, the \"pass rate\" refers only to the internal validation of structural constraints necessary for a trajectory to be considered valid and potentially effective—**not whether it actually solves the task**. We will revise this in the final version, modifying it to **\"validation rate\"** and describing our evaluation function in more detail.\n\n## **Concrete Examples (For W3)**\n\nAs shown in the complete example provided in our response to W1, we have illustrated in detail **how each operation specifically modifies and improves the trajectories**. This example comprehensively demonstrates the entire process—from initial trajectory generation, quality evaluation, and cross-trajectory fusion to the selection of the final solution—including **concrete changes in trajectory content** and the resulting improvements.\n\n### **Additional Clarifications**\n\nWe will add a dedicated limitation section in the final version to discuss computational overhead and the applicable scope of our method. Our approach has indeed achieved **significant performance gains** (up to 55% relative improvement) and **SOTA results**, which validate the effectiveness of the trajectory-level self-evolution paradigm."}, {"review_id": "ZHJCVGyBGR", "reviewer": "Reviewer_c1xU", "summary": "This paper proposes SE-Agent, a so called ''self-evolution'' framework for improving multi-step reasoning in LLM-based agents.  SE-Agent introduces a trajectory-level optimization process featuring three key operations: revision, recombination, and refinement. Some of these mechanisms enable the agent to explore and generate solution paths for complex tasks. The framework is evaluated on the SWE-benc demonstrating  performance gains across five LLMs and outperforming strong open-source baselines.", "questions": "Questions refer to the Weaknesses.\n\nTypo:\n\nline 120: Objetive of Agent -> Objective of Agent", "limitations": "While certain potential limitations may be implicitly touched upon in the Conclusion, the discussion is not explicitly outlined or clearly labeled in the main text or additional section.", "rating": 4, "confidence": 3, "soundness": null, "presentation": null, "contribution": null, "strengths": "", "weaknesses": "", "quality": 2, "clarity": 3, "significance": 2, "originality": 2, "strengths_and_weaknesses": "Strengths\n\n- The paper thoroughly motivates the need for more diverse and optimized multi-step reasoning in LLM agents. \n\n- The three-step mechanism—revision, recombination, and refinement—constitutes a non-trivial advancement over existing trajectory sampling and MCTS approache.\n\nWeeknesses\n\n- I am somewhat confused about how the use of the term ''self-evolution paradigm.'' From my reading, the approach mainly involves generating different sampled trajectories rather than any genuine form of evolution as typically ablity improvement. Therefore, I suggest that the authors reconsider the terminology here. \n\n- One of my main concerns is the soundness of some of the experimental results. If I understand correctly, in Figure 2, the results for SE-Agent are based on Claude-3.7-Sonnet, while the other baselines use Claude-3.5. This raises questions about whether the comparisons are truly fair.\n\n- The ablation study only investigates the impact of the Revision and Recombination modules, but does not include an ablation for the Refinement operation. This omission experiment and explanation makes it difficult to fully understand the contribution of each component to the overall performance.\n\n- Some important experimental details are not clearly described in the current manuscript. For example, the process for generating ''pilot trajectories'' is not explicitly explained in the Experimental Setup section. Furthermore, when comparing with other baseline methods, it is unclear whether these ''pilot trajectories'' or similar auxiliary information are also made available to the baselines.", "was_revised": true, "final_justification": "Most of my concerns are addressed and I'm happy to increase the rating.", "rebuttal": "# Response to Reviewer c1xU\n\nThank you for your detailed feedback. We appreciate your recognition that our three-step mechanism represents a substantial advancement over existing trajectory sampling and MCTS methods. Below, we address each of your main concerns:\n\n\n## **Clarification on the Term \"Self-Evolution\" (For W1)**\n\nWe understand the reviewer's concerns about our use of the term **\"self-evolution.\"** SE-Agent embodies a **genuine evolutionary principle** that goes beyond individual trajectory sampling:\n\n**1) Addressing the Homogenization Problem:**\n\nTraditional multi-trajectory sampling suffers from severe homogenization—trajectories converge to similar solutions, especially with smaller models. The effective search space remains limited despite multiple samples.\n\n**2) A True Evolutionary Mechanism:**\n\nSE-Agent establishes **systematic information exchange** among trajectories through three core operations:\n- **Revision**: Targeted improvement of individual trajectories through self-reflection\n- **Recombination**: Transfer of successful reasoning patterns across trajectories, creating novel hybrid solutions\n- **Refinement**: Iterative optimization of the trajectory pool based on collective performance\n\n**3) Emergent Collective Intelligence:**\n\nUnlike simple sampling, trajectories in SE-Agent **actively influence and evolve with each other**. Superior partial reasoning strategies propagate within the population, while inferior approaches are eliminated, resulting in **emergent collective intelligence** at the population level.\n\n**Concrete Case Demonstration:**\n\n### **Case Study: Fixing UnrecognizedUnit.__eq__ in Astropy**\n\n**Problem Description**: Astropy's UnrecognizedUnit.__eq__ method throws exceptions instead of returning False when compared with None, violating Python's safety conventions for comparison operations.\n\n**Step 1: Revision Operation - Multi-Strategy Trajectory Generation**\n\nFirst, generate 5 initial trajectories using 5 different planning strategies:\n\n| Prompt Variant | Trajectory Summary | Main Issues |\n|----------------|-------------------|-------------|\n| P-greedy | `grep→view→quick-edit` | Only handles None, ignores other types |\n| P-tests-first | `pytest→search→edit` | Too many test failures |\n| P-linter-aware | `flake8→edit→pytest` | Indentation issues, logic still wrong |\n| P-defensive | `try-catch→comprehensive` | Overly broad exception handling |\n| P-minimal | `single-line→submit` | Incomplete functionality |\n\nThen perform reflection and revision operations on each trajectory to generate corresponding improved versions:\n\n**Example - Evolution of P-greedy trajectory:**\n- **Original trajectory issue**: Overly narrow type checking\n- **Revised trajectory**: `grep → view → add comprehensive tests → edit(improve type annotations, add exception handling) → pytest`\n\n**Output**: 10 revised trajectories (original 5 + revised 5) proceed to the next stage.\n\n**Step 2: Refinement.Selection - Quality-Based Trajectory Filtering**\n\nUse evaluation function for quality filtering:\n$$\\text{Reward}(t, T) = \\alpha \\cdot \\text{TaskCompletion}(t,T) + \\beta \\cdot \\text{ReasoningQuality}(t) + \\gamma \\cdot \\text{Efficiency}(t)$$\n\nScoring includes two components:\n- **LLM scoring**: Reasoning quality and solution reasonableness evaluation\n- **Rule-based scoring**: Code completeness, syntax error checking, structural validation\n\n**Result**: Remove low-quality trajectories, retain 5 for the next step.\n\n**Step 3: Recombination Operation - Cross-Trajectory Knowledge Fusion**\n\nBased on task complexity, orchestrate operator combinations to generate 5 new trajectories:\n- **2× Crossover**: Fuse complementary segments from different trajectories  \n- **2× Transfer Learning**: Transfer successful patterns to target trajectories\n- **1× Restructure**: Global restructuring optimization\n\n**Specific trajectory fusion examples:**\n\n**Crossover #1 - Precise Localization × Comprehensive Testing:**\n- **Trajectory A**: `grep \"UnrecognizedUnit\" → edit eq → submit` (fast but shallow)\n- **Trajectory B**: `pytest → analyze failures → view test context → comprehensive edit` (slow but thorough)\n- **Crossover Result**: `grep \"UnrecognizedUnit\" → view test_units.py → analyze eq usage pattern → targeted comprehensive fix`\n\n**Transfer #1 - Exception Handling Pattern Migration:**\n- **Source**: try-except (TypeError, ValueError) pattern from defensive programming trajectory\n- **Target**: Simple None check from greedy trajectory  \n- **Transfer Result**: `None check + multi-type exception catching + graceful degradation`\n\n**Restructure - Global Optimization:**\n- **Global pattern recognition**: All trajectories revolve around the core issue of \"type-safe comparison operations\"\n- **Redundancy elimination**: Merge duplicate search and localization steps\n- **Structural reorganization**: `Problem understanding → Precise localization → Context analysis → Type-safe design → Comprehensive validation`\n\n**Output**: Extended pool contains 10 trajectories (original 5 + newly generated 5)\n\n**Iterative Self-Evolution Support**\n\nSE-Agent supports multi-round iterative optimization, continuing the evolution process based on the current trajectory pool:\n\n**Round 2 Evolution (simplified representation):**\n- **Step2'**: Reflection ⟨5 trajectories⟩ → Revision ⟨...⟩ → `T2'` (10 trajectories)\n- **Step3'**: Quality-Filtering ⟨T2'⟩ → Select ⟨...⟩ → `T3` (5 trajectories)\n- **Step4'**: Recombination ⟨T3⟩ → [Crossover×2, Transfer×2, Restructure×1] → `T4` (10 trajectories)\n\n**Convergence condition**: Stop when consecutive K rounds of highest reward improvement < ε, or reach preset maximum rounds. This iterative mechanism ensures SE-Agent can continuously optimize until finding high-quality solutions or meeting stop conditions.\n\n**Step 4: Final Solution Selection**\n\nSelect the highest-scoring trajectory from candidates as the final solution:\n\n**Core Improvement**: SE-Agent evolved from single-point failure repair to a **type-safe universal solution**, generating entirely new solution methods through **explicit inter-trajectory interactions** (Crossover, Transfer, Restructure), covering all invalid input scenarios.\n\n**Key Innovation**: This trajectory-level collaboration is **unachievable by traditional methods** like MCTS that rely solely on model capabilities for diversified sampling—they can only generate mutually independent trajectories, **unable to achieve collaborative evolution and knowledge transfer** between trajectories.\n\n## **Experimental Fairness (For W2)**\n\nWe acknowledge using different model versions might affect comparison fairness. We conducted **additional experiments** using the same model across all methods:\n\n**Updated Results with Claude-4-Sonnet:**\n\n| Method                          | Performance on SWE-bench Verified |\n|---------------------------------|-----------------------------------|\n| SWE-agent + Claude 4 Sonnet     | 66.6%                            |\n| Augment Agent v1                | 70.4%                            |\n| OpenHands + Claude 4 Sonnet     | 70.4%                            |\n| Moatless Tools + Claude 4 Sonnet| 70.8%                            |\n| TRAE                            | 75.2%                            |\n| **SE-Agent + Claude 4 Sonnet**  | **80.0%**                        |\n\nThese results validate our framework's effectiveness, achieving **SOTA performance** on SWE-bench Verified. We are currently submitting these performance results to the **SWE-bench leaderboard**.\n\n## **More Ablation Study of Refinement (For W3)**\n\nTo ensure completeness of our ablation analysis, we conducted additional experiments removing the Refinement component:\n\n| Model            | SE-Agent | w/o Revision | w/o Recombination | w/o Refinement | w/o All |\n|------------------|----------|--------------|-------------------|---------------|---------|\n| DeepSeek-V3      | **54.8%**    | 36.6%        | 44.6%             | 34.0%         | 31.6%   |\n| Qwen-2.5-72b     | **38.8%**    | 23.8%        | 28.8%             | 22.4%         | 18.8%   |\n| Llama-3.1-70b    | **32.6%**    | 20.4%        | 27.4%             | 19.0%         | 15.4%   |\n| GPT-4o           | **40.4%**    | 27.4%        | 33.4%             | 25.2%         | 22.4%   |\n| Claude-3.7       | **61.2%**    | 45.6%        | 50.6%             | 47.8%         | 40.6%   |\n\nThe results demonstrate that **all three components make significant contributions** to the overall performance of SE-Agent. We will include a detailed discussion of this ablation study in the revised version of the paper.\n\n## **Clarification on \"Pilot Trajectories\" (For W4)**\n\n\"Pilot trajectories\" are initial trajectories using different planning strategies:\n- **P-greedy**: Rapid localization and fixing\n- **P-systematic**: Systematic problem analysis\n- **P-defensive**: Defensive programming approach\n- **P-minimal**: Minimal modification\n- **P-comprehensive**: Comprehensive testing\n\nThese provide the **foundation** for evolutionary operations, ensuring **broad solution space coverage**. Baselines lack our cross-trajectory interaction mechanism.\n\n### **Additional Clarifications**\n\nWe will correct the typo in line 120 and add a **\"Limitations\"** section discussing computational overhead and applicable scope. These clarifications demonstrate SE-Agent's **robustness** through genuine trajectory-level evolution **unattainable by traditional sampling methods**."}, {"review_id": "5mkxnHDlMY", "reviewer": "Reviewer_JbMn", "summary": "This paper proposed an inference-time scaling framework, SE-Agent, for coding tasks. The motivation of this paper is to utilize the interdependence among various trajectories. Specifically, the SE-Agent framework uses the pilot trajectories with operations of revision, recombination, and refinement. For revision, the SE-Agent uses self-reflection to identify the critical point of the trajectory. For recombination, the SE-Agent combines the different trajectories based on their strengths. For Refinement, the agent optimizes the trajectories by improving the efficiency. In the experiment, the SE-Agnet achieves good performance (61.2 pass@1 with backbone model of Calude 3.7 Sonnet) on SWE-bench verified.", "questions": "- How is the computation cost and inference time for the proposed method? This is not critical, but it would be good to include it to show the statement on lines 98-100.", "limitations": "n/a", "rating": 4, "confidence": 3, "soundness": null, "presentation": null, "contribution": null, "strengths": "", "weaknesses": "", "quality": 3, "clarity": 3, "significance": 2, "originality": 3, "strengths_and_weaknesses": "Strenghth\n- The idea is simple but effective. \n- The paper is well-written with a clear structure and well-articulated mathematical formulations (Section 4)\n- The performance on the widely known SWE-bench verified benchmark is strong and demonstrates the performance gains achieved by the proposed framework. The ablation study of each component (Figure 3) provides a clear comparison between the revision and recombination parts.\n\nWeaknesses\n- Lack of inference time comparison. In line 98, the statement is \"our work introduces a novel approach within the ReAct paradigm that incorporates strategic reflection and mutation at critical steps, combining multiple trajectories to generate optimized execution paths **without** requiring extended computation time like Test-Time Scaling techniques.\" However, I did not find the inference time related experiment in the following sections.", "was_revised": true, "final_justification": "I will keep my score of 4", "rebuttal": "# Response to Reviewer JbMn\n\nThank you for reviewing our paper and providing such insightful feedback. We greatly appreciate your recognition of the clarity of our writing, the well-structured mathematical formulations, and the **strong empirical performance** of our proposed framework on the SWE-bench Verified. Furthermore, we have thoroughly addressed your concern as follows:\n\n\n## **Inference Time Comparison (For W1)**\n\nAs **SE-Agent** is designed with efficiency in mind, particularly when compared to frameworks like SWE-Search (based on MCTS), we conduct additional experiments to quantify the average inference time required to solve a single instance successfully. This evaluation focuses on the average wall-clock time per solved case, which we believe is a practical metric for real-world deployment and large-scale adoption. The results are as follows:\n\n| Method               | Inference Time (min) | Resolved Rate (%) |\n|----------------------|-----------------|-------------------|\n| SWE-Agent            | 15.61           | 40.6              |\n| SWE-Search (MCTS)    | 33.42           | 47.4              |\n| **SE-Agent (Ours)**  | **31.06**       | **61.2**          |\n\n*All results are based on Claude-3.7-Sonnet model*\n\n**Our findings show that SE-Agent consistently achieves lower inference time compared to SWE-Search(MCTS)**. This confirms the advantage of our method in **avoiding the heavy computational cost** associated with test-time scaling techniques like MCTS. The proposed SE-Agent not only **improves performance** but also enables **efficient exploration** without incurring significant inference overhead. We will include this comparison and discussion in the revised version of the paper to better support our claims regarding SE-Agent's practical efficiency.\n\nDue to time constraints, we are currently only able to provide inference time comparison results based on Claude-3.7-Sonnet. However, we fully recognize the importance of this evaluation and commit to including a comprehensive inference time analysis—covering all relevant baselines—in the revised version of the paper."}, {"review_id": "3Wmz0kv4EA", "reviewer": "Reviewer_aGqC", "summary": "This paper presents SE-Agent, a framework that enhances LLM agent performance by treating their reasoning paths as \"trajectories\" for optimization. The system employs evolutionary operation to iteratively improve a pool of trajectories and discover superior solutions. Validated on the SWE-bench benchmark, the method demonstrates significant performance improvements over baseline models.", "questions": "See weaknesses", "limitations": "Yes", "rating": 4, "confidence": 4, "soundness": null, "presentation": null, "contribution": null, "strengths": "", "weaknesses": "", "quality": 2, "clarity": 2, "significance": 2, "originality": 2, "strengths_and_weaknesses": "Strengths:\n1. The empirical results are strong, showing substantial relative improvements over established baselines on the challenging SWE-bench benchmark. The method appears to generalize well across multiple open-source and closed-source LLMs.\n\nWeaknesses:\n1. The idea of collecting a pool of trajectories or experiences to guide or improve subsequent reasoning attempts is a well-established concept in agent learning, seen in frameworks like ExpeL[1] and AvaTar[2], which also learns from diverse, past experiences to improve agent performance. The \"self-evolution\" framing appears to be a new wrapper for a familiar concept, and its distinction from prior work in experience-based improvement or iterative refinement is not sufficiently articulated.\n2. The empirical evaluation, while strong, is narrowly focused on a single, highly specific benchmark: SWE-bench.  This makes it difficult to assess the generality of the SE-Agent framework. Results across a wider range of tasks are needed to demonstrate that this isn't just a bespoke solution for fixing GitHub issues. Its applicability to other code-related benchmarks like TerminalBench for terminal coding, LiveCodeBench for competitive programming.\n3. The paper lacks the concrete, low-level details needed for a deep understanding and confident replication of the method. The descriptions of the Revision, Recombination, and Refinement operators remain at a very high level. For example, how exactly does the\nCrossover function identify \"high-performing trajectory segments\" and combine them? What does the output of a Mutate operation actually look like?\n4. The case study presented in Figure 6 is too vague to be truly insightful. It claims that traditional agents get stuck editing `_validation.py` while SE-Agent discovers the root cause in `multioutput.py`, but it fails to show how the evolutionary process enabled this discovery. A step-by-step walkthrough is needed to illustrate the point.\n5. The proposed method generates an initial pool of ten trajectories and then iteratively evolves them. This process could be expensive in terms of number of API calls, tokens, and wall-clock time. The analysis in Figure 5, which plots performance against \"Maximum Cost,\" is insufficient as the \"Cost\" unit is not defined. A transparent discussion of its resource overhead compared to baselines is required.\n\n[1] ExpeL: LLM Agents Are Experiential Learners. AAAI 24\n\n[2] AvaTaR: Optimizing LLM Agents for Tool Usage via Contrastive Reasoning. NIPS 24", "was_revised": true, "final_justification": "The authors have provided a comprehensive and thoughtful rebuttal that addresses all of my initial concerns. Overall, the paper makes a solid contribution to the area of prompt engineering for LLM agents.\n\nThat said, my overall score remains moderate due to the inherent limitations of the proposed approach. Specifically, while trajectory-based prompt engineering offers clear short-term gains, its generalizability and scalability are less convincing. The method requires relearning when applied to new domains beyond software engineering, which may be both costly and resource-intensive. Furthermore, the paper does not evaluate the transferability of the approach to tasks outside the coding domain, and comparative experiments on broader baselines are missing. These gaps limit the demonstrated impact and applicability of the method.", "rebuttal": "# Response to Reviewer aGqC\n\nThank you for your insightful feedback and recognition of our **strong empirical results** and substantial improvements over baselines on SWE-bench. We address your concerns as follows:\n\n## **The contributions of SE-Agent (For W1)**\n\nWhile leveraging historical experience is part of our approach, SE-Agent's core contribution lies in **expanding the search space through multi-trajectory interaction**, overcoming single-trajectory reasoning limitations. This process corresponds to crossover and mutation operations in genetic evolutionary theory, not merely refining individual trajectories.\n\nExpeL and AvaTar lack **cross-trajectory interaction** mechanisms. Despite self-reflection, isolated trajectories remain prone to cognitive limitations and local optima.\n\nOur DeepSeek-R1 experiments show smaller models with GRPO performed worse than distillation due to trajectory homogenization. Classic MCTS generates multiple paths but lacks real-time information exchange, resulting in limited search efficiency compared to our trajectory interaction mechanism.\n\n**Compared to MCTS**: SE-Agent introduces **trajectory-level evolutionary mechanisms** enabling information exchange across reasoning paths, providing:\n\na. **Breaking cognitive boundaries**: Competition and collaboration overcome individual path limitations\nb. **Knowledge transfer**: Successful patterns transfer across trajectories through recombination\n\nThis fosters **emergent population-level intelligence**. Our experiments show relative gains up to **112% (Llama-3.1-70B)** and **51% (Claude-3.7-Sonnet)**, demonstrating **true capability evolution** beyond individual trajectory sampling.\n\n## **The Choice of Benchmark (For W2)**\n\nWe focus on **SWE-bench Verified** because it presents significant challenges requiring cross-file bug localization, patch generation, and test validation over real-world repositories. Even top models achieve only 50-60% success. Leading works like **SWE-agent and SWE-search** report main results on this benchmark.\n\nLiveCodeBench emphasizes single-turn generation rather than multi-step interaction. Terminal-Bench aligns well with SE-Agent's capabilities but requires additional engineering work—a promising future direction.\n\n## **A description of the Operators (For W3&W4)**\n\nWe demonstrate our specific operations through the following case:\n\n### **Case Study: Fixing UnrecognizedUnit.__eq__ in Astropy**\n\n**Problem Description**: Astropy's UnrecognizedUnit.__eq__ method throws exceptions instead of returning False when compared with None, violating Python's safety conventions for comparison operations.\n\n**Step 1: Revision Operation - Multi-Strategy Trajectory Generation**\n\nFirst, generate 5 initial trajectories using 5 different planning strategies:\n\n| Prompt Variant | Trajectory Summary | Main Issues |\n|----------------|-------------------|-------------|\n| P-greedy | `grep→view→quick-edit` | Only handles None, ignores other types |\n| P-tests-first | `pytest→search→edit` | Too many test failures |\n| P-linter-aware | `flake8→edit→pytest` | Indentation issues, logic still wrong |\n| P-defensive | `try-catch→comprehensive` | Overly broad exception handling |\n| P-minimal | `single-line→submit` | Incomplete functionality |\n\nThen perform reflection and revision operations on each trajectory to generate corresponding improved versions:\n\n**Example - Evolution of P-greedy trajectory:**\n- **Original trajectory issue**: Overly narrow type checking\n- **Revised trajectory**: `grep → view → add comprehensive tests → edit(improve type annotations, add exception handling) → pytest`\n\n**Output**: 10 revised trajectories (original 5 + revised 5) proceed to the next stage.\n\n**Step 2: Refinement.Selection - Quality-Based Trajectory Filtering**\n\nUse evaluation function for quality filtering:\n$$\\text{Reward}(t, T) = \\alpha \\cdot \\text{TaskCompletion}(t,T) + \\beta \\cdot \\text{ReasoningQuality}(t) + \\gamma \\cdot \\text{Efficiency}(t)$$\n\nScoring includes two components:\n- **LLM scoring**: Reasoning quality and solution reasonableness evaluation\n- **Rule-based scoring**: Code completeness, syntax error checking, structural validation\n\n**Result**: Remove low-quality trajectories, retain 5 for the next step.\n\n**Step 3: Recombination Operation - Cross-Trajectory Knowledge Fusion**\n\nBased on task complexity, orchestrate operator combinations to generate 5 new trajectories:\n- **2× Crossover**: Fuse complementary segments from different trajectories  \n- **2× Transfer Learning**: Transfer successful patterns to target trajectories\n- **1× Restructure**: Global restructuring optimization\n\n**Specific trajectory fusion examples:**\n\n**Crossover #1 - Precise Localization × Comprehensive Testing:**\n- **Trajectory A**: `grep \"UnrecognizedUnit\" → edit eq → submit` (fast but shallow)\n- **Trajectory B**: `pytest → analyze failures → view test context → comprehensive edit` (slow but thorough)\n- **Crossover Result**: `grep \"UnrecognizedUnit\" → view test_units.py → analyze eq usage pattern → targeted comprehensive fix`\n\n**Transfer #1 - Exception Handling Pattern Migration:**\n- **Source**: try-except (TypeError, ValueError) pattern from defensive programming trajectory\n- **Target**: Simple None check from greedy trajectory  \n- **Transfer Result**: `None check + multi-type exception catching + graceful degradation`\n\n**Restructure - Global Optimization:**\n- **Global pattern recognition**: All trajectories revolve around the core issue of \"type-safe comparison operations\"\n- **Redundancy elimination**: Merge duplicate search and localization steps\n- **Structural reorganization**: `Problem understanding → Precise localization → Context analysis → Type-safe design → Comprehensive validation`\n\n**Output**: Extended pool contains 10 trajectories (original 5 + newly generated 5)\n\n**Iterative Self-Evolution Support**\n\nSE-Agent supports multi-round iterative optimization, continuing the evolution process based on the current trajectory pool:\n\n**Round 2 Evolution (simplified representation):**\n- **Step2'**: Reflection ⟨5 trajectories⟩ → Revision ⟨...⟩ → `T2'` (10 trajectories)\n- **Step3'**: Quality-Filtering ⟨T2'⟩ → Select ⟨...⟩ → `T3` (5 trajectories)\n- **Step4'**: Recombination ⟨T3⟩ → [Crossover×2, Transfer×2, Restructure×1] → `T4` (10 trajectories)\n\n**Convergence condition**: Stop when consecutive K rounds of highest reward improvement < ε, or reach preset maximum rounds. This iterative mechanism ensures SE-Agent can continuously optimize until finding high-quality solutions or meeting stop conditions.\n\n**Step 4: Final Solution Selection**\n\nSelect the highest-scoring trajectory from candidates as the final solution:\n\n**Core Improvement**: SE-Agent evolved from single-point failure repair to a **type-safe universal solution**, generating entirely new solution methods through **explicit inter-trajectory interactions** (Crossover, Transfer, Restructure), covering all invalid input scenarios.\n\n**Key Innovation**: This trajectory-level collaboration is **unachievable by traditional methods** like MCTS that rely solely on model capabilities for diversified sampling—they can only generate mutually independent trajectories, **unable to achieve collaborative evolution and knowledge transfer** between trajectories.\n\n## **Discussion of Resource Overhead (For W5)**\n\nWhile our method introduces **additional cost** due to multiple trajectories, this overhead is **justified by significant performance gains**.\n\nIn Figure 5, \"Maximum Cost\" is in **USD** (Claude-3.7 Sonnet API). At `$2` limit, execution terminates when cost exceeds `$2` per task.\n\nCost-performance analysis shows:\n- At `$1` limit: SE-Agent (41.6%) vs. SWE-Search (43.8%) vs. SWE-Agent (38.4%)\n- At `$2` limit: **SE-Agent (61.2%)** vs. SWE-Search (47.4%) vs. SWE-Agent (40.6%) \n\nMoreover, we report Cost per Resolved Instance without any budget cap: \n- **SE-Agent: `$3.54`**\n- SWE-Search: `$4.08`\n- SWE-Agent: `$4.66`\n\nDespite higher initial cost per run, SE-Agent is **more cost-efficient** for successfully solving tasks."}]

Author rebuttal:

Meta-review: ### (a) Summary of Claims
The paper introduces SE-Agent, a framework designed to enhance the performance of LLM agents on complex, multi-step tasks. The core idea is to treat the agent's reasoning paths as "trajectories" that can be iteratively improved through a self-evolutionary pipeline. This pipeline consists of three main operations: revision (refining a single trajectory through self-reflection), recombination (creating new, superior trajectories by combining segments of existing ones), and refinement (optimizing trajectories based on reward signals). When evaluated on the challenging SWE-bench benchmark for software engineering, the authors claim their method significantly boosts the performance of multiple LLM backbones compared to strong baselines.

### (b) Strengths
* Strong and convincing empirical results 
* Interesting and novel framework

### (c) Weaknesses
* Limited evaluation scope and potentially limited transferability: The most significant remaining weakness is the paper's narrow empirical focus on a single benchmark, SWE-bench. This makes it difficult to assess the framework's generalizability to other complex reasoning domains beyond software engineering.

### (d) Reasons for Acceptance
The authors provided a comprehensive rebuttal that effectively clarified methodological details and addressed the majority of the reviewers' initial concerns regarding fairness, implementation details, and ablations. This effort was crucial in building a consensus for acceptance, with two reviewers raising their scores as a direct result.
Decision: Accept (poster)