SWERank: Software Issue Localization with Code Ranking
Authors: Revanth Gangi Reddy
Tarun Suresh
JaeHyeok Doo
Ye Liu
Xuan-Phi Nguyen
Yingbo Zhou
Semih Yavuz
Caiming Xiong
Heng Ji
Shafiq Joty
Venue: ICLR 2026 Poster (2026)
Keywords: Software Issue Localization
Automated Code Repair
Retrieve-and-Rerank
Primary area: unsupervised, self-supervised, semi-supervised, and supervised representation learning
TL;DR: We introduce SWERank, a retrieve-and-rerank framework for software issue localization, which aims to identify the relevant code that needs to be modified to fix a software issue.

Abstract: Software issue localization, the task of identifying the precise code locations (files, classes, or functions) relevant to a natural language issue description (e.g., bug report, feature request), is a critical yet time-consuming aspect of software development. While recent LLM-based agentic approaches demonstrate promise, they often incur significant latency and cost due to complex multi-step reasoning and relying on closed-source LLMs. Alternatively, traditional code ranking models, typically optimized for query-to-code or code-to-code retrieval, struggle with the verbose and failure-descriptive nature of issue localization queries. To bridge this gap, we introduce SWERank, an efficient and effective retrieve-and-rerank framework for software issue localization. To facilitate training, we construct SWELoc, a large-scale dataset curated from public GitHub repositories, featuring real-world issue descriptions paired with corresponding code modifications. Empirical results on SWE-Bench-Lite and LocBench show that SWERank achieves state-of-the-art performance, outperforming both prior ranking models and costly agent-based systems using closed-source LLMs like Claude-3.5. Further, we demonstrate SWELoc's utility in enhancing various existing retriever and reranker models for issue localization, establishing the dataset as a valuable resource for the community.

