Multi-granularity graph
Modules, classes, functions, methods, and statements become nodes. Edges between them capture contains, calls, inherits, and data-flow relations.
ARISE: A Repository-level Graph Representation and Toolset for Agentic Program Repair and Fault Localization
University of British Columbia
A framework-agnostic toolset that builds a multi-granularity program graph and exposes it through a three-tier tool API that any LLM-based agent can query. Its central primitive is data-flow slicing. Mounted on SWE-agent, it lifts issue resolution by +4.7 points and sharply improves fault localization.
One graph the agent queries like a tool, instead of a pile of files to read.
ARISE parses a repository in two passes and lets an agent ask precise structural and data-flow questions instead of scrolling through source.
Data-flow slicing
This is the central primitive. One call traces which statements define or consume a variable, backward and forward, across the function.
Three-tier tool API
Search and traverse the graph, slice a variable, then rank suspect regions and bundle context under a token budget. It covers what an agent needs to localize a fault.
Framework-agnostic
Drops into an existing agent scaffold as a tool bundle, with no changes to the model or the harness. The paper demonstrates it on SWE-agent.
Why it matters
Agents fail at repair when they localize to the wrong place.
Coding agents navigate an unfamiliar repository the way a rushed person might, opening files, grepping for names, scrolling. That burns the context window, and worse, it often points the agent at code that only mentions a symbol rather than the code that actually produces the buggy value.
ARISE replaces blind reading with structured queries. Asking "what flows into this variable?" returns a precise slice of the statements that define and use it. Better localization drives better repair, and the paper shows the two moving together.
Baseline agent
Reads whole files to guess where the bug lives.
open file → scroll → grep → read again → edit
With ARISE
Slices the variable and jumps to the statements that matter.
search → slice(var) → rank suspects → edit
A measurable lift on SWE-bench Lite.
300 real GitHub issues across 11 Python repositories, with Qwen2.5-Coder-32B-Instruct as the backbone. ARISE is mounted on SWE-agent and compared against the identical baseline under the same host.
0%
issues resolved (66 / 300)
0
Pass@1 gain over the baseline
0
Function Recall@1 (43.0 → 60.0)
0
Line Recall@1 (26.0 → 41.0)
| Metric | SWE-agent baseline | ARISE-Full | Δ |
|---|---|---|---|
| Pass@1 (repair) | 17.3% | 22.0% | +4.7 pp |
| Function Recall@1 | 43.0 | 60.0 | +17.0 pts |
| Line Recall@1 | 26.0 | 41.0 | +15.0 pts |
Data-flow slicing is the single largest contributor, at +7.0 Function Recall@1 and +2.0 pp Pass@1. Controlled ablations trace the gain to the data-flow graph itself, not merely to adding another tool to the agent's schema.
See it on your own code.
Paste a bit of Python and watch ARISE build its program graph. Hover a graph node to spotlight the code it came from, or hover the code to find its node. It runs entirely in your browser on a lightweight approximation of the real analyzer.
your code
program graphready
Your graph will appear here.
Choose an example to get started.
Choose an example to get started.
Node kinds and edge relations mirror ARISE's real model. The nodes are module, class,
function, method, and statement, joined by contains,
calls, inherits, dataflow_def_use, and control_flow_next edges.
Click a legend chip to toggle an edge type. The browser demo handles one file of straightforward
Python; the full toolset builds repository-scale graphs with slicing across files.