AI for quantum computing met its referee at QCE26

This guide follows 51 talks on language models, learning agents and evolutionary search for quantum software at IEEE Quantum Week 2026 in Toronto. Their results held up best wherever an exact check stood behind them.

On the afternoon of Thursday 17 September, Juan Cruz-Benito of IBM Research described a search that went very well and then very badly. Their team let a language model write small programs that generate error-correcting codes, then ran a huge pile of candidates through the search and kept the best. Several of the codes looked like new records. Then a stricter check showed that the fast score behind the search had been too generous, in one case by up to twelve times. For anyone building AI for quantum computing, it was the most useful failure of the week, because it showed a strong player judged by a lenient referee.

Writing quantum software is hard in a particular way. A program is a recipe of gates applied to qubits, usually written in Python with IBM’s Qiskit or Xanadu’s PennyLane. The programmer must reason about amplitudes, the weights a quantum state gives each outcome, which can never be seen directly. A wrong program often returns results that look as plausible as a right one. Few people are trained for this. Large language models already write ordinary software every day, so asking them to write quantum code was an obvious step, though public quantum code is a tiny share of what they learned from.

Every result in AI for quantum computing depends on who, or what, does the checking. A simulator can confirm what a small circuit does, but every extra qubit doubles the memory it needs. Full simulation of a general circuit stops at a few dozen qubits, though special families such as Clifford circuits can be checked at far larger sizes. Coding benchmarks report a pass rate, the share of tasks where a model’s code passes a set of tests, and that score is only as good as the tests. Taken together, the 51 talks followed here suggest a plain rule. These systems are as good as the referee that judges them, and no better.

The strongest objection is that the model matters more than the referee. Fan Chen of Indiana University, Nouhaila Innan of New York University Abu Dhabi and Sharmin Afrose of Oak Ridge all found, with their own results, that the base model sets the ceiling. Extra tooling, such as retrieved examples or agent loops, cannot lift a weak model to where a stronger one starts. Innan’s PennySynth lifted Claude Sonnet 4.6 on QHack coding challenges by up to 28 points. On this reading, better code just arrives with each better model.

That reading holds until code that runs parts company with code that is right. Harmandeep Kaur showed that many model-written circuits that passed in simulation fell short once they were mapped onto a model of a trapped-ion chip, where every gate must be rebuilt from the few the hardware offers. Ming-Kang Ho’s guided agent completed almost every Qiskit task, yet one model’s classifier circuits turned every input into the same state. The code ran, and its answers were wrong. Seung Yeob Shin of Luxembourg argued for tests that check the number a program returns. Cruz-Benito’s inflated scores belong to the same family, a strong player judged by a lenient referee.

Where an exact referee exists, the learners did well. Reinforcement learning, where a program learns by trial and reward much as game-playing systems such as AlphaGo did, suits circuit work, because the choices explode while any answer can still be checked. Quantinuum brought four learned circuit tools to one Thursday workshop. On Monday, AlphaClifford beat Qiskit’s greedy method on circuits a laptop can check. Classical baselines still won some contests. An AMD transformer matched no circuit longer than 26 gates, and the classical tket compiler beat a game-style search on one test.

Yet the referee is turning back into a person. Yuri Alexeev of NVIDIA presented their evolutionary chemistry agent four times in the week, and Kanav Setia of qBraid set a team of agents on D-Wave’s advantage claims. Mark Jack of Zapata Quantum automated a resource estimate Jack put at about three years of analyst effort. In the keynote, Alán Aspuru-Guzik showed agents designing a molecular qubit, and gave success rates from tests the group wrote itself. Setia said the slow step has moved to the humans who must decide which results to believe, and Alexeev named verification as the largest bottleneck. Most benchmarks here are also small and scored by the people who built them. The builders often play and referee the same match.

Language models that write quantum code

Most attention went to language models that write Qiskit, PennyLane or OpenQASM, a plain text format many chips accept. Eight talks measured how well they do it and what helps.

Indiana finds agents cannot rescue a small model

Fan Chen of Indiana University, who trained in classical chip design, opened the Q-GenAI workshop on Sunday 13 September with two lines of work. The first was quantum GANs, image makers in which one part learns to fool another part that judges its work. One design needed 5 times fewer qubits on handwritten digits. It also used 12 times fewer two-qubit gates.

Their newer strand, QAgent, is a team of language-model agents that writes OpenQASM 3. On chains of up to four small programs, gpt-oss-120b got the first try right almost every time, while Qwen 7B fell from 0.59 on one program to 0.02 on four. Chen’s point was that agents cannot rescue a base model too small for the task. Told about a simulated drift in a qubit, the agent wrote the fix into the program. Average fidelity rose from 63 to 89 percent.

Kyushu asks whether models can write and repair quantum programs

Jianjun Zhao of Kyushu University asked two questions, whether a model can write a quantum program and whether it can fix one. QuanBench, from their ASE 2025 paper, holds 44 tasks, and the best first-try pass rate Zhao reported was about 38 percent on models Zhao dated to 2025. Zhao put most misses in the quantum logic. Syntax was the smaller share.

The repair study gave ChatGPT 38 bugs from Bugs4Q, a set drawn from real GitHub reports. The bare code fixed 10, a short description lifted that to 23 and a detailed prompt that named the bug reached 29. Classical bugs were fixed every time. Bugs in the quantum algorithms themselves were fixed in only 2 of 7 cases, which Zhao called the hard class.

PennySynth hands the model worked examples first

Nouhaila Innan of New York University Abu Dhabi opened with a PennyLane program that looks right and will not run, because it calls a device that does not exist and two functions by the wrong names. Qiskit has IBM’s assistant and benchmarks, Innan said. PennyLane had almost nothing.

