Turning Latency into an Advantage: Continuous Calibration for Neutral-Atom Quantum Computers
The long cycle times of neutral-atom systems are often viewed as a limitation. In practice, they may create an opportunity: enabling continuous calibration, real-time feedback and quantum-classical workflows that help sustain fault-tolerant operation over long computations.
Neutral-atom quantum computing has moved from being a promising platform to a credible path toward large-scale fault-tolerant quantum computation. Recent experiments have combined long coherence, arrays of thousands of trapped atoms, and early demonstrations of fault-tolerant primitives below threshold. At the same time, resource estimates suggest that cryptographically relevant applications such as Shor’s algorithm may be achievable with on the order of 10,000 reconfigurable atomic qubits rather than millions, provided the hardware can sustain the required control and error-correction performance.
The headlines rightly emphasize the qubit count. But for fault-tolerant quantum computing (FTQC), how long the machine must stay on its operating point while the algorithm runs matters just as much. Even optimistic resource estimates still require computations that last days, and in some cases much longer. That means the challenge is not only to build high-quality qubits, but to sustain transport, gates, measurement, and error correction over billions of repeated cycles.
At DAMOP 2026, we presented a control-stack view of this problem. Notably, the slow timescales of neutral atoms, often seen as a liability, are precisely what enable continuous in-line calibration in our setup, with OPX1000 and the OPNIC separating deterministic real-time control from computationally intensive classical inference.
From building qubits to running FTQC with neutral atoms
Fault-tolerant quantum computing works by encoding a logical qubit into many physical qubits and repeatedly measuring error syndromes to detect and correct faults before they accumulate. The computation is therefore not defined by a single gate sequence, but by a long sequence of gate, measurement, and classical decoding cycles that must all remain within an error budget. Many FTQC control assumptions emerged from superconducting architectures with fast stabilizer cycles and fixed local connectivity. Consequently, code designs often trade spatial overhead for time efficiency.
Neutral-atom systems operate under a different set of constraints. Their operation cycles are slower, often on the millisecond scale, but the register is dynamically reconfigurable. That flexibility allows for reducing gate overhead and changes how fault-tolerant execution should be optimized.
FTQC architectures for atoms are typically divided into several regions: a memory zone for storing quantum information, a processor zone for storing active computation, an operation zone for Pauli product measurements (PPMs), a resource zone for magic-state generation and a readout zone. Qubits are continuously transported between these regions, allowing for reconfigurability at the cost of transport and readout time.
In any error-corrected machine, a significant and addressable fraction of accumulated error traces back to slow drift. Because atom control is based on free-space optics, many addressable error sources come from instabilities in the laser and trapping fields. Intensity noise and jitter can cause motional heating, atom loss, and collisions during transport, while amplitude, phase, and detuning fluctuations in the gate-addressing beams produce coherent gate errors such as over-rotations and imperfect entanglement.
On the atom-readout side, any loss of fidelity propagates into logical error accumulation over computations as its outcomes feed directly into decoding and recovery. Small improvements in the fidelity of each of the steps translate exponentially into lower logical error rates. But the required control latency depends strongly on the qubit modality. Superconducting systems operate with stabilizer cycles of a few microseconds, whereas neutral-atom systems operate on the millisecond scale.
Real-time control for continuous calibration
Quantum Machines’ Orchestration Platform approaches this problem by splitting the calibration work between resources. The OPX1000 performs the deterministic real-time execution on the controller. This includes computing gates and transport waveforms on-the-fly, decision branching based on feedback, and lightweight real-time compute on a strict local clock.
A PID loop reduces the 200 kHz intensity-noise PSD component by ~10 dB, a factor of 3 in amplitude. Closing the loop with meaningful gain at 200 kHz requires fast feedback latency, which places the OPX1000 control bandwidth well above the disturbance.
The compute-heavy tasks, on the other hand, like image processing, state discrimination, optimization, learning, and decoding are offloaded to a CPU/GPU server. OPNIC returns the decoding results to the OPX in a time-deterministic way, with a latency of about 2 microseconds, updating parameters only at well-defined synchronization points. That separation is also what lets calibration run continuously across timescales. The fast feedback loops can live on the OPX1000 and are updated in each cycle, while the slower, compute-heavy ones run on the server.
For atoms, a noise-eater loop is a simple example. It measures gate-pulse fluctuations on a photodiode, sends that feedback to the OPX1000, which computes an error signal and emits a corrected pulse in real time. Figure X shows such a PID loop reducing the 200 kHz intensity-noise by 10 dB, improving gate fidelity. These routines are written directly in QUA, the Python-based pulse-level language that runs on the OPX1000.
But fast loops solve only part of the problem. A PID suppresses fast fluctuations around a fixed setpoint, but it cannot track slow drift or relocate a setpoint when it moves. Furthermore, many dominant drifts can be too fast for offline re-calibration but too complex for conventional noise-suppression loops. These effects gradually pull the system out of its calibrated regime, degrading fidelity, and increasing error rates.
Schematic showing the OPX1000 and the Open Acceleration Stack (via OPNIC interconnect) for fast, mid-circuit calibration algorithms and QEC.
This motivates a second layer of continuous, program-integrated calibration based on reinforcement learning. Since programs run for days, the system must keep adapting as computation proceeds. In practice, it works as follows: a parameterized quantum circuit — for example, GHZ-state preparation — runs on the controller while a reinforcement-learning agent executes on the server side. The agent proposes updated pulse amplitudes and phases, receives fidelity-derived rewards from measurement outcomes, and iteratively steers the system back toward optimal performance as the hardware drifts.
Such loops usually run at synchronization points between cycles. In atoms, the transport and readout inside each cycle open a gate-free window, leaving ample time for intra-cycle inference and calibration.
Being slow is an advantage
For neutral atoms, operations span widely separated timescales. The gates are sub-microsecond, whereas transport and readout are hundreds of microseconds to milliseconds. While atoms are in transit, no gates are applied, so the logical state is not undergoing active gate evolution.
Decoding relative to the QEC cycle. In superconducting hardware, the decode latency (amber) exceeds the 1 µs stabilizer cycle (blue), so a single round’s decode happens across several cycles and runs off the critical path, tracked in the Pauli frame until a non-Clifford gate forces it to resolve. In neutral atoms, the 1 ms cycle, dominated by transport and readout, is long enough to house the same decode within a single cycle. Panels are not drawn to the same time scale.
That idle time, which makes neutral atoms slow, can now be used as inference time. Every transport and readout opens a window to update and push new parameters at no coherence cost. This means that the calibration routines now run inside the cycle and not as a separate offline step inserted between cycles. A deep circuit then decomposes naturally into slices, each defined by a transport step. Inside a slice, gates fire on the deterministic clock. Between slices, during transport, the system senses context and updates parameters.
The agent does not track a single parameter but rather the full execution context, including the preceding gate and transport layers, the optical intensity distribution, the transport history and its distortions, the global field offsets, the geometry within the array. The QEC decoder draws the same context and can apply a noise-aware view of the machine into its logical inference.
Architectures that achieve cryptographically relevant scale with roughly 10,000 qubits typically rely on high-rate codes: dense, non-locally connected codes that pack many logical qubits into a single block. That density is where the qubit savings come from, and where the control burden lands. Every stabilizer round transports ancilla atoms across the block, involving far more motion than a surface code, and far more chances for a transport error. The logic runs through mid-circuit measurement, so readout and decoding sit on the critical path. The demands of these codes call for the feedback loops we just described. This requires sustained transport fidelity across dense schedules over periods of days, readout and decoding within the cycle time, and continuous calibration.
At DAMOP, we showed the individual moving parts: PID loops eating fast noise in gates, RL algorithms that enable GHZ-state preparation, a readout that closes the loop in under 500 µs, and a range of transport solutions. The next step is to bring them together in a fault-tolerant environment. And who knows, your atomic QPU might be the one to demonstrate it. If you are working on neutral atom systems and want to see this in action, request a demo.
References:
[1] Cain, M., Xu, Q., King, R., Picard, L., Levine H., Endres, M., Preskill, J., Huang, H Y., and Bluvstein, D. “Shor’s algorithm is possible with as few as 10,000 reconfigurable atomic qubits,” arXiv:2603.28627 (2026).
[2] Bluvstein, D., Geim, A.A., Li, S.H. et al. A fault-tolerant neutral-atom architecture for universal quantum computation. Nature 649, 39–46 (2026).
