💻 computer science

Empowering Autonomous Debugging Agents with Efficient Dynamic Analysis

This paper introduces the Agent-centric Debugging Interface (ADI), a cost-efficient, function-level debugging framework powered by Frame Lifetime Trace that significantly enhances autonomous program repair agents, enabling a basic agent to resolve 63.8% of SWE-bench tasks and providing consistent performance gains when integrated with state-of-the-art systems.

Original authors: Jiahong Xiang, Xiaoyang Xu, Xiaopan Chu, Hongliang Tian, Yuqun Zhang

Published 2026-04-28

📖 5 min read🧠 Deep dive

CC BY 4.0

Original authors: Jiahong Xiang, Xiaoyang Xu, Xiaopan Chu, Hongliang Tian, Yuqun Zhang

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

The Problem: The "Blind" Detective and the "Micromanaged" Intern

Imagine you are trying to fix a broken machine (a computer program). You have a very smart AI detective (an Autonomous Agent) whose job is to find the broken part and fix it.

The Old Way (Post-Mortem Debugging):
Currently, most AI detectives work like a coroner. They wait for the machine to crash or give a wrong answer. Then, they look at the final result (the "body") and try to guess what went wrong.

The Flaw: If the machine made a tiny calculation error deep inside a complex process, the final result looks almost the same as the right answer. The detective sees the wrong answer but has no idea why it happened. They are guessing in the dark, often making the same mistake over and over until they run out of money (computational budget).

The "Natural" Solution (Traditional Debuggers):
You might think, "Let's just give the detective a magnifying glass to look at every single step the machine takes!" This is like using a traditional debugger (like PDB or GDB).

The Flaw: This is like hiring a micromanaged intern. To see what's happening, the detective has to ask the machine to "stop," "show me this variable," "go to the next line," "show me that variable," "go to the next line."
Because the AI has to ask a question for every single line of code, it gets exhausted. It spends all its money asking questions and never actually solves the problem. It's too slow and too expensive.

The Solution: The "Executive Summary" Dashboard

The authors introduce a new tool called ADI (Agent-centric Debugging Interface). Think of ADI as a high-tech dashboard or a smart summary report designed specifically for the AI detective.

Instead of looking at the machine line-by-line, ADI lets the detective look at the machine function-by-function.

1. The "Frame Lifetime Trace" (The Movie Reel)

In traditional debugging, you see one frame of a movie at a time. ADI gives the detective a complete, self-contained movie reel for every single function the program runs.

This "reel" (called a Frame Lifetime Trace) shows:
- What ingredients (arguments) went into the function.
- Every single step the function took inside.
- How the ingredients changed at every step.
- What the final result was.
Analogy: Instead of asking the intern, "What is the value of X? Now Y? Now Z?", the detective gets a single document that says: "Here is exactly how this specific part of the machine worked, from start to finish, including every change it made."

2. The "High-Level Commands" (The Remote Control)

ADI gives the detective a set of smart buttons (commands) to navigate these movie reels without getting bogged down in details.

break / continue: "Pause the movie right when this specific function starts, but only if a certain condition is met."
step-into / step-out: "Zoom in to see what happened inside this function," or "Zoom out to see who called this function."
call-tree: "Show me a family tree of who called whom."
execute: "Pretend I changed this one line of code just for a second—what would happen?"

How It Works in Real Life (The Example)

The paper uses a real example from the Astropy library (a tool for astronomy).

The Bug: A function was calculating a "separability matrix" (a grid showing if things are independent). For simple cases, it worked. For complex, nested cases, it gave the wrong answer, but the error was silent (no crash, just wrong data).
The Old AI: Tried to fix it by guessing. It ran the test, saw the wrong grid, guessed a fix, ran the test again, saw the same wrong grid, and got stuck in a loop.
The PDB AI: Tried to step through line-by-line. It asked hundreds of questions, ran out of money, and gave up.
The ADI AI (FramePilot):
1. It asked for a summary of the main function.
2. It saw the "movie reel" and noticed that inside a sub-function, a specific array was being filled with the wrong numbers (all 1s instead of real data).
3. It used a command to jump straight to that sub-function and inspect the specific moment the error happened.
4. It found the exact line of code causing the issue and fixed it.
5. Result: It solved the problem quickly and cheaply.

The Results: Faster, Cheaper, and Smarter

The researchers tested this new system (called FramePilot) on SWE-bench, a famous test suite of real-world software bugs.

Success Rate: The AI with ADI fixed 63.8% of the difficult tasks. This is actually better than a highly optimized, expensive commercial agent (Claude-Tools) that cost much more to run.
Cost: It solved these problems for an average of $1.28 per task.
Plug-and-Play: They also took this ADI tool and added it to two other top-tier AI agents. It made those agents better too, improving their success rates by 6% to 18%.

The Bottom Line

The paper claims that by changing how AI agents "look" at code—moving from a slow, line-by-line interrogation to a fast, function-level "executive summary"—we can make autonomous debugging much more effective and affordable. It turns the AI from a confused intern into a skilled detective with a perfect map of the crime scene.

1. Problem Statement

Autonomous agents for Automated Program Repair (APR) currently face two critical limitations:

