Skip to content

Knowledge-Centric Automated Issue Resolution

A Systematic Survey and Taxonomy

This survey organizes issue-resolution research around a knowledge-centric framework: what knowledge is used, where it comes from, how it is extracted, represented, retrieved, and applied across the resolution lifecycle.

Read Paper Tables & Resources

Included studies 133

Knowledge sources 5

Workflow stages 7

Representative systems 10

01

Problem Setting

Automated issue resolution asks a system to understand an issue, inspect a repository snapshot, localize context, edit code, and validate the patch.

02

Knowledge Taxonomy

The survey organizes knowledge into L1 background knowledge, L2 repository knowledge, and L3 procedural knowledge.

03

RQ Navigation

Home highlights representative papers only. Full browsing, filtering, and cross-dimension lookup are delegated to Tables & Resources.

04

Resources

Papers, tables and figures can all be quickly accessed with one click on the homepage.

RQ1: Knowledge Types — Three-Layer Hierarchy

The survey's first research question builds a three-layer taxonomy explaining what kinds of knowledge issue-resolution systems actually depend on. Rather than treating papers as a flat method list, the Home page keeps the conceptual hierarchy, the manuscript's sub-dimensions, and representative references visible here, while the complete searchable catalog remains in Tables & Resources.

L1 Background Knowledge

Project-independent knowledge that frames how an issue should be interpreted before deep repository reasoning begins, including language, domain, and technology-stack level constraints.

Programming Language Knowledge

3 papers

This category captures language-level constraints that a repository-grounded agent cannot ignore, including syntax, type systems, runtime semantics, and idiomatic repair patterns. In the survey corpus, it appears most clearly when issue resolution must generalize across languages or obey language-specific rules such as Rust ownership or ArkTS compilation constraints.

Evaluating and Improving Automated Repository-Level Rust Issue Resolution with LLM-based Agents

BibTeX: `xiang2026evaluating` · Year: `2026`

arXiv:2602.22764

ArkEval: Benchmarking and Evaluating Automated CodeRepair for ArkTS

BibTeX: `xie2026arkeval` · Year: `2026`

arXiv:2602.08866

SweRank+: Multilingual, Multi-Turn Code Ranking for Software Issue Localization

BibTeX: `reddy2025swerank+` · Year: `2025`

arXiv:2512.20482

View all 3 papers in Tables & Resources

Domain-specific Knowledge

1 papers

This category covers application semantics that live outside generic software engineering knowledge, such as scientific concepts, platform-specific business rules, or field-specific constraints. Although rare in the current corpus, it becomes essential once issue resolution moves beyond standard single-repository bug fixing into tasks where correct patches depend on understanding the target domain itself.

BeyondSWE: Can Current Code Agent Survive Beyond Single-Repo Bug Fixing?

BibTeX: `chen2026beyondswe` · Year: `2026`

arXiv:2603.03194

View all 1 papers in Tables & Resources

Technology Stack Knowledge

4 papers

This category refers to libraries, frameworks, APIs, platform conventions, and dependency ecosystems that shape what counts as a compatible repair. It is especially important in migration, compatibility, and platform-constrained tasks, where an agent must reason about external components rather than only the repository's local implementation.

BeyondSWE: Can Current Code Agent Survive Beyond Single-Repo Bug Fixing?

BibTeX: `chen2026beyondswe` · Year: `2026`

arXiv:2603.03194

ArkEval: Benchmarking and Evaluating Automated CodeRepair for ArkTS

BibTeX: `xie2026arkeval` · Year: `2026`

arXiv:2602.08866

R2e-gym: Procedural environments and hybrid verifiers for scaling open-weights swe agents

BibTeX: `jain2025r2e` · Year: `2025`

arXiv:2504.07164

Training software engineering agents and verifiers with swe-gym

BibTeX: `pan2024training` · Year: `2024`

arXiv:2412.21139

View all 4 papers in Tables & Resources

L2 Repository Knowledge

