Quantum Computing Paradigms: Ion Trap and Neutral Atom MBQC

(For other quantum computing paradigms and architectures, see Taxonomy of Quantum Computing: Paradigms & Architectures)

What It Is

Measurement-Based Quantum Computing (MBQC) – often called the one-way quantum computer – is a model of quantum computation where a pre-prepared entangled resource state is consumed by sequential measurements to perform a computation​. Instead of applying a series of unitary logic gates as in the traditional circuit model, MBQC begins by creating a highly entangled cluster state (a specific multi-qubit entangled state, usually a lattice or graph of qubits)​. Computation proceeds by performing single-qubit measurements on the cluster; these measurements (in chosen bases) drive the quantum logic, with the entanglement causing the measurement outcomes to enact effective gate operations on the remaining unmeasured qubits​. Importantly, the order and basis of later measurements can depend on the results of earlier ones (a process called feed-forward), ensuring that despite the inherent randomness of quantum measurement, the overall computation yields a deterministic result​​. The cluster state is “used up” by these measurements – hence one-way, since qubits cannot be reused after measurement​.

Ion Trap and Neutral Atom implementations of MBQC leverage two leading “matter-qubit” platforms – trapped ions and ultracold neutral atoms – to realize this model. In a trapped-ion MBQC, a string of ions (charged atoms) is confined and entangled via electromagnetic fields and laser pulses. The ions’ internal states serve as qubits that can be entangled pairwise or globally using multi-ion gate operations, preparing a cluster state. The computation then unfolds by measuring individual ions’ states one by one with lasers and collecting fluorescence, with each measurement’s basis and timing chosen according to previous outcomes​. In a neutral-atom MBQC, arrays of neutral atoms (often arranged in optical lattices or optical tweezer arrays) are entangled through controlled interactions like the Rydberg blockade (a mechanism where excited atoms prevent excitation of neighbors)​. Once a 1D or 2D entangled atomic array is prepared, single atoms are measured (for example, by imaging their fluorescence or state-selective removal from the trap) to drive the computation. The key difference from gate-based operation is that after the entangled state is generated, the only operations are measurements – there are no further multi-qubit gates during the computation​​. This paradigm can be especially natural in systems where measurements are easier to perform continuously than maintaining long sequences of coherent gates (notably in photonic systems, which historically motivated MBQC​).

In summary, MBQC in ion traps and neutral atoms replaces explicit gate-by-gate manipulation with an initial entangling phase followed by a measurement-driven “computation by collapse.” This contrasts with the traditional circuit model where qubits are manipulated by unitary gates and only measured at the end. In MBQC, measurements are an integral part of the computational process rather than just a final readout​​. The entangled cluster state serves as a substrate for calculations, and the pattern of measurements (including adaptively chosen bases based on prior results) encodes the quantum algorithm​. Ion traps and neutral atoms provide a way to physically realize these cluster states and controlled measurements with high fidelity.

Key Academic Papers

Research in MBQC, and specifically its realization in ion traps and neutral atoms, has been guided by several foundational papers:

• Raussendorf & Briegel (2001) – “One-Way Quantum Computer”: This seminal paper introduced the MBQC model. It proposed that a large entangled cluster state could serve as a universal resource for quantum computing, with computation proceeding via only single-qubit measurements. It proved that any quantum circuit can be implemented by measurements on a suitably prepared cluster state, establishing MBQC’s universality and launching the field.
• Walther et al. (2005) – “Experimental One-Way Quantum Computing“: This was among the first experimental demonstrations of one-way quantum computing, albeit in a photonic system. Walther’s team created a small cluster state of four entangled photons and used it to implement a simple quantum algorithm (Deutsch’s algorithm) via successive measurements​. It showed the feasibility of MBQC in practice and underscored the model’s potential, especially for systems like photons where entangling gates are challenging but measurements are relatively easy.
• Lanyon et al. (2013) – “Measurement-Based Quantum Computation with Trapped Ions”: This paper reported the first realization of MBQC in a trapped-ion platform​. Using up to 7 trapped calcium ions, the authors deterministically generated small cluster states and performed a universal set of measurements to enact basic quantum logic operations​. Notably, they demonstrated a simple quantum error-correcting code within the MBQC framework, showing error-corrected computation on the cluster state​. This experiment validated that matter-based qubits (not just photons) can perform MBQC, and that one-way computing is achievable in high-fidelity ion systems.
• Multiple – Alongside the MBQC concept, early proposals suggested that neutral atoms in optical lattices could be entangled via cold collisions or Rydberg blockade to create cluster states​. Although not a single paper, a series of theoretical works (e.g. D. Jaksch et al., 2000 on Rydberg gates, and Lukin et al., 2001) laid the groundwork for neutral-atom MBQC by outlining how to generate entangling Controlled-Z gates across an array of atoms​. These ideas indicated that a 2D cluster state of neutral atoms could be built as a resource for one-way quantum computing, inspiring experimental efforts in that direction.
• Weiss & Saffman (2017) – “Quantum computing with neutral atoms”: This overview (by two pioneers of neutral-atom QC) summarized the state of neutral atom qubit technology and noted the appeal of measurement-based schemes. It discussed how large grids of atoms can serve as qubits and mentioned that “the measurement-based approach offers a potential alternative” to circuit-model computing in these systems​. While not introducing new experimental data, this article contextualized MBQC as an important paradigm for neutral atoms and highlighted key advances needed (such as single-site measurement and high-fidelity entanglement) to make one-way computing viable in atomic arrays.
• Topological MBQC (Raussendorf et al. 2007; Fowler et al. 2009) – These theoretical works introduced fault-tolerant quantum computing schemes within the MBQC framework, using 2D or 3D cluster states to implement error-correcting codes​. For example, Raussendorf et al. (2007) described how a 3D cluster state can be used for topologically protected quantum computing (a la surface codes). While hardware-agnostic, such papers have influenced ion/atom experiments by providing a roadmap for how MBQC could eventually incorporate error correction at scale. Lanyon’s trapped-ion demonstration of a “measurement-based quantum error correction code”​ was a direct descendant of these ideas, translating theory into practice on a small scale.
• Ringbauer et al. (2024) – “Verifiable measurement-based quantum random sampling with trapped ions“: This recent work pushed the scale of MBQC in ion traps further. The team generated random 16-qubit cluster states on a trapped-ion processor and performed a quantum sampling task, demonstrating a form of quantum advantage test in the MBQC model​. By recycling physical ion qubits to emulate a larger entangled cluster, they showed that one can go beyond the physical register size while still operating in the one-way model​. This experiment is influential as it merges MBQC with contemporary quantum benchmarking (random circuit sampling), indicating that MBQC can be competitive with circuit-based approaches for demonstrating complex computations.

Each of these works has shaped the field: from the initial concept and photonic proof-of-principle, to matter-based implementations in ions, to proposals and progress in neutral atoms, and toward scalable and fault-tolerant one-way computing. Together, they chart the evolution of MBQC from theory to experimental reality across different hardware.

How It Works

Mechanics of MBQC in Ion Traps

In a trapped-ion implementation, the process begins by preparing a set of $N$ ions in an entangled graph state (typically a cluster state). Trapped ions offer all-to-all connectivity via their shared motional modes, so entanglement can be generated between arbitrary pairs of ions using gates like the Mølmer–Sørensen interaction​​. For example, if one wants a linear cluster state of 4 ions, one can apply a series of two-qubit entangling gates to “link” ion 1 with 2, 2 with 3, and 3 with 4 (each gate effectively creates an entangled bond between qubits). More complex cluster geometries (like 2D lattices) can be created by executing a pattern of entangling operations corresponding to the edges of the cluster’s graph structure. In the Innsbruck experiment​, up to 7 ions were entangled to form small clusters or graph states using high-fidelity laser gate operations.

Once the entangled state is ready, the computation phase consists of single-ion measurements. Each ion is measured in a specific basis (not always the standard $Z$ basis; often a qubit is measured in a rotated basis like $X$ or an arbitrary angle basis in the equatorial plane of the Bloch sphere). The choice of basis for each measurement corresponds to the quantum gate one wishes to enact on the remaining unmeasured qubits. For instance, measuring an ion in the $X$-basis (i.e. projecting onto $|+\rangle/|-\rangle$ states) can effect a Hadamard or identity operation on its neighbor, whereas measuring in an angled basis $|0\pm e^{i\phi}1\rangle$ can impart a specific single-qubit rotation on the connected qubit – this is how one “implements” a single-qubit rotation via MBQC​. Two-qubit gates (like controlled-$Z$ or controlled-$X$ between logical qubits) are achieved by preparing multiple entangled links and then measuring intermediate qubits in a way that entangles the logical qubits. In practice, a small set of measurement patterns constitutes a universal gate set for MBQC (e.g., certain sequences realize an effective CNOT, others realize arbitrary rotations)​.

