💻 computer science

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

ExpeRepair is a novel LLM-based framework that leverages a dual-memory system—comprising episodic memory for concrete repair demonstrations and semantic memory for abstract insights—to dynamically compose context-aware prompts, achieving state-of-the-art open-source performance on SWE-Bench Lite and Verified benchmarks by effectively reusing historical repair knowledge.

Original authors: Fangwen Mu, Junjie Wang, Lin Shi, Song Wang, Shoubin Li, Qing Wang

Published 2026-05-12

📖 4 min read☕ Coffee break read

CC BY 4.0

Original authors: Fangwen Mu, Junjie Wang, Lin Shi, Song Wang, Shoubin Li, Qing Wang

Original paper licensed under CC BY 4.0 (http://creativecommons.org/licenses/by/4.0/). ✨ This is an AI-generated explanation of the paper below. It is not written or endorsed by the authors. For technical accuracy, refer to the original paper. Read full disclaimer

Imagine you are a master mechanic trying to fix a complex, vintage car engine. In the past, every time a new problem popped up, you had to start from scratch: read the manual, guess what's wrong, try a fix, and hope it works. If you failed, you'd just try again, forgetting what you learned from the last mistake.

ExpeRepair is like giving that mechanic a super-powered, two-part memory system inspired by how human brains work. Instead of starting from zero every time, this system helps the AI "remember" past repairs and learn from them, making it much better at fixing software bugs.

Here is how it works, broken down into simple concepts:

The Two Types of Memory

The paper explains that human memory isn't just one big bucket; it has two distinct parts. ExpeRepair copies this design:

Episodic Memory (The "Photo Album"):
- What it is: This is a collection of specific, concrete examples. Think of it as a scrapbook of past repairs. It contains the exact "before and after" photos: the specific error message, the exact code that was broken, and the specific patch that fixed it.
- How it helps: When a new bug appears, the system flips through this scrapbook to find a similar past case. "Hey, we fixed a similar broken light switch last week; let's try that same trick." This provides a concrete recipe to follow.
Semantic Memory (The "Rulebook"):
- What it is: This is the abstract wisdom gained from all those past repairs. It's not about specific photos, but about general principles. Think of it as a list of "Best Practices" or "Rules of Thumb" written in plain English.
- How it helps: It teaches the AI general lessons, like "When fixing security issues, always check for edge cases" or "If a function handles multiple inputs, make sure you fix them all, not just the one mentioned." This helps the AI adapt to new situations it hasn't seen before.

How It Fixes Bugs (The Workflow)

The system uses two "agents" (AI workers) to do the repair: one to write a test script (to prove the bug exists) and one to write the actual fix.

The Old Way: The AI gets a bug report, tries to guess a fix based on its general training, and hopes for the best. If it fails, it tries again with the same static instructions.
The ExpeRepair Way:
1. Look Back: Before trying to fix the new bug, the system checks its Photo Album (Episodic Memory) for similar past failures and successes.
2. Read the Rules: It also checks its Rulebook (Semantic Memory) for high-level advice relevant to this type of problem.
3. Dynamic Instructions: Instead of using a rigid, pre-written instruction manual, the system creates a custom, "dynamic" prompt for the AI worker. It says, "Here is the new bug. Here is a similar bug we fixed last month (from the Photo Album). And remember this rule about handling edge cases (from the Rulebook)."
4. Learn and Update: Once the fix is done (or even if it fails), the system saves the experience. It adds the specific details to the Photo Album and summarizes the lesson learned into the Rulebook for next time.

The Results

The researchers tested this system on two famous sets of real-world software bugs (called SWE-Bench Lite and SWE-Bench Verified).

The Score: Using a powerful AI model (Claude 4 Sonnet), ExpeRepair successfully fixed 74.6% of the bugs on the harder test set and 60.3% on the lighter set.
The Comparison: This was the best performance among all the open-source methods they tested. It beat other top tools like SWE-agent, Aider, and AutoCodeRover.
The Cost: It achieved these high scores without needing expensive, time-consuming retraining of the AI model. It just learned by "reading" its own past work.

Why It Matters

The paper argues that current AI repair tools are like students who take a test, get a grade, and then immediately forget everything before the next test. ExpeRepair is like a student who keeps a study guide, reviews their mistakes, and gets smarter with every single problem they solve.

By combining specific examples (Episodic) with general wisdom (Semantic), the system creates a feedback loop where the AI gets better at fixing software the more it works, mimicking how human developers actually learn and improve over time.

Technical Summary: ExpeRepair

Problem Statement

Automated Program Repair (APR) has traditionally focused on function-level bugs, but real-world software maintenance requires repository-level repair involving large codebases, complex inter-file dependencies, and intricate issue descriptions. While recent Large Language Model (LLM)-based approaches have shifted toward repository-level repair, they suffer from two critical limitations:

Neglect of Historical Experience: Current methods treat each issue in isolation, failing to leverage valuable patterns and insights from previously resolved issues within the same repository.
Static Prompting: Existing approaches rely on rigid, manually crafted prompts that cannot adapt to the diverse coding conventions, architectural patterns, or evolving contexts of different software projects.

Methodology: ExpeRepair

ExpeRepair is a novel LLM-based framework designed to overcome these limitations by mimicking the dual-memory systems of human cognition (episodic and semantic memory). It operates without requiring computationally expensive fine-tuning, instead relying on a dual-channel knowledge accumulation mechanism.

Core Architecture

The system consists of two primary modules:

Program Repair Module: Orchestrates a Test Agent and a Patch Agent that collaboratively perform test generation, patch generation, and patch validation. These agents utilize the ReAct algorithm to iteratively process tasks.
Memory Module: Organizes repair trajectories into two complementary memories:
- Episodic Memory: Stores concrete repair demonstrations, including successful (input, output) pairs and failed attempts with feedback.
- Semantic Memory: Encodes abstract, reflective insights distilled from past repair trajectories (e.g., general strategies, common failure causes).

Workflow

ExpeRepair operates in two phases:

Initial Phase (Cold Start): The system processes a seed set of issues (the first five issues per repository) without prior memory. The resulting repair trajectories are extracted and organized into the episodic and semantic memories to establish a "warm start."
Inference Phase: For new issues, ExpeRepair dynamically activates both memory systems:
- Episodic Activation: Retrieves top- $k$ relevant demonstrations based on the current issue context and execution feedback (using BM25 retrieval). These serve as in-context examples.
- Semantic Activation: Retrieves high-level reflective insights to guide the agents' reasoning strategies.
- Dynamic Prompting: The agents receive augmented prompts combining the task definition, issue context, execution feedback, retrieved demonstrations, and semantic insights. This replaces static prompts with context-aware, experience-driven instructions.

Memory Maintenance

The semantic memory is dynamically updated via a summarize-and-update process where the LLM analyzes repair trajectories to generate new insights. These insights are managed using three operations: ADD (new valuable insights), REMOVE (contradictory or redundant entries), and EDIT (refining or merging overlapping insights). The system caps the number of insights to prevent context saturation.

Key Contributions

Dual-Memory Framework: Proposes ExpeRepair, the first repository-level APR method to continuously learn from historical experiences via a dual-memory system (episodic and semantic) without parameter updates.
Dynamic Prompt Generation: Designs a mechanism that tailors repair strategies by integrating concrete demonstrations and abstract patterns, addressing the rigidity of static prompting.
Empirical Validation: Conducts comprehensive experiments on SWE-Bench Lite and SWE-Bench Verified, demonstrating state-of-the-art performance among open-source methods.
Open Source: Provides publicly accessible source code to facilitate replication and further research.

Experimental Results

The authors evaluated ExpeRepair on SWE-Bench Lite (300 issues) and SWE-Bench Verified (curated solvable issues) using various LLM backbones (Claude 3.5 Sonnet, Claude 4 Sonnet, etc.).

Performance: Using Claude 4 Sonnet, ExpeRepair achieved 60.3% pass@1 on SWE-Bench Lite and 74.6% pass@1 on SWE-Bench Verified.
Comparison: These results surpass all evaluated open-source baselines, including SWE-agent, AutoCodeRover, SpecRover, Agentless, OpenHands, PatchPilot, and DARS. For instance, on SWE-Bench Verified, ExpeRepair (74.6%) significantly outperformed the next best open-source method, DARS (not reported on Verified in the table, but PatchPilot was 53.6%).
Efficiency: ExpeRepair maintains competitive inference costs (approx. $1.91 per instance with Claude 4), significantly lower than high-cost strategies like DARS ($12.24).
Ablation Studies:
- Removing the entire Memory Module caused the largest performance drop (e.g., from 60.3% to ~50% on Verified with Claude 4), confirming the necessity of historical experience.
- Episodic Memory (concrete demonstrations) contributed more to performance gains than Semantic Memory (abstract insights), though both were essential for optimal results.
- Retrieval: Term-based retrieval (BM25) outperformed embedding-based retrieval, suggesting that lexical overlap in error messages and feedback is crucial for code generation.
- Memory Management: Strategies including REMOVE and EDIT operations were critical; simple accumulation (ADD only) led to performance degradation due to context noise.

Significance and Claims

The paper claims that ExpeRepair demonstrates that leveraging past repair knowledge significantly improves performance on challenging repository-level repair tasks. By modeling how developers learn and adapt over time, ExpeRepair achieves a synergistic effect where specific demonstrations provide precise implementation references, and reflective insights enable generalized adaptation.

The authors emphasize that their approach offers a favorable balance between effectiveness and efficiency, avoiding the high costs of fine-tuning while outperforming complex agent orchestration methods. They note that while the method is language-agnostic in design, their current evaluation is limited to Python. Furthermore, they acknowledge that while the dual-memory system enhances test and patch generation, bug localization remains a challenge due to the lack of automated oracles for verification, identifying this as a direction for future work.

The study concludes that different repair methods possess complementary inductive biases; ExpeRepair excels in scenarios with recurring patterns, while other methods (like DARS) may be better suited for novel issues requiring exploratory reasoning.