Knowledge grounded in the target repository itself, spanning local code artifacts, higher-level architectural intent, and the historical evolution signals that connect past maintenance to present repair.

Existing Code Knowledge

128 papers

This is the dominant knowledge type in the survey and forms the core of most issue-resolution systems. It includes concrete repository-native artifacts such as files, classes, functions, call sites, dependency relations, and local implementation context that agents rely on for localization, editing, and validation.

The survey manuscript distinguishes the following sub-dimensions. Representative papers are shown below; use Tables & Resources for the full catalog.

Local Implementation Context

Suspicious files, classes, functions, and surrounding code regions directly relevant to the issue.

Interface and Usage Context

Function signatures, class interfaces, call sites, and project-specific usage conventions.

Structural and Dependency Context

Cross-file dependencies, import graphs, class-method structures, and repository-level relations.

View all 128 papers in Tables & Resources

Design Architecture Knowledge

13 papers

This category captures higher-level repository intent: architectural decomposition, component responsibilities, design constraints, and cross-module coordination logic. It becomes important when systems must produce patches that preserve global structure, satisfy implicit project conventions, or align edits with intended repository organization rather than only local code correctness.

BeyondSWE: Can Current Code Agent Survive Beyond Single-Repo Bug Fixing?

BibTeX: `chen2026beyondswe` · Year: `2026`

arXiv:2603.03194

Architecture-Aware Multi-Design Generation for Repository-Level Feature Addition

BibTeX: `liu2026architecture` · Year: `2026`

arXiv:2603.01814

Closing the Loop: Universal Repository Representation with RPG-Encoder

BibTeX: `luo2026closing` · Year: `2026`

arXiv:2602.02084

Agentic Rubrics as Contextual Verifiers for SWE Agents

BibTeX: `raghavendra2026agentic` · Year: `2026`

arXiv:2601.04171

Does Pass Rate Tell the Whole Story? Evaluating Design Constraint Compliance in LLM-based Issue Resolution

BibTeX: `yu2026does` · Year: `2026`

arXiv:2604.05955

View all 13 papers in Tables & Resources

Repository Evolution Knowledge

43 papers

This category covers the repository's historical memory, including issues, pull requests, commits, prior patches, and longer development-process traces. It allows systems to retrieve precedents, infer repair patterns, and ground current decisions in how the project has changed over time.

The survey manuscript distinguishes the following sub-dimensions. Representative papers are shown below; use Tables & Resources for the full catalog.

Historical Issue-Fix Data

Training or retrieval data from historical issue-fix pairs, pull requests, and commits.

Structured Repository-History Representations

Graph-based or structured representations connecting historical artifacts with current code entities.

Development-Process Traces

Real or simulated development activities, tool use, and agent-environment interaction trajectories.

View all 43 papers in Tables & Resources

L3 Procedural Knowledge

Knowledge accumulated, invoked, or reused during the repair process itself, especially around tool use, execution control, memory, and experience distilled from prior trajectories.

Development Tool Knowledge

103 papers

This category describes operational knowledge about tools, interfaces, environments, and execution feedback channels used during issue resolution. It includes how agents search, run tests, interact with shells and sandboxes, interpret validation results, and orchestrate tool-assisted workflows across the repair loop.

The survey manuscript distinguishes the following sub-dimensions. Representative papers are shown below; use Tables & Resources for the full catalog.

Testing and Validation Tool Knowledge

Test generation, execution, and validation tools that provide executable feedback.

Environment-Interaction and Tool-Control Knowledge

Shell commands, search utilities, editors, containers, sandboxes, and agent tool interfaces.

View all 103 papers in Tables & Resources

Experiential Knowledge

68 papers

This category focuses on reusable experience distilled from prior trajectories, failures, reflections, and successful repair behaviors. In the survey, it appears both as explicit memory structures and as training-time data that teaches agents how to plan, retrieve, edit, and validate more effectively over time.

The survey manuscript distinguishes the following sub-dimensions. Representative papers are shown below; use Tables & Resources for the full catalog.

Experience Memories and Knowledge Banks

