Technical Summary: Learning Adaptive Parallel Execution for Efficient Code Localization

Problem Statement

Code localization—the identification of specific code entities (files, functions, snippets) required to resolve a software issue—is a critical bottleneck in automated software development pipelines. Recent studies indicate that state-of-the-art agents dedicate over 50% of their computational resources to this task. Current approaches typically rely on sequential tool execution, where agents iteratively refine queries and inspect results turn-by-turn.

This sequential paradigm faces a fundamental trade-off under tight computational budgets (limited interaction turns):

1. Information Starvation: Agents exhaust their interaction quota before gathering sufficient contextual evidence, leading to sharp accuracy degradation.
2. Inefficient Parallelism: While parallel tool execution (invoking multiple tools in a single turn) offers a solution to increase information density, naive implementations often enforce a fixed breadth of parallelism. This results in high redundancy; the paper notes that 34.9% of enforced parallel tool calls in existing systems are redundant, providing no incremental information gain while wasting resources and introducing noise.

The core challenge is to achieve comprehensive yet non-redundant parallelization: maximizing information coverage to avoid starvation while eliminating the exploration of previously examined or irrelevant code.

Methodology: FuseSearch

The authors propose FuseSearch, a minimalist code localization agent that reformulates parallel code localization as a joint quality–efficiency optimization task.

1. Minimalist Tool Set

FuseSearch operates without auxiliary infrastructure (e.g., code graphs, ASTs, or language-specific parsers). It relies on three language-agnostic, read-only tools:

• grep: Regex-based pattern search in file contents.
• glob: File path pattern matching.
• read_file: Reading file contents with optional line range specification.

2. Dual-Objective Formulation

The framework optimizes two complementary metrics:

• Localization Quality ($F1$): Measured via precision, recall, and F1 scores at both file and function levels.
• Tool Efficiency ($e$): Defined as the ratio of unique information gain to the total number of invocations.
  • For each tool call $i$, information gain $g_i$ is calculated by comparing the returned entities against the cumulative history of discovered entities ($H$).
  • $g_i = \frac{|E_i \setminus H|}{|E_i|}$ if $|E_i| > 0$, else $0$.
  • Efficiency $e$ is the mean information gain across all $k$ tool calls in a trajectory: $e = \frac{1}{k} \sum g_i$.

3. Joint Optimization Training Pipeline

FuseSearch employs a two-stage training approach to learn adaptive parallel strategies:

• Stage 1: Supervised Fine-Tuning (SFT) with Dual-Metric Filtering

  • A capable teacher model (Kimi-K2-Instruct) synthesizes training trajectories.
  • To ensure high-quality initialization, trajectories are filtered to retain only those satisfying both $F1 \geq \rho_F$ and $e \geq \rho_e$.
  • This produces a dataset of $\sim$6K high-quality trajectories used to fine-tune base models (Qwen3-4B and Qwen3-30B), establishing a baseline for reliable parallel execution (2–8 tools per turn).

• Stage 2: Reinforcement Learning (RL) with Joint Reward

  • Using Group Relative Policy Optimization (GRPO), the model is further optimized to maximize both $F1$ and $e$.
  • The reward function is designed as:
    $$R(\tau) = \alpha \cdot F1(\tau) + \gamma \cdot (F1(\tau) \cdot e(\tau))$$
  • Design Rationale: The linear term ($\alpha \cdot F1$) ensures a baseline reward for correct localization. The multiplicative term ($\gamma \cdot F1 \cdot e$) acts as a "soft gate," amplifying rewards only when high quality is achieved with high efficiency. This prevents the model from optimizing for efficiency at the cost of accuracy (e.g., reading irrelevant but novel files) or accuracy at the cost of massive redundancy.

4. Adaptive Parallelism

Unlike fixed-breadth approaches, FuseSearch learns to dynamically modulate search breadth based on task context. The training process evolves from an exploration phase (broad parallelism to gather context) to a refinement stage (focused, targeted calls), effectively balancing exploration breadth with precision.

Key Contributions

1. Tool Efficiency Metric: The introduction of "tool efficiency" to quantify information novelty in code search, integrated into an efficiency-aware training framework (SFT + RL) to jointly optimize search effectiveness and computational efficiency.
2. FuseSearch Agent: A minimalist localization agent using only three read-only tools that matches or exceeds the performance of complex systems relying on graph navigation or AST parsing.
3. Efficiency-Driven Quality Improvement: Demonstration that efficiency-aware training naturally improves localization quality by eliminating noisy, redundant signals, enabling high-performance, cost-effective agents.

Experimental Results

Evaluated on SWE-bench Verified (386 examples), FuseSearch-4B (trained) demonstrates superior performance compared to both sequential baselines and other agent-based methods:

• Localization Quality:
  • Achieved 84.7% file-level F1 and 56.4% function-level F1.
  • Outperforms the best sequential baseline (RepoSearcher) by a significant margin (e.g., +46.5% file F1).
  • Matches the performance of proprietary models (Claude Haiku 4.5) while using open-source models (Qwen3-4B).
• Efficiency Gains:
  • 93.6% speedup in wall-clock time compared to sequential execution.
  • 67.7% reduction in interaction turns.
  • 68.9% reduction in token consumption.
• Downstream Impact: When used as a pre-search module for a main agent (Kimi-K2), FuseSearch reduced interaction turns by 23.1% and end-to-end task time by 28.5% without sacrificing solution pass rates.

Significance and Claims

The paper argues that efficiency-aware training is a crucial step toward production-grade automated software development. By reformulating parallel execution not just as a latency-reduction tactic but as a joint optimization problem, FuseSearch demonstrates that:

• Redundant exploration is a primary cause of both high cost and degraded accuracy.
• Learning to distinguish between "novel" and "redundant" information allows compact models (4B parameters) to outperform larger, sequential, or infrastructure-heavy agents.
• Adaptive parallelism, evolving from broad exploration to focused refinement, is the key to overcoming information starvation under tight computational budgets.

The authors conclude that their approach enables the creation of agents that are not only accurate but also computationally practical, addressing the "cost–accuracy trade-off" that currently limits the deployability of automated localization in time-sensitive settings.