A critical aspect is that measurements are adaptive. Because each individual measurement yields a random outcome (0 or 1), one must adjust future measurements to correct for these randomness-induced byproduct operations. This is done via classical feed-forward: after measuring one ion, the controller uses that classical result to decide the basis for the next ion’s measurement​. For example, if the outcome was “1” (which might correspond to an extra undesired $\pi$ phase on the neighboring qubit), the basis of a subsequent measurement can be rotated to account for that phase​. By the end of the sequence, the net effect is a deterministic quantum algorithm, with all randomness accounted for by these conditional adjustments. In trapped ions, this means the system must be able to measure one ion while keeping the others coherent, then quickly (within the coherence time of the remaining entangled state) update laser parameters for the next measurement. Lanyon et al. indeed implemented such adaptive steps, showing that different measurement sequences on their 7-ion cluster could realize a universal set of logic gates and even correct certain errors on the fly​.

Mechanics in Neutral Atom Systems

Neutral atom MBQC follows a similar logic but with different physical operations. Initially, one needs to entangle a large array of neutral atoms (often arranged in a 2D grid, which naturally suits cluster state geometry). A leading method is to use the Rydberg blockade to perform multi-qubit entangling operations. In this approach, atoms are excited to high-energy Rydberg states where they interact strongly with nearby atoms. By shining carefully timed laser pulses on atom pairs (or even globally on the whole array with selective resonance conditions), one can induce controlled-phase entanglement between adjacent atoms​. For instance, a sequence of laser pulses can entangle each atom with its right-hand neighbor in parallel across a whole row, creating an entangled chain. Then a similar sequence can entangle each atom with its neighbor in the vertical direction, yielding a 2D cluster state. Proposals have shown that a Rydberg-mediated controlled-$Z$ gate can be done in a single step for an entire array, essentially “writing” a cluster state directly onto a 2D lattice of atoms​. While fully parallel entanglement of a large array is experimentally challenging, recent experiments have achieved entanglement on subsets (like parallel entangling gates on multiple atom pairs simultaneously)​, paving the way toward scaling up entangled neutral-atom networks.

After entanglement, the measurement phase in neutral atoms requires measuring individual atoms’ qubit states. Neutral atom qubits are often two hyperfine states of an atom (analogs of $|0\rangle$ and $|1\rangle$). One common readout is fluorescence imaging: a resonant laser causes atoms in state $|1\rangle$ to fluoresce (appear bright) while atoms in $|0\rangle$ remain dark​. By taking a picture (or using a photodetector), one can determine each atom’s state with high accuracy​. In MBQC, however, measurements must be done sequentially and adaptively, not all at once as in a final readout. This means one must measure a single atom (or a subset) while leaving the rest unmeasured and still quantum-coherent. Until recently, measuring an atom typically meant that atom was removed or its state disturbed in a way that could decohere neighbors (for example, scattered photons could strike nearby atoms). Neutral atom researchers have addressed this by techniques like site-selective readout – for instance, using focused beams or electric field gradients to shift one atom’s energy levels so that only it responds to a detection laser​. A 2023 demonstration by Graham et al. showed mid-circuit measurements in a 48-atom array without perturbing the remaining atoms​​. They measured one subset of atoms and confirmed the others retained 97% of their quantum state fidelity​. This capability is exactly what MBQC needs: one can measure a chosen atom, get a result, and then conditionally adjust the basis for measuring another atom elsewhere in the array.

Thus, in a neutral-atom MBQC, one would: entangle the whole array into a cluster state; perform a projective measurement on one atom (e.g. rotate its basis with microwaves and then detect fluorescence); immediately use that outcome to set the rotation angle for the next atom’s measurement; and continue this process step by step. At the end, some subset of atoms (often the last ones unmeasured in each cluster “row”) hold the output quantum state, which can then be read out in the computational basis. In practice, most atoms get measured during the computation, so what remains at the end is just a set of classical results (which collectively represent the output of the algorithm). The adaptive measurement pattern might, for example, implement a quantum circuit for solving a small problem or correcting an error. Notably, MBQC can implement feed-forward correction inherently through the measurement sequence, whereas in a gate model feed-forward might require stopping computation to apply classically controlled operations. In the one-way model, the only quantum operations are measurements, so classical decision logic simply determines how to measure next – a conceptually simpler feedback loop.

How measurements drive computation

The power of MBQC comes from the combination of entanglement and measurement choices. Entanglement in the cluster state provides contextual correlations such that measuring one qubit influences the state of its neighbors. If qubit A and B are entangled and we measure A in a certain basis, the result “collapses” A and also projects B’s state in a way equivalent to having applied a gate on B​. For example, measuring an entangled qubit in the $X$ basis essentially teleports the quantum information to its neighbor with a Pauli-$X$ or $Z$ gate applied depending on the outcome​. By choosing the right basis for each measurement, one orchestrates a sequence of teleported gates. The randomness of each measurement outcome is countered by real-time adjustments (if outcome = 1, you know an extra $Z$ happened on the neighbor, so you adjust the next measurement by a phase to cancel it)​. In essence, the cluster state plus adaptive measurements equals a quantum circuit.

To give a concrete mini-example: imagine a simple two-qubit algorithm that applies a CNOT gate and measures both qubits. In MBQC, one could start with a linear cluster of three qubits (1–2–3 entangled in a line). Qubits 1 and 2 will represent the control and target at the end, and qubit 2 initially entangles with qubit 3. By measuring the middle qubit (2) in a certain basis, you effectively induce a CNOT between qubits 1 and 3 (with qubit 3 taking the role of the original target). Then measuring qubit 1 and 3 in the $Z$ basis yields the output. The measurement of qubit 2 “drove” the logic operation (CNOT) between the end qubits. This kind of procedure, generalized to many qubits and bases, is how MBQC executes algorithms. The outcome dependence means that the classical control system is part of the loop: after each measurement, a classical compute step decides the next measurement’s basis – but since these classical computations are simple (bit flips, deciding between two angles, etc.), they don’t bog down the quantum computation as long as they’re fast relative to decoherence.

In summary, MBQC on ion traps and neutral atoms works by: (1) entangling a set of ions/atoms into a cluster state using the natural two-qubit interactions of the platform (laser-mediated spin-spin coupling for ions, Rydberg or collisional interactions for atoms)​; (2) performing a sequence of single-qubit measurements, each chosen to enact part of the quantum algorithm on the remaining qubits​; and (3) using the measurement outcomes to adapt subsequent operations, thereby “steering” the computation to the correct result despite quantum randomness. All qubits except possibly a few outputs are measured by the end – the entangled resource is fully consumed to yield the final answer. This one-way approach has been experimentally verified on a small scale in ions (with explicit gate sets reproduced and error correction demonstrated)​​, and the essential ingredients (large entangled states and mid-circuit measurement) have been shown in neutral atom platforms, setting the stage for full MBQC in those systems​.

Comparison to Other Paradigms

Vs. Gate-Based (Circuit) Quantum Computing: MBQC is computationally equivalent to the standard gate model – anything a circuit-based quantum computer can do, an MBQC machine can also do (and vice versa). The primary difference lies in when and how operations occur. In the gate model, unitary gates are applied in sequence and qubits are measured only at the end (or sometimes mid-circuit for conditional branching). In MBQC, entanglement is front-loaded (prepared initially) and the “operations” are implicit in the choice of measurements. One way to see the relationship: designing a MBQC procedure usually starts by taking a circuit and mapping it to a pattern of measurements on a cluster state. Thus, MBQC doesn’t reduce the number of fundamental operations; it just performs them in a different form. For example, a CNOT gate in the circuit model might correspond to preparing a 3-qubit chain and measuring the middle qubit in MBQC – either way, one needs multi-qubit interaction (entanglement) and some single-qubit actions​. The computational power is the same – both models are universal for quantum computation.