Explicitly constructed memories or banks of prior successful and failed experiences.

Training Trajectories and Post-Training Data

Distilling agent experiences into model capabilities through fine-tuning, RL, or other training paradigms.

View all 68 papers in Tables & Resources

Knowledge sources & extraction

RQ2 Knowledge Sources and Extraction Methods

RQ2 examines the supply chain of knowledge inside issue-resolution systems: which artifacts provide useful evidence, how that evidence is transformed into model-usable form, and why different tasks lean on different sources. The homepage therefore follows the paper's source-first and method-first organization, so readers can see not only what a system uses, but also how that knowledge is surfaced from repositories, execution, history, documents, and expert design.

Knowledge Sources

These five source families recur throughout the corpus and together explain where repository-grounded, behavior-grounded, and expert-curated knowledge actually enters the pipeline.

Codebase

128 papers

Codebase knowledge refers to the repository's directly inspectable artifacts: source files, classes, functions, call relations, interfaces, dependency structure, and configuration context. In the survey, this source anchors most localization and patch-generation systems because it provides the most immediate evidence about where a defect lives and what edits are compatible with the existing implementation.

  • Repository-native code, structure, APIs, and local dependency context.

Codexgraph: Bridging large language models and code repositories via code graph databases

BibTeX: `liu2024codexgraph` · Year: `2024`

arXiv:2408.03910

Marscode agent: Ai-native automated bug fixing

BibTeX: `liu2024marscode` · Year: `2024`

arXiv:2409.00899

SACL: Understanding and Combating Textual Bias in Code Retrieval with Semantic-Augmented Reranking and Localization

BibTeX: `gupta2025sacl` · Year: `2025`

arXiv:2506.20081

CoSIL: Software Issue Localization via LLM-Driven Code Repository Graph Searching

BibTeX: `jiang2025cosil` · Year: `2025`

arXiv:2503.22424

Explore in Tables

Dynamic Execution Results

105 papers

Dynamic execution results provide behavior-grounded signals that static repository inspection alone cannot supply, including test outcomes, runtime logs, command outputs, traces, and debugging observations. This source becomes especially valuable when systems need to verify hypotheses, expose hidden failures, or iteratively refine candidate patches against actual program behavior.

  • Execution traces, tests, logs, and debugger-style observations.

Dars: Dynamic action re-sampling to enhance coding agent performance by adaptive tree traversal

BibTeX: `aggarwal2025dars` · Year: `2025`

arXiv:2503.14269

Otter: Generating tests from issues to validate swe patches

BibTeX: `ahmed2025otter` · Year: `2025`

arXiv:2502.05368

Swe-search: Enhancing software agents with monte carlo tree search and iterative refinement

BibTeX: `antoniades2024swe` · Year: `2024`

arXiv:2410.20285

Masai: Modular architecture for software-engineering ai agents

BibTeX: `arora2024masai` · Year: `2024`

arXiv:2406.11638

Explore in Tables

Repository History

43 papers

Repository history captures the project's accumulated repair memory through issues, commits, pull requests, historical patches, and linked development artifacts. Surveyed systems use it to mine precedents, retrieve analogous fixes, build training signals, and reconstruct how past maintenance activity can inform current issue resolution.

  • Issues, PRs, commits, historical patches, and long-range evolution signals.

KGCompass: Knowledge Graph Enhanced Repository-Level Software Repair

BibTeX: `yang2025kgcompass` · Year: `2025`

Scholar

SweRank: Software Issue Localization with Code Ranking

BibTeX: `reddy2025swerank` · Year: `2025`

arXiv:2505.07849

SweRank+: Multilingual, Multi-Turn Code Ranking for Software Issue Localization

BibTeX: `reddy2025swerank+` · Year: `2025`

arXiv:2512.20482

BLAZE: Cross-language and cross-project bug localization via dynamic chunking and hard example learning

BibTeX: `chakraborty2025blaze` · Year: `2025`

Scholar

Explore in Tables

Document

11 papers

