AI Agents Now Fix Errors in Next-Generation Quantum Programs

A B. B. Pham and colleagues of The University of Melbourne have developed QBugLM, a framework using large language models to automate the debugging process for OpenQASM 3.0 programs, encompassing error introduction and repair validation. The framework identifies and rectifies errors in quantum software, a challenge made key by the tendency of these programs to produce incorrect results without indicating failures.

Automated quantum debugging achieves eighty per cent success with novel fault injection and repair

A single retry utilising QBugLM elevates the Pass@1 rate, the probability of correctly fixing a quantum software bug on the first attempt, from below 25% to over 80%, representing a substantial leap in automated debugging capability. Such accuracy in quantum code repair was previously unattainable because of the subtle nature of errors, which often produce silent failures unlike classical software crashes. Classical software typically signals errors through exceptions or crashes, allowing developers to pinpoint the source of the problem. Quantum programs, however, can execute without explicit error messages, yielding incorrect outputs that are difficult to trace back to their origin. This is due to the probabilistic nature of quantum mechanics and the sensitivity of quantum states to even minor disturbances. QBugLM, a multi-agent framework, automates the entire debugging process for OpenQASM 3.0 programs, a standardised language for quantum computing, from deliberately introducing faults to validating successful repairs; this end-to-end approach distinguishes it from existing methods. The framework’s architecture allows for a systematic and reproducible debugging workflow, crucial for ensuring the reliability of quantum software.

Forty-eight distinct bug categories within OpenQASM 3.0 programs were identified, encompassing issues like deprecated syntax and structural errors in circuit construction; this detailed taxonomy enabled the systematic injection of faults into quantum code for testing purposes. These categories were developed through a thorough analysis of common errors encountered in OpenQASM 3.0, including incorrect gate sequences, invalid qubit initialisation, and improper handling of quantum measurements. The taxonomy facilitates targeted bug injection, allowing researchers to assess the framework’s ability to detect and correct specific types of errors. Over 14,000 optimised quantum circuits were analysed, demonstrating that the automated pipeline successfully validated repairs in over 80% of cases following a single retry attempt, highlighting the potential for iterative feedback loops to substantially improve debugging accuracy. The validation process involved executing the repaired code and comparing its output to the expected result, ensuring that the fix not only removes the error but also preserves the intended functionality of the program. Benchmarking across Claude 4.6 Sonnet and Qwen3 Coder Next revealed that performance varied sharply depending on the prompting strategy employed, with simpler structured prompting proving surprisingly effective, even exceeding the capabilities of more complex methods like Chain-of-Thought and ReAct under resource constraints. Chain-of-Thought prompting encourages the LLM to explain its reasoning step-by-step, while ReAct combines reasoning with action-taking. However, the study found that, for this specific task, a more direct and concise prompting approach yielded better results. This is potentially due to the limited context window of the LLMs. However, these figures currently represent performance on relatively small, isolated programs and do not yet demonstrate the framework’s scalability to the complex, multi-component quantum applications required for real-world use. Further investigation will focus on expanding the testing suite to include larger, more intricate quantum programs, and exploring the limits of the framework’s performance with increased program size and complexity. The development of robust and scalable quantum software is essential for unlocking the full potential of quantum computing, and QBugLM represents a significant step towards achieving this goal.

Evaluating large language model performance in automated quantum error correction

Establishing automated quantum software debugging is a vital step towards realising the potential of this emerging technology, particularly as programs grow in complexity and scale. Quantum algorithms are becoming increasingly sophisticated, requiring millions of lines of code and intricate interactions between quantum and classical components. Manual debugging of such programs is a daunting task, prone to human error and requiring significant expertise. Automated debugging tools are therefore essential for ensuring the reliability and correctness of quantum software. The current reliance on only two large language models, Claude 4.6 Sonnet and Qwen3 Coder Next, raises questions about generalisability; do these findings hold true across the wider field of available LLMs, or are the results specific to these particular models. Investigating the performance of other LLMs, such as GPT-4 and Gemini, is crucial for determining the robustness and adaptability of the QBugLM framework. Furthermore, exploring the impact of different LLM architectures and training datasets could reveal valuable insights into the factors that contribute to successful quantum code debugging. Nevertheless, this initial progress offers a standardised method for assessing large language model capabilities in a challenging new area: quantum computing. The ability to systematically evaluate LLMs on quantum tasks provides a valuable benchmark for comparing different models and tracking progress in the field.

Quantum programs, unlike their classical counterparts, can yield incorrect results without signalling a failure, presenting a considerable debugging challenge. This research tackles this issue by systematically introducing faults, then employing large language models to detect and correct them. The process of fault injection is critical for creating a realistic testing environment, as it allows researchers to simulate the types of errors that are likely to occur in real-world quantum programs. A success rate of over 80% with a single retry highlights a key finding, as iterative feedback improves performance from below 25% to above 80%. This demonstrates the power of reinforcement learning and the ability of LLMs to learn from their mistakes. Simpler prompting techniques can also perform as well as more complex methods for capable models with limited resources. This suggests that, for certain tasks, a minimalist approach to prompting can be more effective than attempting to provide the LLM with extensive contextual information. The findings have implications for the design of future quantum software development tools, suggesting that LLMs can play a significant role in automating the debugging process and improving the reliability of quantum code.

The research demonstrated that large language models could assist in identifying and correcting errors in quantum programs, achieving a Pass@1 rate exceeding 80% with iterative feedback. This is important because quantum software bugs often produce silent errors, making traditional debugging methods ineffective. Researchers developed a framework, QBugLM, to systematically inject faults into OpenQASM 3.0 programs and then utilise models like Claude 4.6 Sonnet and Qwen3 Coder Next to detect and repair them. The authors suggest further work is needed to assess the performance of other large language models and explore different LLM architectures.