Author: Jaap Kautz
Cloud access has made quantum processors easier to reach, but running a useful experiment still requires a significant amount of technical work.
A starting point for a quantum experiment can be a published protocol, a patent, a technical note, or simply a research idea that has not yet been translated into hardware terms. In all cases, it has to become something a quantum processor can execute. For neutral-atom systems, that means choosing an atom register, defining pulse parameters, checking hardware constraints, validating the sequence in simulation, submitting the job, and interpreting measurement data. Each step is well understood on its own. The difficulty is coordinating them consistently across physics, software, emulation, and cloud execution.
Pasqal’s agent skills are now available to help researchers carry out this work using AI-assisted coding environments. They support the steps between a scientific objective and a hardware experiment, from extracting an experiment specification and generating a Pulser sequence to emulation, QPU submission through Pasqal Cloud, and analysis.
The goal is to help researchers with the implementation work while keeping them responsible for the scientific decisions: what to test, how to validate the experiment, and what the results mean.
In this article, we explain how the workflow works and what a recent Pasqal research paper reveals about its capabilities and limitations.
Inside the agentic workflow
The agent skills can be installed as a plugin in a supported agentic coding environment, including Claude Code, Cursor, and Codex. They work with Pasqal’s existing software stack: Pulser for pulse-sequence design, emu-mps for emulation, and the Pasqal Cloud SDK for device access, calibration data, and QPU execution.
The input can be a well-defined experiment, for example:
“I want to know whether a square array of about 25 atoms orders antiferromagnetically when I ramp the detuning through the transition. Set it up so I can emulate it locally first.”
If the idea is less concrete, or is not an experiment at all, the agent works it out with the researcher:
“I have access to a neutral-atom machine and I would like to do an experiment on thermalization. I don’t know what to measure.”
Or, when the problem is not a physics problem:
“I have to choose the best configuration for a problem with 50 discrete variables. Could a neutral-atom machine do anything useful with that, and what would it cost me to find out?”
From there, the agentic workflow moves through a sequence of steps. For each step a dedicated skill is available. The agent selects the right skill on its own and guides the user through the following stages:
- Define an idea
The application-to-idea skill turns an application, a problem or a hunch into a technical idea for an experiment with a proposed algorithm.
- Turn the objective into an experiment specification
The idea-to-spec skill extracts all the relevant physical parameters, target observables, constraints, and hardware assumptions from this idea or from a paper. Its output is a structured file called experiment_spec.json.
- Review the specification before moving forward
The researcher can inspect, modify, or approve experiment_spec.json before the workflow continues. This step matters because the specification becomes the reference input for everything that follows.
- Generate the pulse sequence
The spec-to-sequence skill converts the specification into an executable Pulser sequence. For a neutral-atom experiment, this includes the atom register and the time-dependent laser controls.
- Validate before hardware execution
Before anything is submitted to a QPU, the candidate sequence is tested in emulation. The validate-emu and noise-emulate skills compare ideal behavior with simulations that include device-aware noise, helping estimate whether the target observable should remain visible under realistic conditions.
- Submit through Pasqal Cloud
If the protocol passes validation, the qpu-submit skill manages hardware execution through the Pasqal Cloud SDK. The workflow can also incorporate calibration information from the device’s current operating point.
EU-based researchers can also run their experiments free of charge on the Pasqal QPU hosted at TGCC–GENCI. The apply-genci-tgcc-cea skill guides them through the application process.
- Analyze the results
Once the QPU jobs are complete, harvest-and-analyze retrieves the measurement data and converts raw bitstrings into the observables defined in the specification. The results can then be compared with the noiseless prediction and the noise-aware emulation.
If the results suggest that the register, pulse schedule, or observable should be adjusted, the agent can update the specification and rerun the relevant stages.
Testing the workflow on real QPU experiments
The workflow was tested on three research cases, each designed to stress a different part of the process. The results were published in a paper published on arXiv earlier this year.
The first case takes a published experiment and asks whether it can be reproduced on Pasqal hardware. The second begins with a theory paper and asks whether it can be turned into a real QPU experiment. The third uses a patent as input and tests whether the described protocol can be implemented on a Pasqal QPU.
Together, the examples demonstrate what the agentic workflow can automate successfully and where expert review remains necessary.
Reproducing a published quantum experiment
The first case revisits a 2019 Rydberg-array experiment on density-wave ordering. The goal was to test whether the agentic workflow could extract a published protocol, adapt it to Pasqal hardware, and identify when the target regime was outside device constraints.
The researchers deliberately asked the agent to reproduce a phase they knew was not feasible on the target QPU. The agent correctly identified the hardware limitation, then redirected the implementation toward a feasible regime. From there, it generated the corresponding sequence, validated it in emulation, and supported execution on Pasqal QPUs.
The resulting density-density correlations reproduced the expected physical behavior. This first case highlights the workflow’s strength in feasibility checking and protocol-to-hardware translation.
Translating a theory proposal into a hardware experiment
The second case is more open-ended. It starts from a theory paper on frustrated quantum magnetism in a triangular Rydberg array, where the paper describes several phases of matter but does not provide a ready-to-run QPU implementation.
The agent compared the requirements of the proposed phases with the available hardware constraints and identified which regimes were feasible, marginal, or infeasible. It then helped generate experiments for the accessible regime.
The more interesting result was not that the workflow produced a runnable experiment, but where it failed. The agent initially selected observables that were straightforward to compute but insufficient to certify the target phase. The sequence generation and validation steps worked, and the resulting data looked plausible, but the scientific diagnostic was incomplete. A domain expert redirected the analysis toward the appropriate order parameter and finite-size scaling strategy.
This case makes one of the central points of the paper: execution success is not the same as scientific correctness.
Translating a patent into a complex hardware workflow
The third case starts from a Pasqal patent describing a Rydberg-based approach to graph coloring. Unlike the first two examples, this was not a single QPU submission: the algorithm required several rounds of execution, with each round depending on the previous results.
The agent translated the patent into a multi-round procedure, managed repeated QPU jobs, and benchmarked the output against a classical baseline. This tested whether the workflow could coordinate feedback and post-processing across several hardware runs, not just prepare one experiment.
It also exposed another limitation. When the agent saw an unexpectedly high number of invalid results, it initially attributed the issue to a hardware effect. Further inspection showed that the problem was actually a mismatch between atom positions and measured bitstrings – a workflow bug, not a QPU issue.
This example illustrates both the orchestration potential of the approach and the need to check the agent’s explanations when results look surprising.
From today’s hardware reach to future capabilities
The paper also reports a broader scan of theory papers on neutral-atom quantum computing. After search, deduplication, and filtering, 633 relevant papers were identified. A lighter agentic workflow then classified the 526 papers that could be reliably analyzed.
Of those 526 papers, 258 are assessed as implementable with publicly available Pasqal QPUs today, either directly or with modest adaptation. For the remaining papers, the main blockers are hardware capabilities that are not yet publicly available, especially the ability to implement different types of atom-atom interactions or to control individual atoms locally.
This analysis serves two complementary purposes. First, it estimates how much of today’s neutral-atom theory literature could already be brought to hardware using an agentic workflow. Second, it identifies which future hardware capabilities would unlock the largest share of the remaining literature. In that sense, the scan is not only a measure of current hardware reach, but also a way to connect scientific demand with future hardware development.
Lowering the implementation barrier
Cloud access makes quantum hardware reachable. The next challenge is helping researchers turn scientific objectives into experiments that use that hardware well.
Pasqal’s agent skills are now available to support that implementation work. The research examples show how an agentic workflow can coordinate protocol extraction, sequence generation, emulation, submission, and analysis. They also show why runnable code and plausible results are not enough: researchers still need to check that the experiment and its observables answer the intended scientific question.
Get started with the Neutral-Atom Agentic Toolkit
Have a published protocol to reproduce or a research idea to test on a neutral-atom QPU? Install the toolkit in your coding environment and follow the setup guide to run your first experiment.
For the experimental demonstrations and detailed analysis behind the workflow, read the full paper on arXiv: Lowering the implementation barrier of neutral-atom quantum computing with agentic workflows
