💻 computer science

ARISE: A Repository-level Graph Representation and Toolset for Agentic Fault Localization and Program Repair

ARISE is a repository-level framework that enhances LLM-based agents for fault localization and program repair by introducing a multi-granularity program graph with intra-procedural data-flow edges and a queryable slicing API, achieving significant improvements in localization accuracy and repair success rates on the SWE-bench Lite benchmark.

Original authors: Shahd Seddik, Fatemeh Fard

Published 2026-05-06

📖 5 min read🧠 Deep dive

CC BY 4.0

Original authors: Shahd Seddik, Fatemeh Fard

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 detective trying to solve a crime in a massive, sprawling city (the software repository). The city has thousands of buildings (files), each containing hundreds of rooms (functions), and inside those rooms are countless pieces of furniture and documents (lines of code).

Your job is to find the one specific document that contains the lie (the bug) causing the city's power grid to fail, and then rewrite that document to fix it.

The Problem: Getting Lost in the City

In the past, detectives (AI agents) trying to solve these cases had two main problems:

They only had a map of the buildings: They knew which building was next to which, and which building had a door leading to another. But they didn't know how information moved inside the rooms.
They had to read everything: To find the lie, they often had to read entire books or scan every single page in a building, hoping to stumble upon the clue. This was slow, expensive, and often led them to the wrong room.