Document knowledge includes README files, specifications, migration guides, issue narratives, comments, API references, and other written artifacts that explain project expectations beyond raw code. It is particularly important when tasks require interpreting intended behavior, framework conventions, dependency changes, or repository-specific validation standards.

  • README files, specifications, migration notes, and platform guidance.

BeyondSWE: Can Current Code Agent Survive Beyond Single-Repo Bug Fixing?

BibTeX: `chen2026beyondswe` · Year: `2026`

arXiv:2603.03194

ArkEval: Benchmarking and Evaluating Automated CodeRepair for ArkTS

BibTeX: `xie2026arkeval` · Year: `2026`

arXiv:2602.08866

Agentic Rubrics as Contextual Verifiers for SWE Agents

BibTeX: `raghavendra2026agentic` · Year: `2026`

arXiv:2601.04171

Training software engineering agents and verifiers with swe-gym

BibTeX: `pan2024training` · Year: `2024`

arXiv:2412.21139

Explore in Tables

Expert

43 papers

Expert knowledge refers to human-designed workflows, heuristic repair strategies, task decompositions, reward shaping, and reviewer-defined constraints embedded into an issue-resolution system. Rather than being mined directly from repository artifacts, this source injects curated operational know-how that helps agents search, evaluate, and recover more reliably.

  • Human-designed workflows, heuristics, reward signals, and repair strategies.

Swe-agent: Agent-computer interfaces enable automated software engineering

BibTeX: `yang2024swe` · Year: `2024`

Scholar

Openhands: An open platform for ai software developers as generalist agents

BibTeX: `wang2024openhands` · Year: `2024`

arXiv:2407.16741

Agent-RLVR: Training Software Engineering Agents via Guidance and Environment Rewards

BibTeX: `da2025agent` · Year: `2025`

arXiv:2506.11425

SIADAFIX: issue description response for adaptive program repair

BibTeX: `cao2025siadafix` · Year: `2025`

arXiv:2510.16059

Explore in Tables

Extraction Methods

The paper groups extraction into three styles, ranging from deterministic parsing to semantic model inference and human curation, each with different tradeoffs in control, cost, and flexibility.

Rule-based Extraction

127 papers

Rule-based extraction uses deterministic procedures such as AST parsing, static analysis, graph traversal, log parsing, and predefined heuristics to turn raw artifacts into usable knowledge. Within the survey, it is the backbone of many repository-grounded systems because it offers traceability, controllability, and low ambiguity when structural signals are available.

Autocoderover: Autonomous program improvement

BibTeX: `zhang2024autocoderover` · Year: `2024`

Scholar

Codexgraph: Bridging large language models and code repositories via code graph databases

BibTeX: `liu2024codexgraph` · Year: `2024`

arXiv:2408.03910

Otter: Generating tests from issues to validate swe patches

BibTeX: `ahmed2025otter` · Year: `2025`

arXiv:2502.05368

Swe-agent: Agent-computer interfaces enable automated software engineering

BibTeX: `yang2024swe` · Year: `2024`

Scholar

Explore in Tables

Model-based Extraction

91 papers

Model-based extraction relies on learned semantic processing, typically through LLMs, embedding models, or neural summarization, to infer which information matters and how it should be transformed. It becomes important when relevant context is diffuse, cross-file, weakly structured, or too semantically rich for hand-written rules alone.

KGCompass: Knowledge Graph Enhanced Repository-Level Software Repair

BibTeX: `yang2025kgcompass` · Year: `2025`

Scholar

EXPEREPAIR: Dual-Memory Enhanced LLM-based Repository-Level Program Repair

BibTeX: `mu2025experepair` · Year: `2025`

arXiv:2506.10484

Devstral: Fine-tuning Language Models for Coding Agent Applications

BibTeX: `rastogi2025devstral` · Year: `2025`

arXiv:2509.25193

Codexembed: A generalist embedding model family for multiligual and multi-task code retrieval

BibTeX: `liu2024codexembed` · Year: `2024`

arXiv:2411.12644

Explore in Tables

