Pith. sign in

REVIEW 5 major objections 4 minor 2 cited by

QAgent: An LLM-based Multi-Agent System for Autonomous OpenQASM programming

T0 review · 5 major / 4 minor · reviewed 2026-08-05 · deepseek-v4-flash

Challenge this review Re-run · record.json Download PDF Read on arXiv ↗ Review JSON

Pith's one-line read This paper argues that a multi-agent LLM system can take a natural-language description of a quantum problem and return a working OpenQASM program without human intervention; across three model sizes it reports a 71.6% accuracy gain over st

desk verdict QAgent applies the standard LLM-agent stack to OpenQASM and reports big gains, but the evaluation has a load-bearing leakage gap: the RAG store and test set are both from QCircuitNet with no described split, so the 71.6% claim should not be taken at face value. read the letter →

arxiv 2508.20134 v1 pith:ZRVYYNIA submitted 2025-08-26 cs.AI cs.ETquant-ph

Zhenxiao Fu , Fan Chen , Lei Jiang This is my paper · ORCID
classification cs.AIcs.ETquant-ph
keywords OpenQASMLLMagentsretrieval-augmentedgenerationfew-shotlearningchain-of-thoughtreflectionquantumcircuitNISQmulti-agentsystem
verification ladder T0 review T1 audit T2 compute T3 formal

The pith

A machine-rendered reading of the paper's core claim, the machinery that carries it, and where it could break.

The reading

This paper is trying to show that programming quantum computers in OpenQASM can be automated for non-experts by a multi-agent LLM system. Its central claim is that combining two coding strategies — retrieving and imitating known example circuits for short structured tasks, and composing predefined quantum tools via a planning agent for complex parameterized ones — with iterative self-reflection raises the rate of correct generated code by 71.6% relative to prior static few-shot LLM prompting, across several LLM sizes. If true, the practical consequence is that a researcher without quantum expertise can describe a quantum problem in natural language and obtain a compilable, functionally verified circuit, lowering the entry barrier to NISQ computing.

What carries the argument

The central mechanism is the two-coder hybrid. A Dynamic-few-shot Coder retrieves similar example QASM programs via retrieval-augmented generation and writes code by imitation; a Tools-augmented Coder plans a sequence of composable predefined tools (gate application, oracle generation, formatting) and writes code by execution. Each pipeline runs generation, automated syntax/functional testing, and chain-of-thought reflection, and a fallback route sends easy tasks to imitation, escalating failures to planning.

What would settle it

Construct a held-out set of OpenQASM tasks whose algorithms are absent from the example database, run QAgent with retrieval forced off and on, and inspect the retrieved examples for identity or near-identity with the target. If pass@k on genuinely unseen algorithms falls to the static-baseline level, or if near-duplicate examples are routinely retrieved for benchmark tasks, the central claim of autonomous generation fails.

Watch

Extended reading notes

Core claim

QAgent's claim is that generation quality in OpenQASM is governed by matching the strategy to the task structure. For short, well-defined algorithms (Bernstein-Vazirani, Deutsch-Jozsa, Grover), a Dynamic-few-shot Coder retrieves similar examples and builds a composite prompt with analysis; for longer, parameter-sensitive algorithms (phase estimation, W-state), a Tools-augmented Coder plans a sequence of predefined gate and oracle operations. The two are combined in a fallback hierarchy, and the paper reports that the full system beats the static baseline by 71.6% on average and beats either component alone. Ablations show few-shot prompting, analysis, and chain-of-thought reflection all cont

Load-bearing premise

The load-bearing premise is that the RAG database does not contain near-duplicates of the benchmark problems; if retrieved examples are effectively the answer keys, then the reported gains measure retrieval rather than code generation.

Editorial extensions

If this is right

  • A non-expert can describe a quantum problem in natural language and receive a compilable, functionally verified OpenQASM program, lowering the barrier to using NISQ devices.
  • For templated algorithms like Deutsch-Jozsa and Grover, the limiting factor is the quality of the retrieved example set, not the base LLM; for parameterized algorithms like phase estimation and W-state, tool planning is the strategy that carries the gain.
  • Reflection rounds add little in the imitation path and much in the planning path, so the system's default budget could be reallocated by path.
  • On composite tasks that mention two to four algorithms, accuracy falls sharply as the task count grows, making robust decomposition of multi-algorithm requests the next capability needed.