Their answer is retrieval, which hands the model close worked examples before it writes. Their store holds 13,389 checked pairs of tasks and code. On 74 QHack challenges from 2022 to 2024, PennySynth on Claude Sonnet 4.6 passed 52 to 68 percent within five attempts, against 24 to 43 percent for Claude alone. Gemini 2.5 Pro stayed at 8 percent or below even with help, which Innan read as a weak model gaining little. Their co-authors were Minghao Shao, Hariharan Janardhanan, Muhammad Kashif, Alberto Marchisio and Muhammad Shafique.

QAgent’s paper routes each task to the better agent

Fan Chen presented the full QAgent paper on Thursday 17 September in place of first author Zhenxiao Fu, with Lei Jiang of Indiana and Yilun Xu and Gang Huang of Lawrence Berkeley National Laboratory. Chen argued that a programmer who writes OpenQASM with today’s calibration in hand can get more from a device than a compiler will. A planner drafts a task graph. A critic checks it.

Two coding agents each pair an advisor, a coder and a reviewer that runs code in simulation, one guided by examples and one that calls tools. On Qwen 235B the average first-try pass rate rose from 0.30 for a fixed-prompt baseline to 0.81 and 0.96. On Qwen 7B it rose only to 0.52 and 0.22. Neither agent wins everywhere, so each task is routed to one.

Oak Ridge surveys the quantum coding assistants

Sharmin Afrose of Oak Ridge National Laboratory surveyed the field with Ethan Seefried, Nicholas Stapleton, Vicente Leyton Ortega, Travis Humble and Tirthankar Ghosal. The best models pass a classical coding test on the first try 80 percent of the time or more, the survey found, but only 44 to 56 percent on its Qiskit version. Afrose gave four reasons. Training data is scarce, the toolkits change fast, syntax cannot capture the physics and checking costs a lot.

From 87 papers dated January 2023 to March 2026, the team kept 13 systems and 9 benchmarks, reran nothing, and found that the benchmarks score different things, from pass rates to process fidelity. Only one comparison was fair. It put QSpark at 56.3 percent on Qiskit HumanEval against 46.5 for the Qiskit Code Assistant. Retrieval lifted Qwen 7B by 33 points and did nothing for GPT-4o mini or Claude 3.5 Sonnet. Afrose agreed that benchmarks should let a model run its code and try again.

A written guide helps agents finish, though not always correctly

Ming-Kang Ho of Taiwan’s National Center for High-performance Computing, with Tai-Yue Li, tested whether a written guide helps a language-model agent write and run Qiskit programs. Four models ran three fixed tasks, from a chemistry energy to a small classifier, for 240 trials in all. With the guide, 119 of 120 trials completed. Without it, 96 did.

Completion did not mean correct science. Guided runs met the hydrogen energy target in 29 of 40 trials against 16 without the guide, yet one model’s classifier circuits used gates that turned every input into the same physical state. On IBM’s Kingston chip the guided runs varied 17.2 percent less. They still missed the target energy by slightly more.

Qlippy brings experiment tracking into the code editor

Mahee Gamage of the University of Jyväskylä built Qlippy, with Vlad Stirbu, as a helper that sits beside the code in Visual Studio Code. Their group’s physicists were meant to log 26 details of each quantum run with a tool called MLflow, and the habit had not spread. Qlippy answers their questions from tracking notes and documentation. It mixes meaning-based and keyword search.

GPT-5.4-mini judged the answers on 15 question pairs, left from a pool of 20. A local model with 9 billion parameters came close on faithfulness and led on relevance, and small models said when the notes were silent, while large ones made up an answer to a chocolate cake request. Gamage noted that no person has checked the judge. The test is only a first pass.

Hugging Face holds few real quantum AI apps

Tia Pope, who now teaches computer science at North Carolina A&T State University, combed through public apps on Hugging Face Spaces, a site where anyone can post a small AI demo, looking for ones that mix quantum and generative AI. Seven search phrases, each run three times between 25 May and 28 June 2026, left 212 Spaces after duplicates went. Fewer than half were running. Their co-author Jada Emodogo of the Harvard Quantum Initiative did not speak.

Only 7 of the 212 showed strong evidence of both quantum and generative content. One expert reviewed 89 running Spaces and marked 7 relevant, and the team warned that this rate does not describe the rest. Sonnet found 6 of the expert’s 7 with a precision of 85.7 percent. Another model sat near 50.

Benchmarks and checks for AI-written quantum code

A model’s code can run and still be wrong. Five talks built tests that tell the two apart.

Luxembourg’s language-model linter beats the rules

Seung Yeob Shin of the University of Luxembourg argued that linting, which checks code for likely mistakes without running it, matters more for quantum programs, because time on real hardware is scarce. The rule-based tool LintQ lists 10 quantum problems. One is a gate applied after a measurement.

The team built two GPT-5 linters, one that walks the model through fixed steps and one that also fetches the closest checked example. On 55 Qiskit files LintQ scored 0.41 on F1, a blend of precision and recall, while the step-by-step version reached 0.70. Fetched examples raised precision a little. They cost some recall. Shin worked with Pietro Cassieri, Giuseppe Scanniello, Fabrizio Pastore and Domenico Bianculli.

StabilizerBench uses circuits that are hard to build and easy to check

Andres Paz of the University of Washington built StabilizerBench on one observation. Fault-tolerant error-correction circuits are hard to build but quick to check, which makes them a good test for AI agents. Paz wrote it with Sarju Patel, Cordelia Li, Sylvie Lausier, Christian Tarta and Mayee Sun. It holds 192 tasks from 4 to 196 qubits, and agents may call a checker built on the Stim simulator and revise until attempts or time run out.

