IonQ and Oak Ridge use generative AI to remove parameter tuning from quantum circuit design

What the teams built

Researchers at Oak Ridge National Laboratory, working with IonQ and NVIDIA, have demonstrated a generative AI method that designs quantum optimization circuits without iterative parameter tuning, according to a report on dev.to. Parameter tuning is the step that normally dominates hybrid quantum workflows, and eliminating it is the central claim of the work.

Hybrid quantum optimization works by splitting a large problem into smaller subproblems, each of which needs its own circuit. Today that means a guess-and-check loop: run a circuit, measure the result, adjust the parameters and repeat until the output is good enough. As subproblems get bigger, the time and compute spent on that loop grow quickly — dev.to notes that the cost of finding good parameters can outweigh the benefit of the quantum approach at larger scales.

A transformer trained on circuits

The automation comes from a transformer model, the same architecture behind modern large language models. Instead of human language, it was trained on high-quality, near-optimal circuits produced by earlier manual methods. When presented with a new subproblem, the model writes circuit instructions directly rather than searching a parameter space.

The pipeline is not a single-shot generator: for each subproblem the model produces ten candidate circuits, which are then simulated and evaluated, and the best candidate feeds into the overall solution. Even so, a fixed number of candidate evaluations replaces an open-ended optimization loop with unpredictable timelines.

Benchmark numbers

The team tested the approach on a high-order benchmark problem with 100 decision variables, comparing it against current state-of-the-art trial-and-error techniques as subproblems scaled from four to twelve qubits.

The contrast was sharp. Under the conventional method, the time needed to find a circuit rose from 34 seconds at the small end to more than 11 minutes at twelve qubits, according to dev.to. The generative approach held steady at roughly 28 seconds across all tested sizes. Solution quality moved in the right direction too: the model-generated results showed a twofold accuracy improvement when larger subproblems were used.

The simulation environment

The study ran entirely in simulation rather than on physical quantum hardware, which let the researchers compare both methods under controlled conditions. Simulations used the NVIDIA cuQuantum SDK and the CUDA-Q platform, executed on the Defiant2 system at the Oak Ridge Leadership Computing Facility, powered by a single NVIDIA H200 GPU.

The collaboration spanned government, industry and academia: Oak Ridge led the study, with contributions from its National Center for Computational Sciences and its Materials Science and Technology Division; IonQ supplied the quantum expertise behind the circuit-generation models; graduate researchers from the University of Tennessee, Knoxville participated; and NVIDIA handled software and hardware integration.

What comes next

The researchers plan to extend the framework beyond benchmarks to real scientific and engineering problems and to scale it across larger high-performance computing clusters. A stated goal is compatibility with coming generations of quantum hardware — as physical processors gain qubit count and stability, automated circuit design is expected to become more, not less, important.

Why it matters

Variational parameter search is one of the long-standing bottlenecks in hybrid quantum algorithms, and a key reason larger problem instances often stop being practical. Replacing that loop with a trained model that emits circuits directly changes the scaling math: runtime stays flat as subproblems grow, and accuracy improves rather than degrades. If the result holds on physical hardware and at larger qubit counts, it offers a repeatable route to quantum optimization workloads that enterprise and scientific users could actually schedule rather than tune indefinitely. The caveats are real — the demonstration is simulation-only and capped at twelve-qubit subproblems — but as a proof of AI-assisted circuit synthesis it points to a plausible division of labor: classical GPUs and generative models design the circuits, and quantum processors run them.