The Solution: ARISE (The Super-Sleuth's Toolkit)

The authors created a new system called ARISE. Think of ARISE as giving the detective a super-powered, interactive 3D map of the city that doesn't just show buildings, but also shows exactly how a specific piece of evidence (a variable) moves from one document to another inside a room.

Here is how ARISE works, broken down into three simple tools:

1. The Structural Map (Tier 1)

This is the "building map." It tells the detective: "This file contains this class, which calls that function." It's like knowing that the Library is connected to the School. This helps the detective narrow down which building to search, but it doesn't tell them which page in the book is wrong.

2. The "Follow the Money" Tool (Tier 2 - The Big Innovation)

This is the magic part. In the old days, if a detective found a suspicious number in a document, they had to manually flip through every page before and after it to see where that number came from or where it went.

ARISE introduces a tool called Data-Flow Slicing. Imagine you have a magical magnifying glass. You point it at a specific number in a document and say, "Show me everything that touched this number."

Backward Slice: The glass instantly highlights every single sentence that created or changed that number.
Forward Slice: It highlights every sentence that used that number later.

Instead of reading 50 pages, the detective gets a single, highlighted list of just the 5 or 6 sentences that actually matter. This is like being able to instantly trace a specific drop of water from a faucet all the way to the sink, ignoring the rest of the plumbing.

3. The Evidence Binder (Tier 3)

Once the detective has found the suspicious sentences, they have to put them together into a report to fix the bug. Sometimes, the report gets too long and the detective's brain (the AI model) gets overwhelmed.
This tool acts like a smart librarian. It takes all the highlighted sentences, ranks them by importance, and packs them into a neat, concise "Evidence Binder" that fits perfectly into the detective's backpack (the memory limit). This ensures the detective sees the most important clues first.

The Results: Did It Work?

The researchers tested this new system on 300 real-world "crimes" (bugs) from popular software projects. They compared ARISE against a standard detective (the SWE-agent) who only had the basic tools.

Finding the Crime Scene: The standard detective could guess the right building (file) about 57% of the time. ARISE got it right 67% of the time.
Finding the Exact Room: The standard detective guessed the right room (function) 43% of the time. ARISE jumped to 60%.
Finding the Exact Sentence: The standard detective found the right line of code 26% of the time. ARISE improved this to 41%.

Most importantly, because the detective could find the exact problem faster and more accurately, they were able to fix the bug successfully 22% of the time, compared to only 17% for the standard detective.

Key Takeaways from the Paper

Structure isn't enough: Just knowing how files connect isn't enough; you need to know how data moves inside the code.
The "Magic Glass" is the key: The biggest improvement came from the Data-Flow Slicing tool. It allowed the AI to skip the guesswork and go straight to the source of the problem.
No need for a translator: The researchers tried adding a step where a smaller AI would summarize the data into plain English for the main detective. They found this was unnecessary. The main detective (a large AI model) could read the raw, structured data just fine. Adding the summary step just wasted time and money.
The Limit: The system is great at finding problems inside a single room. However, if the problem starts in one room, gets passed to a neighbor's room, and causes a crash there, the detective sometimes gets confused. This is the one area the authors say needs more work in the future.

In short, ARISE gives AI agents a way to "trace the thread" of a variable through code, turning a needle-in-a-haystack search into a direct path to the solution.

Technical Summary: ARISE – A Repository-level Graph Representation and Toolset for Agentic Fault Localization and Program Repair

Problem Statement

Automated Program Repair (APR) and fault localization at the repository scale require agents to navigate complex codebases spanning multiple files, modules, and packages. While existing agentic systems (e.g., SWE-agent) can interact with repositories, they often struggle with fine-grained fault localization (identifying specific functions and lines) due to a lack of semantic precision.

Current graph-based approaches typically model structural relationships (files, classes, functions, and their call/import dependencies) but fail to model intra-procedural data flow. Consequently, agents lack the ability to trace how variable values are defined and propagated within a procedure. This limitation forces agents to rely on lexical similarity or broad structural traversal, which is insufficient for pinpointing the exact statements responsible for a bug, especially when the fault involves complex variable usage within a function.

Methodology

The authors present ARISE (Agentic Repository-level Issue Solving Engine), a system that augments the SWE-agent framework with a structured, queryable program graph and a three-tier tool API. The core innovation is the integration of data-flow slicing as a first-class agent primitive.

1. Multi-Granularity Program Graph

ARISE constructs a directed, typed property graph ( $G = (V, E)$ ) that unifies two layers of information:

Structural Relationships: Nodes represent directories, modules, classes, functions, methods, and statements. Edges capture containment, imports, inheritance, and call relationships.
Data-Flow Relationships: The graph extends to the statement level. For every function/method, the system performs an intra-procedural analysis to identify definition-use (def-use) chains.
- Nodes: Statement nodes correspond to top-level AST statements.
- Edges: DataflowDefUse and DataflowUseDef edges connect statements where a variable is defined to statements where it is used (and vice versa).
- Scope: This analysis respects lexical scope (handling global/nonlocal declarations) and covers common Python assignment patterns (assignments, augmented assignments, loop targets, context managers, and parameters).

2. Three-Tier Tool API

The graph is exposed to the LLM agent through a modular API, allowing the agent to query evidence iteratively:

Tier 1: Structural Retrieval: Tools for searching entities, traversing call/import graphs, and retrieving code spans. This reproduces the capabilities of prior structural-graph systems (e.g., RepoGraph, LocAgent).
Tier 2: Data-Flow Slicing: The core novelty. The get_dataflow_slice tool allows the agent to trace variable flows. Given a seed (file, line, variable) and a direction (backward, forward, or bidirectional), it returns a structured list of statement spans that define or consume the variable. This allows the agent to answer "which statements affect this variable?" in a single query.
Tier 3: Context Bundling: Tools (build_context_bundle, rank_suspect_regions) that assemble the retrieved evidence into a token-budget-constrained context package. They score code spans based on TF-IDF relevance, structural proximity, and slice membership, ensuring the most causally relevant code is presented to the repair sub-agent.

3. Agent Loop

ARISE operates on the SWE-agent scaffold. The agent interacts with the repository via a multi-turn protocol, choosing to call structural tools, slicing tools, or bundling tools as needed. The system is designed to be framework-agnostic, allowing the graph builder and slicing API to be dropped into any tool-use-capable agent.

Key Contributions

Multi-Granularity Program Graph: A repository graph that unifies structural organization with statement-level intra-procedural data-flow information, enabling agents to query value propagation directly.
Data-Flow Slicing as an Agent Primitive: The introduction of get_dataflow_slice as a queryable tool. Unlike static preprocessing, this allows agents to dynamically trace variable definitions and uses during reasoning, returning structured output that models can reason over directly.
Framework-Agnostic Toolset: A decoupled implementation of the graph builder and slicing API, designed as a drop-in plugin for future APR research without requiring re-implementation of the underlying analysis logic.

Experimental Results

The system was evaluated on SWE-bench Lite (300 real GitHub issues across 11 Python repositories) using Qwen2.5-Coder-32B-Instruct as the backbone.

Localization Performance

Compared to the unmodified SWE-agent baseline:

Function Recall@1: Improved by 17.0 points (from 43.0% to 60.0%).
Line Recall@1: Improved by 15.0 points (from 26.0% to 41.0%).
File Recall@1: Improved by 10.0 points.
Ablation Insights:
- Adding Tier 1 (Structural) provided a baseline improvement over SWE-agent.
- Adding Tier 2 (Data-Flow Slicing) yielded the largest single-step gain (+7.0 points in Function Recall@1), confirming that data-flow tracing is critical for fine-grained localization.
- Adding Tier 3 (Context Bundling) provided further incremental gains.
- ARISE-Coarse (Tier 1 + Tier 2 schema but no data-flow edges) performed similarly to Tier 1 only, proving that the improvement comes from the graph data itself, not merely the presence of an additional tool.
- ExplainSlice (adding natural language summaries to slices) provided no measurable improvement, indicating that large code models (32B scale) can reason over structured slice outputs directly without natural language mediation.

Repair Performance

Pass@1: ARISE-Full achieved 22.0% (66/300), a 4.7 percentage-point improvement over the SWE-agent baseline (17.3%).
Correlation: There is a strong, monotonic increase in the Spearman correlation between Function Recall@1 and Pass@1 as more precise tools are added (from 0.38 in SWE-agent to 0.53 in ARISE-Full). This confirms that localization quality is the binding constraint on repair success in this setting.

Significance and Claims

The paper claims that the primary bottleneck in repository-level APR is not just the reasoning capacity of the LLM, but how relevant context is located and structured.

Data-Flow as a Retrieval Primitive: The authors argue that exposing intra-procedural def-use slices as a first-class tool is more effective than relying on structural topology alone. It reduces the search space, allowing agents to commit to a function-level hypothesis based on a single backward slice rather than traversing broad call graphs.
Structured vs. Natural Language: The results challenge the assumption that structured analysis must be summarized into natural language for LLMs. At the 32B parameter scale, models consume structured slice outputs directly, making summarization layers unnecessary and costly.
Modest Limitations: The authors acknowledge that the current system is intra-procedural. It cannot trace variable flows across call boundaries (inter-procedural), which accounts for 45% of remaining failures (wrong-file errors). They identify extending to inter-procedural slicing as the primary direction for future work. Additionally, the approach is currently specific to Python due to its reliance on AST node types.

In summary, ARISE demonstrates that augmenting agentic workflows with precise, queryable data-flow graphs significantly improves fault localization and, consequently, automated program repair success rates.