In the paper’s runs Claude Opus 4.6 scored 10,772 on preparing encoded states, just ahead of GPT-5.2 at 10,646. On fault-tolerant synthesis, Paz said, models stop producing good circuits at around 50 stabilisers, the checks a code makes. Settings moved results a great deal. Claude scored 1,838 with 15 attempts at 300 seconds and 10,772 with one attempt at 900 seconds, so time, attempts and prompt must travel with every score.

Q-AssertBench finds the best model passes about four in five

Qiming Li of Kyushu University, working with Jianjun Zhao, tested six language models on writing assertions, the checks a programmer adds to state what a correct result looks like. Quantum programs make assertions hard to write. The result is a spread of outcomes, measurement destroys the state and any check needs room for sampling noise. A good assertion passes the correct program and fails a broken copy.

The benchmark has 37 tasks, each run 20 times per model, and GPT-5.4 passed 78.92 percent of its trials while Claude Sonnet 4 passed 71.49 and Llama 4 Scout trailed at 32.30. Tasks that needed the model to infer a hidden pattern, such as a repeating period, were hardest. Strict rules were the common fault. Li reported that the strongest models tend to reject correct programs.

Code that passes in simulation can fail on a modelled chip

Harmandeep Kaur presented master’s work from the University of Connecticut. Their point was that a circuit that passes in a simulator may still fail once its gates are fitted to a chip. Their hardware score is an estimate from calibration data after mapping, which Kaur said is not a fidelity measured on a device. Nothing feeds back to the model.

At a pass mark of 0.9 on a trapped-ion style target of about 20 to 25 qubits, the mean gap across four frontier models was about 33.6 percentage points. Among circuits already correct in simulation, 39 to 46 percent missed the mark. Claude Sonnet 4.5 fell from 0.83 to 0.46. On a copy of IBM’s 133-qubit Heron, every small correct circuit passed.

Luxembourg checks that a program returns the right number

Seung Yeob Shin returned on the Sunday afternoon with an invited talk on a gap in existing benchmarks. Tests for PennyLane and QuanBench check whether code compiles and runs, but a program can clear both checks and still return a wrong number. Their study aims to catch that on scientific problems. It compared five models.

Standard feedback and feedback that told the model more gave similar results, the gains shrank as problems grew harder, and GPT 5.2 was the strongest of the five models on the cases shown. A second chart compared two ways of making test inputs. One method clearly led. Shin said it reached more varied states with fewer gates, a gap that grew with the qubit count.

Learning to build and route circuits

Reinforcement learning treats circuit building as a game, in which an agent makes a move, gets a reward when the circuit improves and slowly learns a strategy, much as AlphaGo learned to play Go. Ten talks put that idea to work.

Delft’s tutorial grows circuits from an empty board

Sebastian Feld, an associate professor at Delft University of Technology and a group lead at QuTech, opened the Sunday tutorial, and Akash Kundu of the same group ran the notebook. Feld’s case was that the ansatz, the circuit shape a variational algorithm tunes, is still drawn by hand. A learner holding only a pool of gates can start from an empty circuit. It needs no grid fixed in advance.

The live demo rebuilt a two-qubit Bell state in at most six gates over 1,000 training rounds, and random search solved about 15 percent of attempts while the trained agent ended close to all of them. Kundu told the room not to publish on a Bell state. Far longer training, Kundu warned, can make an agent overfit.

Kundu’s warm start cuts time per training round by 98 percent

In the tutorial’s second session Akash Kundu of Delft University of Technology turned to why circuit-building learners slow down as circuits grow. Simulating each candidate is the cost. Kundu’s timings ran from about a tenth of a second per circuit at 8 qubits to about 10 seconds at 12, and at that rate 10,000 training rounds take about 27 hours.

The first fix, from a NeurIPS paper with Stefano Mangini, starts the learner from a matrix product state, a compact tensor-network answer, drawn onto a circuit the hardware can run. For eight-qubit water the paper claims 98 percent less time per round. A second fix starts a noisy run from the memory of a noiseless one. It comes from a preprint with Sebastian Feld, and on 12-qubit water it reported 88.2 percent fewer steps and 57.6 percent fewer CNOT gates with no change in the error.

The live three-qubit notebook went the other way. A memory saved after 2,000 rounds overfit, and a fresh run did better. Kundu put that down to an easy problem whose settings still needed tuning, and advised taking the donor memory at 60 or 70 percent success.

QuTech maps more than 200 references on learning to optimise circuits

Akash Kundu of QuTech and Delft presented a review, written with Aritra Sarkar, Prayag Tiwari and Sebastian Feld, that carries more than 200 references. It sorts published work by how the circuit is encoded, what the reward is, which gates are allowed and which learning method is used. The most common choice is the double deep Q-network. Training cost is the main obstacle.

A 12-qubit problem at depth 400 to 500 takes about 10 seconds per training round, Kundu said, and training usually runs 10,000 to 100,000 rounds. Early random play can fill the agent’s memory with poor examples. Warm starts from a classical estimate cut training by about 90 percent, though Kundu was unsure of the exact figure. A study Kundu cited found no single agent best across problems.

AlphaClifford plays Clifford synthesis as a game

Daniele Lizzio Bosco, a PhD student, trained a game-playing model to build Clifford circuits, a kind that a normal computer can run in full, so every answer can be checked. Lizzio Bosco wrote the paper with Jacopo Cossio, Carla Piazza and Giuseppe Serra. Like AlphaZero, AlphaClifford pairs a search tree with learned guides. Each gate costs points.

Run 10 times with the shortest result kept, it needed about 37 gates on random seven-qubit cases, against about 62 for Qiskit’s greedy method and 43 for the best rival search. On chips with limited wiring it used fewer gates in all than IBM’s own learned tool but slightly more CNOT gates. Lizzio Bosco blamed a reward that weighs every gate the same. As a clean-up step it trimmed Clifford gates by up to 2.75 percent.

