Researchers Build AI to Generate Quantum Applications from Natural Language

A new system autonomously generates executable quantum applications from natural-language task requirements. Ming Tao of Beihang University, and colleagues, present QPipe, a large language model-based architecture utilising multiple specialised agents to translate high-level instructions into complete quantum workflows, encompassing requirement parsing, code generation, and verification. Evaluating QPipe on twenty real-world benchmark problems, the team achieved 100% code compilation and 96.7% application execution rates, with generated solutions frequently surpassing the performance of existing offline genetic algorithms. The system offers a key step towards lowering the barrier to entry for quantum computing in software engineering optimisation, by reducing the need for extensive quantum and programming expertise.

Decomposition of quantum application development into collaborative agent tasks

QPipe’s success stems from its multi-agent architecture, a system where multiple independent software components, or ‘agents’, collaborate to achieve a shared objective, much like a team of specialists working on a complex project. Each agent within QPipe handles a specific stage of quantum application development, parsing the initial natural language request, formulating it into a mathematical problem suitable for quantum computation, and subsequently generating, reviewing, executing, and verifying the resulting quantum code. This decomposition of tasks allows for focused expertise at each step, improving accuracy and efficiency, akin to an assembly line where each worker specialises in a single operation.

Twenty natural language requirements were used to evaluate QPipe, each linked to a real-world benchmark and a test-optimisation problem. Code compilation succeeded in all instances, and application execution combined with final result combination achieved a 96.7 percent success rate. Average generation costs were 260.1 seconds and 1.89 million tokens per requirement, a computational expense accepted to reduce the need for extensive specialist knowledge.

Large language models facilitate automated quantum application development for software testing

Investigations are underway to explore the use of large-language models (LLMs) for generating executable quantum applications to tackle test optimisation problems from real-world benchmarks. Quantum optimisation has recently been applied to software engineering (SE) tasks, including test case minimisation (TCM) with quantum annealing (QA) and test case selection (TCS) with quantum approximate optimisation algorithm (QAOA). These results suggest quantum optimisation is a plausible execution target for SE tasks, but demands substantial expertise. Translating natural language (NL) requirements into executable applications presents the main challenge, encompassing problem formulation, encoding, solver selection, and orchestration.

Existing quantum workflow engineering offers abstractions such as workflow modelling in QuantME, pattern-based workflow construction, and feasibility-oriented design in Q-READY. LLMs have demonstrated promise in benchmarked quantum code generation, QAOA circuit generation, and NL-to-quadratic unconstrained binary optimisation (QUBO) transformation. QPipe, an LLM-based multi-agent architecture for requirement-to-application generation, is presented. When provided with an NL requirement of an SE optimisation task, QPipe produces an executable quantum application alongside traceable intermediate artifacts.

The process is structured using specialised agents for requirement parsing, quantum-suitability analysis, workflow planning, encoding, code generation, review, execution, and verification. QPipe was instantiated and evaluated on test case optimisation (TCO) through two problem variants, TCS and TCM, using 10 benchmark instances from prior quantum-optimisation studies and 20 NL requirements. This evaluation measures generation cost and effectiveness. It also analyzes workflow patterns, compares solution quality against a genetic algorithm (GA) baseline, assesses ablations removing code-generation skills, task knowledge, review feedback, and multi-agent decomposition, and compares three backbone LLMs. Results show that QPipe completes key quantum-application generation stages, with average costs of 260.1 seconds and 1.89M tokens per requirement.

Executable applications generated by QPipe produce solutions that exceed the GA baseline in most cases. Workflow traces show that QPipe’s agents autonomously converge on QUBO+QAOA formulations and script-based final aggregation, while varying decomposition and orchestration structure across runs. Removing code-generation skills, task knowledge, review feedback, and multi-agent decomposition all contribute to performance reductions, with the largest performance drop resulting from the removal of code-generation skills.

Claude performs strongest in the backbone comparison, while DeepSeek remains competitive in early stages and compilation, and Llama fails earlier at code generation. Broader empirical studies are needed to generalise these model-level observations. Quantum applications often combine quantum computation with classical orchestration, as quantum programs operate on quantum states and return probabilistic classical outcomes after measurement, unlike classical programs.

A qubit state can be written as |ψ⟩= α|0⟩+ β|1⟩ with |α|2 + |β|2 = 1, and measuring in the computational basis returns 0 with probability |α|2 and 1 with probability |β|. Therefore, classical orchestration is needed to prepare inputs, configure execution, collect samples, and interpret results. In the noisy intermediate-scale quantum (NISQ) era, limited qubit counts, noise, backend constraints, and access cost further emphasize the importance of orchestration to practical quantum applications. Hybrid workflows can take different forms, with a common pattern involving classical code encoding an input instance into a quantum-compatible representation, configuring the solver or optimizer, executing it on a quantum simulator or hardware backend, and post-processing sampled or optimised outputs.

Optimisation is a common target for quantum applications in the NISQ era. A discrete optimisation problem is often encoded as a QUBO objective or an equivalent Ising energy: min x∈{0,1}n x⊤Qx ⇔ min s∈{−1,+1}n X i hisi + X i QAOA realizes this objective with a parameterised gate-based circuit optimised by a classical optimizer. QA maps the same style of objective to an energy landscape and searches for low-energy states. These routines usually produce candidate assignments or samples, not guaranteed optima.