Reliance on Coarse-Grained Feedback: Existing agents primarily rely on "post-mortem" execution feedback (e.g., final test failure messages or assertion errors). This provides insufficient information about the intricate data and control flow relationships that cause complex bugs, making it difficult for Large Language Models (LLMs) to localize faults and generate correct patches.
Inefficiency of Traditional Debuggers: Integrating traditional interactive debuggers (like GDB or PDB) seems like a natural solution. However, these tools operate on a line-by-line, atomic command paradigm (e.g., next, print var). For an LLM agent, this is cost-inefficient: every single command requires a full LLM inference cycle to process a tiny fragment of state information. This leads to exhausted computational budgets and unproductive debugging loops, preventing fully autonomous operation.

2. Methodology: Agent-centric Debugging Interface (ADI)

The authors propose ADI, a novel interface designed to enable cost-efficient, end-to-end autonomous interaction between agents and debuggers. ADI shifts the interaction paradigm from statement-level to function-level.

Core Components:

Frame Lifetime Trace (FLT):
- This is the central data abstraction. Instead of a linear stream of statements, an FLT encapsulates the complete stateful execution trace of a single function invocation.
- Structure: An FLT is a tuple containing:
  - fid: Unique Frame Identifier (function name + invocation index).
  - fidcaller: Identifier of the calling frame.
  - args: Arguments passed to the function.
  - ret: The return value (or exception info).
  - τ (Trace): An ordered sequence of executed statements, capturing state modifications ( $\Delta S$ ) for each step (variable definitions and value changes).
- Efficiency: The system uses on-demand instrumentation. It does not trace the entire program at the statement level. It first records a lightweight sequence of function calls. Only when an agent selects a specific frame for inspection does the system dynamically generate the detailed FLT for that specific frame.
High-Level Navigational Commands:
- ADI provides a set of semantic commands that allow agents to navigate the dynamic state space efficiently without issuing thousands of low-level commands:
  - Navigation: break (set function-level conditional breakpoints), continue, prev, step-into, step-out.
  - Inspection: call-tree (visualizes the call hierarchy), execute (allows "what-if" analysis by injecting code into a specific execution context to inspect variables without modifying source code).
Interaction Algorithm:
- The system models the debugging session as a state transition system. The state is defined by the breakpoint set, the full execution trace, and the current inspection index.
- The ADI_Interaction_Loop manages the session: it receives a command from the agent, updates the state, and triggers the FrameLifetimeTracer to construct the detailed FLT for the newly selected frame, providing the agent with rich context.

3. Key Contributions

Novel Interface Design: Introduction of ADI, which replaces inefficient line-by-line debugging with a function-level interaction model powered by the Frame Lifetime Trace.
Superior Performance: Demonstration that equipping a basic agent with ADI allows it to outperform highly optimized, high-investment commercial agents (e.g., Claude-Tools) on complex benchmarks.
Generality: Validation that ADI acts as a "plug-and-play" component that significantly enhances existing State-of-the-Art (SOTA) agents with different architectures (ReAct-based and Retrieve-and-Generate-based).

4. Experimental Results

The evaluation was conducted on the SWE-bench (Lite and Verified) benchmarks, which contain real-world repository-level repair tasks.

Performance (RQ1):
- FramePilot (a basic agent equipped with ADI) achieved a 63.8% resolved rate on the SWE-bench Verified set using Claude-Sonnet-3.7.
- This outperformed the highly optimized Claude-Tools agent (63.2%) and other baselines like SWE-agent (58.2%) and AutoCodeRover (46.2%).
- Cost Efficiency: FramePilot achieved this at an average cost of $1.28 per task, significantly lower than the $3.95 cost of Claude-Tools.
- Ablation: FramePilot solved two unique tasks on the leaderboard that no other baseline could solve.
Generality (RQ2):
- Integrating ADI into mini-SWE-agent improved its resolved rate by 10.6% to 18.5%.
- Integrating ADI into AutoCodeRover improved its resolved rate by 6.2% to 7.3%.
- This confirms ADI is a general-purpose enhancement, not limited to a specific agent architecture.
Behavioral Analysis (RQ3):
- Stronger LLMs (e.g., Claude-Sonnet-3.7) utilized ADI commands more frequently (71-73% of tasks) compared to weaker models (28-31%), indicating that ADI amplifies the capabilities of advanced models.
- The break and continue commands were most frequently used, followed by execute, which proved crucial for diagnosing subtle state mismatches (e.g., in the django-11119 case study).

5. Significance

Paradigm Shift: The paper successfully argues that for autonomous agents, the traditional "line-by-line" debugging model is fundamentally flawed due to cost and token limits. ADI proves that function-level abstraction is the correct granularity for LLM-based debugging.
Cost-Effectiveness: It demonstrates that high-performance automated repair does not require massive computational budgets; efficient dynamic analysis can yield better results at a fraction of the cost.
Scalability: By showing that ADI works as a modular component across different agent architectures, the work suggests a path toward a standardized, efficient debugging layer for the next generation of autonomous software engineering agents.
Practical Impact: The ability to resolve complex, silent logical errors (where the program runs but produces wrong results) without human-in-the-loop guidance represents a significant step forward in fully autonomous software maintenance.