City College teaches an agent to look across block edges

Christian Rasmussen of the City College of New York taught an agent to look across the edges of circuit blocks. Tools such as QSearch rebuild small blocks as short circuits, but they treat each block alone, so they miss savings that sit across the joins between blocks. Their agent chooses. For each block it decides to leave it, rebuild it or merge it with the next. Rasmussen worked with Mohammad Walid Charrwi, Ed Younis, Wibe Albert De Jong and Samah Saeed.

With every qubit linked to every other, the agent averaged a 23.4 percent cut in CNOT gates at 2.8 times QSearch’s run time, while a rival tool called PAM cut 20.7 percent at 9.8 times. PAM won every circuit that simulates a physical system on IBM’s heavy-hex layout. Run after TKET on one 20-qubit circuit, the agent raised the CNOT cut from 37.0 to 64.4 percent. It trains on ordinary processors.

Quantinuum learns which compiler pass to run next

Gabriel Matos, a senior scientist at Quantinuum, asked which compiler pass should run next on a given circuit. A pair of networks trained with a standard method called PPO picks the next pass from Quantinuum’s PyTKET toolkit, and a do-nothing move ends the loop. The reward is the share of two-qubit gates removed so far. Matos did the work with five colleagues.

Across the full test the policy removed 57.7 percent of two-qubit gates on average, 15.9 points more than the default pass list, after training on 402,558 circuits of three to seven qubits. One run took 2.73 hours on one GPU. On a family of circuits where the obvious first move is wrong, it reached 99.2 percent. Matos said it had already been tried near 100 qubits.

A high-school senior routes with same-day error rates

Yash Vardhan Tomar, a self-described high-school senior in West Lafayette, built a router that feeds same-day error rates into its choices, in work with Dheeraj Peddireddy. It will add extra two-qubit gates when the expected score rises. The network holds about 67,000 settings. The code is public.

Tomar stated their score as 0.727 against 0.440 for SABRE baselines, using snapshots of three 156-qubit IBM chips, Fez, Kingston and Marrakesh, each cut down to a 10-qubit tree of linked qubits. Once a circuit filled the tree, SABRE won. A tree offers only one path between two qubits, which leaves a clever router nothing to choose.

Chalmers scores routes with mirror circuits

Marvin Richter of Chalmers scored compiled routes by how well they survive noise, in work with Harshdeep Singh, Mats Granath and Anton Frisk Kockum. A mirror circuit runs the compiled gates and then their reverse, so a perfect run returns all zeros. The share of all-zero results scores the route. Two learned models rank the routes.

On 300 nine-qubit circuits in a simulated copy of one chip, mean mirror success rose from 25.2 to 36.4 percent, mostly from the choice among finished routes. A simple formula with no training matched it. Richter said the gain from learning has not been shown yet.

Quantinuum clears a graph to prepare error-correction states

Jasmine Brewer of Quantinuum turned the preparation of error-correction states into a game of clearing edges from a graph, in a paper led jointly by Doherty and Puviani. Any such state matches a graph state up to single-qubit gates, so the naive circuit needs one two-qubit gate per edge. Some two-qubit gates change many edges at once. The task becomes clearing the graph in as few moves as possible.

Brewer compared simple searches with reinforcement learning and with QuSynth, which adds tree search in the style of AlphaZero, on codes from the 23-qubit Golay code up to IBM’s 144-qubit gross code. Gate counts sat at roughly 0.45 to 0.8 of a simulated annealing baseline. QuSynth was lowest on all but the largest codes. Beam search, a simpler method, found an answer within 10 percent of the best in about 300 seconds.

Copenhagen learns to gadgetize T gates

Yousra Farhani of the Niels Bohr Institute at the University of Copenhagen trained a graph neural network to cut the cost of T gates, with co-authors there and at Aarhus University. T gates need magic states from costly factories, and a gadget does the same work with fewer of them, so a CCZ gate that needs seven T gates can cost about two T states. Their agent chooses which gadgets to commit. Training took about 12 hours.

Farhani said the policy carried to 48 qubits with a 60 to 70 percent cut. On one 19-qubit test it needed 64 T states, against 84 for a standard pipeline. On a small case it reached 6 T gates in about a second, where a rerun of AlphaTensor-Quantum took over 100 seconds, though that tool’s own paper had reported 2.

Learned synthesis, trainable circuits and their limits

Synthesis asks for a short circuit that does exactly what a given matrix does, and here the check is perfect, since any answer can be compared with the target before anyone trusts it. Six talks tested how far learned models get.

AMD’s transformer drifts on long circuits

A transformer from AMD, trained to shorten circuits by removing T gates, matched most short circuits exactly and none longer than 26 gates. The paper is by Mehdi Saeedi, Eddie Richter and Paul Hartke. The model had 44.8 million parameters and was trained on one AMD Instinct MI300X, using pairs cleaned up by the PyZX package. Every answer was checked against the input.

With 100 samples the model matched 87.5 percent of circuits of 1 to 9 gates and none above 26. At 200 samples each circuit took 45 seconds, against about 6 thousandths of a second for PyZX. The speaker called this autoregressive drift, since one early wrong token carries through every gate that follows, and gate count predicted failure better than qubit count. More training data barely helped the long circuits.

IBM’s Granite reads a quantum operation as an image

Rogerio Feris of IBM presented work with Yunchao Liu, Pengyuan Li, Hang Hua and David Kremer. A four-qubit operation is turned into a grid of numbers and read as an image, and a small adapter feeds it to Granite 4.0 Micro, a 3-billion-parameter IBM model. At each step the model predicts the next gate. It stops once what is left does nothing.