Reading between the lines

Editorial extensions of the paper, not claims the author makes directly.

  • Because the example database and the benchmark tasks come from the same dataset family, the strongest test of the 71.6% claim would be to hold out algorithms absent from the retrieval database; without that split, part of the gain could be retrieval of near-duplicates.
  • The same hybrid architecture could transfer to Qiskit or PennyLane code generation, where static LLM baselines also struggle with parameterized circuits.
  • The differing value of reflection suggests an adaptive budget policy: spend candidates on imitation-path tasks and reflection rounds on planning-path tasks, rather than fixed rounds.
  • A cost-per-correct-program measurement would clarify whether the accuracy gain justifies the inference cost, since the paper reports accuracy but not compute.
Share X Bluesky LinkedIn Reddit HN

Editorial analysis

A structured set of objections, weighed in public.

Desk editor's note, referee report, and a circularity audit.

Referee Report

5 major / 4 minor

Summary. The paper proposes QAgent, a multi-agent LLM system for generating OpenQASM programs from natural-language descriptions. The system combines a Dynamic-few-shot Coder that retrieves similar QASM examples via RAG and imitates them, a Tools-augmented Coder that plans and calls predefined quantum-programming functions, and a hybrid fallback that escalates from the former to the latter on failure. The authors evaluate syntax and functional pass@k on a set of single-algorithm benchmarks (Bernstein-Vazirani, Deutsch-Jozsa, Grover, Phase Estimation, W-state) and on composite multi-algorithm tasks, across three Qwen model sizes. They report that QAgent improves QASM code-generation accuracy by 71.6% over a static few-shot LLM baseline, and they present ablations of reflection rounds, candidate number, model size, and prompt components.

Significance. If the central claims are substantiated, QAgent would be a useful engineering contribution: it demonstrates a plausible architecture for combining RAG, few-shot prompting, reflection, and tool use for quantum code generation, with a pluggable base LLM and a hybrid dynamic/tools routing strategy. The ablation of reflection rounds and candidate number, and the explicit separation of syntax vs. functional correctness, are useful empirical details. The planned public release of code and data is also a positive step. However, the paper's main quantitative claim — a 71.6% improvement and 'fully automated' OpenQASM programming — is not currently established because the evaluation pipeline has a major potential leakage path: the RAG retrieval database and the test benchmark are both derived from QCircuitNet with no described split. If retrieved examples are identical or near-identical to test programs, the reported pass rates reflect retrieval-copying rather than generation. The lack of error bars, significance tests, and a validated static baseline further weaken the quantitative conclusions. These issues are addressable with additional experiments and analysis, but they are load-bearing