Recent work has applied such formulations to SE optimisation problems, such as TCO. Search-based software engineering (SBSE) formulates SE tasks as optimisation problems over discrete choices, objectives, and constraints. This work focuses on TCO because it is well established in both classical SBSE and quantum optimisation, and provides formulations and benchmarks for evaluation. Two TCO problems are presented: TCM, which selects a minimum subset T ′ ⊆T that satisfies all objectives as much as possible, given a test suite T = {t0, · · · , tn−1} with testing attributes and objectives F = {f0, · · · , fm−1}, and TCS, which selects a subset T ′ ⊆T that maximizes objective satisfaction, given the same test suite and objectives.

provides an overview of QPipe, which takes an NL requirement as input and produces an executable quantum application and a generation record. QPipe uses 8 specialised agents to manage the transition from an NL requirement to executable code. The Parse Agent extracts the SE task, objectives, constraints, and project data from the requirement. The Analysis Agent assesses whether and how the task can be formulated as a quantum-suitable optimisation problem, such as a QUBO or Ising model.

The Blueprint Agent turns this analysis into an application-level plan, specifying the formulation, workflow structure, solver choice, and expected artifacts. The Encoding Agent constructs the concrete optimisation encoding required by the selected quantum formulation. The Codegen Agent generates candidate implementations from the blueprint and encoding. The Review Agent inspects artifacts from previous agents and requests repairs when inconsistencies or execution risks are detected.

After review, the generated quantum application is executed in an Execution Sandbox, and the Combination Agent/Script combines decomposed subproblem outputs when needed. Finally, the Verification Agent verifies the result against both the quantum application and the generation record. This architecture is motivated by the heterogeneous nature of requirement-to-application generation, requiring requirement interpretation, quantum-suitability analysis, workflow planning, encoding, code generation, and consistency checking.

Assigning these steps to specialised agents makes the process more controllable, enables targeted feedback and repair, and preserves traceability across intermediate artifacts. This modular design also supports independent improvement of individual agents, as their prompts, skills, tools, models, and verification strategies can be updated separately. QPipe takes an NL requirement for an SE optimisation task as input and returns an executable quantum application together with a generation record.

Each requirement specifies an SE optimisation task for the generated application, including the target problem, benchmark instance, presence of constraints, optimisation objectives, and potential predefined parameters. These requirements are not full industrial specifications but define the intended functionality, problem scope, and input conditions of the quantum application. The benchmark instance grounds the task in concrete project data, such as a test suite with per-case attribute fields.

Constraints delimit the feasible search space, including minimum coverage for the TCS variant and target subset size for the TCM variant, as well as non-negativity of selection indicators. Objectives specify the search targets to minimise, maximise, or balance, such as execution cost or required coverage. Parameters provide task-specific values stated in the requirement, such as requested solution sizes, regularization coefficients, or per-objective weights. For example, a TCS requirement may ask for a subset of tests from a given test suite, provide fields such as execution cost and fault-detection rate, specify a required coverage threshold, and assign weights to the optimisation objectives. Together, these elements capture the task, search space, and optimisation criteria in the same way SE optimisation problems are typically specified in practice, while QPipe handles quantum formulation, encoding, and feasibility constraints.

Natural language translation advances automated quantum program generation

Systems are being built to automate quantum application development, an important step towards wider adoption of this powerful but complex technology. Researchers at Beihang University and Mondragon University have created QPipe, an architecture that successfully translates natural language into functioning quantum programs for test optimisation, sidestepping the need for deep expertise in both quantum physics and software engineering. The Beihang University and Mondragon University researchers acknowledge that their current evaluation relies on a relatively narrow set of test problems, raising questions about how well this approach will scale to more varied and complex real-world scenarios.

This work represents a major stride towards democratising quantum computing, lowering the barrier to entry for developers lacking specialist knowledge. The automated system streamlines the process of building and testing quantum applications, potentially accelerating innovation across various fields. Beihang University and Mondragon University researchers have demonstrated QPipe, capable of generating executable quantum applications directly from natural language descriptions of software testing tasks.

This achievement bypasses the traditional need for specialist knowledge in both quantum computing and software programming, representing a significant step towards broader accessibility in the field. QPipe utilises a multi-agent architecture, where individual software components collaborate to translate requirements into functioning quantum workflows, encompassing code creation and verification. Successful code compilation for all tested requirements and achieving application execution in 96.7 percent of cases confirms the system’s viability on benchmark problems.

QPipe successfully transforms natural language requirements into executable quantum applications, demonstrating a new approach to quantum program generation. This matters because it reduces the need for specialist quantum computing and software engineering expertise, potentially broadening access to this technology. The system achieved 100% code compilation and 96.7% application execution rates across 20 test optimisation problems, outperforming a genetic algorithm baseline. Researchers indicate that retaining code-generation skills, task knowledge, review feedback, and multi-agent decomposition were key to QPipe’s success.