Growing only the training set lifted success on 2,000 held-out circuits from 23.4 percent at 145,000 examples to 71.0 percent at 9.2 million, and Feris said the climb had not levelled off. Adding longer circuits and ten tries per circuit lifted it to 97.1 percent. On the same circuits greedy search reached 14 percent. An earlier learning method reached 84.

Quantinuum learns Clifford and CNOT synthesis from tables

Richie Yeung, Aleks Kissinger and Rob Cornish of Quantinuum built a learned model that synthesises Clifford and CNOT circuits with few entangling gates. Such a circuit can be stored as a compact table, and the model finds a way back from the table to doing nothing. At eight qubits the space holds about 10 to the 40 states. Search alone cannot cover it.

At four qubits the model matched the best possible circuits, and at six it sat within a third of a gate of the best, well ahead of the strongest baseline that scales to larger sizes. Eight qubits is harder. There no optimum is known, and the model used 18.42 CNOT gates against 21.38 for AlphaCNOT.

Quantinuum’s AlphaZero for ZX rewriting trails tket

Alexander Koziell-Pipe of Quantinuum, who is finishing a PhD at Oxford, trained a game-playing search to choose which rewrite rule to use next, with Richie Yeung and Aleks Kissinger. The rules come from the ZX-calculus. Each one keeps the result exact.

On 200 random circuits their Gumbel AlphaZero search cut the mean two-qubit count by 7.4 percent, where Qiskit cut 10.0 percent and the classical tket compiler 21.2. Other search methods made circuits larger. Koziell-Pipe agreed that turning a ZX diagram back into a circuit is very hard in general.

Singapore hunts for circuits that are cuttable, trainable and hard

Lirandë Pira of the National University of Singapore looked for circuits that pass three tests at once, being cheap to cut into pieces, still easy to train and hard for a normal computer to simulate. Pira had not found one. In one family, simple chains called matrix-product states, both the cut and the classical run came cheap.

A two-block layout keeps the seam between pieces small while the inside grows, and their numerical runs went to 100 qubits without finding a depth that was both hard to simulate and trainable. Pira called a higher T count the more hopeful lever. Follow-up work screens 16 circuit families and a toric-code trial on IBM hardware.

Aktar’s transformer picks Trotter orderings for chains it never trained on

Shamminuj Aktar, a postdoctoral researcher at Los Alamos National Laboratory, trained a transformer to choose the order in which a simulation applies its terms. A Trotter step moves a system forward in time by applying each part of its energy in turn. Order matters when parts do not commute. To check every order you must run the full simulation, and the cost of that grows exponentially with size, so it soon runs out of reach. The paper, with Reuben Tate and Stephan Eidenbenz, won a best-paper award in the QGDD track.

The test case was a one-dimensional XXZ Heisenberg chain in a transverse field. Colouring methods from Tate split the terms into three groups that commute within themselves, which gave 24 candidate orderings per chain, and the model reads each term as a token and picks one. Trained on 3 to 14 qubits and tested on 16 to 20, it came within a mean fidelity gap of 0.0015 of the best candidate, five times smaller than the strongest simple baseline. Aktar named the limits plainly. The model chooses only among its 24 candidates and was tested on one family of Hamiltonians.

Evolutionary search and agent-built compilers

Evolutionary search breeds and mutates candidates and keeps the fittest. Six talks let a language model make the mutations, which lets knowledge into the search.

NVIDIA’s evolutionary agent shrinks chemistry circuits

Yuri Alexeev of NVIDIA, a developer of the GAMESS chemistry code, swaps the mutation step of a genetic algorithm for a large language model, which lets chemical knowledge into the search and removes the need for a smooth score. The chemistry starts from the best classical answer. The quantum computer is asked only for the small missing piece of the energy.

Against ADAPT, a costly method that grows compact circuits, the agent’s circuits were 16 times smaller for lithium hydride on 4 qubits and 190.4 times smaller for fluorine on 16. Alexeev said overlap with the target state judges a circuit better than energy alone. The figures come from their own group and are measured against ADAPT alone.

Quantinuum’s Hive evolves algorithms

Konstantinos Meichanetzidis of Quantinuum showed the Hive, from the Cambridge start-up Hiverge, which takes a poor program on purpose, lets language models rewrite it as mutations and keeps the best. NVIDIA and AWS were partners. Meichanetzidis said evolved code is easier to read than a neural network’s weights. It also worked on chemistry. Bred versions of one method kept three small molecules within the accuracy chemists need.

A second search bred problem cases and QAOA schedules together, hunting for cases where QAOA beats three standard classical solvers, and found some, but only under an assumed quantum clock 10,000 times faster than today’s. A run takes about a week on a thousand GPUs. Meichanetzidis warned the room against calling this a quantum advantage.

IBM’s code search meets a stricter judge

Juan Cruz-Benito of IBM Research closed the Thursday workshop with a hunt for error-correcting codes and a warning about how it was scored. Cruz-Benito borrowed the method behind FunSearch and AlphaEvolve, in which a model proposes programs and a checker keeps or drops them. The model writes a short Python function that builds a whole family of bicycle codes. About 200,000 went in.

The weak point was the fast estimate of each code’s distance, the number of errors it can absorb. The fast estimate was too kind. A longer check tightened 147 of 154 earlier bounds, the loosest original bound was high by up to twelve times, and one apparent record came back with distance two. Cruz-Benito said genetic algorithms won while checks were thin, and language models won once distance was enforced. Their closing line was to let the models propose and the exact tools decide.

Tremba’s evolved adders need a third fewer Toffoli gates