Manual Extraction

39 papers

Manual extraction covers expert annotation, human curation, and deliberately authored knowledge structures that are inserted into the pipeline when automatic extraction is insufficient or too noisy. In the survey, it often appears around evaluation rubrics, workflow templates, high-value training signals, and domain- or platform-specific constraints.

Swe-agent: Agent-computer interfaces enable automated software engineering

BibTeX: `yang2024swe` · Year: `2024`

Scholar

Openhands: An open platform for ai software developers as generalist agents

BibTeX: `wang2024openhands` · Year: `2024`

arXiv:2407.16741

BeyondSWE: Can Current Code Agent Survive Beyond Single-Repo Bug Fixing?

BibTeX: `chen2026beyondswe` · Year: `2026`

arXiv:2603.03194

ArkEval: Benchmarking and Evaluating Automated CodeRepair for ArkTS

BibTeX: `xie2026arkeval` · Year: `2026`

arXiv:2602.08866

Explore in Tables

Representation formats

RQ3 Knowledge Representation

RQ3 asks how captured knowledge is represented once it enters an issue-resolution system. The paper identifies three major representation families and then further decomposes them into subforms that reflect whether a method privileges flexibility, schema, or explicit relational structure.

Representation Families

Each representation family below preserves the manuscript's internal subform breakdown so readers can connect concrete systems to the kinds of structures they rely on.

Unstructured Text

125 papers

Unstructured text is the most flexible representation family in the survey: it can hold issue descriptions, code snippets, comments, execution logs, plans, and free-form repair rationale with minimal preprocessing. Its strength is breadth and low overhead, but that flexibility comes with weaker control over structure, consistency, and downstream retrieval precision.

Raw Contextual Text

Issue descriptions, inline code snippets, surrounding context, and repository notes.

Textual Feedback Trace

Terminal output, failing tests, runtime logs, and textual debugging feedback.

Narrative Experience

Plans, reflections, and reusable textual repair experience.

Explore in Tables

Structured Text

72 papers

Structured text introduces explicit schema into otherwise textual knowledge, for example through repository records, validation reports, trajectory templates, or reusable procedural memory. Compared with raw text, it gives systems clearer slots for storing localized facts, execution outcomes, and stepwise reasoning while remaining easier to manipulate than full graph representations.

Structured Repository Records

Position-aware code records, code locations, and structured change descriptions.

Structured Feedback Records

Validation reports, rubric tables, and organized execution outcomes.

Structured Procedural Memory

Reusable procedures, reasoning schemas, and distilled workflow memory.

Explore in Tables

Graph

22 papers

Graph representations encode repository entities and their relations explicitly, making them well suited to structure-aware navigation, dependency reasoning, and repository-history linking. In the survey, graph-based systems often target tasks where cross-file context, issue-code alignment, or architectural coordination matter more than isolated local snippets.

Code-Structure Graph

Files, classes, functions, imports, calls, and dependency graphs over repository code.

Repository-Aware Semantic Graph

Issue, PR, commit, file, and code-entity relations tied to repository history.

Causal and Task-Oriented Graph

Reasoning, localization, or task decomposition graphs for agent execution.

Architecture-Aware Planning Graph

Repository architecture, high-level responsibilities, and plan alignment structures.

Explore in Tables

Usage methods

RQ4 Knowledge Usage Methods

RQ4 shifts the focus from storing knowledge to using it: whether systems inject it passively, search for it actively, update beliefs through feedback, or internalize it during training. The categories below are written as a narrative reading layer over the reviewed database so the reader can quickly compare operational strategies rather than only isolated paper tags.

Usage Method Families

These cards follow the paper's conceptual usage-method taxonomy and connect each branch to concrete systems, revealing how retrieval, execution, and training-time grounding are combined in practice.

Passive Retrieval

~112 mapped papers

Passive retrieval covers settings where useful knowledge is selected before the agent takes its next major reasoning or editing step, then injected as prompt context, retrieved snippets, ranked candidates, or structured support artifacts. It is the most common usage mode in the survey because it offers a relatively controlled way to ground model behavior without requiring the agent to search continuously at run time.