In terms of efficiency, MBQC can sometimes offer advantages in parallelism. Since the entire cluster state is entangled at the start, many qubit interactions are “ready” and do not have to be applied sequentially as gates. Certain circuits can be executed with very low depth in MBQC – for instance, any Clifford circuit (which in the gate model might have multiple time steps) can in principle be done in one round of measurements on a suitably prepared state​. This is because the entanglement can be consumed in a single layer, effectively performing many gates at once. In contrast, a hardware that does gates one by one might need multiple sequential steps. However, preparing the cluster state itself may take multiple gate operations, so the advantage is not absolute. It often shifts the burden: a depth-$d$ circuit might require a cluster state that took depth $d$ to prepare via entangling gates. In a best-case scenario, if one had the ability to entangle many qubits simultaneously (as some proposals for neutral atoms suggest​), one could generate a large cluster in constant time and then carry out a computation with a series of measurements that is also in constant depth (just one qubit after another, or even some in parallel if they don’t depend on each other’s outcomes). This kind of extreme parallelism is not yet realized but is conceptually possible in MBQC.

From a practical feasibility standpoint, the gate model has been more natural for many platforms. Trapped ions and superconducting qubits, for example, have well-developed gate operations and typically perform algorithms by compiling to gates. MBQC requires the extra capability of quick, adaptive measurement. In ion traps and neutral atoms, performing mid-computation measurements without disrupting other qubits was a significant challenge that had to be addressed by engineering solutions​. Gate-based computation doesn’t require that – it can keep everything coherent until the end. So historically, gate model implementations progressed faster in matter qubits. MBQC, on the other hand, offers an alternative route that can simplify certain tasks like error correction. For instance, many quantum error correcting codes involve frequent parity measurements of qubits; in the gate model these are done by ancillary qubits and multi-qubit gates, whereas in MBQC they can be done by measuring qubits that are part of a cluster encoding the code. Lanyon et al. showed that a bit-flip code could be implemented by a sequence of measurements on a graph state in the ion trap, with errors detected and corrected by feed-forward within the one-way model​. In a circuit model, this would have required multiple controlled-NOT gates and resets. Thus, MBQC can embed certain complex circuits (like those for error syndrome extraction or certain oracle queries) into a streamlined measurement sequence.

Compared to analog/adiabatic quantum computing, MBQC is a digital, discrete model – more akin to the gate model in spirit. Adiabatic quantum computing or quantum annealing uses gradual Hamiltonian evolutions rather than discrete operations. MBQC doesn’t have a direct analog in that world; it’s firmly in the category of quantum logic implementation. However, one might compare MBQC to teleportation-based quantum computing, which is another model that uses entangled states and measurements to enact gates. MBQC can actually be viewed as a large network of teleportation operations: each measurement “teleports” a quantum state across the cluster with a gate applied. Gate-based computing can sometimes use teleportation too (for fault-tolerance or distributed computing), but MBQC uses it as the central mechanism for all computations.

Ion Trap MBQC vs Ion Trap Gate Model: In an ion trap specifically, the circuit model has seen more use (e.g. IonQ and Quantinuum machines operate by applying laser pulses as gates). Ion traps have the advantage of long-lived qubits and high-fidelity gates​​, and they also feature all-to-all connectivity​, which means even the gate model doesn’t suffer much from connectivity constraints. So, an ion trap cluster state can be prepared by the same gates that would run a circuit; it might require a similar number of gate operations as the circuit itself. The benefit of MBQC in ions might be more about flexibility – once a cluster is prepared, one can perform many different algorithms on it just by choosing different measurement patterns, potentially even adaptively switching algorithms if something is detected (like an error). Another subtle benefit is that measurement outcomes are available immediately in MBQC (since measurement is the computation). In gate-based runs, one might defer measurements to the end and only know the results after the full sequence. In MBQC, because measurement is continuous, one could incorporate real-time classical computation in between steps. This is useful for interactive protocols (like adaptive algorithms or certain verification tasks).

Neutral Atom MBQC vs Gate Model: Neutral atom quantum computers in the gate model have some limitations: typically interactions are local (neighboring atoms) and two-qubit gates, while now high-fidelity​, can still be slower and less reliable than single-qubit gates. MBQC could leverage the ability to entangle many atoms in parallel, as mentioned, to reduce the number of sequential operations. For example, instead of performing hundreds of two-qubit gates one after another, a neutral atom system might use a few global Rydberg pulses to entangle the whole array, and then only do measurements (which can also potentially be done in parallel on different regions if their operations commute or don’t depend on each other’s outcomes). In principle, this could shorten the required coherence time because the “active” quantum operations happen in just a couple of big bursts (entangle, then measure measure measure rapidly). The trade-off is that measurement precision and control have to be extremely good, and any missed measurement or error could ruin the computation just as a bad gate would.

In terms of computational power and complexity, MBQC and circuit model are the same (both can achieve BQP, the class of problems quantum computers solve efficiently). There is no known asymptotic difference in the number of operations needed – a gate sequence of length $L$ can be translated to an MBQC pattern of $L$ (or O($L$)) measurements on a cluster of size $L$ (plus input/output qubits)​. Practically, though, certain operations might be easier or harder. For instance, mid-circuit reset (reusing a qubit after measuring it) is a non-trivial operation in circuits but in MBQC, qubits are naturally one-time-use and new effective qubits can emerge at the other end of the cluster. Conversely, an arbitrary two-qubit gate far apart in a circuit is straightforward in an ion trap (since any two ions can interact directly), but in MBQC on a 2D cluster it might require a path of entanglements linking those qubits. That said, ion traps could create a “non-local” cluster that directly entangles distant qubits, bypassing that issue. Neutral atoms are usually arranged geometrically, so their cluster states will likely also be geometric (e.g. nearest-neighbor entanglement forming a grid). This mirrors a local gate model, whereas ion traps can realize non-local gates easily.

Comparison to Photonic MBQC: It’s worth noting that MBQC gained fame through photonic implementations because photons are hard to interact (making circuits hard) but easy to measure. Ion and atom platforms are the opposite: interactions are available (making gates natural), and measurements during computation were, until recently, harder (because you typically destroyed the qubit). Now that ion/atom experiments have enabled mid-run measurements​, MBQC is becoming as feasible for matter qubits as it has been for light. Photonic MBQC also often uses probabilistic entangling operations to build cluster states (leading to resource overheads), whereas ion/atom entanglement is usually deterministic. This means ion/atom MBQC could create cluster states on-demand without the huge overhead that photonic approaches need to get high success probability​. In that sense, matter-based MBQC might ultimately be more resource-efficient for large computations if it can be scaled, combining the best of both worlds: deterministic entanglement (like circuit models) and flexible measurement-driven logic (like photonic MBQC).

In summary, MBQC with ions/atoms offers a different toolset but achieves the same results as gate-based quantum computing. It may require more qubits (because you need a whole entangled cluster from the start, which might include sacrificial qubits that don’t exist as independent logical qubits in a circuit model), but it potentially simplifies the sequencing of operations. Both paradigms require high-fidelity control; MBQC shifts some of that demand to high-fidelity measurements and the ability to maintain entanglement while doing them. From a feasibility standpoint, today’s small quantum computers (ions, superconductors, neutral atoms) predominantly use the gate model, but MBQC has been proven on those same devices in principle​. As systems grow, a hybrid approach could emerge: for example, an ion trap might use a gate-model quantum computer to generate a large cluster state (using its entangling gates), then switch to MBQC mode to carry out a computation with many adaptive measurements. Ultimately, whichever approach yields lower error rates and overhead for a given task will be chosen – MBQC is an alternative execution model that any capable gate-model hardware can emulate (and vice versa, one can simulate gates via MBQC measurements). It’s likely that both will coexist, with MBQC being especially useful for certain frameworks like quantum error correction or secure delegated computing, and gate model for direct algorithm implementations, until one proves definitively more practical at scale.

Current Development Status