Matthew Tremba, a post-baccalaureate researcher at Argonne National Laboratory, let a language model evolve quantum adders, in a paper with Paul Hovland and Ji Liu. Adders sit inside many quantum algorithms, Shor’s among them. A carry-lookahead adder works out its carries by merging bits in a tree, and the shape of the tree trades depth against the number of gates. The best survey so far held 160 designs. Tremba called that a small corner of the space.

The team ran OpenEvolve with GPT-5.4 to mutate the code that builds a tree of any size, so each candidate is a recipe for a whole family. Every candidate was checked, turned into a circuit, simulated and scored at 16 bits. At 32 bits the evolved designs kept the Sklansky adder’s optimal Toffoli depth of 11 while cutting its Toffoli count from 210 to 141, or to 129 when scored on space-time volume. The model also pruned propagate bits that are never used. Tremba said the team had not found that trick in the literature.

San Diego guides a neutral-atom compiler with a language model

Jixuan Ruan, a PhD student at UC San Diego who works with Yufei Ding, started from PowerMove, a compiler for neutral-atom machines that Ruan said already sits in QuEra’s software. Fitting it to one new kind of hardware touched up to nine core parts. Making those changes by hand is slow work. Ruan tested whether a language model could propose schedules that checkers and a hardware simulator accept.

The pipeline hands each stage of a circuit to placement, routing and optimisation agents, and repeated winning moves are mined and written back as rules. Against a standard compiler set at 1.00, the full loop cut run time to 0.80 on one circuit and 0.09 on another. Ruan said every number so far comes from simulation.

NVIDIA’s Friday talk claims no quantum advantage

Alexeev came back on Friday 18 September with the same method, in work with Marwa Farag, and was careful to claim no quantum advantage for it at all. Alexeev starts each molecule from a strong classical method and asks the quantum step only for what is missing. Most of the energy, Alexeev said, is classical.

Their energies matched ADAPT within chemical accuracy of 1 kcal per mole, and their circuits were about ten times shorter on small molecules. Guided mutations beat random ones. Versions of the search model with 3 and 7 billion parameters failed. Alexeev wants 20 to 30 billion, since the frontier models are too slow and cost too much.

Agents that run the research loop

Agents are language models that run in a loop, call tools and try again. Eleven talks handed them whole research tasks, or automated the choices a researcher makes.

Aspuru-Guzik’s agents design a molecular qubit in 36 hours

Alán Aspuru-Guzik, a professor of chemistry and computer science at the University of Toronto and a senior director at NVIDIA Research, gave Wednesday’s keynote on El Agente. It is a family of agents from a lab run with Varinia Bernales. It began as a way to ask a chemistry code for work in plain words, and now some of its agents run the ORCA package, edit files and send jobs to a supercomputer. A quantum branch works with CUDA-Q, Qiskit and other toolkits. Asked to cost a phase estimation on water, it gave 290 logical qubits.

The centrepiece was a spin qubit built from a molecule, a vanadyl acetylacetonate dimer. Up to 10 agents ran 62 jobs on a supercomputer over 36 hours to find which of the molecule’s vibrations drive decoherence, and so which part a chemist should stiffen. A lead author put the same work at a year and a half for a graduate student. The report carries symbolic checks on its equations.

Aspuru-Guzik guessed, and called it hand-waving, that an agent built for the job gets 90 to 95 percent of tasks right, where a general coding agent gets about 70. The group wrote those tests itself, from recent papers. Yonatan Cohen of Quantum Machines opened the session with sponsor remarks and said CUDA-Q now runs end to end on qubits in Tel Aviv.

NVIDIA’s Alexeev hands most of the coding to agents

Yuri Alexeev of NVIDIA opened the Accelerated Quantum Supercomputing workshop on Wednesday 16 September by urging researchers to hand most of their coding to agents. Alexeev said 80 to 90 percent of their own working time now goes on directing them. It was, Alexeev said, an opinion piece. The loop to start with is simple, with a person who sets the goal, an agent that proposes code changes, and a score that decides whether each change stays.

The worked example was the group’s evolutionary chemistry agent, built on the lines of DeepMind’s AlphaEvolve. It starts from the best classical answer and searches for a short circuit to prepare it. On 10 qubits Alexeev reported that circuits shrank 9.89 times for nitrogen and 32 times for water, beside the 16 for lithium hydride and 190.4 for fluorine shown on Monday. Running thousands of agents across a supercomputer is, Alexeev said, still unsolved. A person is still needed to set the problem up well.

Feeney’s SCALAR fingerprints predict QAOA angles in 98.8 percent of groups

Sean Feeney, a PhD student at Texas A&M University, asked how research agents will pick which questions are worth their time. Their answer is SCALAR. It runs QAOA on Max-Cut graphs in CUDA-Q and lays out traits of each graph beside the best angles, then a tool called txGraffiti writes guesses from the table and Claude Sonnet 4.6 sorts the useful ones from the dull. Feeney wrote the paper with Pooja Rao, Andreas Klappenecker, Reuben Tate, Yuri Alexeev, Stefano Mensa, Elica Kyoseva and Stephan Eidenbenz.

The loop looks hardest at the cases that break a guess. On 82 graphs from the MQLib library, a fingerprint of four graph traits gave the same best angles in 54.0 percent of matching groups. Adding the spread of vertex degrees lifted that to 96.9 percent, and one more trait took it to 98.8. In follow-up work not yet published, 22 statements went to the Lean proof checker, which proved 18 of them and refuted the other 4. Feeney framed it as finding known theory first.

Toronto’s autoresearch tunes ground-state methods

Luis Mantilla Calderon of NVIDIA and the Matter Lab in Toronto used a recipe from Andrej Karpathy called autoresearch, in which a coding agent keeps editing a program to raise one score that it may not touch. Ground-state work suits the recipe. A lower energy is always better.

