Quantum AI Report

The convergence of Quantum with AI

Archived edition

25 September 2026

Lead story

MQSS-Selector: RL-Guided Pass Selection for an MLIR Compilation Pipeline

arXiv quant-ph

A new arXiv preprint introduces MQSS-Selector, a reinforcement-learning-guided method for selecting optimization passes in an MLIR-based compilation pipeline. The work is situated within the emerging convergence of high-performance computing and quantum computing into unified HPCQC infrastructure, where compiler and runtime layers must bridge classical and quantum workflows.

Why it matters

Compiler pass ordering and selection are typically fixed or heuristic, and poor pass sequences can significantly affect execution time and generated code quality. In emerging HPCQC toolchains built on MLIR, the space of classical and quantum passes is larger and less well understood than in either domain alone. Applying reinforcement learning to pass selection moves from hand-tuned pipelines toward learned, workload-specific optimization; if the method works, it could reduce manual burden and improve portability across heterogeneous HPCQC testbeds.

AI analysis — not reported by the source

What this could make possible

0–2 years

  • Plausible

    MQSS-Selector could become a reusable RL pass-ordering component for MLIR-based quantum compilation toolchains such as Xanadu's Catalyst or academic HPCQC compilers.

    MLIR already has quantum dialects and pass-management infrastructure. RL pass selection has been demonstrated in LLVM and could be adapted to quantum passes with modest engineering. The near-term path depends mainly on integration effort rather than new fundamental results.

2–5 years

  • Plausible

    Learned pass selection could reduce end-to-end compile time or improve circuit-level metrics on representative hybrid classical-quantum workloads, but only if reward signals are tied to actual backend cost models.

    RL policies can learn to avoid expensive or unhelpful transformations after seeing enough training instances. However, constructing meaningful rewards for quantum programs requires access to backends or accurate resource estimators; without that, the policy may optimize irrelevant proxies.

5+ years

  • Speculative

    This work could seed fully learned whole-stack compiler policies for HPCQC systems that jointly optimize classical and quantum passes, reducing the need for per-machine hand tuning as quantum resources scale.

    A single MLIR-based policy that observes both classical and quantum IR could coordinate transformations across the stack. This requires standardized quantum IRs, stable reward definitions, and generalization across very different quantum backends, all of which are unresolved today.

What would have to be true

  • The RL policy must be trained on a sufficiently diverse set of HPCQC workloads with meaningful performance or fidelity feedback; otherwise it may not generalize beyond the training set.
  • MLIR quantum dialects and pass boundaries need to be stable and well-defined across the relevant hardware targets.
  • A reliable cost model or execution feedback loop must exist to provide reward signals for both classical runtimes and quantum circuit quality.

Who’s positioned

  • Xanadu — Its Catalyst compiler already uses MLIR for hybrid quantum-classical compilation, positioning it to integrate learned pass selection for quantum-classical programs.
  • Oak Ridge National Laboratory — Active in HPCQC integration and co-design, it could leverage learned pass ordering to improve performance of hybrid workloads on large systems.
  • IBM — Has Qiskit and HPC partnerships; a learned MLIR pass policy could complement its quantum runtime and compiler stack, especially for hybrid cloud HPC jobs.

What could change this

  • The abstract does not report quantitative results; it is unclear whether RL-selected passes outperform strong heuristic baselines or random search.
  • The definition of 'HPCQC workload' is broad, and the policy may not transfer between different quantum backends or problem domains.
  • Reinforcement learning for compiler pass selection can be brittle and may require retraining for new MLIR dialects or hardware targets.
Permalink to this story →513 words · 3 possibilities

Quantum Networking

arXiv quant-ph

Learning and interpreting policies for simultaneous entanglement requests in quantum networks

An arXiv preprint proposes learning schedulers that allocate simultaneous entanglement requests across future quantum networks while reducing resource use and latency. The paper also develops methods to interpret the learned policies, making their decision-making more transparent. It targets scenarios including distributed quantum computing and quantum sensing operating concurrently in different network regions.

OutlookPlausible

Interpreted policies could be distilled into simple rule-based schedulers that run on near-term quantum network testbeds without continuous reinforcement-learning inference.

Error Correction

arXiv quant-ph

Non-Abelian sheaf quantum LDPC codes: good and magical

A new arXiv preprint introduces a method for constructing non-Abelian quantum low-density parity-check codes by gauging sheaf codes with cup products. The authors report obtaining code families with constant encoding rate and linear distance.