Academic Progress: Measurement-based quantum computing in ion traps and neutral atoms is transitioning from proof-of-concept to more advanced demonstrations. In the trapped-ion world, after the landmark 2013 experiment in Innsbruck​, researchers have been steadily scaling up and refining MBQC techniques. In 2023, Ringbauer et al. (Innsbruck group) used a 10-ion trap to create and manipulate 16-qubit cluster states (by reusing ions) for a quantum random sampling task​. This experiment, published in 2024, showed that verifiable quantum advantage protocols can be run in the MBQC model on ion hardware​​. It effectively combined contemporary quantum computing benchmarks with the one-way model, indicating that MBQC is not just a theorist’s playground but can leverage the full power of today’s best ion processors. On the other side of the Atlantic, an Oxford ion trap group demonstrated blind quantum computing protocols on a small ion trap network – entangling ions with photonic links to create cluster states that enable a form of secure, cloud-based MBQC where the server (ion trap) doesn’t learn the client’s algorithm. In a 2024 PRL, Drmota et al. showed blind and verifiable MBQC between trapped ions and photons, effectively combining trapped-ion robustness with photonic communication​. These advances illustrate a trend: ion traps are being used to explore networked and scalable MBQC (via photonic links and qubit recycling), as well as secure MBQC protocols.

Neutral-atom MBQC has seen progress mainly in achieving the necessary components. Neutral atom arrays have exploded in size and capability in the last few years. For instance, Harvard/MIT (Lukin, Vuletić, Greiner and colleagues) demonstrated control of 256-atom Rydberg arrays for quantum simulation tasks in 2021, and by 2019 they had shown two-qubit gate fidelities around 97% on small subsets​​. A 2019 experiment by Levine et al. at Harvard showcased parallel entangling gates on multiple atoms, reaching fidelities that “rival the highest-performing competitors” (superconducting qubits and ions)​. In that work, they entangled clusters of 2–3 rubidium atoms in optical tweezers with ~97–98% fidelity and noted no fundamental barriers to scaling to 2D arrays of dozens or hundreds of atoms​​. This was a gate-model experiment, but it essentially demonstrated the ability to create graph states in a neutral atom system. Around the same time, another team (in Paris, affiliated with Pasqal) entangled 6–8 atoms in a 2D array and performed simple algorithms.

The biggest recent stride for MBQC specifically was the mid-circuit measurement achievement by the University of Wisconsin group (Graham et al., PRX 2023)​. They performed single-site measurements in a 48-atom optical tweezer array and showed those atoms could be measured (and even removed) without destroying the quantum coherence of the rest​. This is precisely what’s needed for one-way computing on neutral atoms: the ability to measure qubits one by one while the rest remain entangled. With this capability demonstrated, performing a full MBQC algorithm on a neutral atom array is now within reach. We are likely to see a small-scale neutral atom MBQC demonstration (maybe a few qubits cluster running a simple logic gate sequence) in the next couple of years, as groups integrate this measurement technique with entangled state preparation.