Their co-authors were Jérôme Gonthier, Ignacio Gustin, Varinia Bernales and Alán Aspuru-Guzik. Agents tuned three methods, each on a fixed laptop budget of 20 seconds for DMRG and 60 for quantum Monte Carlo, and on a 64-site chain of spins the DMRG error fell nearly six million fold. Mantilla conceded that an expert using Bayesian optimisation, a standard tuning method, could beat autoresearch. The gain is for someone new to a method.

Singapore lets a model tune a variational solver

Monit Sharma and Hoong Chuin Lau of Singapore Management University let a language model tune a variational solver, which adjusts a circuit’s dials in a loop run on a normal computer. The model reads each run’s results and suggests a small change to a plan set by people. A fixed test keeps the change only if the score goes up.

On one graph problem the best policy changed with size, from a warm-started QAOA at 16 nodes to a method that packs more variables into fewer qubits at 32 to 64. On two IBM chips the 16-node policy found the exact best answer. The presenter called that encouraging and possibly a coincidence. The team has not yet split the model’s part from that of the search space it was given.

qBraid sets 12 agents on D-Wave’s claims

Akshat Tandon of Airbus and Kanav Setia, chief executive of qBraid, gave a joint talk. Tandon began with a project on corrosion in aluminium panels, using a quantum reservoir, a fixed quantum system that holds a memory of a time series so that only a simple final layer needs training. A hybrid did a little better than classical ones on their data. Then Setia took over.

In one of Setia’s campaigns, 12 agents with roles such as validator and red team spent several days judging D-Wave’s quantum advantage claims, and a 170 dollar GPU allowance came back unspent with a NO-GO verdict. Setia said the bottleneck has moved from the agents to the humans who must check their output. The team had not yet verified these results.

Zapata automates a three-year resource estimate

Mark Jack of Zapata Quantum automated a 13-step job from DARPA’s Quantum Benchmarking study, which takes a catalyst molecule through a chain of chemistry steps to a count of the qubits a fault-tolerant machine would need. Jack put the work at about three years for a human analyst. Vincent Russo, Michael Souffrant and Yudong Cao worked with them.

A plain Python supervisor hands the steps to four sub-agents, which call standard chemistry codes through tool servers on Google’s cloud, and the team reported 1.2 to 34 hours per molecule with nobody watching. Estimates ran from 749 to 3,565 logical qubits. Four harder molecules still need work. One run had been going for four days.

NVIDIA’s agents and CUDA-Q Logical

Alexeev also described NVIDIA’s new research centre in Boston, built around a large NVIDIA supercomputer, in work with Marwa Farag. It hosts a tool called CUDA-Q Logical, which turns a program written for error-corrected qubits into the signals that drive a real device. For now, Alexeev said, its main use is to estimate what a program will need. Partners include Quantinuum and QuEra.

Alexeev called AI shockingly underused in quantum research and said about 90 percent of their day now goes on setting up AI workflows, from simple prompts to teams of agents. Most researchers, on their map, still type prompts by hand. At the far end, many agents review each other on a supercomputer and the agent in charge jams. Checking results is the real limit, Alexeev said.

Oak Ridge replaces a tuning loop with a transformer

DQAOA-GPT, which won a best-paper award in the QGDD track, swaps the slow tuning loop of a split-up QAOA for a trained transformer that writes each part’s circuit in one go. The Oak Ridge National Laboratory team presented it. The target is large materials problems.

On a 100-variable problem it was about as accurate and ran about 28 times faster at the largest part size. Tests on IQM, IBM and IonQ machines covered sizes 6 to 12, and IonQ was most accurate at the smallest sizes but used far more machine time. All three lost accuracy as problems grew. The paper is by Seongmin Kim, Abhinav Rijal, Yuri Alexeev, Nora Bauer, Martin Roetteler, Mina Yoon, George Siopsis and In-Saeng Suh.

Farag’s QAOA-GPT writes a circuit in 14 milliseconds

Marwa Farag of NVIDIA trained a GPT-style model to write QAOA circuits in one pass. Its teacher, ADAPT-QAOA, grows a short circuit one layer at a time, and for every new problem it must work out its gradients and tune itself all over again. With the University of Delaware and Virginia Tech, the team made 50,000 random graphs and kept ADAPT circuits that scored at least 0.97. The model writes each circuit as a sentence of tokens.

On 1,000 unseen 14-node graphs it reached an approximation ratio of 0.969 against ADAPT’s 0.973. Each circuit took about 14 milliseconds, against roughly 370 seconds. With Oak Ridge National Laboratory and IonQ, Farag swapped the model into distributed QAOA, which splits a 100-node problem into small pieces, and at a piece size of 12 it cut run time 24-fold. The model only predicts the next token. So the next step, Farag said, is reinforcement learning on energy, to let it beat its teacher.

Fraunhofer’s database picks a variational algorithm

Lena Tokuhiro, a research scientist at Fraunhofer IKS, presented a scaling database inside the open-source QuaST Decision Tree, a tool that walks a user from a problem to an algorithm, an optimiser and a machine. Their group lumps all noise into one term. It finds a critical noise level that falls quickly as problems grow.

A pairing counts as workable only if its total shots stay below the cost of simply checking every answer on a classical computer. For a weighted MaxCut problem on 60 points, only VQE with two optimisers passed. Every QAOA variant failed or could not be judged. The fits ran from 3 to 10 qubits, so everything beyond that is a guess drawn from the trend, which Tokuhiro named as a limit.

AI in the lab, from calibration to device design

Calibration is the daily tuning of every qubit’s settings, and a lab makes plots faster than people can read them. Six talks put AI models and agents to work on that loop, and on designing the devices themselves.

Caldwell says NVIDIA’s open Ising Calibration model beats Gemini at reading plots