OutlookSpeculative

Within two years, this framework could help identify non-Abelian qLDPC codes whose anyon content enables transversal non-Clifford gates, reducing fault-tolerance overhead.

Infleqtion Achieves 30 Entangled Logical Qubits on Its Sqale Quantum Computer

Infleqtion's Sqale neutral-atom system entangled 30 logical qubits built from 80 physical atoms. The company reported roughly a 1,000-fold improvement in signal-to-noise. An AI-assisted method for one logical operation cut the number of physical gates required by about half.

OutlookPlausible

AI-assisted compilation could enable neutral-atom devices to run longer logical circuits within existing hardware constraints.

arXiv quant-ph

Decoder Model Compatibility Provides Information beyond the Logical Gap under Drifting and Correlated Quantum Noise

A preprint on arXiv examines quantum error-correcting decoders that produce both corrections and confidence estimates for logical errors. It studies what happens when physical noise drifts or becomes correlated, and suggests that assessing whether a decoder's noise model remains compatible with the device can reveal information beyond the standard logical gap measure.

OutlookPlausible

Decoder-model compatibility checks could soon be used to improve postselection in real quantum error correction experiments, flagging runs where confidence estimates are miscalibrated before a logical qubit is accepted.

arXiv quant-ph

Syndrome measurements enable deterministic fault-tolerant $T$ gates

A preprint describes a method for fault-tolerantly implementing non-Clifford gates in stabilizer codes. The key idea is to release one stabilizer check, which makes an additional logical qubit available within the encoded data block, and use that syndrome degree of freedom to mediate the logical operation. This is presented as a path toward deterministic fault-tolerant T gates.

OutlookPlausible

If the syndrome-release scheme can be mapped to a small stabilizer code on today's hardware, early fault-tolerant processors could test deterministic T gates without a full magic-state distillation factory, reducing qubit overhead and logical circuit depth.

arXiv quant-ph

MagiCFirm: A Runtime for Magic-State Cultivation with Algorithm-Hardware Co-Design

Researchers have introduced MagiCFirm, a classical runtime layer positioned between logical quantum software and physical control in fault-tolerant quantum computers. The system is aimed at magic-state cultivation, a technique for reducing the cost of non-Clifford operations. The paper frames an open-source runtime and latency management as the two main practical obstacles the design targets.

OutlookPlausible

If MagiCFirm is released as open source, it could give FTQC researchers a common interface for testing magic-state cultivation schedules against hardware-specific latency constraints, accelerating comparisons across different cultivation protocols.

The Quantum Insider

QC Design Reports 10x Logical Error Reduction With Meridian AI

QC Design published a white paper reporting that its Meridian AI system reduced logical error rates by more than 10x compared with published methods and general-purpose AI agents. The results covered more than 100 fault-tolerance design tasks, according to the company.

OutlookPlausible

Hardware teams could begin using purpose-built AI design tools like Meridian to more rapidly explore fault-tolerant architectures, compressing the iteration time needed to select and refine logical qubit schemes.

arXiv quant-ph

Design Principles for Ultra-High-Rate Quantum Codes

A new arXiv preprint examines systematic design principles for ultra-high-rate quantum error-correcting codes, which have emerged as a route to reducing physical qubit overhead. Some recent constructions in this class need as few as two physical data qubits per logical qubit. The work aims to provide a framework for navigating the space of these codes rather than relying on isolated examples.

OutlookPlausible

This could enable experimental quantum computing groups to rapidly screen and adapt ultra-high-rate codes for their specific hardware noise models, testing logical qubits with much lower overhead than surface-code baselines.

Algorithms & Software

Quantum Computing Report

Independent Cross-Stack Benchmark Evaluates Commercial Quantum Error Management on 156-Qubit IBM Heron Hardware

An independent benchmark measured commercial quantum error management tools on a 156-qubit IBM Heron processor. Q-CTRL and Qedma QESEM reduced errors relative to IBM's native Qiskit Runtime, with Qedma achieving the highest precision at a higher QPU time cost and Q-CTRL offering a balance between error reduction and runtime. The study highlighted different resource-accuracy profiles among the tools.

OutlookPlausible

This could push IBM to integrate select third-party error management layers directly into Qiskit Runtime as user-selectable options, letting users trade accuracy against QPU time per job.