major comments (5)
  1. [§2.2, §5.1, §6] Potential RAG/test leakage undermines the central claim. The Prompt Agent retrieves 'a set of similar example QASM code from a quantum algorithm database' (§2.2); the evaluation uses the QCircuitNet dataset (§5.1); and the released dataset is 'modified from [24]' (§6). The paper never defines a split between the RAG store and the test benchmark, and never excludes test-adjacent examples from retrieval. Because QCircuitNet provides Python-based QASM generators and test cases for each algorithm, retrieved examples for bv, dj, gr, pe, and ws can be exact or near-exact copies of the target program (e.g., the pe and ws examples in §7.3 have fixed constants). Under these conditions, pass@3 and the 71.6% gain measure retrieval-copy success, not autonomous OpenQASM generation. The authors must specify a split, deduplicate or remove test instances from the RAG store, and report results with the R
  2. [§3 and §5.4] The headline '71.6%' improvement is not backed by a clear computation. No numerical table reports per-model, per-algorithm, or per-level pass rates; Figures 2 and 4 are bar charts without error bars, confidence intervals, or significance tests. The manuscript does not state whether 71.6% is the average over algorithms, over model sizes, or the best-case improvement, nor whether it refers to syntax or functional pass@k. The authors should provide a table with means and variances, state the aggregation formula, and add significance tests or confidence intervals. Five repetitions averaged together cannot support a precise percentage without variance reporting.
  3. [§3.1 and §5.4] The Static baseline is asserted to 'reproduce the setup from prior work [24]', but the paper gives no validation that its static few-shot results match the original QCircuitNet static results. If the static prompts, example selection, or sampling parameters differ from [24], the comparison is not controlled and the claimed improvement over 'previous static LLM-based approaches' may be inflated. The authors should run the exact static configuration from [24] as a control and report the comparison, or otherwise justify that the baseline is equivalent to prior work.
  4. [§3.2.4] The ablation study removes the few-shot prompt, the analysis component, and reflection, but never removes the RAG database. The '0-shot' condition presumably removes the few-shot examples, yet it is unclear whether retrieval is still active and whether the Prompt Agent still injects retrieved code into the prompt. Given that RAG is a central mechanism, the contribution of the retrieval memory itself must be ablated. Without this, the paper cannot distinguish between the value of retrieved examples and the value of the generation/reflection loop.
  5. [§2.2, §2.4, §5.4] The inference-budget specifications are internally inconsistent. Section 2.2 states the Dynamic Coder by default performs 'one candidate generation and up to three reflection rounds'; Section 2.4 says the default budget is '3 candidate, 5 reflection rounds'; Section 5.4 says the default budget is '3 candidate and 5 reflection rounds' for both Dynamic and Tools. Section 3.2.2 then 'fixes the default candidate number to 1'. This inconsistency affects reproducibility and the interpretation of pass@k: pass@3 results reported elsewhere depend on which budget was actually used. Please reconcile these numbers and report the exact default configuration used for each experiment.
minor comments (4)
  1. [General] Typos and small editorial issues: §5.1 'foundamental', §7.3 'W rongIQFT' and 'inaccuate', and inconsistent hyphenation 'Dynamic-few-shot' vs 'Dynamic'. The paper would also benefit from a careful pass for keyword capitalization ('T ools', 'V alue').
  2. [Figures 2–4] The bar charts would be much easier to interpret with numerical labels and error bars. The caption of Figure 4(a) says 'p-best' but it is not defined in the caption; the reader has to infer from the text.
  3. [§5.4, Eq. (1)] In the pass@k formula, n_t is described as 'total number of generated samples', but it is not stated whether n_t is per task, per prompt, or aggregated over the five repetitions. Please clarify the sampling procedure used to compute the unbiased estimator.
  4. [Reference [3]] Reference [3] (Renner and Wolf, 'Quantum advantage in cryptography') is listed as appearing in AIAA Journal 61(5), 1895–1910, which appears to be an incorrect venue. Please verify.

Circularity Check

1 steps flagged · score 6.0 of 10

RAG retrieval corpus and evaluation benchmark are both QCircuitNet-derived with no described split; the reported 71.6% improvement may reduce to retrieving test-adjacent solutions.

  1. fitted input called prediction [Sec. 2.2 (Prompt Agent), Sec. 5.1 (Dataset), Sec. 6 (Data Availability)]
    "“retrieves a set of similar example QASM code from a quantum algorithm database” (Sec. 2.2); “We evaluated QAgent using the QCircuitNet dataset [24] … Each problem includes a dedicated Python-based OpenQASM code generator accommodating varying qubit counts and associated test cases” (Sec. 5.1); “the dataset modified from [24]” (Sec. 6)."

    The retrieval database that feeds the Dynamic Coder is not described as separate from the evaluation benchmark; the paper says the released dataset is “modified from [24]” (QCircuitNet) and Methods says QCircuitNet resources “adequately support both in-context few-shot learning and RAG-based tool invocation.” Since QCircuitNet is both the source of retrieved examples and the test set, and no deduplication/train-test split is reported, a retrieved “similar example” can be the exact or near-exact QASM program being asked for (e.g., the Phase Estimation CU_0 repetition pattern 1,2,4,8 or W-state ry constants in Sec. 7.3). The Dynamic Coder’s pass@k then measures retrieval/copying of test-set content, not autonomous generation. The central 71.6% improvement over Static is partially forced by c

full rationale