Prompt-Context Injection

Pre-selected repository or issue context inserted into the model input.

Similarity-Based Context Retrieval

Retriever or ranker selects code fragments or historical analogs before generation.

Structured Knowledge Retrieval

Structured memory, graph, or rubric artifacts are fetched and injected.

Explore in Tables

Active Retrieval

~106 mapped papers

Active retrieval describes systems in which the agent decides what to inspect next and actively navigates repositories, tools, graphs, or external resources while solving the issue. Compared with passive retrieval, this mode gives the system more adaptability and search power, but it also raises the cost of coordination, tool control, and error recovery.

Autonomous Codebase Exploration

Interactive exploration over files, classes, tests, and suspicious regions.

Structure-Aware Active Navigation

Navigation guided by repository graphs, causal relations, or dependency structure.

Memory- and History-Guided Retrieval

Historical traces and stored experience determine what the agent inspects next.

External Knowledge-Seeking Retrieval

The agent supplements local repository knowledge with documents, platform rules, or broader context.

Explore in Tables

Feedback-Based Usage

~105 mapped papers

Feedback-based usage treats tests, execution traces, debuggers, verifiers, and reward signals as live knowledge channels that reshape what the system believes during repair. In the survey, this mode is central to iterative issue resolution because it closes the loop between proposed edits and observable repository behavior.

Test-Execution Feedback

Generated or existing tests provide pass/fail evidence and regression signals.

Dynamic Execution and Debugging Feedback

Execution traces, runtime observations, and iterative diagnosis guide next actions.

Guidance and Reward Feedback

Reward shaping, verifier signals, or teacher guidance are used as learning-time or run-time feedback.

Explore in Tables

Parametric Injection

~52 mapped papers

Parametric injection internalizes knowledge into model parameters through supervised fine-tuning, synthetic trajectory construction, preference learning, or reinforcement learning. Rather than retrieving all knowledge explicitly at run time, these systems try to bake recurring repair behavior, tool-use policy, and repository reasoning patterns into the model itself.

  • Training-time internalization is especially visible in SWE-Gym, Devstral, SWE-Master, SWE-Lego, and related post-training pipelines.

Training software engineering agents and verifiers with swe-gym

BibTeX: `pan2024training` · Year: `2024`

arXiv:2412.21139

Devstral: Fine-tuning Language Models for Coding Agent Applications

BibTeX: `rastogi2025devstral` · Year: `2025`

arXiv:2509.25193

SWE-Master: Unleashing the Potential of Software Engineering Agents via Post-Training

BibTeX: `song2026swe` · Year: `2026`

arXiv:2602.03411

Swe-lego: Pushing the limits of supervised fine-tuning for software issue resolving

BibTeX: `tao2026swe` · Year: `2026`

arXiv:2601.01426

Explore in Tables

Workflow stages

RQ5 Knowledge Usage Stages

RQ5 organizes the literature along the issue-resolution workflow itself, making it easier to see which knowledge types dominate before, during, and after repair decisions. The homepage therefore presents the stages as a pipeline view, with each stage summarizing its main knowledge demands and representative systems.

Offline Preparation

These stages happen before a live issue is solved: they construct environments, training data, and reusable policies that later shape how an agent behaves online.

Environment Building

10 papers

Environment building covers the pre-resolution work required to make a task executable, reproducible, and repository-compatible. In the survey, this stage often combines tool knowledge with codebase and dependency understanding so that agents can reconstruct runnable contexts, verify setup assumptions, and prepare reliable execution sandboxes.

  • Environment operation, repository-grounded setup, historical reproduction, and runtime compatibility.
  • Dominant knowledge: Development Tool + Existing Code + Repository Evolution.

SWE-Factory: Your Automated Factory for Issue Resolution Training Data and Evaluation Benchmarks

BibTeX: `guo2025swe` · Year: `2025`

arXiv:2506.10954