Published as a conference paper at ICLR 2026
SWERANK: SOFTWARE ISSUE LOCALIZATION WITH CODE RANKING
Revanth Gangi Reddy=1.3 Tarun Suresh"! JaeHyeok Doo Ye Liu Xuan Phi Nguyen2 Yingbo Zhou² Semih Yavuz² Caiming Xiong² Heng Ji Shafiq Joty² University of Illinois at Urbana- Champaiinn Salesforce Research
KAIST AI
ABSTRACT
Software issue localization, the task of identifying the precise code locations (files, classes, or functions) relevant natural language issue description (c.g., bug report, feature request), is a critical yet time-consuming aspect of software devel- opment. While recent L.M- --aded agentic approaches demonstrate promise, they often incur significant latency and cost due to complex multi-step reasoning and relying on closed-source LLMs. Alternatively, traditional code ranking models, typically optimized for query-to-code or code-to-cee toceee retrieval, struggle with the verbose and failure-decriptiiee nature of issue localization queries. To bridge this gap, we introduce SWERANK', an efficient and effective retrieve-and aeree-nndrrrrntt frame- work for software issue localization. To facilitate training, we construct SwE.OO,, large-scale dataset curated from public GitHub repositories, featuring real-world issue descriptions paired with corresponding code modifications. Empirical results SWE-Bench-Lite and LocBench show that SWERANK achieves state-of-the-art performance, outperforming both prior ranking models and costly agent-based systems using -oouee- LLMs like Claude-3.5. Further, we demonstrate SWE- Loc's s utility in enhancing various existing retriever and reranker models for issue localization, establishing the dataset as valuable resource for the community.
INTRODUCTION
The scale and complexity of modern software systems continue to grow exponentially, with significant portion of development effort dedicated to identifying and resolving software issues. This has fueled growth in automated software issue fixing (Cognition AI, 2024), with recent LLM-based patch generation (Yang et al., 2024a; Gauthier, 2024) solving real-world issues on benchmarks such as SWEE-Bench (Jimenez et al., 2023), and commercial copilots integrating "one-click" quick-fix -ix suggestions directly into IDEs (Microsoft, 2023; Cursor, 2025; Windsurf, 2025). Central to the process of fixing software issues is the task of issue localization: accurately identifying where in the codebase the necessary changes should be made. This involves pinpointing the specific files, classes, or functions relevant to given issue description, typically provided in natural language (e.g.. ... a bug report). Effective localization is critical; without correctly identifying the relevant code segments, any subsequent attempt automated repair is likely to fail or, worse, introduce
faults.
Given the importance of localization, recent work treats as an agentic reasoning problem (Yao al., 2023) and has investigated the use of sophisticated M.M--a agents (Yang al., 2024b; Yu et al., 2025; Chen et al., 2025) that issue commands such as 'read-file', 'grep' and "traverse- graph' to iteratively explore codebases, navigate file structures, search for code patterns, and analyze dependencies. While powerful, these ageee- compound systems often involve multiple rounds of interaction (s-7-0 on average) with large models and complex reasoning processes, which can incur considerable API costs (=:00.6 per example with Claude-3.5) at high latency. Moreover, agent traces are brittle: they rely on temperature sampling and require complex tool orchestration.
An alternative, more efficient strategy is to frame issue localization as an information retrieval problem, specifically using code ranking models (Yue et al., 2021; Zhang et al., 2024; Suresh
"Equal Contribution. Work done during Revanth's 's internship at Salesforce Al Research. Code and models are available here: https:/ //gi thub. wtw.b..ww/.llleefrreerrssssccaaa

---

Published as a conference paper at ICLR 2026
et al., 2024). Such models can directly rank candidate code snippets (e.g., functions files) based on their relevance to a given natural language query, and quickly score and sort potential locations within large codebase. However, prior code ranking models are still inferior in per- formance as they have predominantly been optimized for tasks distinct from issue localization. These typically include query-to-code retrieval (Li et al., 2024a), which aims to find code im- plementing a described functionality, and code-to-code retrieval (Wang et al., 2023a; Li et al., 2024b), focused on identifying semantically similar code fragments. The task of issue localiza- tion presents unique characteristics; input queries (issue descriptions) are often substantially more verbose than typical NL-to-code queries² and, more crucially, issues tend to describe observed erroneous behavior or system failures rather than specifying desired functionality. This fundamental difference in query nature and intent suggests that models trained on conventional code retrieval data (Husain et al., 2019; Suresh et al., 2024) may not be optimally suited for issue localization.
To bridge this gap, we introduce SWERANK, a code ranking framework trained specifically for software issue localization. SWERANK employs standard yet effective
SWi--enchbutee Locatiaation Performance Gasl
50
Fimurte (Sedff L-
Gartalia Sevalla
ing two core components: (1) architecture, compris- bi-encoder embedding model serving as the code re- triever; and (2) SWERANKLLM, an instruction-tune -undedd LLM serving as code reranker. To train SWERANK, we construct SWELOC, new large-scale issue local- ization dataset curated from public Github repositories, providing realistic training examples. SWERANKEM- BED is trained using contrastive objective, where the issue descriptions serve as queries, the known local- ized functions act positive examples. and carefully mined code snippets from the same repository func- tion hard negatives. Subsequently, SWERANKLLLM is trained as a list-wise reranker (Reddy et al., 2024); it takes input the issue description alongside the top-K candidates retrieved by SWERANKEMBED and predicts an improved ranking permutation, thereby enhancing the final localization.
tocagn
Retrever Bow wor.e
Oour
san
12'
Cord par instance (Sarti LLng Scale
Comparison of localization perfor- mance versus cost per instance on SWE-Bench- Lite. Our proposed SWERANK EMBED retriever and SWERANKLLM reranker models achieve su- perior accuracy at a significantly lower cost com- pared agent-based localization methods.
Figure 1:
Empirical results demonstrate that SWERANK achieves tfae-offthheaatt performance for file, module and function-level localization on Awe-Bench-Lite (Jimenez et al., 2023) and LocBench (Chen et al., 2025). Further, we show that SWERANK, built on open-source models, has a considerably better performance to cost ratio compared to agent-based approaches that employ closed- -ossre L.MMs like Claude-3.5 (Anthropic, 2023), as illustrated in Figure 1. Finally, we demonstrate the effectiveness of our SWELoC data by showing that it consistently improves localization performance when used for finetuning a variety of text and code-pretrained retriever and reranker models.
2
RELATED WORK
2.1 SOFTWARE ISSUE LOCALIZATION
Software issue localization or Fault Localization (FL) aims to identify the specific code locations responsible for reported bugs. Traditional fault localization methods (Wong et al., 2016) can be grouped into spectrumm-asse
approaches. Spectrum-based fault localization (SFL) (de Souza et al., 2016; Amario de Souza et al., 2024) statistically associates test outcomes with executed code clements to rank statements or functions by their 'suspiciousness' based on passing and failing test coverage. Complementary static and dynamic analyses exploit program structure- structure-through call-graph traversal (Adhiselvam et al., 2015), dependency analysis (Elsaka, 2017), or program slicing (Soremekun et al., 2021)-to constrain the search space of potential bug locations. While these methods provide statistical basis for finding faults, they require precise program models and cannot leverage the rich natural language context in bug reports.
and program-
460 tokens in SWE-Bench (Jimenez et al., 2023) issues 12 tokens in CSN (Li et al., 2024a) queries.
2

---

Published as a conference paper at ICLR 2026
Scraping
Negative Mining
Quality filtering
Tap PyPi
Open- nourre Repository
Enteddiing Sinkamy Fiber
leckinedd the edpttec Wileshot...
Issue
G Codabaan
Decontaminatin Dedipficatio
Codebase
Ratay
Fitteed Packages
Crette Drenter
P Railey
Free pobkeee aeort Hite
0.12
Prazer Crance
Top-M Hard Negative selection
Figure 2: Overview of SwELoc data construction pipeline, illustrating the three main stages.
Modern approaches instead use LLM-based agent frameworks that treat bug localization as a planning and searching problem. AgentFl. (Qin et al., 2024) incorporates multi-agent system with a three step procedure involving interpreting the bug context, traversing the codebase and verifying the suspected fault. OpenHands (Wang et al., 2025) and SWE-Agent (Yang al., 2024b) use bash commands or custom interfaces to navigate repositories and access files. Other agentic systems combine IR with tool use: MoatlessTools (Örwall, 2024) integrates semantic code search engine into an agent's loop to guide it to relevant files. More recently, LocAgent (Chen et al., 2025) constructs a graph of the codebase for LLM agent to do multi-hop reasoning over code dependencies. While these agent-driven approaches have achieved impressive results, they incur substantial costs and have high latency. Agent-based methods must orchestrate multiple steps of reasoning and tool use, which makes them brittle; single failure in the chain (c.g.. misleading intermediate query an incomplete code observation) can derail the entire localization process. SWERANK instead formulates issue localization single-shot ranking problem, which is highly efficient and cost-effective.
2.2 CODE RANKING
Transformer-be based code ranking models (Wang et al., 2023c; Zhang et al., 2024; Günther et al., 2023; Suresh et al., 2024) have set state-of-the-art on a variety of code retrieval tasks (Li et al., 2024a:b) by learning joint embeddings of text and code. Wang et al. (2023c) and Zhang et al. (2024) learn improved code representations by incorporating a mix of training objectives, such as span denoising, text-code matching and causal LM pretraining, over large-scale code corpora such as CodeScarchNet (Husain et al., 2019) and The Stack (Kocetkov et al., 2022). Suresh et al. (2024) improve the contrastive training process between function snippets and associated doc-strings with better consistency filtering and harder negative mining. Liu et al. (2024b) incorporate multi-task contrastive data that includes code contest generation (Billah et al., 2024), code summarization (Sontakke et al., 2022), code completion (Liu al., 2024a), code translation (Pan al., 2024) and code agent conversation (Jin et al., 2024). However, prior code ranking models rarely include error logs in their training data and are not optimized for issue localization, where queries are verbose bug reports rather than precise functionality requests. In contrast, SWERANK is explicitly trained on SWELoC, new automatically collected set of real-world issue reports paired with known buggy functions. By optimizing bi- encoder retriever and listwise LLM reranker on this task-specific data, SWERANK directly aligns verbose bug descriptions with faulty code, thereby improving localization accuracy.
3 SWELOC: ISSUE LOCALIZATION DATA
Existing code retrieval datasets (Husain et al., 2019: Suresh et al., 2024) are generally valuable for tasks like NL-to-code search which mainly requires functionality matching. However, they are sub- optimal for training models aimed at software issue localization. The nature of software issues-often detailed descriptions of failures rather than concise functional specifications-nceesiiie accurately reflects this challenge of precisely identifying the problematic functions. To address this gap and provide suitable training ground for our SWERANK framework, we constructed SwELoc, a novel large-scale dataset specifically curated for the task of localizing code snippets relevant to software issues. SWELoC is derived from real-world software development activities captured in public GitHub repositories. Our methodology comprises three main phases: (1) identifying and filtering relevant pull requests (PRs) from popular Python repositories ($3.1), (2) processing these
a dataset that
3

---

Published as a conference paper at ICLR 2026
Distribution and of Iexue Lengthx
Files Modified
Functions Moditied
10
11.2%
10000
5608
203
300
890
260
1006
1200
1408
Number
Towers
Figure 3: (I.eft) Distribution of query lengths in the SwELLoc dataset. The red dashed line indicates mean query length of 382.56 tokens. underscoring the detailed nature typical of issue reports. (Right) Distribution of the number of (a) files, (b) modules, and (c) functions modified per GitHub issue. This highlights that while many localizations are concentrated, a significant number span multiple code units, particularly at finer granularities.
PRs to extract issue descriptions paired with their corresponding code modifications ($3.2), and (3) applying consistency filtering and ($3.3). An overview of this process is shown in Figure 2.
mining to enhance the quality of training instances
3.1 IDENTIFYING RELEVANT PRs
Our data collection involves selecting the repositories associated with the top 11,000 PyPI packages on GitHub. To ensure repository quality and relevance to our task, we apply several filtering criteria. Repositories required to contain at least 80% Python code. To prevent data leakage and overlap with existing benchmarks, we exclude repositories already present in WWE-Bench (Jimenez et al., 2023) and LocBench (Chen et al., 2025). Finally, we perform deduplication based source code overlap to remove near-identical repositories. This process results in a curated set of 3387 repositories.
Following the SWE-Bench methodology, we identify pull requests (PRs) within these repositories that (1) resolve a linked GitHuub issue and (2) include modifications to test files, indicating the issue resolution was verified. For each such PR, collect the issue description and the codebase snapshot at the PR's s base commit. This procedure results in 67,341 initial (PR, codebase) pairs. Figure 3 provides further details on the dataset's 's composition, including query and repository edit distributions.
3.2 LOCALIZATION PROCESSING
Using the collected (PR, codebase) pairs, we create contrastive training data in the form of (query, positive, negatives) tuples. For each tuple, the issue description serves the query. Each function modified within the PR is designated as positive example, corresponding to a distinct training instance. Thus, PR modifying N functions yields N training instances. The negatives for each instance come from the unmodified functions within the corresponding codebase. This initial set of instances are further refined via consistency filtering and hard- nard-ieeetive mining, as described next.
3.3 CONSISTENCY FILTERING AND HARD NEGATIVES
The quality of (query. positive, negatives) tuples used for training significantly impacts the ranking model performance (Suresh et al., 2024). Effective contrastive learning requires relevant positives and challenging negatives (semantically similar to the positive but irrelevant to the query). However, issue descriptions in open-source repositories can be vague, leading to noisy signals for relevance between the issue descriptions and associated code modifications when directly used for training.
To mitigate this, we employ filtering and mining techniques following recent work (Günther et al., 2023; Suresh et al., 2024). First, we apply top-K consistency filtering (Suresh et al., 2024) to retain only instances where the positive code snippet is semantically close to the query relative to other code snippets in the repository. Formally, given an instance i with issue description 4; positive function C₁ and the set of other unrelated functions F, in the repository, we use a pre-trained embedding model (CODERANKEMBEE (Suresh et al., 2024)) to compute similarities between t, e, and all functions in F, Instance is retained only if c; ranks within the top K functions in F,, based on similarity to t, We set K 20, with ablation studies in 1.
4

---

Published as a conference paper at ICLR 2026
Beyond filtering for relevance of positive pairs, incorporating challenging negatives is crucial for enabling the model to distinguish between semantically similar instances (Moreira et al., 2024). To this end, we employ hard negative mining strategy that leverages the previously computed similarities to select a set of hard negatives B, = {c, } j=1 for each instance i. These negatives chosen from F; such that they among the top M (=15) most similar functions to the query /,
4 SWERANK METHODOLOGY
In this section, we present our proposed ranking framework for software issue localization. SWERANK adopts a two-stage retrieve-and bi-encoder retriever that efficiently narrows down candidate code snippets from large codebases; and (2) SWERANKLLM a listwise LLM reranker that refines these initial results for improved localization accuracy. Next, we elaborate on the architecture and training objectives for these components.
approach with two key components: (1) SWERANKEMBED. a
4.1
SWERANKEMBED
The retriever component, SWER ANKEMBD,, utilizes a bi-encoder architecture (Reimers & Gurevych, 2019) to generate dense vector representations for GitHub issues and code functions within shared embedding space. Let (4i, c,t) represent a positive pair from the SWELOC dataset, consisting of an issue 44 and the corresponding code function modified c²" The bi-encoder maps these to embeddings (hi, h ). derived from the last hidden layer of the encoder. For training batch of size N, let H = = J denote the set of positive code embeddings. Let H U (1. ( 7=1 be the set of embeddings for the M hard negatives mined for each issue t, in the batch (as described in $3.3).
SWERANKEMBED is trained using an InfoNCE contrastive loss (Oord et al., 2018). The objective encourages the embedding h; of issue have a higher similarity with its corresponding positive code embedding hrt compared to its similarity with all other fig embeddings (A & i) and all hard negative embeddings hig within the batch. The loss for single positive pair (h;, h is:
exp(h, h h+t)
Lcc = - EHH exp(h: h&)
The denominator sums over the positive embedding h itself and N +1) - negative embeddings relative to h4 During inference, candidate code functions for given issue description are ranked based on the cosine similarity between their respective embeddings and the issue embedding.
4.2 SWERANKLLM
For the reranking stage, we employ SWERANKLLM, an instruction-tuned LLM for reranking. SWERANKLLM adopts a listwise ranking approach (Pradeep et al., 2023b), which offers better performance than pointwise methods by considering the relative relevance of candidates. Typically, listwise LLM rerankers are trained to process an input consisting of the query and a set of candidate documents, each associated with a unique identifier. The model's training objective is then generate the full sequence of identifiers, ordered from most to least relevant according to the ground-true -ruth ranking. However, since SwELoc does not provide a ground-trute -oouh ranking among the negative functions for the issue 4. generating a complete target permutation for training is not feasible.
To adapt listwise reranking training to our setting where only the positive is known, we modify the training objective. Formally, let D = {d)) be a training dataset of triplets, where each sample d, := (t,, ( includes a GitHub issue f; a relevant positive code et and a set of M irrleevant negative codes ( M We first assign unique numerical identifier from 1 to M+1) to each function in the set cf U (CT Let It* be the identifier assigned to the positive function ot. Instead of training the model to predict the full ranked list of identifiers, we train it to correctly generate the identifier corresponding to the single positive function, 1,a. Thereby, the training objective for given sample d, is thus simplified to maximizing the likelihood of the first generated (i.e. top-ranked) identifier:
LIM log( (T)
5

---

Published as a conference paper at ICLR 2026
File (9)
Module (%)
Function (%)
Type
Method
Model
Acc@1
Ace@3
Ace@5
Acc@
Acc@10
Ace@5
Acc
Moatles/Tools
GFT-4o
73.36
84.31
85.04
74.82
76.28
57.30
59.49
Örwall (2024)
Claude-3.5
72.63
85.77
86.13
76.28
76.28
64.60
64,96
age-t
GPT-4o
57.30
64.96
68.98
58.03
58.03
45.99
46.35
Yang et al. (2024b)
Gl Claude-3.5
77.37
87.23
90.15
77.74
78.10
64.23
64.60
Agent
Openhands
GPT-4o
60.95
71.90
73.72
62.41
63.87
49.64
50.36
Wang et al. (2025)
L.aude-3.5
76.28
89.78
90.15
83.21
83.58
68.25
70.07
70.80
84.67
88.32
81.02
82.85
64.23
71.53
LocAgcat
Chen (2025)
0ven2.5-328(ft)
75.91
90.51
92.70
85.77
87.23
71.90
77.01
315
77.74
91.97
94.16
86.50
87.59
73.36
77.37
BM25 (Robertson 1994)
38.69
$1.82
61.68
45.26
52.92
31.75
36.86
Jina Code-v2 (161M) (Günther et 2023)
43.43
71.17
80.29
63.50
72.63
42.34
52.19
Codesage-Karge-22 (1.3B) (Zhang al., 2024)
47.81
69.34
78.10
60.58
69.71
33.94
44.53
Retriever
CodeRankEmhed (137M) (Suresh et al., 2024)
52.55
77.74
84.67
71.90
78. 83
51.82
58.76
SFR 2in--Embcdiing-22 (7B) (Meng al,, 2024)
58.03
80.29
83.94
70.07
79.20
56.20
64,23
GTE- TFEE-Qeen2.70 Beoven2-BB-Bee Instruct (7B) (1.i et al., 2023)
65.33
82.85
89.78
76.28
83.58
63.14
70.44
WWERANKKEMEED-SMAAL (137M) (Ours)
66.42
86.50
90.88
79.56
85.04
63.14
74.45
BEERANKKEMBED-LARGG (7B) (Ours)
72.63
91.24
94.16
84.31
89.78
71.90
82.12
CodeRankLLMM (7B) (Suresh al., 2024)
72.99
89.78
91.80
85.04
90.88
71.90
83.58
GPT4.11
82.12
95.62
97.08
93.07
93.43
81.75
87.96
+ Reranker
SWERANKLLM-SAAE M--LLLL (7B) (Ours)
78.10
92.34
94.53
89.05
92.70
79.56
86.13
SWERANKLLM-L (32B) (Ours)
83.21
94.89
95.99
90.88
93.43
81.39
88.69
Table 1: Performance (in %) on SWE-Bench-LLte The rerankers use SWERANKKEMBED-LLARE as the retriever.
Gray corresponds to results with closed- llosed-ouurce models. Best retriever numbers are blue, while overall numbers (except GPT-4.1) I) in bold.
where x is the input prompt constructed from the issue and the set of candidate functions of (GT)) along with their assigned identifiers, and Po represents the listwise LLM reranker.
During training, we omit the -fe-oe-seueence token after predicting 1 to retain the model's capability to generate full ranked lists for inference, required by the listwise format. As show later in experiments in $5.322, our approach enables finetuning any listwise reranker for the software issue localization task, without needing the full candidate ranking ordering for training supervision.
EXPERIMENTS
The experiments compare SWERANK'S performance against state-of-the-ar based localization methods, and other code ranking models ($5.2). Furthermore, we investigate the impact of our SWELOC dataset, analyzing how its quality controls (such as consistency filtering) and size influence model performance ($5.3.1). I), and examining its generalizability by evaluating effectiveness in fine- tuning various pre-existing retriever and reranker models for the issue localization task ($5.3.2).
5.1 SETUP
Model Training: We train the SWERANK models in two sizes: small and large. All models are finetuned using our SWELoC dataset. SWERANKE SWERANNEEBEDD-SSAA. is initialized with CodeR- ankEmbed (Suresh et al., 2024). SOTA 137M code embedding model, while the large variant is initialized with TTTE--wen2-7B-IInttuu (Li et al., 2023), 7B parameter text embedding model employing Qwen2-7B-Instree
as its encoder. The small version of SWERANKLLM is initialized with CODERANKLLAN (Suresh et al., 2024), a 7B parameter code- pretraredd listwise reranker. The large version is initialized with Swen-2..5322 In-stuutttt that is pretrained using text listwise reranking data (Pradeep et al., 2023b). More details in Appendix A.
Our primary comparison is against prior agent-based localization methods. Specifically, include OpenHands (Wang et al., 2025), SWE-Agent (Yang et al., 2024b), MoatlessTooll. (Örwall, 2024) and LocAgent (Chen et al., 2025), the current SOTA agent-based approach. Notably, these methods predominantly use closed-source models, with LocAgent also finetuning open-source models
Baselines:

---

Published as a conference paper at ICLR 2026
for this task. For the retrieve-and-rerank framework, we compare SWERANKEMBED -AALEL against BM25 (Robertson et al., 1994) and several code embedding models comparable size, including Jina- C2de-v2 (Günther et al., 2023), Codesage- -aage-lge---2 (Zhang al., 2024), and CodeRankEmbed (Suresh et al., 2024). For the 7B parameter embedding model comparison, we include SI'F--Qee2--7B5 Instruct, which ranks third on the MTEB leaderboard (Muennighoff et al., 2023) the time of evaluation. For the reranker comparison, we include CODERANKLLM and other closed source- models such as GPT-4.1. Due to the larger size of LocBench, comparisons on this benchmark are limited to subset of the best- best-performing baselines.
Datasets & Metrics: We evaluate on SWE-Bench-LLic (Jimenez. et al., 2023) and LocBench (Chen al., 2025). Following Suresh et al. (2024), we exclude examples from SWE-Bench-Lite where no existing functions were modified by the patch, resulting in 274 retained examples out of 300. While SWE-Bench-Lite primarily consists of bug reports and feature requests, LocBench 560 examples) also includes security and performance issues. Consistent with Chen et al. (2025), we measure localization performance at three granularities: file, module (class) and function, with Accuracy at k (Acc@) @K k) as the evaluation metric. This metric deems localization successful if all relevant code locations are correctly identified within the top-k results. The relevance score for specific file or module is determined by the maximum score of any function contained within that file or module.
5.2 LOCALIZATION RESULTS
Table I compares performance of different localization methods on the SWE-Bench-Lite benchmark. The results indicate that our SWERANK models surpasses the performance of all evaluated agent- based methods. Furthermore, the size of 137M parameters, demonstrates highly competitive performance, outperforming prior 7B parameter embedding models. Notably, AVERRAKKEMBE--ARCEE achieves higher Acc@ 10 for function localization than LocAgent with Claude-3.5. Employing the SWER ANWLAN reranker subsequently enhances the retriever's output, establishing new SOTA for localization performance on this benchmark across all granularities. Qualitative examples are provided in Appendix H.
SMLLL model, despite its relatively small
Table 2 shows results on LocBench. sim- ilar trend is observed, with the large variants of SWERANKEMBED and SWERANKLLM set- ting new SOTA performance. Figure 4 pro- vides a detailed breakdown of localization ac- curacy across the four distinct difficulty cate- gories within LocBench. Despite being primar- ily trained with bug reports in SwELoc, the SWERANK models demonstrate impressive gen- eralizability across other categories.
Syntean (127))
Feet al Requise
Pertaracc
Secutty
Figure 4: Localization performance across differrnnt categories within LocBench. SWERANK considerably outperforms agent-based methods using Claude-3.5.
5.3
ANALYSIS
Our analysis presented in this section aims to demonstrate the following key points: 1) the impact of SWELoC data quality and size on final model performance 18), 2) the utility of SwELoc for finetuning various retriever and reranker models ($5.3.2; and 3) the cost-effectiveness of the proposed SWERANK framework ($5.3.3). Unless otherwise mentioned, the results are on SWE-Bench-Lite.
5.3.1 DATA QUALITY AND SIZE
Public GitHub repositories, as source for contrastive data, often contain noisy instances. This study first examines the effectiveness of consistency filtering ($3.3), specifically the influence of the positive-rank threshold, K. This parameter dictates the minimum rank of the instance's 's positive (relative to negatives, based on similarity with the issue description) for inclusion of the instance in the training set. Increasing K relaxes the filtering, yielding more training instances but potentially introducing more noise. As shown in Figure 5a, finetuning SWERANKEMER data filtered by different K values reveals that optimal performance is achieved with a moderate K (e.g., K=20), striking a balance between instance quality and dataset size. The absence of filtering (K (K=None) proves detrimental as performance drops after finetuning compared to pre-trained model.
SMALL with SWELoC
7

---

Published as a conference paper at ICLR 2026
File
Module (%)
Function (%)
Method
Loc Model
Acc@5
Acc@10 10
1cc@10
Acc@ 15
Acc@ 10
Acc@15 15
Agentless
Claude-3.5
67.50
53.39
53.39
42.68
42.68
OpenHands
Claude-3.5
79.82
80.00
68.93
69.11
59.11
59.29
SWE-agent
Claude-3.3
77.68
77.68
63.57
63.75
51.96
51.96
Qwen2.5-78(f1) --7(ff))
78.57
79.64
63.04
63.04
51.43
51.79
LocAgent
C1aude-3.5
83.39
86.07
70.89
71,07
59.29
60.71
CodeRankFmmedd (137M)
74.29
80.36
63.93
67.86
47.86
50.89
GTE-Qwen2-7B-Imne (7B)
75.54
82.50
67.14
71,61
51.79
57.14
Retriever
SWERANKEMBED-SMAA (137M)
80.36
84.82
71.43
75.00
58.57
63.39
SWERANKEAIEED-LARG (7B)
82.14
86.96
73.54
78.93
63.21
67.32
CodeRankLLLM (7B)
83.93
88.21
64.64
69.29
GPT-4.1
85.89
88.75
79.64
82,50
71.61
74.64
Reranker
SWERANKLLM-SME --ALL (7B)
85.54
88.39
79.11
82.14
69.46
74.46
SWERANKLLM,
(32B)
86.61
89.82
81.07
83.21
71.25
76.25
Table 2: Performance (in %) on LocBench. The rerankers use SWERANCEMBED-LARGG as the retriever.
Gray correspond to results with closed- models. Best retriever model numbers in blue, while best overall numbers (except GPT-4.1) 1) are in bold.
Flee33
Ke5
Function@10
Accurscy (%)
80
nlog1
K=10
K-20
K-none
70
Km5
84
Notulbe
60
10
3x
10
Rucctor910
Training Examples (log scale)
30
(a) While accuracy improves from doing consistency filtering, ie. discarding instances where the positive's rank among
Braming Data
(b) All metrics show general upward trend as the percentage training data (K=20) increases.
negatives is filtering (K=None) hurts performance.
Figure 5: Impact of (a) training data filtering and (b) data size SWERANKEMBED--AE SMALL performance.
Controlling for data quality (by fixing K=20), the impact dataset size investigated. Figure 5b illustrates that training with varying proportions of the filtered data yields considerable performance improvements, even with only 5% of the data. Generally, larger dataset sizes correspond further performance gains. These experiments underscore the significance of both data quality and quan- tity, demonstrating that merely increasing data volume without quality control can be detrimental. Appendix $E further examines the impact of negative hardness model performance.
5.3.2 CHOICE OF RETRIEVER AND RERANKER
Here, demonstrate the efffcctiveness of SwELoc by showing improvements for a variety retriever and reranker models from finetuning. First, the follow- ing embedding models, pre- pre-trained on different data types, finetuned for one epoch SwELoc: Aretic- Embed (Merrick et al., 2024), primarily pre-trained on English text retrieval data; CodeRankEimbed, pre- trained on 22 million NL-to-Code examples (Suresh al., 2024); and Pretic-Embed--2.000 (Yu al.. 2024), pre-trained on mix of English and multi- lingual data. From Table 3, we see all models showing significant performance improvement from finetuning. Notably, models that initially performed weaker (e.g.. Aretic-Embed) showed greater gains. This outcome validates that SWELoc can substantially improve the performance of any embedding model for software issue localization.
Base Retriever
Pretrain
Func. Accl0 10 (%)
CodeRankEmbed
English+Code 59.5->72.3 (+12.8)
Aretic-Embed
English
53.7++71.9 (+17.4)
Arctic Emb
Multlingual
62.0-4701 (+8.1)
Table 3: Accuracy (Before-AAiie from fine- tuning different retrievers with SwELoc data.
8

---

Published as a conference paper at ICLR 2026
Next, text- and sedde-nnstruction-tmme LLMs of different sizes from the Qwen2.5 family ( (Yang et al., 2024c; Hui et al., 2024) are finetuned as listwise LLM rerankers using SWELoC data,
Base LLM Rerunker
Func. Acc@5 (%)
Func. Acc (5)
Qwen-2,5-Text (32B)
77.0-1814 (44.4)
82.5 -66.1 (43.6)
Qwen-2.5-Code (328)
76.3-479.9 (43.6)
81.8 -88.7 (+2.9)
Since we only apply loss the first genera- tion token, to ensure compatibility with the list- wise output format, all models were initially pre- trained on listwise text reranking data (Pradeep al., 2023b), which provides the full ranking order to use for supervision. The results, shown Table 4, indicate that rerankers across differ- ent model sizes universally benefit from finetuning on SWELOC. An interesting observation is that the code-pretie sode-ppetrained model performs marginally better at the 7B scale, while the text-pretrained models achieve better results at the 3B and 32B scales. Results with finetuning Llama-3.1 are in Appendix B.
Qwen-2.5-Text (7B)
75.2-+75.6 (+0.4)
81.4 -+2.5 (+1.)
Qwen-2.5-cC (7B)
75.5-475.9 (+0.4)
81.0 -83.6 (+2.6)
Qwen-2.5-Text
68.3-473.7 (44.6)
76.6->82.5 (45.9)
Qwen-2,5-Code (3B)
71.2-911.9
(40.7)
Table 4: Localization accuracy (Before- -After from finetuning different listwise rerankers with SwELoc.
5.3.3 INFERENCE COST ANALYSIS
Agent-based localization approaches typically involve multiple iterations, each requiring extensive chain-of- thought generation (Wang et al., 2023b), incurring consid- erable cost at inference. In contrast, SWERANK offers sig- nificant costteffeeciveeess as the SWERANKLLM reranker only needs to generate output candidate identifiers deter- mine the ranking order. Furthermore, the SWERANKIA EM- BED output embeddings in negligible extra cost. Table 5 compares the inference costs of SWERANKLLM with other agent-based meth- ods. Clearly, agent-based approaches, often relying on closed-source models for better performance, are highly cost-intensive. SWERANK is substantially cheaper while providing significantly better performance, with up to 6X better performance-cost tradeofTs compared to LocAgent,
Acc@10
Method
Model
Cost())
Cost
GPT-40
0.46
0.8
SWE-ggen
Claude-3.5
0.67
L.0
GPT-40
0.8
0.6
Openhands
Claude-3.5
0.79
0.9
Claude-3,5 3.5
0.66
1.2
be pre-computed, resulting
LocAgent
(-7(f)))))(
0.05
13.2
(w3n2.5-378(ft)
0.09
8.6
GPT-4.1
0.16
5,9
Reranker
SWIRANKLLLM (7B)
0.011
79.0
SWIRANKLL (32B)
0,15
57.5
Table 5: SWERANKLLM has considerably better inference cost- efficiency than agent- based methods while being more performant.
5.3.4 IMPACT ON DOWNSTREAM ISSUE RESOLUTION
This section analyzes the impact improved localization on downstream code repair performance. To evaluate issue res- olution, we utilize SWE-Fixer (Xie et al., 2025), a two-step pipeline consisting of code file retrieval (localization) followed by code editing. We compare the repair outcomes on SWE- Bench-Lite when employing different localization methods: the native localization mechanism of SWE-Fixer, LocAgent (with Claude-3.5), our SWERANK (large variant), and an oracle. The oracle simulates perfect localization by using the ground-truth edited file. thereby providing an upper bound for the repair framework. From Table 6, we see that better localization provided by SWERANK yields improved issue resolution, with oracle results showing that repair performance is currently constrained by the code editing model.
Localization File Acc@1
Repair Pass@!
SWE-Fixer
69.7
21.0
LocAgent
78.5
22.6
SWERank
83.2
24.5
Oracle
100
25.9
Table 6: Impact of localization accu- racy on downstream issue resolution.
5.3.5 PERFORMANCE ANALYSIS BY ISSUE COMPLEXITY
Aggregate metrics often obscure per- formance variance on complex issues. To address this, we stratify the test set by num-gold (the number of functions modified in the ground truth patch) as a proxy for issue complexity. We com- pare approach against LocAgent and Gemini- Embedding, with results summarized in Figure 6.
Loctlench
41
Colee1
C60603
Golerl
Gr
Figure Function Acc@: 10 breakdown by issue complexity.

---

Published as a conference paper at ICLR 2026
As expected, performance degrades as the number of modified functions increases. Instances requiring changes to > 5 functions are extremely difficult for all models, resulting in single-digi accuracy. However, SwEE
demonstrates significantly better scaling on complex issues (num gold=2-3) compared to Agentic approaches; on SWE-Bench-Lite. LocAgent drops from 82.0% to 47.1%, %, while our retriever maintains 77.1%. Furthermore, the reranker consistently improves performance across all complexity levels, confirming that it successfully captures cross-function dependencies that the bi-encoder might miss.
5.3.6 PERFORMANCE ANALYSIS BY LEXICAL AND SEMANTIC OVERLAP
To further dissect the model's capabilities, we analyzed performance by grouping instances based on Lexical Overlap (Rouge-1) 1) and Semantic Overlap (Cosine Similarity).
Lexical Overlap. We bucket instances into four groups using the Rouge-1 score between the issue description and the ground- truth localized functions. A high Rouge score indicates significant keyword overlap. Figure 7 sum- marizes the results. We ob- serve that performance generally degrades as lexical overlap de- creases. However, even in the lowest overlap bucket (0.0-0.1), SWERANKEMBED-LAACE on SWE-Bench-LLite demonstrating that our model does not rely solely keyword matching. Furthermore, SWERANKLLM consistently improves performance, with significant gains seen specif-- ically for instances with low lexical overlap.
SWE Bench Ute
LocBench
Lears Ouerie (hhoge-11
Leural (aaupe11
Lackgenz (0lude2.21
GemniCrbedting
Centandrant 133.0
Sestan I001
KONaRAmILLA 620)
Figure 7: Performance breakdown by Lexical Overlap (Rouge l).
outperforms LocAgent (65.2% vs 60.9%
Semantic Overlap. We also categorize instances based on the mean cosine similarity (com- puted via EmbbidinEm of the issue description and the ground-truth functions. As shown in Figure 8, perfor- mance is directly correlated with semantic overlap, achieving near-perfect accuracy for high- similarity instances (> 0.8). No-
SWi-Bench-LLtee
Loctlench
055 3.7
77-8 17g
08-39
Secferkfrrece (78)
Figure 8: Performance breakdown by Semantic Overlap.
tably, SWERANKLLM reranker considerably boosts performance the retriever in low- low-similarity buckets (0.65-0.75), outperforming the multi-turn LocAgent approach. This suggests that while agentic tool-use can bridge the semantic gap. our training on SweLoc-which incorporates hard negatives- enables the SWERANK framework to learn these non-obvious mappings effectively without the cost of agentic inference.
6 CONCLUSION
This paper frames software issue localization as specialized ranking task and introduces SWERANK, a highly performant and cost-effective retrieve-and-rerank. framework. To effectively train SWERANK models, we construct SWELOC, a large-scale contrastive training dataset derived from real-world GitHub issues, employing consistency filtering and negd-iegttive mining for quality. Empirical evalu- ations on SWe-Bench-Lite and LocBench demonstrate state-of-the-art the-art localization performance using SWERANK, significantly outperforming costly closed-source agent- systems. The introduction of SWELoC dataset provides valuable resource for advancing research in this domain.
10

---

Published as a conference paper at ICLR 2026
REFERENCES
A Adhiselvam, E Kirubakaran, and R Sukumar. An enhanced approach for software bug localization using map reduce technique based apriori (mrtba) algorithm. Indian Journal of Science and Technology, 8:35, 2015.
Higor Amario de Souza, Marcelo de Souza Lauretto, Fabio Kon, and Marcos Lordello Chaim. Understanding the use of spectrum-based fault localization. Journal of Software: Evolution and Process, 36(6):2262,, 2024.
Anthropic. Claude: Conversational ai by anthropic, 2023. URL https::/www.ntthrooi....
claude. Accessed: January 21, 2025.
Md Mustakim Billah, Palash Ranjan Roy, Zadia Codabux, and Banani Roy. Are large language models a threat to programming platforms? an exploratory study. In Proceedings of the 18th ACM/IEEE International Symposium on Empirical Software Engineering and Measurement, pp. 292-301, 2024.
Zhaoling Chen, Xiangru Tang, Gangda Deng, Fang Wu, Jialong Wu, Zhiwei Jiang, Viktor Prasanna, Arman Cohan, and Xingyao Wang. Locagent: Graph-guide Ilm agents for code localization. arXiv preprint 1133:::500000089 2025.
Cognition AI. Devin: The First AI Software Engineer. https://devin ai/, 2024. Accessed:
2025-04-22.
Cursor. Cursor: The AI Code Editor. https://wwwcursrr.coom
Accessed: 2025-04-22.
Higor A de Souza, Marcos Chaim, and Fabio Kon. Spectrum- based software fault localization: survey of techniques, advances, and challenges. arXiv preprint arXiv: urXiv:16077 1607.04347 2016.
E. Elsaka. Chapter three fault localization using hybrid static/dynamic analysis. volume 105 of Advances in Computers, pp. 14. Elsevier, 2017. doi: 004. URL httpps:/wwwit wttp::/wwwwwiiiiccwww.....c com
Paul Gauthier. How aider scored sota 26.3% on bench lite aider, 2024. URL https: html. Accessed: January 21, 2025.
Aaron Grattafiori, Abhimanyu Dubey, Abhinav Jauhri, Abhinav Pandey, Abhishek Kadian, Ahmad Al-Dahle, Aiesha Letman, Akhil Mathur, Alan Schelten, Alex Vaughan, et al. The llama herd of models. arXiv preprint 2w..h:2407.21726 2024.
Michael Günther, Georgios Mastrapas, Bo Wang, Han Xiao, and Jonathan Geuter. Jina embeddings: A novel set of high-performance sentence embedding models. In Proceedings of the 3rd Workshop for Natural Language Processing Open Source Software (NLP-OSS 2023), 8-18, 2023.
Michael Günther, Louis Milliken, Jonathan Geuter, Georgios Mastrapas, Bo Wang, and Han Xiao. Jina embeddings: A novel set of perfforrformecc sentence embedding models, 2023, URL https://arriv.orr/bbb/2000 abgg/bbs//30000 11224.
Binyuan Hui, Jian Yang, Zeyu Cui, Jiaxi Yang, Dayiheng Liu, Lei Zhang, Tianyu Liu, Jiajun Zhang, Bowen Yu, Kai Dang, An Yang, Rui Men, Fei Huang, Shanghaoran Quan, Xingzhang Ren, Xuancheng Ren, Jingren Zhou, and Junyang Lin. Qwen2.5-coder codder technical report. ArXiv, 0bs/2409.12186. 2024. URL / aemanticcen cschollarr org. Pttp:/CoopIII::2227775500
Hamel Husain, Ho-Hsiang Wu, Tiferet Gazit, Miltiadis Allamanis, and Mare Brockschmidt, Code- searchnet challenge: Evaluating the state semantic code search. arXiv preprint arXiv: 09436, 2019.
Neel Jain, Ping yeh Chiang, Yuxin Wen, John Kirchenbauer, Hong-Min Chu, Gowthami Somepalli, Brian R. Bartoldson, Bhavya Kailkhura, Avi Schwarzschild, Aniruddha Saha. Micah Goldblum. Jonas Geiping, and Tom Goldstein. Neftune: Noisy embeddings improve instruction finetuning, 2023. URL https: //tp///aivv////////////a////iav/ wtwaa/iwwwr///b//////.... 05914.

---

Published as a conference paper at ICLR 2026
Carlos E Jimenez, John Yang, Alexander Wettig, Shunyu Yao, Kexin Pei, Ofir Press, and Karthik Narasimhan. Swe-bench: Can language models resolve real-world github issues? arXiv preprint arXiv:2310.06770, 2023.
Hyoungwook Jin, Seonghee Lee, Hyungyu Shin, and Juho Kim. Teach ai how to code: Using large language models as teachable agents for programming education. In Proceedings of the 2024 CHI Conference on Human Factors in Computing Systems, pp. 1-28, 2024.
Denis Kocetkov, Raymond Li, LI Jia, Chenghao Mou, Yacine Jernite, Margaret Mitchell, Car- los Muñoz Ferrandis, Sean Hughes, Thomas Wolf, Dzmitry Bahdanau, et al. The stack: 3 th of permissively licensed source code. Transactions on Machine Learning Research, 2022.
Aditya Kusupati, Gantavya Bhatt, Aniket Rege, Matthew Wallingford, Aditya Sinha, Vivek Ra- manujan, William Howard-Snyder, Kaifeng Chen, Sham Kakade, Prateek Jain, and Ali Farhadi. Matryoshka representation learning. In S. Koyejo, S. Mohamed, A. Agarwal, D. Belgrave, K. Cho, and A. Oh (eds.), Advances in Neural Information Processing Systems, volume 35, pp. 30233- 30249. Curran Associates, Inc., 2022. URL https: http///rrreeennnsspeeeeeepcessss neurips sccpaper_files. haper/2022/file/// c3231 http://ieeee322219446686866686 9ww.8ff.766 3d78af 8w18839999991111 P00e002--aar----oeeeeeeeeee .dff.
Tom Kwiatkowski, Jennimaria Palomaki, Olivia Redfield, Michael Collins, Ankur Parikh, Chris Alberti, Danielle Epstein, Illia Polosukhin, Jacob Devlin, Kenton Lee, et al. Natural questions: benchmark for question answering research. Transactions of the Association for Computational Linguistics, 7:453-466, 2019.
Jinhyuk Lee, Feiyang Chen, Sahil Dua, Daniel Cer, Madhuri Shanbhogue, Iftekhar Naim, Gus- tavo Hernández Ábrego, Zhe Li, Kaifeng Chen, Henrique Schechter Vera, et al. Gemini embedding: Generalizable embeddings from gemini. arXiv preprint arXi::2503.07811 2025.
Xiangyang Li, Kuicai Dong, Yi Quan Lee, Wei Xia, Yichun Yin, Hao Zhang, Yong Liu, Yasheng Wang, and Ruiming Tang. Csn: A comprehensive benchmark for code information retrieval models. arXiv preprint arXiv:2407.0288) 2024a.
Xiangyang Li, Kuicai Dong. Yi Quan Lee, Wei Xia, Yichun Yin, Hao Zhang, Yong Liu, Yasheng Wang, and Ruiming Tang. Coir: A comprehensive benchmark for code information retrieval models. arXiv preprint (tt::2407.02888. 2024b.
Zehan Li, Xin Zhang, Yanzhao Zhang, Dingkun Long, Pengjun Xie, and Meishan Zhang. Towards general text embeddings with multi-stage contrastive learning. arXiv preprint 23Xv:22308.03281, 2023.
Tianyang Liu, Canwen Xu, and Julian McAuley. Repobench: Benchmarking repository-level code auto-completion systems. In The Twelfth International Conference on Learning Representations, 2024a.
Ye Liu, Rui Meng, Shafiq Joty, Silvio Savarese, Caiming Xiong, Yingho Zhou, and Semih Yavuz. Codexembed: A generalist embedding model family for multiligual and multi-task code retrieval. arXiv preprint arXiv:2411. 2024b.
Rui Meng, Ye Liu, Shafiq Rayhan Jotya, Caiming Xiong, Yingbo Zhou, and Semih Yavuz. Sfr-embeediing-2 Advanced text embedding with multi-stage training, 2024. URL https: //huggingfaal ace. co/ SeaaleesooreeSS--EEeeddiiiii
Luke Merrick, Danmei Xu, Gaurav Nuti, and Daniel Campos. Aretic-embed: Scalable, efficient, and accurate text embedding models. arXiv preprint arXiv:2405.0537. 2024.
Microsoft. GitHub Copilot-Your Al pair programmer, 2023. URL https://gi http:///gtttu...../ com/ features/copilot.
Gabriel de Souza P Moreira. Radek Osmulski. Mengyao Xu, Ronay Ak, Benedikt Schifferer, and Even Oldridge. Ny-retriever: Improving text embedding models with effective hard-negative mining. arXiv preprint arXiv:2407.1583) 2024.
12

---

Published as a conference paper at ICLR 2026
Niklas Muennighoff, Nouamane Tazi, Loic Magne, and Nils Reimers. Mteb: Massive text embedding benchmark. In Proceedings of the 17th Conference of the European Chapter of the Association for Computational Linguistics, pp. 2014-2037, 2023.
Zach Nussbaum, John X. Morris, Brandon Duderstadt, and Andriy Mulyar. Nomic embed: Training a reproducible long context text embedder, 2024.
Aaron van den Oord, Yazhe Li, and Oriol Vinyals. Representation learning with contrastive predictive coding. In Advances in Neural Information Processing Systems, pp. 10203-10213, 2018.
Rangeet Pan, Ali Reza Ibrahimzada, Rahul Krishna, Divya Sankar, Lambert Pouguem Wassi, Michele Merler, Boris Sobolev, Raju Pavuluri, Saurabh Sinha, and Reyhaneh Jabbarvand. Lost in translation: A study of bugs introduced by large language models while translating code. In Proceedings of the IEEE/ACM 46th International Conference on Software Engineering, pp. 1-13, 2024.
Ronak Pradeep. Sahel Sharifymoghaddlmm, and Jimmy Lin. Rankvicuna: Zero-shot listwise document reranking with open-source large language models, 2023a. URL httpss://aaxiioooggaaaaa//////// 15088.
Ronak Pradeep, Sahel Sharifymoghaddam. and Jimmy Lin. Rankzephyr: Effective and robust zero-shot listwise reranking is a breeze! arXiv preprint arXi::2312.02224. 2023b.
Yihao Qin, Shangwen Wang, Yiling Lou, Jinhao Dong, Kaixin Wang, Xiaoling Li, and Xiaoguang Mao. Agentfl: Scaling Ilm-based fault localization to project-level context. arXiv preprint arXiv:2403.16362, 2024.
Jeff Rasley, Samyam Rajbhandari, Olatunji Ruwase, and Yuxiong He. Deepspeed: System optimiza- tions enable training deep learning models with over 100 billion parameters. In Proceedings of the 26th ACM SIGKDD International Conference on Knowledge Discovery & Data Mining, pp. 3505 -3065,356,,-00 2020.
Revanth Gangi Reddy, JacHyeok Doo, Yifei Xu, Md Arafat Sultan, Deevya Swain, Avirup Sil, and Heng Ji. First: Faster improved listwise reranking with single token decoding. In Proceedings of the 2024 Conference on Empirical Methods in Natural Language Processing, pp. 8642-8652, 2024.
Nils Reimers and Iryna Gurevych. Sentence-BERT: Sentence embeddings using Siamese BERT- networks. In Kentaro Inui, Jing Jiang, Vincent Ng. and Xiaojun Wan (eds.). Proceedings of the 2019 Conference on Empirical Methods in Natural Language Processing and the 9th International Joint Conference on Natural Language Processing (EMNLP-IJCNLP)) pp. 3982-3992, Hong Kong, China, November 2019. Association for Computational Linguistics. doi: 10. 1L.11863//1/DD191444
URL https://aaclanttoooggg.. 1tw.://9yy..r/19111111110
Stephen E. Robertson, Steve Walker, Susan Jones, Micheline Hancock- Beaullee, and Mike Gatford. Okapi at trec-3. In Text Retrieval Conference, 1994. URL https: semanticscholas org/
CorpusID:41563977
Ankita Nandkishor Sontakke, Manasi Patwardhan, Lovekesh Vig. Raveendra Kumar Medicherla. Ravindra Naik, and Gautam Shroff. Code summarization: Do transformers really understand code? In Deep Learning for Code Workshop, 2022.
Ezekiel Soremekun, Lukas Kirschner, Marcel Böhme, and Andreas Zeller. Locating faults with program slicing: an empirical analysis. Empirical Software Engineering, 26:1-45, 2021.
Tarun Suresh, Revanth Gangi Reddy, Yifei Xu, Zach Nussbaum, Andriy Mulyar, Brandon Duderstadt, and Heng Ji. Comstack: High-quality contrastive data for better code ranking. arXiv preprint arXiv:2412.01007, 2024.
James Thome, Andreas Vlachos, Christos Christodoullpoulls,, and Arpit Mittal. FEVER: a large- scale dataset for fact extraction and VERification. In NAACL-HIT,, 2018.
13

---

Published as a conference paper at ICLR 2026
Weishi Wang. Yue Wang, Shafiq Joty, and Steven C.H. Hoi. Rap-gen: Retrieval-augge augmented patch generation with codet5 for automatic program repair. In Proceedings of the 31st ACM Joint European Software Engineering Conference and Symposium the Foundations of Soft- ware Engineering, ESEC/FSE 2023, pp. 146-158, New York, NY, USA, 2023a. Association for Computing Machinery. ISBN 9798400703270.
doi: 10.1145/361 1643.3616256. URL
https://doi. ww..oo.///..// 1145/361 1641. 3.1...66223 3616.56.
Xingyao Wang, Boxuan Li, Yufan Song, Frank F. Xu, Xiangru Tang, Mingchen Zhuge, Jiayi Pan, Yueqi Song. Bowen Li, Jaskirat Singh, Hoang H. Tran, Fuqiang Li, Ren Ma, Mingzhang Zheng, Bill Qian, Yanjun Shao, Niklas Muennighoff, Yizhe Zhang, Binyuan Hui, Junyang Lin, Robert Brennan, Hao Peng, Heng Ji, and Graham Neubig. Openhands: An open platform for Al software developers as generalist agents. In The Thirteenth International Conference on Learning Representations. 2025. URL https: http:::///ppeeeeeereeeee mett/Forum)dd=DJdayyyo)
Xuezhi Wang, Jason Wei, Dale Schuurmans, Quoe Le, Ed Chi, Sharan Narang, Aakanksha Chowdh- ery, and Denny Zhou. Self- improves chain of thought reasoning in language models, 2023b. URL https: /tattpps/////ii..i// www.aa.ww..w..aa........ orgg/bb///03...../ 11177
Yue Wang, Hung Le, Akhilesh Deepak Gotmare, Nghi D. Q. Bui, Junnan Li, and Steven C. H. Hoi. Codet5+: Open code large language models for code understanding and generation, 2023c. URL https://arxiv orgooog////. abs/ 2305. 07922.
Windsurf. Windsurf Editor: The AI-Native IDE. https://windsurf.com/eeee tor,, 2025. Accessed: 2025-04-22.
W Eric Wong, Ruizhi Gao, Yihao Li, Rui Abreu, and Franz Wotawa. A survey on software fault localization, IEEE Transactions on Software Engineering, 42(8):707-740, 2016.
Chengxing Xie, Bowen Li, Chang Gao, He Du, Wai Lam, Difan Zou, and Kai Chen. Swe-fixer: Training open-source Ilms for effective and efficient github issue resolution. arXiv preprint arXiv:2501.05040, 2025.
John Yang, Carlos Jimenez, Alexander Wettig, Kilian Lieret, Shunyu Yao, Karthik Narasimhan, and Ofir Press. Swe-agent: Agent-computer interfaces enable automated software engineering. Advances in Neural Information Processing Systems, 37:50528-50652, 2024a.
John Yang, Carlos E Jimenez, Alexander Wettig, Kilian Lieret, Shunyu Yao, Karthik Narasimhan, and Ofir Press. Swe-agent: Agent-compuct interfaces enable automated software engineering. arXiv preprint arXiv:2405. 2024b.
John Yang, Kilian Lieret, Carlos E. Jimenez, Alexander Wettig, Kabir Khandpur, Yanzhe Zhang, Binyuan Hui, Ofir Press, Ludwig Schmidt, and Diyi Yang. Swe-smith: Scaling data for software engineering agents, 2025. URL
221798.
Qwen An Yang, Baosong Yang, Beichen Zhang, Binyuan Hui, Bo Zheng, Bowen Yu, Chengyuan Li, Dayiheng Liu, Fei Huang, Guanting Dong, Haoran Wei, Huan Lin, Jian Yang. Jianhong Tu, Jianwei Zhang, Jianxin Yang, Jiaxin Yang. Jingren Zhou, Junyang Lin, Kai Dang, Keming Lu, Keqin Bаo, Kexin Yang, Le Yu, Mei Li, Mingfeng Xue, Pei Zhang. Qin Zhu, Rui Men, Runji Lin, Tianhao Li, Tingyu Xia, Xingzhang Ren, Xuancheng Ren, Yang Fan, Yang Su, Yi- Chao Zhang, Yunyang Wan, Yuqi Liu, Zeyu Cui, Zhenru Zhang, Zihan Qiu, Shanghaoran Quan, and Zekun Wang. Qwen2.5 technical report. ArXiv, abs/2412.151155, 2024c. URL https: //api.
wew.:esssannccccollaa. wttpaiicccccoaaraor/oorrrsrsesee wtg/CorpusID: 2748::274492111
Zhilin Yang, Peng Qi, Saizheng Zhang, Yoshua Bengio, William Cohen, Ruslan Salakhutdinov, and Christopher D Manning. Hotpotqa: A dataset for diverse, explainable multi-hop question answering. In Proceedings of the 2018 Conference Empirical Methods in Natural Language Processing. Association for Computational Linguistics, 2018
Shunyu Yao, Jeffrey Zhao, Dian Yu, Nan Du, Izhak Shafran, Karthik Narasimhan, and Yuan Cao. React: Synergizing reasoning and acting in language models. In International Conference on Learning Representations (ICLR), 2023.
14

---

Published as a conference paper at ICLR 2026
Puxuan Yu, Luke Merrick, Gaurav Nuti, and Daniel Campos. Aretic-embed 2.0: Multilingual retrieval without compromise. arXiv preprint arXiv:2412.04506, 2024.
Zhongming Yu, Hejia Zhang, Yujie Zhao, Hanxian Huang, Matrix Yao, Ke Ding, and Jishen Zhao. Orcaloca: An Ilm agent framework for software issue localization. arXiv preprint arXiv:2502.00330, 2025.
Wang Yue, Wang Weishi, Shañi Joty, and Steven C.H. Hoi. Codet5: Identifier-aware unified pre-trained encoder-decoder models for code understanding and generation. EMNLP. 2021.
Dejiao Zhang, Wasi Uddin Ahmad, Ming Tan, Hantian Ding, Ramesh Nallapati, Dan Roth, Xiaofei Ma, and Bing Xiang. CODE REPRESENTATION LEARNING AT SCALE. In The Twelfth International Conference on Learning Representations, 2024. URL forum?id=vf2RRjumg
net/
Yanzhao Zhang. Mingxin Li, Dingkun Long, Xin Zhang, Huan Lin, Baosong Yang, Pengjun Xie, An Yang, Dayiheng Liu, Junyang Lin, Fei Huang, and Jingren Zhou. Qwen3 embed- ding: Advancing text embedding and reranking through foundation models, 2025. URL https://arxiv.org//aa http://rrr/abb//5..05551155
Albert Örwall. Moatless tools, 2024. URL https: /tt///gitttt gigthu....... http::///gituubcoooooeea wwt..///mmarrrll//oooesssstooo.o
15


Reviews:
[{"review_id": "YLdTB0N9BC", "reviewer": "Reviewer_mEZB", "summary": "This paper presents SWERANK, a retrieve-and-rerank framework for software issue localization, i.e., identifying code locations related to natural language issue descriptions such as bug reports. Experiments on SWE-Bench-Lite and LocBench show that SWERANK achieves state-of-the-art performance, surpassing agent-based systems (e.g., LocAgent with Claude-3.5) at all localization granularities.\nIt also offers significant cost advantages, at only $0.011–$0.015 per instance, compared to $0.46–$0.66 for agent-based approaches.", "questions": "Q1: Could the authors provide independent evaluations of SWERANKEMBED and SWERANKLLM?\nFor example, what is the standalone retrieval recall of SWERANKEMBED at different Top-N settings, and how well does SWERANKLLM rerank full candidate lists without relying on the retriever’s output?\n\nQ2: Given that both modules adopt well-established designs (bi-encoder retrieval with InfoNCE and listwise reranking), how does SWERANK differ conceptually from prior retrieve-and-rerank systems like CodeRankEmbed or RankVicuna?\nWhat makes its design particularly suited to issue localization beyond efficiency gains?", "limitations": "", "rating": 4, "confidence": 4, "soundness": 3, "presentation": 3, "contribution": 2, "strengths": "- The paper is well-structured.\n\n- Practical significance and efficiency. The paper targets the underexplored yet practically important problem of software issue localization. SWERANK offers a simple, efficient alternative to costly multi-step LLM agents. Its cost-effectiveness (up to 40–60× cheaper than Claude-based agents) enhances its industrial applicability.", "weaknesses": "- **Limited methodological novelty**. The overall framework (retrieve-then-rerank) and component designs largely reuse existing paradigms. SWERANKEMBED is a standard bi-encoder trained with InfoNCE loss, similar to prior works such as CodeRankEmbed (2022–2024). SWERANKLLM simplifies listwise reranking to predicting the positive sample ID, which resembles earlier weakly supervised rankers like RankVicuna.\nGiven the rapid development of retrieval and reranking methods by 2025, the paper’s contribution is mainly empirical rather than conceptual. The authors should better justify why this design suits issue localization uniquely, beyond cost reduction.\n\n- **Lack of independent component analysis**.\nThe two modules are evaluated only in combination. For SWERANKEMBED, there is no analysis of standalone retrieval quality (e.g., recall@N). If recall is low (e.g., <60% at Top-20), the reranker’s potential impact becomes limited. For SWERANKLLM, the authors do not report results when reranking the full candidate set independently. Demonstrating that each module performs reasonably well on its own would strengthen the technical soundness of the retrieve-then-rerank pipeline.\n\n- **Insufficient analysis on issue complexity** The differences between Acc@5, Acc@10, and Acc@15 are small. It remains unclear whether issue complexity (e.g., single-function vs. cross-module dependencies) influences localization difficulty.\nGrouping issues by dependency complexity or code change scope could reveal where the reranker struggles, providing deeper insight into model limitations.", "quality": null, "clarity": null, "significance": null, "originality": null, "strengths_and_weaknesses": "", "was_revised": false, "final_justification": "", "rebuttal": "", "claims_and_evidence": "", "methods_and_evaluation_criteria": "", "theoretical_claims": "", "experimental_designs_or_analyses": "", "relation_to_broader_scientific_literature": "", "essential_references_not_discussed": "", "other_strengths_and_weaknesses": "", "other_comments_or_suggestions": "", "questions_for_authors": "", "summary_of_paper": "", "summary_of_recommendation": "", "technical_quality": "", "clarity_of_presentation": "", "potential_impact": "", "robotics_focus": "", "quality_of_limitations": "", "questions_for_rebuttal": "", "reasons_to_accept": "", "reasons_to_reject": "", "questions_to_authors": "", "extra_scores": {}}, {"review_id": "vEQnqCdB5J", "reviewer": "Reviewer_8WzV", "summary": "This paper presents SWERANK, a two-stage retrieve-and-rerank framework for software issue localization. The authors first use a retriever to quickly identify candidate code snippets, then apply an LLM-based reranker to refine the ranking. They also introduce a large-scale training dataset, SWELOC. Experiments on multiple benchmarks show that SWERANK outperforms existing retrieval and agent-based approaches.", "questions": "- In some cases, the bug location may have little semantic overlap with the issue description. Agent-based methods can handle this via multi-step tool-assisted navigation within the repository. How would SWERANK handle such scenarios?\n- If I understand correctly, SWERANKEMBED performs retrieval at the function level. How does it handle very long functions?", "limitations": "", "rating": 4, "confidence": 4, "soundness": 3, "presentation": 3, "contribution": 3, "strengths": "- The paper is well-written and easy to follow.\n- The proposed SWELOC dataset is a valuable contribution to the software engineering community.\n- The authors provide thorough comparisons with multiple baselines across two benchmarks.", "weaknesses": "- Retrieve-and-rerank is a well-established approach, and prior work (e.g., agentless) has already applied it to software issue localization.\n- The effectiveness of retrieve-and-rerank is heavily constrained by the recall of the retrieval stage; compared to agent-based methods, its upper bound may be lower.", "quality": null, "clarity": null, "significance": null, "originality": null, "strengths_and_weaknesses": "", "was_revised": false, "final_justification": "", "rebuttal": "", "claims_and_evidence": "", "methods_and_evaluation_criteria": "", "theoretical_claims": "", "experimental_designs_or_analyses": "", "relation_to_broader_scientific_literature": "", "essential_references_not_discussed": "", "other_strengths_and_weaknesses": "", "other_comments_or_suggestions": "", "questions_for_authors": "", "summary_of_paper": "", "summary_of_recommendation": "", "technical_quality": "", "clarity_of_presentation": "", "potential_impact": "", "robotics_focus": "", "quality_of_limitations": "", "questions_for_rebuttal": "", "reasons_to_accept": "", "reasons_to_reject": "", "questions_to_authors": "", "extra_scores": {}}, {"review_id": "zt7iD7EGSm", "reviewer": "Reviewer_NXP9", "summary": "The author proposed SWERank of an efficient method for SW issue localization. It fine-tuned two models SWERank-Embed and SWERank-LLM to retrieve and rank the issue localization in just one shot. Comparing to agent based approach, it achieves both cost and accuracy goal, as demonstrated by SWE-bench-lite and LocBench SOTA performance. The author also created a new dataset SWELoc by carefully processing public GitHub PR data, valuable resource for future research works. This work shows a purposely built non-agentic retrieval + ranking models can be more effective and practical for automated software engineering than general-purpose reasoning agents.", "questions": "1. SWE is built from Python repositories (>80%). will it work as effectively for strongly typed language such as C++, Java etc.? Will it work as single model finetuning with all major programming languages?\n2. do you think a hybrid approach embedding + LLM finetuning as starter to guide the multi-agent - will that combination achieve better accuracy + reasoning + up-to-date knowledge?", "limitations": "", "rating": 8, "confidence": 5, "soundness": 3, "presentation": 4, "contribution": 4, "strengths": "1. The author proposed the  retrieval + ranking models fine-tuning with open-source qwen model instead of agent using close source model, demonstrating both SOTA performance and cost efficiency. The accuracy improvement (Acc@1,3,5,10) over existing methods are significant.\n2, The idea is intuitive and reasonable, the theoretical analysis is good. The novelty on top of existing work is explained well. The experiments are relatively thorough, including baselines setup, ablation study, different methods and metrics comparison.\n3. The SWELoc dataset (query, positive, negatives) is a great contribution to the community.\n4. Overall writing is decently good.", "weaknesses": "1. even though agent based approach might be costly or inefficient (i.e. not single step), it can be dynamic and up-to-date knowledge with reasoning on the results. while the embedding + LLM finetuning approach becomes static and without much reasoning support with the author's current implementation. Better tradeoff must be taken in real situation.\n2. the embedding model is fine-tuned from qwen2-7b, which seems to be extremely huge for a simple embedding. This significant expense of preprocessing the index should be accounted in the cost comparison instead of retrieval and re-rank only.", "quality": null, "clarity": null, "significance": null, "originality": null, "strengths_and_weaknesses": "", "was_revised": false, "final_justification": "", "rebuttal": "", "claims_and_evidence": "", "methods_and_evaluation_criteria": "", "theoretical_claims": "", "experimental_designs_or_analyses": "", "relation_to_broader_scientific_literature": "", "essential_references_not_discussed": "", "other_strengths_and_weaknesses": "", "other_comments_or_suggestions": "", "questions_for_authors": "", "summary_of_paper": "", "summary_of_recommendation": "", "technical_quality": "", "clarity_of_presentation": "", "potential_impact": "", "robotics_focus": "", "quality_of_limitations": "", "questions_for_rebuttal": "", "reasons_to_accept": "", "reasons_to_reject": "", "questions_to_authors": "", "extra_scores": {}}, {"review_id": "K7gmamghbF", "reviewer": "Reviewer_ok1L", "summary": "The paper proposes SWERANK, a retrieve-and-rerank framework for software issue localization. It combines  (1) SWERANKEMBED, a\nbi-encoder embedding model serving as the code retriever; and (2) SWERANKLLM, an instruction-tuned\nLLM serving as a code reranker. To support training, the authors curate SWELOC, a large dataset pairing real GitHub issue descriptions with the functions/files modified in the corresponding fixes. On SWE-Bench-Lite and LocBench, SWERANK achieves new SOTA across file/module/function granularity while being far cheaper than multi-step agent systems using closed LLMs; ablations analyze data quality filters (consistency threshold K), dataset size, and localization method.", "questions": "See weakness.", "limitations": "", "rating": 6, "confidence": 3, "soundness": 3, "presentation": 3, "contribution": 3, "strengths": "The work is useful and practical: it reframes issue localization as a lightweight retrieve→rerank pipeline that is easy to deploy and far cheaper than agentic alternatives, while remaining compatible with standard IR/LLM components. It delivers good performance, achieving strong (often SOTA) results across file/module/function granularities on multiple benchmarks. The paper also provides insightful ablations—covering data consistency filtering, dataset scale, and hard-negative mining", "weaknesses": "1. Missing capacity/design ablations. The paper does not report sensitivity to model capacity or design choices for the retriever/reranker—e.g., embedding dimension, encoder depth/width. A controlled ablation study would strengthen causal claims.\n2. Numerical latency study. Could you report latency for SWERank vs. agent baselines. The paper currently mentions multi-round agent latency qualitatively (Line 47, Line 125) but lacks a quantitative latency analysis for your method.\n3. First-token objective may underutilize reasoning. The reranker trains only on the first generated token to select the positive, which could limit the model’s ability to use structured reasoning before deciding. A format-constrained “think-then-answer” protocol might improve generalization; loss could be defined over the formatted answer (or via RL with a verifier/reward), rather than solely first-token CE.", "quality": null, "clarity": null, "significance": null, "originality": null, "strengths_and_weaknesses": "", "was_revised": false, "final_justification": "", "rebuttal": "", "claims_and_evidence": "", "methods_and_evaluation_criteria": "", "theoretical_claims": "", "experimental_designs_or_analyses": "", "relation_to_broader_scientific_literature": "", "essential_references_not_discussed": "", "other_strengths_and_weaknesses": "", "other_comments_or_suggestions": "", "questions_for_authors": "", "summary_of_paper": "", "summary_of_recommendation": "", "technical_quality": "", "clarity_of_presentation": "", "potential_impact": "", "robotics_focus": "", "quality_of_limitations": "", "questions_for_rebuttal": "", "reasons_to_accept": "", "reasons_to_reject": "", "questions_to_authors": "", "extra_scores": {}}]

Author rebuttal:

Decision: Accept (Poster)