The central claim (QAgent “fully automates OpenQASM programming” with 71.6% improvement) rests on an evaluation where the same QCircuitNet resource supplies both the RAG example database and the test problems. The paper never describes a split, deduplication, or exclusion of test-adjacent programs from the retrieval store, so the Dynamic Coder—the first/default module—can succeed by reproducing retrieved examples. This makes the reported pass@k partly a measure of memory, not generation. This is the one load-bearing circularity: the predicted outputs are not independent of the retrieval input. I did not count the ablation-derived defaults (reflection rounds, candidate counts) as definitional circularity; that is benchmark tuning, an external validity concern rather than a reduction-by-construction. No self-citation chain or imported uniqueness theorem is involved.

Assumptions & free parameters 5 free parameters · 3 assumptions · 0 invented entities

The central claim depends on several hand-chosen system parameters (candidates, reflection rounds, sampling temperature) and on domain assumptions about LLM capability, test correctness, and RAG/test independence. No new physical entities are introduced.

free parameters (5)
  • candidate number (k) = 3
    Number of generated candidates for pass@k; chosen to balance cost and performance, ablated in Fig. 3c-d.
  • reflection rounds = up to 5 (hybrid), 3 default
    Number of CoT-based revision iterations; ablated in Fig. 3a-b, showing gains mainly for Tools Coder.
  • sampling temperature = 1.0
    Generation temperature fixed across all models; no sensitivity analysis provided.
  • RAG retrieval size = not specified
    Number of similar examples retrieved for few-shot prompts is not reported.
  • maximum qubit number = 12
    Set to ensure simulation feasibility; may limit benchmark difficulty.
assumptions (3)
  • domain assumption The LLM can follow the structured prompts and produce valid OpenQASM syntax.
    The entire system relies on the base LLM's instruction-following and code generation capacity.
  • domain assumption The QCircuitNet test cases correctly verify functional correctness of generated circuits.
    Used as ground truth for pass@k (Functional); no validation of test case correctness shown.
  • domain assumption Retrieved example codes from the quantum algorithm database are representative and do not leak test answers.
    The paper does not describe splitting the RAG database from the test benchmark, so this unstated assumption is critical to the validity of the results.

how reviews work

0 comments
Cite this review

Pith. "Pith review of QAgent: An LLM-based Multi-Agent System for Autonomous OpenQASM programming." pith.science (2026). https://pith.science/paper/ZRVYYNIA

