InspectWare: LLM-Enabled Debugger Middleware

• InspectWare is an open-source middleware that abstracts complex debugger protocols, enabling stateful, interactive debugging sessions for Python testing environments.
• It integrates seamlessly with frameworks like unittest and pytest, managing execution states and breakpoint lifecycles across diverse test scenarios.
• The system empowers LLM-driven agentic systems to conduct targeted, hypothesis-based debugging and automated repairs, enhancing efficiency and repair accuracy.

InspectWare is an open-source middleware system designed to abstract traditional debugger complexities and maintain stateful, interactive debugging sessions across mainstream Python testing frameworks. Its primary function is to facilitate dynamic analysis by enabling LLMs and agentic systems to engage in targeted, interactive debugging and self-repair workflows in real-world software engineering contexts.

1. Role and Architectural Abstraction

InspectWare is architected as a middleware layer that encapsulates the intricate operational logic of debuggers. Rather than exposing low-level debugger protocols—with their myriad error modes and state transitions—to LLM-driven self-repair agents, InspectWare presents a clear, stateful abstraction that decomposes debugging into distinct operational modes (e.g., Start, Runtime State, Runtime Error, Post Mortem, and Done). State transitions within the session are automatically managed, allowing for deterministic control flow across debugging sessions.

This abstraction lets LLM agents issue high-level, structured commands, such as set_breakpoint, control_execution, and interact_code, with InspectWare autonomously handling low-level protocol tasks, such as disabling breakpoints after they are hit. By translating these high-level directives into granular debugger actions and maintaining session state, InspectWare operationalizes interactive program inspection without burdening the LLM agent with protocol details.

2. Integration with Python Testing Frameworks

InspectWare is engineered for deep compatibility with mainstream Python testing frameworks, notably including the unittest and pytest ecosystems. It abstracts execution state capture across diverse test setups, including IO-bound and mock-based test environments. The middleware harmonizes the presentation of runtime execution states such that all debugger-mediated inspections and experiments within tests—or application runs—are exposed in a standardized, developer-friendly format.

This level of integration facilitates dynamic analysis in typical repository-level workflows and enables InspectWare to support automated repair systems such as InspectCoder without requiring per-project debugger customizations. The middleware ensures seamless session management and execution state consistency within Python’s diverse testing landscape.

3. Dynamic Analysis and Interactive Debugging

Built upon its abstraction capabilities, InspectWare supports strategic breakpoint placement, targeted state inspection, and transient perturbations of intermediate program states, all via structured high-level commands. Example operations include:

• set_breakpoint(line:int): instructs InspectWare to inject a runtime breakpoint at a specific line.
• interact_code("print(variable)"): executes transient diagnostic statements for immediate feedback.

Through these mechanisms, agentic systems (such as the Program Inspector agent of InspectCoder) can focus on suspicious code regions, collect variable values, and, if necessary, experimentally modify runtime state to validate hypotheses about bug root causes. Critically, these actions do not require permanent code modifications, preserving codebase integrity across iterative inspection cycles.

InspectWare systematically decomposes the session into discrete modes (Start, Runtime State, Runtime Error, Post Mortem, Done), and tracks progression through these modes to support complex, stateful dynamic analysis. This state management underpins the agent’s ability to react adaptively to runtime feedback.

4. LLM–Debugger Collaboration via Agentic Frameworks

InspectWare enables agentic LLM frameworks, specifically the dual-agent InspectCoder system, to leverage dynamic debugging through collaborative workflows:

• Program Inspector agent: interacts with the debugger using InspectWare’s abstraction, orchestrates breakpoint placement, inspects live program state, and deploys runtime experiments (e.g., variable examination, object structure analysis).
• Patch Coder agent: receives stateful diagnostic feedback and synthesizes concrete code patches for bug resolution.

The agents communicate through an adaptive inspection-repair loop. The Inspector agent iteratively refines its understanding of failures based on immediate debugger feedback (“process rewards”), targeting increasingly specific hypotheses. The Patch Coder agent then operationalizes successful hypotheses into code changes, validated across the test suite. The process is mathematically formalized as:

$$C_{\text{patched}} \leftarrow \text{Debug}_{(\theta)}(R, C_{\text{buggy}}, t_{\text{fail}})$$

$$\text{s.t.}\ \forall t_i \in T,\ f_{\text{test}}(C_{\text{patched}}, t_i) = 1$$

where $C_{\text{patched}}$ is the debugged code, $R$ is repair context, $C_{\text{buggy}}$ is the faulty source, and $t_{\text{fail}}$ models the failing tests. The full test suite $T$ validates the repair candidate.

5. Performance Characteristics and Validation

Experiments detailed in InspectCoder’s research (Wang et al., 21 Oct 2025) demonstrate substantial performance gains attributable to InspectWare’s integration. On the BigCodeBench-R benchmark, InspectCoder delivers an 81.40% pass rate and a 67.87% bug resolve rate, with mean debug times of 121.74 seconds, and an average of 20.07 bug fixes per hour. Relative improvements in repair accuracy with the InspectWare-enabled workflow span 5.10%–60.37% over strong baselines, alongside 1.67×–2.24× gains in bug-fix efficiency.

These advances are realized by transitioning debugging from blind trial-and-error (as in log-augmented or rubber-duck methods) to a systematic, hypothesis-driven regime rooted in interactive, stateful analysis. InspectWare’s provision of concise, contextually relevant state information and direct runtime feedback is essential to these outcomes.

6. Implications for Automated Software Engineering

InspectWare’s middleware architecture and its role in interactive LLM-debugger systems represent a paradigm shift in automated software debugging and repair. By facilitating dynamic analysis through adaptive, targeted inspection, InspectWare overcomes the inherent limitations of purely static and log-based analysis approaches—namely, excessive, noisy data and restricted reasoning about intermediate states.

The abstraction and state management underpin not only enhanced repair accuracy and efficiency but also position dynamic analysis as a practical method for automated debugging of complex real-world Python codebases. A plausible implication is that by incorporating InspectWare into broader repository-level and continuous integration workflows, agentic debugging and automated repair may become a core component of future AI-driven software engineering systems.

7. Technical Features and Session Management

InspectWare maintains rigorous state tracking of debugger sessions. Operational modes—Start, Runtime State, Runtime Error, Post Mortem, Done—are explicitly defined, with automatic management of breakpoint lifecycles (e.g., disabling and cleanup following execution) and consistent state exposure to LLM agents. By encapsulating debugger-specific details, the middleware ensures robustness and generalizability, accommodating a spectrum of testing scenarios (including IO and mock-based test cases).

Integration with agentic frameworks is direct: all dynamic inspection and repair commands issued by the LLM agent are mapped to protocol-compliant debugger actions behind the middleware barrier. Throughout execution, session state is continuously synchronized, guaranteeing coherent interaction patterns and minimizing manual intervention or error recovery requirements.

---

InspectWare constitutes the foundational middleware for LLM-enabled agentic debugging and automated repair, bridging interactive reasoning with real-time program execution, and abstracting debugger complexity to facilitate dynamic, stateful analysis across Python testing workflows. Its integration underpins empirically validated improvements in accuracy and efficiency, marking substantial progress in the practical application of LLM-driven software engineering methodologies.