R2e-gym: Procedural environments and hybrid verifiers for scaling open-weights swe agents

BibTeX: `jain2025r2e` · Year: `2025`

arXiv:2504.07164

SWE-MiniSandbox: Container-Free Reinforcement Learning for Building Software Engineering Agents

BibTeX: `yuan2026swe` · Year: `2026`

arXiv:2602.11210

Cwm: An open-weights llm for research on code generation with world models

BibTeX: `copet2025cwm` · Year: `2025`

arXiv:2510.02387

Explore in Tables

Model Training

52 papers

Model training is the stage where knowledge is turned into reusable capability through supervised fine-tuning, reinforcement learning, representation learning, or verifier training. Surveyed systems use this stage to internalize repository understanding, historical supervision, tool-use behavior, and experience-derived repair strategies before deployment.

  • Process behavior learning, repository understanding, historical supervision, and tool-use policy learning.
  • Dominant knowledge: Experiential + Existing Code + Repository Evolution.

Cwm: An open-weights llm for research on code generation with world models

BibTeX: `copet2025cwm` · Year: `2025`

arXiv:2510.02387

Codexembed: A generalist embedding model family for multiligual and multi-task code retrieval

BibTeX: `liu2024codexembed` · Year: `2024`

arXiv:2411.12644

Sorft: Issue resolving with subtask-oriented reinforced fine-tuning

BibTeX: `ma2025sorft` · Year: `2025`

arXiv:2502.20127

SweRank+: Multilingual, Multi-Turn Code Ranking for Software Issue Localization

BibTeX: `reddy2025swerank+` · Year: `2025`

arXiv:2512.20482

Explore in Tables

Online Issue Resolution

These stages unfold during actual issue solving, covering planning, reproduction, localization, editing, and validation as an end-to-end operational loop.

Task Planning

38 papers

Task planning organizes how an agent interprets an issue and chooses what to do next. This stage is where experience, repository context, and sometimes architecture-level knowledge combine to produce search strategies, decomposition plans, retrieval priorities, and execution orderings for the rest of the repair loop.

  • Experience-guided, repository-aware, architecture-aware, and history-guided planning.
  • Dominant knowledge: Experiential + Existing Code + Design Architecture.

Reasoningbank: Scaling agent self-evolving with reasoning memory

BibTeX: `ouyang2025reasoningbank` · Year: `2025`

arXiv:2509.25140

Lingxi: Repository-Level Issue Resolution Framework Enhanced by Procedural Knowledge Guided Scaling

BibTeX: `yang2025lingxi` · Year: `2025`

arXiv:2510.11838

Closing the Loop: Universal Repository Representation with RPG-Encoder

BibTeX: `luo2026closing` · Year: `2026`

arXiv:2602.02084

SIADAFIX: issue description response for adaptive program repair

BibTeX: `cao2025siadafix` · Year: `2025`

arXiv:2510.16059

Explore in Tables

Reproduction Test Generation

44 papers

Reproduction test generation focuses on constructing executable evidence for the reported issue, often by translating issue descriptions into failing tests, scripts, or behavior checks. It sits at the boundary between understanding the issue and validating a solution, so it depends on both tool interaction and repository-compatible behavioral context.

  • Test workflow construction, repository-compatible context, fail-to-pass recovery, and runtime-compatible reproduction.
  • Dominant knowledge: Development Tool + Existing Code.

Otter: Generating tests from issues to validate swe patches

BibTeX: `ahmed2025otter` · Year: `2025`

arXiv:2502.05368

Issue2test: Generating reproducing test cases from issue reports

BibTeX: `nashid2025issue2test` · Year: `2025`

arXiv:2503.16320

Aegis: An agent-based framework for bug reproduction from issue descriptions

BibTeX: `wang2025aegis` · Year: `2025`

Scholar

Utboost: Rigorous evaluation of coding agents on swe-bench

BibTeX: `yu2025utboost` · Year: `2025`

arXiv:2506.09289

Explore in Tables

Localization

117 papers