@misc{pith2026250820134,
  author       = {Pith},
  title        = {Pith review of: QAgent: An LLM-based Multi-Agent System for Autonomous OpenQASM programming},
  year         = {2026},
  howpublished = {\url{https://pith.science/paper/ZRVYYNIA}},
  note         = {Machine review of arXiv:2508.20134}
}
read the original abstract

Noisy Intermediate-Scale Quantum (NISQ) devices have begun to exhibit early quantum advantages on classically intractable problems, spanning physics simulations to Gaussian boson sampling. Yet, realizing these benefits remains challenging for non-experts, primarily due to the complexities of programming in Open Quantum Assembly Language (OpenQASM). Although Large Language Model (LLM)-based agents have shown promise in automating classical programming workflows, their quantum counterparts have largely been restricted to specialized tasks such as quantum chemistry or error correction. In this paper, we present QAgent, an LLM-powered multi-agent system that fully automates OpenQASM programming. By integrating task planning, in-context few-shot learning, retrieval-augmented generation (RAG) for long-term context, predefined generation tools, and chain-of-thought (CoT) reasoning, the agents systematically improve both compilation and functional correctness. Our evaluations demonstrate substantial improvements: across multiple LLMs of varying sizes, QAgent enhances the accuracy of QASM code generation by 71.6\% compared to previous static LLM-based approaches. We envision this multi-agent system as a key enabler for democratizing quantum programming, bridging expertise gaps, and accelerating the practical adoption of quantum computing.

Discussion (0). Continue with ORCID to comment.

Forward citations

Cited by 2 Pith papers

Reviewed papers in the Pith corpus that reference this work. Sorted by Pith novelty score. Full citation record

  1. QuantumMind: Constraint-Grounded Agentic Reasoning for Speedup Analysis in Quantum Computing

    cs.AI 2026-08 conditional novelty 6.0 of 10

    A structured AI agent with typed steps and deterministic checks beats prompting and agentic baselines for producing auditable quantum-speedup hypotheses, scoring 53.1 versus 35.8 mean ODS on 582 tasks.

  2. Aligning Quantum Operators with Large Language Models

    quant-ph 2026-06 conditional novelty 6.0 of 10

    An LLM that reads a quantum operator as image-like patches can synthesize 4-qubit Pauli-rotation circuits at high success and obey English gate constraints.

Reference graph

Works this paper leans on

33 extracted references · 23 canonical work pages · cited by 2 Pith papers

  1. [24]

    arXiv preprint arXiv:2410.07961 (2024)

    Yang, R., Gu, Y., Wang, Z., Liang, Y., Li, T.: Qcircuitnet: A large-scale hier- archical dataset for quantum algorithm design. arXiv preprint arXiv:2410.07961 (2024)

    arXiv 2024

  2. [1]

    Nature607(7920), 667–676 (2022)

    Daley, A.J., Bloch, I., Kokail, C., Flannigan, S., Pearson, N., Troyer, M., Zoller, P.: Practical quantum advantage in quantum simulation. Nature607(7920), 667–676 (2022)

    work page 2022

  3. [2]

    Science 376(6598), 1182–1186 (2022)

    Huang, H.-Y., Broughton, M., Cotler, J., Chen, S., Li, J., Mohseni, M., Neven, H., Babbush, R., Kueng, R., Preskill, J., et al.: Quantum advantage in learning from experiments. Science 376(6598), 1182–1186 (2022)

    work page 2022

  4. [3]

    AIAA Journal 61(5), 1895–1910 (2023)

    Renner, R., Wolf, R.: Quantum advantage in cryptography. AIAA Journal 61(5), 1895–1910 (2023)

    work page 1910

  5. [4]

    Nature communications 14(1), 1952 (2023)

    Lee, S., Lee, J., Zhai, H., Tong, Y., Dalzell, A.M., Kumar, A., Helms, P., Gray, J., Cui, Z.-H., Liu, W., et al.: Evaluating the evidence for exponential quantum advantage in ground-state quantum chemistry. Nature communications 14(1), 1952 (2023)

    work page 1952

  6. [5]

    Physical Review A 111(3), 032411 (2025)

    Bode, T., Ramesh, K., Stollenwerk, T.: Quantum combinatorial optimization beyond the variational paradigm: Simple schedules for hard problems. Physical Review A 111(3), 032411 (2025)

    work page 2025

  7. [6]

    Nature 606(7912), 75–81 (2022)

    Madsen, L.S., Laudenbach, F., Askarani, M.F., Rortais, F., Vincent, T., Bulmer, J.F., Miatto, F.M., Neuhaus, L., Helt, L.G., Collins, M.J.,et al.: Quantum compu- tational advantage with a programmable photonic processor. Nature 606(7912), 75–81 (2022)

    work page 2022

  8. [7]

    ACM Transactions on Quantum Computing 3(3), 1–50 (2022)

    Cross, A., Javadi-Abhari, A., Alexander, T., De Beaudrap, N., Bishop, L.S., Hei- del, S., Ryan, C.A., Sivarajah, P., Smolin, J., Gambetta, J.M., et al.: Openqasm 3: A broader and deeper quantum assembly language. ACM Transactions on Quantum Computing 3(3), 1–50 (2022)

    work page 2022

Show all 33 references
  1. [8]

    In: IEEE LLM Aided Design Workshop, pp

    Dupuis, N., Buratti, L., Vishwakarma, S., Forrat, A.V., Kremer, D., Faro, I., Puri, 11 R., Cruz-Benito, J.: Qiskit code assistant: Training llms for generating quantum computing code. In: IEEE LLM Aided Design Workshop, pp. 1–4 (2024)

    2024

  2. [9]

    In: IEEE International Confer- ence on Quantum Computing and Engineering (QCE), vol

    Vishwakarma, S., Harkins, F., Golecha, S., Bajpe, V.S., Dupuis, N., Buratti, L., Kremer, D., Faro, I., Puri, R., Cruz-Benito, J.: Qiskit humaneval: An evaluation benchmark for quantum code generative models. In: IEEE International Confer- ence on Quantum Computing and Engineer...

    2024

  3. [10]

    arXiv preprint arXiv:2503.02497 (2025)

    Basit, A., Innan, N., Asif, H., Shao, M., Kashif, M., Marchisio, A., Shafique, M.: Pennylang: Pioneering llm-based quantum code generation with a novel pennylane-centric dataset. arXiv preprint arXiv:2503.02497 (2025)

    2025 arXiv

  4. [11]

    Nature 624(7991), 238–238 (2023)

    Castelvecchi, D.: Ibm releases first-ever 1,000-qubit quantum chip. Nature 624(7991), 238–238 (2023)

    2023

  5. [12]

    Physical Review X 13(4), 041052 (2023)

    Moses, S.A., Baldwin, C.H., Allman, M.S., Ancona, R., Ascarrunz, L., Barnes, C., Bartolotta, J., Bjork, B., Blanchard, P., Bohn, M.,et al.: A race-track trapped-ion quantum processor. Physical Review X 13(4), 041052 (2023)

    2023

  6. [13]

    Quantum Science and Technology 5(3), 034013 (2020)

    Litteken, A., Fan, Y.-C., Singh, D., Martonosi, M., Chong, F.T.: An updated llvm-based quantum research compiler with further openqasm support. Quantum Science and Technology 5(3), 034013 (2020)

    2020

  7. [14]

    arXiv preprint arXiv:1809.03452 (2018)

    McKay, D.C., Alexander, T., Bello, L., Biercuk, M.J., Bishop, L., Chen, J., Chow, J.M., C´ orcoles, A.D., Egger, D., Filipp, S., et al.: Qiskit backend specifications for openqasm and openpulse experiments. arXiv preprint arXiv:1809.03452 (2018)

    2018 arXiv

  8. [15]

    ACM Journal on Emerging Technologies in Computing Systems (JETC) 18(1), 1–24 (2021)

    Khammassi, N., Ashraf, I., Someren, J., Nane, R., Krol, A.M., Rol, M.A., Lao, L., Bertels, K., Almudever, C.G.: Openql: A portable quantum programming framework for quantum accelerators. ACM Journal on Emerging Technologies in Computing Systems (JETC) 18(1), 1–24 (2021)

    2021

  9. [16]

    https://github.com/ amazon-braket/amazon-braket-examples (2024)

    Amazon Braket Team: Amazon Braket Examples. https://github.com/ amazon-braket/amazon-braket-examples (2024)

    2024

  10. [17]

    ACM Transaction on Software Engineering Methodology (2025)

    Ramalho, N.C.L., Souza, H., Lordello Chaim, M.: Testing and debugging quan- tum programs: The road to 2030. ACM Transaction on Software Engineering Methodology (2025)

  11. [18]

    In: Advances in Neural Information Processing Systems, vol

    Tang, H., Key, D., Ellis, K.: Worldcoder, a model-based llm agent: Building world models by writing code and interacting with the environment. In: Advances in Neural Information Processing Systems, vol. 37, pp. 70148–70212 (2024)

    2024

  12. [19]

    In: Forty-first International Conference on Machine Learning (2024)

    Wang, X., Chen, Y., Yuan, L., Zhang, Y., Li, Y., Peng, H., Ji, H.: Executable code actions elicit better LLM agents. In: Forty-first International Conference on Machine Learning (2024)

    2024

  13. [20]

    https://learn.microsoft.com/en-us/training/modules/github-copilot-agent- mode/ (2025)

    microsoft: Building applications with GitHub Copilot agent mode. https://learn.microsoft.com/en-us/training/modules/github-copilot-agent- mode/ (2025)

    2025

  14. [21]

    Communications Physics 8(1), 49 (2025)

    Pan, H., Mudur, N., Taranto, W., Tikhanovskaya, M., Venugopalan, S., Bahri, Y., Brenner, M.P., Kim, E.-A.: Quantum many-body physics calculations with large language models. Communications Physics 8(1), 49 (2025)

    2025

  15. [22]

    Science China Physics, Mechanics & Astronomy 68(4), 240313 (2025) 12

    Zhou, S., Chen, R., An, Z., Zhang, C., Hou, S.-Y.: Application of large lan- guage models to quantum state simulation. Science China Physics, Mechanics & Astronomy 68(4), 240313 (2025) 12

    2025

  16. [23]

    arXiv preprint arXiv:2504.11109 (2025)

    Jern, L., Uotila, V., Yu, C., Zhao, B.: Fine-tuning large language mod- els on quantum optimization problems for circuit generation. arXiv preprint arXiv:2504.11109 (2025)

    2025

  17. [25]

    arXiv preprint arXiv:2401.09253 (2024)

    Nakaji, K., Kristensen, L.B., Campos-Gonzalez-Angulo, J.A., Vakili, M.G., Huang, H., Bagherimehrab, M., Gorgulla, C., Wong, F., McCaskey, A., Kim, J.- S., et al.: The generative quantum eigensolver (gqe) and its application for ground state search. arXiv preprint arXiv:2401.09...

    2024

  18. [26]

    arXiv preprint arXiv:2307.08191 (2023)

    Liang, Z., Cheng, J., Yang, R., Ren, H., Song, Z., Wu, D., Qian, X., Li, T., Shi, Y.: Unleashing the potential of llms for quantum computing: A study in quantum architecture design. arXiv preprint arXiv:2307.08191 (2023)

    2023 arXiv

  19. [27]

    arXiv preprint arXiv:2412.20956 (2024)

    Kashani, S.: Quantumllminstruct: A 500k llm instruction-tuning dataset with problem-solution pairs for quantum computing. arXiv preprint arXiv:2412.20956 (2024)

    2024 arXiv

  20. [28]

    arXiv preprint arXiv:2505.07711 (2025)

    Sinha, P., Jha, S.K., Raj, S.: Circuit partitioning using large language models for quantum compilation and simulations. arXiv preprint arXiv:2505.07711 (2025)

    2025 arXiv

  21. [29]

    In: ACM/IEEE International Symposium on Empirical Soft- ware Engineering and Measurement, pp

    d’Aloisio, G., Fortz, S., Hanna, C., Fortunato, D., Bensoussan, A., Mendiluze Usandizaga, E.n., Sarro, F.: Exploring llm-driven explanations for quantum algorithms. In: ACM/IEEE International Symposium on Empirical Soft- ware Engineering and Measurement, pp. 475–481. Associati...

    2024

  22. [30]

    arXiv preprint arXiv:2505.02484 (2025)

    Zou, Y., Cheng, A.H., Aldossary, A., Bai, J., Leong, S.X., Campos-Gonzalez- Angulo, J.A., Choi, C., Ser, C.T., Tom, G., Wang, A., et al.: El agente: An autonomous agent for quantum chemistry. arXiv preprint arXiv:2505.02484 (2025)

    2025 arXiv

  23. [31]

    https://arxiv.org/abs/2412.07978

    Cao, S., Zhang, Z., Alghadeer, M., Fasciati, S.D., Piscitelli, M., Bakr, M., Leek, P., Aspuru-Guzik, A.: Agents for self-driving laboratories applied to quantum computing (2025). https://arxiv.org/abs/2412.07978

    2025

  24. [32]

    In: ACM/IEEE Design Automation Conference (2025)

    Campbell, C., Chen, H.M., Luk, W., Fan, H.: Enhancing llm-based quantum code generation with multi-agent optimization and quantum error correction. In: ACM/IEEE Design Automation Conference (2025)

    2025

  25. [33]

    stdgates.inc

    Chen, M., Tworek, J., Jun, H., Yuan, Q., Pinto, H.P.D.O., Kaplan, J., Edwards, H., Burda, Y., Joseph, N., Brockman, G., et al.: Evaluating large language models trained on code. arXiv preprint arXiv:2107.03374 (2021) 13 7 Supplemental Material 7.1 Dynamic-few-shot Coder Exampl...

    2021 arXiv

Pith tools

Reviewed August 5, 2026 · model on record in the stance chip above.