Connecting AI-generated quantum programs to executable experiments requires more than syntactically valid code: the workflow must also control execution authority and preserve the basis for interpreting its results. This paper develops a conceptual architecture organized around three responsibilities: AI-assisted circuit proposal, deterministic classical validation, and quantum measurement execution. A quantum-job contract binds circuit artifacts, measurement settings, resource allocations, backend information, and provenance to explicit admission conditions. The design separates permission to run an experiment from evidence that its output answers the intended scientific question. An analytical single-qubit variational example demonstrates this distinction through exact energy calculations, finite-shot variance, and budget-constrained measurement allocation. Responsibility allocation, runtime interception, and staged transformation provide the architectural principles, while uncertainty reporting and reference calculations supply the scientific checks. A prospective evaluation protocol covers accuracy, policy violations, reproducibility, end-to-end cost, and researcher effort. The framework is presented as a design proposal supported by mathematical illustration, not as a tested implementation; its operational benefits and applicability to larger quantum workloads remain to be established.
Connecting AI-generated quantum programs to executable experiments requires more than syntactically valid code: the workflow must also control execution authority and preserve the basis for interpreting its results. This paper develops a conceptual architecture organized around three responsibilities: AI-assisted circuit proposal, deterministic classical validation, and quantum measurement execution. A quantum-job contract binds circuit artifacts, measurement settings, resource allocations, backend information, and provenance to explicit admission conditions. The design separates permission to run an experiment from evidence that its output answers the intended scientific question. An analytical single-qubit variational example demonstrates this distinction through exact energy calculations, finite-shot variance, and budget-constrained measurement allocation. Responsibility allocation, runtime interception, and staged transformation provide the architectural principles, while uncertainty reporting and reference calculations supply the scientific checks. A prospective evaluation protocol covers accuracy, policy violations, reproducibility, end-to-end cost, and researcher effort. The framework is presented as a design proposal supported by mathematical illustration, not as a tested implementation; its operational benefits and applicability to larger quantum workloads remain to be established.
AI-assisted quantum programming requires a clear separation between generating candidate solutions and authorizing their execution. This paper presents a conceptual framework that assigns proposal generation to an AI assistant, validation and orchestration to a classical controller, and measurement execution to a quantum backend. A structured quantum-job contract links circuit artifacts, observables, shot allocations, backend selection, and provenance to explicit admission checks. The framework adapts responsibility-allocation and runtime-control principles from enterprise AI architectures while distinguishing software compliance from scientific correctness. An analytically solvable single-qubit variational example illustrates expectation-value estimation, finite-shot uncertainty, and resource-aware measurement allocation. The analysis shows why an authorized execution must still be assessed for measurement consistency, statistical uncertainty, and physical bias. A proposed evaluation protocol addresses accuracy, policy enforcement, reproducibility, operational cost, and researcher workload. The contribution is an architectural design and analytical illustration rather than an experimentally validated system; no measured reliability improvement or quantum advantage is claimed.
This paper proposes a conceptual framework for coordinating quantum computation, clas-sical control, and artificial-intelligence-assisted development. The central design principle isto separate suggestions from execution authority: an AI assistant may propose circuits or ex-plain results, while deterministic software validates executable artifacts, enforces resource limits,and records experimental provenance. We formulate a policy-constrained quantum-job contractand illustrate its scientific component through an analytically solvable single-qubit variationalproblem. The example distinguishes exact expectation values from finite-shot estimates andshows why software authorization alone cannot establish physical accuracy. Drawing on workon enterprise AI responsibility allocation, runtime defense, and modular software generation,the framework adapts architectural ideas to quantum research without treating those sourcesas evidence of quantum performance. We provide an evaluation protocol covering scientific ac-curacy, policy enforcement, reproducibility, and end-to-end cost. This is a design proposal withan analytical illustration, not an experimental report; it makes no claim of measured reliabilitygains or quantum advantage.
Existing artificial intelligence governance and runtime execution governance frameworks were developed primarily within classical computing environments. While autonomous and agentic systems have introduced new governance challenges, most governance architectures continue to rely upon assumptions regarding deterministic execution, reproducibility, authorization validity, and auditability. Quantum and hybrid classical-quantum systems introduce execution characteristics that challenge these assumptions. Probabilistic measurement, circuit compilation and transpilation, hardware-dependent execution behavior, calibration drift, shot-based execution, hybrid computational workflows, and emerging distributed quantum architectures create governance obligations not fully addressed by existing execution-governance models. This paper proposes an extension of execution-layer governance into quantum environments through the introduction of Quantum Runtime Governance Invariants and corresponding Quantum Governance Requirements. The proposed invariants identify governance properties that must remain true regardless of implementation details, hardware platforms, programming models, or execution environments. These invariants are explicitly tied to governance properties including authorization integrity, admissibility integrity, provenance continuity, governance evidence integrity, replayability, governance continuity, and governance authority. The paper further introduces the concept of Probabilistic Admissibility, in which governance systems evaluate and authorize bounded outcome distributions rather than deterministic outcomes. Building upon this foundation, the paper derives a structured set of Quantum Governance Requirements spanning quantum resource governance, circuit governance, compilation governance, probabilistic outcome governance, shot governance, calibration governance, hybrid classical-quantum governance, quantum artificial intelligence governance, and distributed quantum governance. Finally, the paper examines the implications of these concepts for the Artificial Intelligence Governance Control Plane (AGCP), arguing that quantum systems do not require a fundamentally new governance architecture. Rather, they require an extension of existing execution-governance semantics capable of operating over probabilistic execution environments. The resulting framework establishes an initial foundation for AGCP-Quantum profiles, governance conformance assessment methodologies, registry assessment frameworks, governance assurance models, and future standards development activities.
Academic quantum computing platforms often face unique challenges in executing quantum workloads due to fragmented software environments and limited engineering support. Unlike commercial ecosystems, academic devices typically evolve without full-stack integration in mind, making it difficult to run complex applications—such as variational quantum algorithms (VQA)—reliably and efficiently. Issues such as incompatible software layers and lack of automated job management significantly increase the overhead of theory-experiment collaboration. To address these challenges, we develop a modular, end-to-end workflow that decouples application-layer code from low-level hardware control, automates circuit submission and result collection, and supports fine-grained circuit-level job scheduling and recovery. The architecture employs a dual-end application programming interface (API) design, enabling robust operation across unstable or resource-constrained hardware backends. For practical use, the framework is lightweight and user-friendly, allowing rapid prototyping of full-stack workflows using basic Python tools. We validate this workflow on a high-fidelity trapped-ion quantum computer by demonstrating a variational quantum eigensolver (VQE) experiment with a classically bootstrapped ansatz initialization technique. The system successfully executed over 60,000 circuits across multiple molecular test cases with minimal human intervention, highlighting the framework’s effectiveness in enabling reproducible, resilient quantum experimentation in academic settings.
Quantum programming is today largely discussed at the level of circuits and application programminginterfaces: a developer constructs a circuit, submits it to a simulator or a cloud-hosted device, and readsback measurement results. As quantum computing moves toward shared, heterogeneous, andincreasingly hybrid quantum-classical environments, a complementary systems-level question becomesimportant — how should the lifecycle of a quantum computation be managed once it leaves the hands ofthe programmer, particularly when many such computations compete for limited execution resources?This paper presents QuantumOS, a research-oriented software platform that treats a quantum circuit notmerely as an object to be executed, but as a managed workload: a quantum job that is created, queued,scheduled according to a selectable policy, assigned to a computational resource by a resource manager,optionally transformed by a circuit-processing stage, executed on a local Quantum Virtual Machine(QVM), and finally recorded and surfaced through a monitoring dashboard. QuantumOS is explicitly aresearch prototype and does not control physical quantum hardware; its current execution backend is aclassical, local circuit simulator. We describe the system's layered architecture, its job-lifecycle andscheduling abstractions, and its execution workflow, and we report an experimental evaluation of theQVM's performance and correctness characteristics. Measured results show that QVM execution timeremains low for small circuits and rises sharply beyond approximately eight to nine simulated qubits,consistent with the expected cost of classical state-vector simulation, and that execution time growsroughly in proportion to the number of measurement shots requested. A correctness evaluation of fourcanonical circuits — a single-qubit Hadamard gate, a Pauli-X gate, a two-qubit Bell state, and a three-qubitGHZ state, each sampled at 10,000 shots — shows observed outcome probabilities within approximatelyhalf a percentage point of their theoretical values, consistent with ordinary statistical sampling variationrather than simulation error. We discuss how the broader scheduling and resource-managementarchitecture supports the paper's central systems claim even where full quantitative benchmarking ofevery subsystem remains for future work, and we outline the educational value of a locally runnableplatform that makes both quantum-circuit behavior and workload-management concepts directlyobservable. We conclude by identifying the prototype's current limitations and the concrete next stepsrequired to mature QuantumOS into a more completely benchmarked research platform.
Abstract Quantum applications are hybrid, i.e., they comprise quantum and classical programs, which must be orchestrated. Workflows are a proven solution for orchestrating heterogeneous programs while providing benefits, such as robustness or scalability. However, the orchestration using workflows can be inefficient for some quantum algorithms, requiring the execution of quantum and classical programs in a loop. Hybrid runtimes are offered to efficiently execute these algorithms. For this, the quantum and classical programs are combined in a single hybrid program, for which the execution is optimized. However, this leads to a conceptual gap between the modeling benefits of workflow technologies, e.g., modularization, reuse, and understandability, and the efficiency improvements when using hybrid runtimes. To close this gap, we introduce a method to model all tasks explicitly in the workflow model and analyze the workflow to detect parts of the workflow that can benefit from hybrid runtimes. Furthermore, corresponding hybrid programs are automatically generated based on the quantum and classical programs, and the workflow is rewritten to invoke them. To ease the live monitoring and later analysis of workflow executions, we integrate process views into our method and collect related provenance data. Thus, the user can visualize and monitor the workflow in the original and rewritten form within the workflow engine. The practical feasibility of our approach is validated by a prototypical implementation, a case study, and a runtime evaluation.