Shane Caldwell, NVIDIA’s product manager for NVQLink, said NVIDIA’s open Ising Calibration model reads calibration plots better than leading Gemini, Claude and GPT models. It is a vision-language model with 35 billion parameters, which means it reads images as well as text. On QCalEval it scored 74.7. Gemini 3.1 Pro scored 72.3, Claude Opus 4.6 scored 67.8 and GPT 5.4 scored 64.6, and NVIDIA has put out the weights, the data and the recipe for anyone to use.

NVQLink joins the control system of a quantum chip to ordinary CPUs and GPUs. Caldwell said a round trip takes less than 4 microseconds. In Will Oliver’s group at MIT, tuning a nine-qubit memory circuit with about 714 settings, the slow step was one matrix calculation that took 8.1 seconds on a CPU and 0.040 seconds on a GPU. A group at Academia Sinica, Caldwell added, used the model to cut an hour of calibration by hand on a five-qubit chip to four minutes.

Cao’s QCalEval catches GPT-5.4 misreading a Ramsey fringe

Shuxiang Cao of NVIDIA tests AI models instead of chips. QCalEval holds 243 calibration plots from 22 kinds of experiment, each with six questions. In one, a Ramsey fringe, a trace used to fine-tune the frequency of a qubit, showed beating from mixed frequencies, and GPT-5.4 called it normal. In another, the model accepted a T1 fit that a human expert would have run for longer to see the flat tail at the end.

NVIDIA trained Ising Calibration 1 on 72,000 pairs of questions and answers, and Cao said it does about as well as the leading paid models. In a demo, an agent planned and ran a calibration sequence with the model as its eyes. The code for that agent is public. Open models, Cao said, still cannot learn well from a few example plots.

McEvoy and Mishechkin’s agents lift a QuEra laser relock from 58 to 96 percent

Luke McEvoy and Misha Mishechkin of QuEra set three AI agents on a laser-relocking script overnight. In a neutral-atom machine each qubit is an atom held by lasers, and each laser must hold its frequency to within about one kilohertz, so a shift in heat or an opened door can break the lock. Four engineers had turned an expert’s hand method into a script. It took about 150 seconds and worked first time 58 percent of the time.

One agent proposed a change, one wrote it and one analysed the results, while the script ran on the hardware with no agent attached. Over about 760 experiments against four reproducible disturbances, first-attempt success rose to 96 percent and relock time fell to about 6 seconds. With the AI removed, the finished script succeeded 99.3 percent of the time over hundreds of randomised tests. McEvoy stressed that nothing in it was beyond a good engineer. The gain was pace.

Severin keeps calibration agents for the failures

Brandon Severin, who co-founded Conductor Quantum and runs it, wants calibration to run as a fixed set of steps, with an agent that steps in when one fails. The firm has tuned 64 silicon devices and 20 superconducting qubits. Even two spin qubits in silicon need about 10 voltages set, Severin said, and no one can do that by hand for a billion qubits.

Agent-only control is the simplest design and works across kinds of hardware, though Severin put it at about 80 percent of the way. Agents can also be slow and unreliable, Severin said. Some cheat, for instance by making a good-looking plot without having taken the measurement it claims to show. The hybrid Severin favours keeps the fixed workflow, so that customers keep their own data and can see why a device does what it does. QuEra’s work ended in that shape too.

Deng’s agent explains why a qubit got worse

Xiaolong Deng, who runs quantum services at the Leibniz Supercomputing Centre near Munich, built an agent that explains calibration data to staff with no lab training. The centre’s 54-qubit IQM machine makes about 200 megabytes of it a day. Users ask why a qubit got worse. The agent uses NVIDIA’s Nemotron model to reason and a second model to read plots, and a strict layer lets through only claims the records support.

Early versions reported a CNOT gate the chip does not have and mixed up qubit pairs, so the agent was tied more tightly to the records. In one case it compared July and August records for qubit 15 and found that T1, the time a qubit holds its excited state, had fallen from 46.95 to 33.50 microseconds. It declined to name a firm cause for the poorer readout. Deng said a systematic evaluation is planned.

Patti’s neural surrogate solves Schrödinger’s equation 10 million times faster

Taylor Lee Patti, who leads a quantum simulation and AI research group at NVIDIA, said a trained neural network can solve Schrödinger’s equation about 10 million times faster than step-by-step number crunching. That makes design a cheap search. The group used it to plan pulses that set the state of a hydronium ion with help from a calcium ion, and to choose gate layouts for a quantum dot, which has since been built.

With Fermilab, the University of Southern California and others, the group trained a network on about 8,000 field simulations. A second, small network then works back from a wish list of qubit traits to a layout. Patti said it can design a million qubits in the time one full simulation takes. For quantum dots, where gate voltages trace out the charge maps used to tune a device, an intern, Pranav Vaidhyanathan, built QArray+, a tool that makes those simulated maps more true to life and far quicker to compute.

What it means for teams using AI for quantum computing

A team deciding where to use AI for quantum computing should start where an exact check is cheap, such as a matrix comparison, a stabiliser checker or a fixed energy score. Treat any result scored by a fast proxy as a lead to verify. In the lab the hardware is the referee, and QuEra’s agents raised a laser script’s first-try relock rate from 58 to 96 percent because each attempt either locked or did not. Bigger base models still matter more than scaffolding, and several groups said so with their own numbers. For the wider reliability question, see our report on gaps in AI’s quantum engineering reliability.

Most results here came from simulation or small circuits. Afrose found only one fair comparison among the coding assistants Afrose surveyed, and most benchmarks were built and scored by the same people. Ask who wrote the test before trusting the score.

Cruz-Benito’s apparent records held only until the strictest check was run on them. Anyone building these tools should hire the referee first.