Industry and Key Players: Both ion traps and neutral atoms feature prominently in the quantum computing industry, though most commercial efforts have so far used the circuit model. In trapped ions, Quantinuum (formed by Honeywell Quantum and Cambridge Quantum) and IonQ are the two leaders. Quantinuum’s H1 machine has 20 qubits and H2 aims for 32+ fully connected qubits, and they have a roadmap to modular systems (e.g. two 32-ion traps connected by photonic links to make 64 qubits)​. IonQ has reported “algorithmic Qubit” (#AQ) measures in the 20s and plans a 64-qubit system by 2025 by using 4 chains of 16 ions each, optically connected​. These companies have not explicitly advertised MBQC usage – they expose a gate-based interface to programmers – but the hardware could support MBQC. IonQ’s systems already perform measurement and re-cooling of ions at the end of a run; with additional laser routing they could do mid-run measurement and feed-forward. Quantinuum has demonstrated mid-circuit measurement for error correction on their H1 (circuit model context). Thus, the industrial ion-trap devices are essentially MBQC-ready if and when the software layer decides to use that model.

On the neutral atom side, there are several startups: Pasqal (France) offers devices with 100+ atom arrays, currently used in an analog mode or for digital quantum simulation; QuEra (USA) has a 256-atom analog quantum simulator (built from Harvard’s tech) and is developing digital gate capabilities; ColdQuanta/Infleqtion (USA) works on smaller arrays (dozens of atoms) with an emphasis on integrating photonics and microwave control; Atom Computing (USA) is another entrant using optically trapped atoms (recently they’ve used Rydberg states of strontium) and they announced a 100-atom prototype. These companies are at various stages of delivering hardware via the cloud. Pasqal, for instance, is making its neutral atom processor available on Microsoft’s Azure Quantum cloud. Currently, users interact via circuits or analog Hamiltonians (e.g. you can program sequences of laser pulses). None publicly offer a “provide measurement pattern for MBQC” interface yet. However, Pasqal’s team wrote in 2020 about the intrinsic scalability of their approach “in the 100–1,000 qubits range”​, and they discuss prospects for universal fault-tolerant quantum computing in their roadmap​. This hints that they have their eye on full computational models like MBQC once the basic gate fidelities and control technologies (like mid-circuit measure) mature. Indeed, Pasqal’s co-founders and researchers have backgrounds in cluster state generation proposals​, so the concept is certainly known in those circles.

Academic labs remain key players in pushing the frontier for these implementations: the Innsbruck ion trap group (Blatt, Monroe – now at Duke/IONQ – and others) and Oxford ion group (Lucas, et al.) for trapped ions, and the Paris (Browaeys, Lahaye) and Wisconsin/Maryland (Saffman) groups for neutral atoms, among others. Government and large collaborations are also underway: the EU’s AQTION and MQUT projects for ion traps, and Quantum Flagship programs focusing on neutral-atom scalability. The US Department of Energy and Department of Defense have funded neutral atom quantum computing research (e.g. through ARL and IARPA programs), accelerating progress in that area.

In terms of capability as of 2025: Trapped-ion processors have achieved ~50 physical qubits (Quantinuum’s latest, though typically only 20 are fully utilized with error correction overhead) with very high gate fidelity (>99.5%) and are beginning to implement error correction and mid-circuit operations routinely​. Neutral atom processors have achieved >200 qubits in analog mode, ~50 in partial-prototype digital mode, with two-qubit gate fidelities now creeping into the 99% range in best cases​​, and single-qubit control and measurement at >99% fidelity. Both platforms are on cloud access (IonQ via AWS/Azure, Quantinuum via AWS/Azure, Pasqal soon via Azure, QuEra via Amazon Braket for analog tasks). While MBQC is not the typical user-facing mode, the research developments suggest that in the next generation of experiments, one could see a cloud-based MBQC service where a user uploads an MBQC measurement pattern instead of a circuit. This might happen first in a research setting (for example, a demonstration of blind quantum computing for a remote user on an Oxford ion trap, as a showcase of quantum cloud security).

The bottom line: Ion trap MBQC has been experimentally validated on up to ~16-qubit entangled states​, and the hardware is steadily improving. Neutral atom MBQC is on the cusp – all ingredients are in place (large entangled states and now single-site measurements​), so a full demonstration is expected soon. Companies in both sectors are supporting the necessary technologies as they scale up their machines. It’s an exciting era where MBQC, once a purely theoretical alternative model, is becoming an operational mode on some of the world’s most advanced quantum processors.

Advantages

MBQC in ion traps and neutral atoms offers several notable advantages:

• Natural Support for Adaptive Algorithms and Error Correction: Because measurement is built-in to the computational process, MBQC can handle adaptive algorithms (where later operations depend on earlier outcomes) seamlessly. In the circuit model, doing an adaptive step means inserting measurement and feed-forward operations explicitly, which can be cumbersome. In MBQC, this adaptivity is the default – the one-way computer inherently does a measurement, applies a classical bit-flip based on it, then continues. This is advantageous for quantum error correction and fault tolerance. For example, MBQC provides an elegant way to implement error-correcting codes by measuring redundantly encoded qubits in a cluster: syndrome extraction is just part of the measurement pattern​. The 2013 ion-trap experiment showed improved error rates by using a measurement-based repetition code​, indicating that even small clusters can detect/correct errors in real time. Many proposals for fault-tolerant quantum computing use MBQC on 3D cluster states (topological cluster states) to achieve high error thresholds​ – a scheme very compatible with ion and atom platforms that can produce 2D/3D entanglement.
• High Connectivity and Flexibility (Ion Traps): Trapped ions have inherent all-to-all connectivity (any ion can be entangled with any other)​. This means one can prepare arbitrary graph states rather than being limited by a geometric layout. An ion trap MBQC computer could create cluster states with long-range links or non-regular graphs tailored to particular algorithms. That offers flexibility to optimize the entangled resource for a given computation (e.g. one could entangle an ion with a distant partner if needed for a shortcut in the measurement pattern). While gate-model ion computers also enjoy all-to-all gates, using that connectivity to build a cluster allows those entangling operations to be parallelized or pooled at the start. In other words, you can use the all-to-all coupling to very quickly build a highly entangled state, and then do the simpler measurements one by one. This plays to ion traps’ strength (excellent entanglement fidelity) and sidesteps their relative weakness (slower operation speed), since a large entangled state can in principle be generated with just slightly longer pulses or a few parallel operations.
• Scalability (Neutral Atoms): Neutral atom arrays are arguably the most scalable physical qubit approach in terms of sheer numbers – 2D arrays of 100+ atoms have been demonstrated, and 3D lattices with thousands of atoms exist in labs (though not all individually controlled yet). This suits MBQC because MBQC often uses many qubits (including “ancillary” ones that get measured out) to accomplish a computation. The statement by Pasqal researchers that neutral atom processors have “intrinsic scalability… in the 100–1,000 qubits range”​ underscores that advantage. In a neutral-atom MBQC, one could imagine preparing a cluster state involving hundreds of atoms, far more than the count of logical qubits needed, to serve as a robust resource for a complex algorithm. Having a surplus of qubits is helpful for quantum error correction and for parallelizing operations. Moreover, neutral atom platforms can sometimes reconfigure atom positions on the fly (by moving optical tweezers) – this could allow dynamic cluster state shaping where you entangle a set, measure some, then physically move others together to entangle in new ways (a form of reusing atoms for multiple cluster layers). This kind of flexibility in space and number of qubits is a big plus.
• Deterministic Large Entangled States: Both trapped ions and neutral atoms can create entangled states deterministically, with high success probability on each attempt, in contrast to photonic systems where probabilistic entanglement is more common. Ion traps have achieved GHZ states of 14 ions in 2011 and 24 ions more recently; neutral atoms have achieved many-particle entanglement through Rydberg blockade. Creating a cluster state of 20 or 30 qubits in these systems does not require exponentially many trials – it can be done on demand with calibrated pulses. In 2019, two-qubit and three-qubit gate demonstrations on neutral atoms achieved fidelities ~97–98%​; since then improvements are bringing that over 99%. With those gates, constructing a 2D cluster of, say, 5×5 atoms (25 qubits) is feasible within the coherence time. Indeed, the ion trap cluster of 16 qubits (4×4 grid) in 2023 was achieved by a clever scheme of recycling, but it underscores that no fundamental roadblock exists to reach a few dozen entangled qubits in MBQC​. As hardware improves, the size of deterministic cluster states will grow, which will directly translate to the ability to run larger MBQC algorithms. High entanglement fidelity also means each measurement-based gate has high fidelity. For example, if an ion trap can create a cluster with 99% fidelity bonds, each teleported gate inherits that fidelity, potentially offering a high overall gate fidelity in the MBQC process.
• Feed-forward = Real-time classical processing: An often overlooked advantage is that MBQC forces the integration of classical and quantum processing. This means that an MBQC quantum computer naturally is a quantum-classical hybrid that processes measurement outcomes on the fly. From a computer architecture perspective, this could enable efficient conditional logic and even interfaces with classical computing during the quantum algorithm. For instance, one could branch a computation if a certain measurement result is observed (without having to stop the whole computation). This opens the door to more flexible quantum algorithms that can adapt or optimize themselves mid-run. While this is possible in circuit models, MBQC has it at its core. It could be beneficial for algorithms like quantum heuristics, where real-time feedback might guide the quantum process.
• Secure Computing and Networking: The structure of MBQC provides a built-in way to do Blind Quantum Computing, where a server (holding the cluster state) can perform computations for a client without learning the client’s input or output. The client can essentially encrypt the quantum computation by choosing random measurement bases shifts. This protocol, introduced by Broadbent-Fitzsimons-Kashefi, relies on MBQC’s property that measurement angles can be offset by random amounts without affecting the correctness of the computation (only requiring simple classical post-processing)​. Ion traps and neutral atoms, as stationary matter qubits, are amenable to serving as the server in blind QC – they can produce large cluster states and share them (via photons) with clients or accept quantum states from clients to embed in the cluster. Recent work in Oxford with ions and photons indeed demonstrated a step in this direction​. So an advantage of MBQC in these platforms is the potential for cybersecure quantum cloud computing (more on that in the cybersecurity section). Additionally, cluster states are a resource for quantum networks – e.g., a 2D cluster can enable multi-party quantum communication protocols or distributed quantum sensing. Ion traps can network via photons and neutral atoms can interface with fibers or cavities; by using cluster states, one can distribute entanglement in a network more efficiently (since a single $N$-qubit cluster can yield entanglement between many pairs by appropriate measurements). In short, MBQC fits well with the vision of networked quantum processors and secure delegation.
• Conceptual Simplicity and Modularity: From a software standpoint, once a cluster state is prepared, the remaining operations are just a sequence of single-qubit measurements, which are relatively simple operations to execute and benchmark. This modularizes the process: the complex part (entangling many qubits) is separated from the computational part (measurements). In a large system, this could allow a factory-like approach: one part of the system constantly churns out cluster states (or patches of a cluster) while another part handles measurements and feed-forward. This pipeline could be easier to scale than having to coordinate many different two-qubit gates all across a large chip in real-time. In neutral atom setups, for example, one could envisage a 2D conveyor of atoms where one zone entangles incoming atoms into a cluster, and another zone immediately measures them in sequence – a literal one-way conveyer-belt quantum computer. Because ions are trapped in one place, they can’t quite do a conveyer, but they could use multiple trapping zones: prepare entangled states in one zone, then move ions to a measurement zone. This modularity – separating entangle and compute phases – is a distinct advantage of MBQC as systems scale up.

In summary, the advantages of MBQC on ion trap and neutral atom platforms include leveraging physical strengths (like ion connectivity and atom scalability), enabling advanced protocols (adaptive error correction, blind computing), and architectural benefits (parallelism and modular operation). These strengths make MBQC an attractive approach as quantum hardware grows in size and complexity.

Disadvantages

Despite its promise, MBQC with ion traps and neutral atoms faces several challenges and limitations:

• Resource Overhead (Qubits and Operations): MBQC often requires more qubits than the equivalent circuit model implementation. Every logical qubit and gate in a circuit may translate to multiple qubits in a cluster state. For example, a $n$-qubit algorithm of depth $d$ might need on the order of $n \times d$ qubits in the cluster (though clever techniques like qubit recycling can mitigate this​). In hardware terms, this means you need many physical qubits available to do a given task. For currently small devices, that overhead is significant. In an ion trap with 20 ions, if you want to run even a 5-qubit algorithm of depth 4 via MBQC, you’d fill the device with cluster qubits. In contrast, a circuit model could perhaps execute it with just those 5 ions over 4 time steps. Similarly, building a large 2D cluster state requires a lot of entangling operations. If those are done sequentially, it might actually take longer than just running the circuit gates one by one. In other words, MBQC doesn’t eliminate the need for two-qubit interactions; it may even use more of them overall to form all the cluster links. This is a well-known tradeoff: MBQC shifts temporal complexity (depth of circuit) into spatial complexity (number of qubits/entanglements). If the hardware has limited qubit count, this can be a disadvantage.
• Cumulative Decoherence: In MBQC, the entire cluster state must maintain coherence at least until each qubit in it is measured. If a cluster state is large and the measurements proceed one by one, the later qubits have to stay coherent for a long time while earlier ones are being measured. Any decoherence (e.g. an ion decaying or an atom losing its state) in that interim can spoil the computation. In a circuit model, one might perform operations on a pair of qubits and then immediately measure or reset them if they’re done, potentially limiting how long each qubit must survive. MBQC doesn’t “use up” a qubit until it’s measured, and if that qubit is designated to be measured late, it has to hold quantum information for almost the whole algorithm’s duration. Ions have long coherence times (seconds to minutes for hyperfine qubits) so this is less of a problem for them, but neutral atoms, while generally stable, can be affected by laser noise or collisions that limit coherence to maybe a few seconds or less. If one needs to measure qubits sequentially with feed-forward, there might be a latency while classical processing decides the next basis. If that latency is, say, a few microseconds and you have to do it 100 times, that’s 0.0001 seconds, which is fine. But if classical processing or experimental overhead makes it milliseconds, then 100 steps is 0.1 s – not a huge issue for ions (which can maintain superposition that long), but potentially an issue for certain Rydberg-state encodings in neutral atoms. In fact, current neutral atom experiments often have total algorithm durations in the tens of microseconds range to avoid decoherence. Thus, feed-forward latency is a concern: the classical compute between measurements must be ultra-fast and synchronized. If it lags, the remaining entangled qubits might accumulate phase errors. This demands a tight integration of classical control hardware with the quantum device (like FPGA controllers that make nanosecond-scale decisions), which adds complexity.
• Measurement Crosstalk and Technical Challenges: Performing a measurement on one qubit without disturbing others can be experimentally difficult. In ion traps, measuring an ion typically involves hitting it with resonant light to make it fluoresce. That fluorescing ion emits many photons that could hit neighboring ions (causing decoherence or unintended measurement). Ion experiments mitigate this by using different ion species (one as a readout ancilla) or by physically transporting the ion to a different zone for measurement – techniques not yet demonstrated in the context of MBQC sequences, except in specialized experiments​. Neutral atoms have a similar issue: shining a resonant laser on one atom could off-resonantly excite neighbors or heat the trap. The recent neutral-atom mid-circuit measurement result had to carefully isolate one atom’s fluorescence from the rest​. They achieved 97% state preservation in neighbors, which is good but that 3% disturbance is not negligible if you need to do many sequential measurements. Additional error from measurement crosstalk can accumulate. Essentially, the hardware complexity for measurement isolation is significant – you might need additional laser beams, shielding, or use of different internal states, all of which complicate the system. This is a disadvantage unique to MBQC (since circuit models normally avoid mid-run measurements precisely to not deal with this).
• Lack of Mature Software Tooling: The quantum software stack today is largely built around circuits (Qiskit, Cirq, PyQuil, etc. all express algorithms as gate sequences). MBQC requires a different compiling approach (graph states and measurement patterns). While there is research on automating this translation, it’s not yet mainstream. This means that programming an MBQC device could be less straightforward for users. One would likely design a circuit and then rely on a compiler to produce a measurement pattern for a cluster state. Projects like Google’s Cirq include some rudimentary support for quantum circuits with mid-circuit measurements (which could emulate MBQC on a gate device), but generally a lot of quantum algorithm literature assumes circuit model. So there’s a “cultural” disadvantage in that MBQC might face a higher barrier to adoption unless abstractions are developed. However, this is a surmountable issue with time and interest – similar to how programming for parallel computers required new compilers and languages, programming for MBQC would too.
• Slow Physical Operations (Ion Traps): Ion traps, though high fidelity, have relatively slow gate and measurement speeds (gate times in the tens of microseconds, measurement taking perhaps tens to hundreds of microseconds due to photon collection). If an MBQC requires many sequential measurements, the total algorithm time can become long. For instance, if each measurement (with feed-forward decision) takes, say, 50 µs, and you need 100 of them, that’s 5 milliseconds. While 5 ms is short, consider that superconducting qubit processors might execute an equivalent circuit in a few microseconds total (because gates are ~10-50 ns and can be parallel). Thus, an ion-trap MBQC might be orders of magnitude slower in wall-clock time than a superconducting circuit machine. Even though both solve the problem in polynomial time, the actual speed difference matters for practicality. This is partly an issue with ion trap gate speeds in general, but MBQC could exacerbate it if it can’t parallelize measurements that a circuit might parallelize gates for. One can mitigate this by measuring some qubits simultaneously if their measurement bases are known in advance or do not depend on each other. Indeed, not all measurements in MBQC have to be strictly one after the other; some layers of the cluster can be measured in parallel if they don’t require feed-forward from each other. Careful scheduling can reduce the sequential depth of measurements, but it’s algorithm-dependent.
• Fidelity Accumulation and Error Propagation: In MBQC, an error in the entangled resource or an early measurement can propagate and affect later steps. For example, if one entangled link in the cluster is broken (say a phase error between two qubits), it might behave like a broken gate in the effective circuit, potentially corrupting the outcome unless error correction is built in. MBQC is not immune to noise – it just has a different noise structure. Some argue that MBQC could be more noise-tolerant because you can measure out entangled qubits before they accumulate too many errors (essentially remove them from the system). However, if the cluster state is noisy, the one-way computation will be noisy too. Fault-tolerant threshold theorems exist for MBQC (especially with topological cluster states​), but currently ion and atom experiments operate in the noisy, non-error-corrected regime. So a disadvantage is that MBQC introduces new failure modes: e.g., a measurement result might be misread (measurement error) – in a circuit model you might never measure until the end, but in MBQC every operation is a measurement so readout errors directly translate to logic errors if not corrected by repetition. This places a burden on having extremely high measurement fidelity. Ion traps fortunately have very high readout fidelity (>99% typically), and neutral atom readout fidelity is also very high (~98-99% in many setups), but if one has to do hundreds of measurements, those few percent errors can compound without error correction. Thus the tolerance for measurement error is low.
• Geometry Constraints (Neutral Atoms): Neutral atoms naturally entangle with nearest neighbors (unless one does more complex schemes). This means the cluster states they make will likely be planar or have a fixed connectivity. Certain quantum algorithms might benefit from non-planar connectivity, which would be harder to embed in a 2D grid cluster without using extra qubits to mediate (adding to overhead). Ion traps don’t have this problem due to all-to-all connectivity, but they have fewer qubits. Neutral atoms have many qubits but fixed geometry. This is analogous to the difference between a fully connected vs nearest-neighbor circuit model: some algorithms will suffer an overhead when mapped to a restricted geometry. MBQC on a 2D grid is universal, but mapping an arbitrary algorithm to it may require increasing the grid size or using additional “swap” operations (which in MBQC correspond to certain measurement patterns that effectively reroute quantum information on the cluster). This overhead is well-understood but still a disadvantage in efficiency.
• Still Experimental for Neutral Atoms: While ion traps have demonstrated MBQC computations, neutral atom implementations have not yet shown a full end-to-end MBQC algorithm. The lack of a clear experimental success story in neutral atoms means there could be unforeseen difficulties when everything is put together. It’s possible, for instance, that while single-site measurement works and entanglement works, doing them back-to-back repeatedly could introduce some technical instability (like laser scattering effects building up or background gas collisions over a long sequence). Until a neutral atom MBQC is performed, one has to acknowledge that it’s an unproven approach on that platform. This is more of a temporary disadvantage – expected to be overcome – but it contrasts with the gate model on neutral atoms which has already been used for small algorithmic demonstrations and analog quantum simulations.

In summary, MBQC on these platforms demands more qubits and meticulous control. It shifts some hardware difficulties (precise multi-qubit gates) to other difficulties (lots of qubits, fast adaptive control, and isolation of measurements). The overheads in qubit count and operation count, the challenges of sequential measurement (crosstalk and speed), and the early-stage nature (especially for neutral atoms) are the main disadvantages. These are active areas of research: scientists are working on faster feed-forward electronics, clever cluster optimization to reduce qubit overhead, and error mitigation techniques for MBQC. The hope is that as devices scale, these disadvantages will be outweighed by the advantages, but in the near term they make MBQC a bit more complex to implement reliably than simply running a circuit on the same device.

Impact on Cybersecurity

The advent of quantum computing, whether via MBQC or gate-model, has profound implications for cybersecurity. Ion trap and neutral atom quantum computers are universal quantum machines, so a sufficiently large-scale device implemented with these technologies could run Shor’s algorithm to factor large integers and break widely used cryptosystems like RSA and elliptic-curve cryptography​. In fact, trapped-ion qubits are known for extremely high fidelity, which has allowed demonstrations of small instances of Shor’s algorithm (for example, factoring 15 with 5 ions)​. While factoring 15 is trivial, it was a proof-of-concept that foreshadows using more ions to attack larger numbers. The main limitation has been scale – current ion/atom devices have on the order of 10–20 qubits, far below what’s needed to factor a 2048-bit RSA number or break 256-bit ECC. Experts estimate that we’d need thousands of logical (error-corrected) qubits, which might correspond to millions of physical qubits without error correction, or a few thousand with effective error correction, to factor RSA-2048. Ion traps’ high gate and measurement fidelities mean they are strong candidates to achieve the first error-corrected qubits​​. Once error-corrected quantum logic is running on dozens of logical qubits, one could conceivably attack medium-sized cryptographic keys (RSA-512, RSA-1024)​. If the growth in qubit count continues (with companies aiming for ~50–100 qubit devices in the next 5 years and modular scale-up beyond that), by the 2030s or 2040s ion-trap or neutral-atom quantum computers with a few hundred logical qubits could exist​. Such a machine would pose a serious threat to classical public-key encryption like RSA and ECC, as it could implement Shor’s algorithm to break them in feasible time. Neutral atom systems, once they achieve similar error rates and logical qubit encoding, would pose the same threat – the paradigm (MBQC vs gate) doesn’t change the threat, it’s the capability that matters. And as one analysis put it, the existence of multiple paradigms (ions, atoms, superconductors, etc.) increases the certainty that large quantum computers will be built, thereby increasing the urgency for cryptographic migration​.

Shor’s algorithm and cryptography: To be clear, any universal quantum computer can run Shor’s algorithm, and MBQC is just another way to run those same quantum algorithms. If an ion trap MBQC machine reaches the necessary size, it could break RSA just as a superconducting gate-based machine could. One might wonder if MBQC offers any special speedup or advantage in attacking cryptography – generally it does not, other than the fact that it might be easier to scale in some ways (which indirectly affects when the threat materializes). So from a cybersecurity perspective, trapped-ion and neutral-atom MBQC devices are part of the general quantum threat landscape. Governments and researchers project that in a couple of decades there is a credible risk of quantum computers (perhaps including ion/atom-based ones) being able to break current encryption standards​. This has already prompted action: NIST has been driving a Post-Quantum Cryptography (PQC) standardization process to develop algorithms that are resistant to quantum attacks. The NSA in the US has advised moving to quantum-resistant algorithms as well, precisely because they anticipate machines like those built by IonQ or Quantinuum eventually reaching a level that threatens classical encryption.

One unique angle: Ion traps may be slightly slower to scale in quantity but have high accuracy; superconductors scale in quantity faster but each qubit is noisier. It’s uncertain which will hit the cryptographically relevant scale first​. But from a security planner’s viewpoint, one must assume some technology will succeed by the time frames mentioned. Therefore, agencies are algorithm-agnostic: they prepare for quantum attacks regardless of whether it’s ions, atoms, or any other qubits that enable it​.

Quantum-safe (advantageous) uses: On the flip side, quantum computers can also enhance cybersecurity through new capabilities. A notable example is Quantum Random Number Generation (QRNG). Trapped-ion and neutral-atom systems are excellent sources of true randomness – measuring qubits in superposition yields inherently random 0/1 outcomes. Companies like Quantinuum have capitalized on this by launching services such as Quantum Origin, which provides cryptographic keys derived from quantum-generated randomness​. Ion trap qubits can produce high-quality randomness due to their low bias and high detection fidelity. Embedding a QRNG in devices can strengthen security (for instance, to generate unpredictable encryption keys or nonces). In fact, Quantinuum’s Quantum Origin Onboard is explicitly aimed at IoT and edge devices to “strengthen device security against advanced cyber-attacks” by using quantum-derived keys​. While QRNG doesn’t require MBQC specifically, any measurement of a qubit in a superposition is effectively a one-qubit MBQC (trivial cluster of one qubit, measured) – so one could whimsically say MBQC’s core operation (measuring an entangled qubit) is at the heart of QRNG. Neutral atoms could similarly be used for QRNG, though currently most commercial QRNGs use photons or other simpler quantum systems for practical reasons.

Another cybersecurity application of MBQC is Blind Quantum Computing (BQC), as mentioned earlier. This is directly relevant to secure cloud computing: a user can delegate a computation to a quantum server (perhaps an ion-trap quantum cloud) without revealing the computation to the server. MBQC makes this possible by enabling the user to prepare or direct the preparation of a specific entangled state (like a partially random cluster) and then only send classical instructions of how to measure, which the server cannot interpret without the secret parameters. The MBQC-based BQC protocol ensures the server learns nothing about the data or algorithm, yet still carries out the computation​. This could become an important cybersecurity feature: privacy-preserving quantum computing. If companies or governments want to utilize external quantum computing resources (cloud services) for sensitive data, BQC would be the enabling technology. Trapped ions are a good platform for this because they can interface with photons (to get entangled input states from the client) and have stable operations to carry out the computation. A 2022 demonstration (by University of Oxford and collaborators) entangled trapped ions with photonic qubits and verified a simple blind computing task​​, hinting that future ion-trap networks could offer secure cloud quantum computing. Neutral atom systems could also do blind computing theoretically, but the optical interfacing is easier with ions (since ions routinely emit photons for communication). Regardless, MBQC is the underlying scheme that makes blind computing feasible, so its realization in these platforms will directly translate to a cybersecurity advantage: clients can securely outsource quantum computations without risk of leaking information.

Potential threats unique to MBQC? One might ask if measurement-based implementations introduce any new vulnerabilities compared to gate-based. The computations themselves are equivalent, so the ability to break encryption is the same. However, MBQC might be harder to verify for an external observer: if a quantum computer announces it used MBQC to solve a problem, how do we verify the computation was correct? There are protocols for verification (like measurement-based verifiable blind computing, where trapdoors in the cluster state can check the server’s honesty). In fact, MBQC can be turned into a verification tool: by deliberately inserting known sequences in the measurement pattern, a client can catch a malicious server that deviates, without the server knowing which parts are tests. This is another security enhancement – verifiable quantum computation – which has been explored in theory and small experiments. Trapped ions recently were used to demonstrate a form of verifiable quantum random sampling in MBQC​​, which is more about verifying quantum advantage but the techniques overlap with verifying correctness (they used fidelity estimation to certify the cluster state preparation). So MBQC provides handles for making sure a quantum computation is done right even by an untrusted party.

From a national security perspective, the development of high-end trapped-ion and neutral-atom quantum computers is closely watched. Governments recognize that if one nation achieves a cryptographically relevant quantum computer first, it could potentially decrypt sensitive communications of others (assuming those communications were recorded and stored, a practice known as “harvest now, decrypt later”). Thus, there is a race not just in technology but in transitioning cryptographic infrastructure to be quantum-safe before quantum computers reach that capability. The National Academies 2019 report on quantum computing emphasized moving to post-quantum cryptography as a priority given the uncertain but potentially rapid progress in quantum hardware​. IonQ’s own blog has discussed the concept of “Q-day” – the day a quantum computer cracks RSA-2048 – as something that might happen in a couple of decades and urged preparations​​. So the consensus is that large-scale trapped-ion or neutral-atom quantum computers will be part of that future threat, and the existence of multiple approaches (MBQC included) only reinforces that it’s not a single point of failure – even if one approach falters, another might succeed​.

In summary, cybersecurity threats from ion trap and neutral atom MBQC implementations are essentially the standard quantum threats: the ability to undermine classical encryption by running algorithms like Shor’s and Grover’s at scale. Cybersecurity applications and advantages include: quantum-based secure key generation (QRNG)​, blind quantum computation for data privacy​, and verifiable computing protocols to ensure quantum cloud honesty – all of which MBQC either directly enables or benefits from. The impact on cybersecurity is therefore two-fold: a need to secure our current cryptosystems against these quantum machines (driving the adoption of quantum-resistant encryption), and an opportunity to use those same machines or techniques for enhancing security (through new quantum cryptographic protocols). Ion traps and neutral atoms are among the leading hardware choices to realize both the threat and the defensive tools.

Future Outlook

The future of MBQC on ion traps and neutral atoms looks promising, with a clear trajectory towards larger, more integrated, and more practical systems. Here are some expected developments and roles this approach might play in quantum computing:

• Scaling Up and Modular Systems: In the next 5–10 years, we anticipate trapped-ion MBQC systems scaling from demonstrations of tens of qubits to hundreds. This will likely involve modular architectures. As cited in a recent review, ion-trap companies plan to link multiple ion trap modules (e.g., 4 traps of 16 ions to make a 64-qubit device, or 2 traps of 32 ions for a 64-qubit device) via photonic interconnects​. These photonic links essentially create remote entanglement, which can be used to form cluster states between modules. So one can imagine a future MBQC machine where each module produces a cluster state of its ions, and then modules are entangled pairwise to form one big distributed cluster. Such networked MBQC could circumvent the limitations of a single hardware unit. The technology for remote entanglement of ions is already established (ions in separate traps entangled via photons since 2007)​. So by 2030, we might see ion trap processors with a few hundred physical qubits across modules, using MBQC as a natural way to operate a distributed quantum computer (since MBQC doesn’t require direct gates between qubits in different traps, only an initial entanglement link and then measurements). This fits well with the concept of a quantum multi-core network​.
• Toward Fault-Tolerance: Both ions and neutral atoms are being pursued for quantum error correction experiments. Ion traps have already demonstrated elements of fault tolerance (repeating error correction cycles, etc.), and neutral atoms are catching up (the midcircuit measurement result was explicitly a step towards error-corrected quantum memory)​. MBQC has a unique footing here because the leading scheme for fault-tolerant MBQC is the topological cluster state (Raussendorf-Harrington-Goyal) approach​. In that scheme, a large 3D cluster state encodes a surface code, and performing measurements on that cluster implements error-corrected logic. Ion traps and neutral atoms could create such 3D clusters by either using a third physical dimension or using time as the third dimension (e.g., a 2D cluster that is grown layer by layer over time to make a 3D structure). The high connectivity of ions could help create the complex entanglement needed, while the scalability of atoms could supply the sheer number of qubits. It’s conceivable that the first generation of fully error-corrected logical qubits will be realized in a measurement-based manner on these platforms. In other words, instead of doing circuit-based surface code with hundreds of rounds of gates, one might entangle a bunch of ions or atoms into a gigantic cluster that is the code space, and then just measure it. This could simplify control when qubit numbers grow. Some recent proposals for “measurement-free error correction” in neutral atoms (a bit of an oxymoron name, but they mean performing error correction through tailored interactions) are exploring alternatives​, but the mainstream view is that frequent measurements (hence MBQC style) are needed for high-performance error correction.
• Integration with Photonics and Other Systems: Ion traps and neutral atoms may not remain standalone. For example, there’s work on integrating ion traps with photonic chips (to get faster readout and communication)​. One can imagine an ion trap MBQC device where each ion is coupled to an optical waveguide on the chip for ultrafast detection of its state​. That would drastically speed up measurement and feed-forward, alleviating a current bottleneck. Neutral atoms might be integrated with nanophotonic cavities or fibers (there’s research on nanofiber traps entangling atoms via fiber links​). These hybrid systems would allow MBQC to extend over optical networks, enabling distributed quantum computing or cluster states that span distant nodes. Such developments are in line with the quantum internet vision, where quantum processors exchange entanglement. MBQC could serve as the computational model that naturally fits a network environment (since local operations are measurements and entanglement is the resource transmitted over the network).
• Commercialization and Use-Cases: As MBQC implementations mature, they might find niches where they outperform gate-model execution. One likely scenario is cloud quantum computing services offering measurement-based computation for clients requiring privacy. If blind quantum computing is in demand (say, banks wanting to run proprietary algorithms on a cloud quantum computer without revealing their data), an ion-trap provider might roll out a blind-QC service. This would effectively be a MBQC-based offering. Another scenario is offering template cluster states as a service – perhaps a cloud service could generate a large cluster state and allow users to “tap into it” by requesting certain measurements to be performed, which could implement a variety of algorithms on-the-fly. This is speculative, but it aligns with the flexibility MBQC offers.
• Role in Broader Architectures: MBQC might also complement other paradigms. For instance, one could use an analog quantum simulator (say, a neutral atom analog Hamiltonian evolution) to prepare a highly entangled state that isn’t exactly a cluster but can be converted into one with a few additional steps, and then do MBQC on it. Or consider a scenario where superconducting qubits (very fast gates) are used to rapidly generate a cluster state, which is then teleported into an ion trap memory for slow, high-fidelity measurement processing. Such hybrid architectures might maximize strengths of each technology: superconductors for fast entangle, ions for precise measure, etc. While this is complex, the future quantum ecosystem might indeed mix modalities – and MBQC provides a common language (entanglement + measurement) that can glue different systems together.
• Neutral Atoms in the Long Run: Neutral atom quantum computers are projected to achieve very large numbers of qubits (hundreds to a thousand) even without full error correction​. By the time they reach that scale, if two-qubit gate fidelities are high enough, they will be able to run quantum algorithms far beyond what’s possible today. If mid-circuit measurement is also fully in hand, they could opt to use MBQC for implementing complex multi-step algorithms. One can imagine a neutral atom device preparing a 2D cluster of size 1000 (maybe a 20×50 grid) and performing a sequence of measurements that executes a quantum algorithm with, say, 20 logical qubits and depth 50. That might allow solving intermediate-size instances of problems or running variational algorithms. In the fault-tolerant era, neutral atoms might serve as an excellent platform for certain error-correcting codes because of their parallelism. For example, a color code (a type of quantum error correction) on a 2D lattice could be naturally implemented with MBQC on a 2D neutral atom cluster. So the future might see neutral-atom MBQC being one route to fault-tolerant quantum computing, which is the ultimate goal. It might not require as extensive hardware overhead as some other approaches if the physical qubit count is already high.
• Timeline Expectations: In rough terms, within ~5 years we expect to see: a clear demonstration of MBQC on a neutral atom array (solving a small problem), ion trap MBQC used to run a few-qubit algorithm end-to-end (beyond basic gates, maybe a small quantum protocol like teleportation or a tiny algorithm like Grover’s search on 2-3 qubits with adaptive steps), and hybrid blind computing demos. Within ~10 years: integration of MBQC with error correction on ions (maybe a logical qubit realized via a cluster-state method), neutral atom systems with 100+ qubits performing measurement-based algorithms that surpass what classical simulation can do, and possibly early specialized applications (like quantum optimization or quantum chemistry problems) where MBQC is leveraged for mid-circuit measurements (for example, measuring and re-preparing qubits adaptively in variational algorithms to save qubit resources). By ~20 years, if trends hold and assuming no fundamental roadblocks, we could have modular quantum computers using ions/atoms with hundreds of logical qubits, on which MBQC might be the preferred mode for running very large algorithms reliably (thanks to its synergy with error correction). At that stage, as discussed, the devices would be capable of breaking traditional encryption – underscoring the importance of quantum-safe cryptography by then.
• Continued Role of Gate Model: It’s unlikely MBQC will replace the gate model entirely. Rather, it will coexist. Some computations might be more straightforward to compile as circuits, and hardware can execute them directly. Others might benefit from MBQC. Also, MBQC can be emulated on gate hardware (after all, one can always create a cluster by gates and then measure), so even machines not explicitly built for MBQC can still run MBQC algorithms if desired. The choice will come down to error rates and efficiency: whichever method yields the correct result with less overhead will be chosen by engineers. That might vary by platform and by problem. So the future quantum computer might dynamically switch between circuit mode and one-way mode depending on what is being done. Trapped ions, for example, could run a sequence of gates for part of an algorithm, then decide to entangle a bunch of ancillas and do an MBQC sub-procedure (like error syndrome extraction) because it’s more efficient that way, then go back to gates. Thus, the integration of MBQC into broader architectures likely means users won’t necessarily see or care about the distinction – they’ll just know the quantum computer uses all available tricks to get the job done.
• Commercial Integration: Companies like IonQ and Quantinuum are aware of MBQC but currently focus on circuit model for user interfaces. If MBQC offers a performance edge, they will incorporate it under the hood. Quantinuum, for instance, could use measurement-based techniques to optimize their error correction pipeline or to implement logical operations via lattice surgery (which is basically a form of cluster-state MBQC on the code level). Pasqal might advertise the ability to run measurement-based circuits especially for workflows that need mid-circuit measurements (once they have that fully operational). As quantum computing moves toward practical applications, it wouldn’t be surprising to see marketing of “one-way quantum processors” that emphasize large entangled states – especially as neutral atom companies leverage the narrative of scalability.

In conclusion, the future of ion trap and neutral atom MBQC is one of increasing maturity and integration. They are poised to contribute significantly to achieving large, stable quantum computers. The strengths of each – ions for fidelity, atoms for scale – complement the MBQC approach, potentially accelerating the arrival of error-corrected quantum computing. Within a decade or two, MBQC could shift from a lab curiosity to a workhorse technique inside quantum computers, especially for tasks like error correction, secure computing, and distributed quantum systems. As that happens, the distinction between MBQC and circuit models may blur for end-users, but under the hood MBQC will be a critical piece of the quantum computing puzzle, enabling capabilities that would be hard to realize otherwise. The measurement-based paradigm, once an abstract idea, is set to take on a very concrete role in the quantum machines of tomorrow, whether it’s breaking cryptography, solving chemistry, or ensuring that our quantum cloud computations remain private and verifiable. The continued progress in trapped-ion and neutral-atom technologies will likely make those theoretical possibilities a reality​.