Localization narrows the search space from a full repository to the files, functions, modules, or entities most likely to require modification. It is one of the most repository-intensive stages in the survey, frequently combining structural code context, search tools, historical hints, and execution feedback to identify suspicious regions.

  • Code-entity search, interactive exploration, history-aware localization, architecture-aware reasoning, and constraint awareness.
  • Dominant knowledge: Existing Code + Development Tool.

Locagent: Graph-guided llm agents for code localization

BibTeX: `chen2025locagent` · Year: `2025`

arXiv:2503.09089

CoSIL: Software Issue Localization via LLM-Driven Code Repository Graph Searching

BibTeX: `jiang2025cosil` · Year: `2025`

arXiv:2503.22424

GraphLocator: Graph-guided Causal Reasoning for Issue Localization

BibTeX: `liu2025graphlocator` · Year: `2025`

arXiv:2512.22469

Improving Code Localization with Repository Memory

BibTeX: `wang2025improving` · Year: `2025`

arXiv:2510.01003

Explore in Tables

Patch Generation

103 papers

Patch generation is the stage where retrieved knowledge is converted into concrete edits. Systems surveyed here balance local code correctness, repository consistency, tool feedback, historical analogies, and sometimes architecture-level constraints to produce candidate changes that are both plausible and project-compatible.

  • Repository-grounded editing, interactive refinement, experience-guided repair, and architecture-constrained patching.
  • Dominant knowledge: Existing Code + Development Tool + Experiential.

PatchPilot: A Cost-Efficient Software Engineering Agent with Early Attempts on Formal Verification

BibTeX: `li2025patchpilot` · Year: `2025`

arXiv:2502.02747

Codexgraph: Bridging large language models and code repositories via code graph databases

BibTeX: `liu2024codexgraph` · Year: `2024`

arXiv:2408.03910

EXPEREPAIR: Dual-Memory Enhanced LLM-based Repository-Level Program Repair

BibTeX: `mu2025experepair` · Year: `2025`

arXiv:2506.10484

KGCompass: Knowledge Graph Enhanced Repository-Level Software Repair

BibTeX: `yang2025kgcompass` · Year: `2025`

Scholar

Explore in Tables

Patch Validation

89 papers

Patch validation checks whether a candidate repair is actually acceptable, using tests, verifiers, search, execution feedback, and explicit constraints. In the survey, this stage is especially tool-centric because it must distinguish superficially plausible edits from repairs that truly satisfy repository behavior and project expectations.

  • Execution-based, search-based, experience-guided, architecture-constrained, and history-aware validation.
  • Dominant knowledge: Development Tool by a wide margin.

Dars: Dynamic action re-sampling to enhance coding agent performance by adaptive tree traversal

BibTeX: `aggarwal2025dars` · Year: `2025`

arXiv:2503.14269

Swe-search: Enhancing software agents with monte carlo tree search and iterative refinement

BibTeX: `antoniades2024swe` · Year: `2024`

arXiv:2410.20285

Otter: Generating tests from issues to validate swe patches

BibTeX: `ahmed2025otter` · Year: `2025`

arXiv:2502.05368

Large language monkeys: Scaling inference compute with repeated sampling

BibTeX: `brown2024large` · Year: `2024`

arXiv:2407.21787

Explore in Tables

Trend reading

Recent dominant knowledge

Existing Code Knowledge, Development Tool Knowledge, and Experiential Knowledge show the strongest recent signals.

Open table

Dominant combinations

Existing Code Knowledge + Development Tool Knowledge and Existing Code Knowledge + Experiential Knowledge are the strongest co-occurrence patterns.

Open table

Temporal shift

The field is moving toward repository-grounded and feedback-driven systems.

Open table

Representative Systems

The survey (§9.2) highlights 10 systems that exemplify distinct knowledge portfolios. Each system remains a spotlight entry here, while related papers can be opened directly in Tables & Resources.

Future work

Future Opportunity Map

Tables & Resources

Inspect the filterable catalog, cross-dimension tables, taxonomy explorer, and curated resources.

Go to Tables