Quantum Computing Modalities: Measurement-Based Quantum Computing (MBQC)
Table of Contents
(For other quantum computing modalities and architectures, see Taxonomy of Quantum Computing: Modalities & Architectures)
Updated July 2026
What It Is
Measurement-Based Quantum Computing (MBQC), also known as the one-way quantum computer, is a modality where quantum computation is driven entirely by measurements on an entangled resource state. Instead of applying a sequence of unitary gates to a register of qubits, MBQC starts with a highly entangled state of many qubits (typically a cluster state) and then performs single-qubit measurements in a carefully chosen order and basis. The outcomes of these measurements determine the results of the computation, and crucially, they may dictate how later measurements are performed (a concept called feed-forward). Once a qubit is measured, it’s essentially removed (consumed) from the computer—hence “one-way” quantum computing, as the entangled resource is gradually used up.
The cluster state is the central resource in MBQC. A cluster state is a specific type of entangled state that can be described on a graph: each vertex is a qubit initialized to $$|+\rangle = (|0\rangle+|1\rangle)/\sqrt{2}$$, and each edge represents applying a controlled-phase gate (CZ) between the two connected qubits. For example, a simple cluster could be a 1D chain of qubits entangled by CZ gates between nearest neighbors, or a 2D lattice of qubits entangled in a grid. In notation, if $$E$$ is the set of edges, a cluster state on graph $$G=(V,E)$$ can be written as:
$$∣Φcluster⟩=∏(i,j)∈ECZij ⨂k∈V∣+⟩k.|\Phi_{\text{cluster}}\rangle = \prod_{(i,j)\in E} CZ_{ij} \;\bigotimes_{k \in V} |+\rangle_k.∣Φcluster⟩=∏(i,j)∈ECZij⨂k∈V∣+⟩k$$.
This state has the special property that it is highly entangled and serves as a universal substrate for quantum computation. It’s an eigenstate of certain commuting stabilizers (e.g., for a 2D cluster, each qubit’s $$X \otimes Z$$ neighbors is a stabilizer). One doesn’t need to fully grasp that formalism; the key point is that the cluster is a fixed entangled resource.
Computation in MBQC: Given a cluster state, quantum computation proceeds by single-qubit measurements:
- If you measure a qubit in the $$Z$$ basis (i.e., $${|0\rangle,|1\rangle}$$), you essentially read out a result (which might be part of the output) and remove that qubit from the cluster without affecting the remaining ones (aside from collapsing that qubit).
- If you measure in the $$X$$ – $$Y$$ plane (at some angle $$\phi$$), this has the effect of performing a certain logical gate on the remaining unmeasured qubits up to a known correction. Because of the entanglement, measuring one qubit can induce a gate (like a rotation) on the neighboring qubits. The exact effect depends on the measurement angle and the outcomes of previous measurements (this is where the feed-forward comes in).
Amazingly, any quantum circuit can be realized by an appropriate sequence of single-qubit measurements on a large enough cluster state. For example, to do a particular gate $$U$$ on the logical qubits, you would measure certain ancillary qubits in a pattern that implements $$U$$ on the remaining qubits’ state (this is akin to teleportation-based gates). By adjusting measurement bases based on earlier outcomes (which introduce random Pauli byproduct operations), one can ensure the correct overall transformation is realized. Raussendorf and Briegel showed in 2001 that a 2D square lattice cluster state is universal for quantum computing under such measurements. In their scheme, the measurements are the “program” – once the cluster is prepared, no further unitary gates are needed; we only perform a sequence of adaptive measurements.
Key Academic Papers
The foundational paper for MBQC is “One-Way Quantum Computing“ by Raussendorf and Briegel (2001). They introduced the cluster state model and showed any quantum logic network can be simulated with one-qubit measurements on a cluster. Another important paper by Raussendorf, Browne, and Briegel (2003) further detailed how universal quantum computation is achieved with 2D cluster states. Michael Nielsen also wrote a lucid early description (2004) of MBQC and showed the equivalence with circuit models from a different angle. In Nielsen’s approach, measuring a cluster state was shown to effectively propagate quantum information in a way identical to gates.
In terms of implementation, photonic experiments by Philip Walther and Anton Zeilinger’s group (2005) demonstrated a 4-qubit cluster state and performed simple algorithms (like a one-bit adder) via one-way computing. This was a proof-of-principle that MBQC works. Since then, photonic cluster states of increasing size have been demonstrated: 8-photon cluster states in 2011 (Pan’s group in China), and multiplexed continuous-variable cluster states with thousands of modes (Furusawa’s group in 2019), which showed a deterministic generation of a very large entangled state of light. More recently, Xanadu’s Aurora system (published in Nature, January 2025) demonstrated 12 logical GKP qubits with real-time error-correction decoding in a modular four-rack photonic architecture interconnected by 13 km of optical fiber. In July 2026, QuiX Quantum announced Carina, a discrete-variable MBQC system using on-chip GHZ-state cluster generation with single-photon qubits, which the company positions as the first universal photonic quantum computer designed for customer deployment. At four computational qubits, Carina is an architecture proof rather than a computationally capable machine, but it represents the first integration of on-chip cluster state generation, feed-forward control (150 ns latency), and room-temperature photon sources in a single deployable system.
The link between cluster states and error correction was made by Robert Raussendorf and Jim Harrington (2007), who showed a topological error-correcting code using a 3D cluster (the Raussendorf-Harrington code, a form of topological MBQC). This work connects MBQC with the notion of a fault-tolerant universal quantum computer realized as a giant cluster state with defects encoding logical qubits – an idea that underlies some of Google’s and others’ approaches to future fault-tolerance.
Comparison To Other Modalities
MBQC is equivalent in power to the circuit model (it can simulate any circuit and vice versa), but it contrasts in how and when entanglement and operations occur:
- In circuit model, you entangle qubits as needed during the computation by applying two-qubit gates. In MBQC, you entangle all (or most) qubits upfront into a big cluster, and then computation is just measurement.
- MBQC shifts the “hard part” to state preparation. Creating a large, high-fidelity cluster state is resource-intensive. But once you have it, the actual computing is just local measurements, which (in some implementations like photonics) can be easier than performing deterministic gates.
- Feed-forward (adaptive measurement) is a feature not present in basic circuits (unless you explicitly allow mid-circuit classical control). MBQC naturally incorporates a classical side-computation: after measuring each qubit, based on the random outcome (0 or 1), you may need to change the basis of future measurements (e.g., flip an angle) to account for a Pauli $$X$$ or $$Z$$ error that occurs if the outcome was, say, 1 instead of 0. This is analogous to applying a correction gate in a circuit, but here we just adjust the next measurement. This classical control is an integral part of MBQC.
- MBQC can be more parallel in some respects. For instance, measurements on a large cluster can be done in layers, and some commuting measurements can be done simultaneously. Certain gates (Clifford gates) have particularly simple implementations that might allow massive parallelism – e.g. it’s known that a layer of certain Clifford operations in a circuit model can be done by measuring an entire layer of qubits at once in MBQC. Raussendorf et al. noted that circuits in the Clifford group can be done in a single measurement step on a cluster. Non-Clifford (especially the “T” or $$\pi/8$$ phase gates) require multiple steps and ancillas, but MBQC handles those with a bit more overhead (like magic state injection via measurements).
- From a theoretical standpoint, MBQC has ties to stabilizer formalism and error correction: cluster states can be seen as a resource state that is a stabilizer state, and one-way computing can be described in that language. This has made MBQC a convenient framework for certain error-correcting codes and fault-tolerance schemes (like topological cluster state computing in 3D).
Advantages
- Suitable for Photonic Implementation: One of the biggest motivations for MBQC is in linear optics (photonic) quantum computing. Photons don’t interact easily, making two-qubit gates probabilistic and challenging (as per the KLM scheme). However, creating entangled cluster states of photons (via probabilistic entangling gates or parametric down-conversion sources) and then measuring them is a viable route. Photons can be generated in entangled webs (for example, through time-bin entanglement or by entangling photon pairs and fusing clusters together), and once you have a large photonic cluster, you just measure each photon’s polarization or phase at the required angle to perform the computation. This avoids trying to do deterministic photon-photon gates during the computation; all the interference and entanglement is upfront. Companies like PsiQuantum, Xanadu, and QuiX Quantum, along with research groups worldwide, are pursuing photonic quantum computers that rely on MBQC with cluster states of light. In these systems, measurement is technically easier than maintaining long-lived quantum memories, which MBQC leverages by consuming qubits quickly.
- Temporal and Distributed Flexibility: Because measurement-based computing separates the entanglement resource from processing, one can imagine modular or distributed quantum computing scenarios. For instance, different cluster state portions could be prepared in parallel (or even in different locations) and then connected (via Bell measurements or fusion operations) into a larger cluster. Also, one can produce cluster states on-the-fly: e.g. a time-multiplexed cluster state where entangled photons are generated sequentially and coupled by delay lines. This was demonstrated in continuous-variable clusters where arbitrary size cluster states can be built in time domain. This extensibility means MBQC can be scalable in a pipelined fashion — you don’t need all qubits present from the start, you can keep adding and measuring.
- High Parallelism: In MBQC, many measurements can be done at once if they commute or act on different parts of the cluster. The depth of the measurement “circuit” can sometimes be less than the depth of the equivalent unitary circuit, because entanglement is already present globally. A noteworthy result from Raussendorf’s work was that some quantum circuits have a natural translation to a shallow sequence of measurements. This parallelism could potentially help speed up execution in wall-clock time (though feed-forward can force some sequentiality, since you might need a result before deciding the next basis).
- Resilience via Adaptive Correction: The need for feed-forward means MBQC inherently has a mechanism to correct certain errors (specifically, the random byproduct Pauli errors from measurements). This is not error correction in the full sense, but it shows that the model is comfortable with nondeterminism and adapts to it. In fault-tolerant schemes, one can incorporate error correction steps as part of the measurement sequence. Indeed, some of the leading quantum error correction implementations (like the surface code) can be formulated in the MBQC picture: a 3D cluster state with appropriate measurements can realize error-corrected logical gates topologically. Microsoft’s topological cluster approach (for a gate-based topological QC) is conceptually similar to doing MBQC on a 3D cluster state.
Disadvantages
- Resource State Preparation: The upfront cost of generating a large, high-quality cluster state is enormous. If your algorithm needs $$n$$ logical qubits and a circuit depth $$d$$, you might need of order $$n \times d$$ qubits entangled in a cluster (because roughly one qubit is consumed per time-step per logical qubit). For a realistic quantum computation, this could mean thousands or millions of qubits entangled together. Creating such a state with low error is challenging. In physical terms, if using matter qubits (trapped ions, atoms, superconductors, etc.), entangling a huge lattice of them is limited by control and connectivity. If using photons, you face probabilistic entanglement and photon loss. The larger the cluster, the more points of failure. Many experiments currently create small cluster states (e.g. 4 to 10 photons entangled). Scaling that to even 50 or 100 photons with high success probability is an active area of research.
- Feed-forward Latency: MBQC requires a classical processing loop in the middle of the quantum experiment – you measure a qubit, get a classical bit result, then adjust the basis of the next measurement based on that result. If the physical system is such that all qubits exist simultaneously (like an array of trapped atoms), you need classical electronics to keep up with the quantum device’s coherence time. For photons, since they travel at the speed of light, one often uses delay lines or fiber loops to slow them down enough that the measurement results can catch up to control the next ones. QuiX Quantum’s Feed-Forward Control Unit (FFCU), deployed in Carina in 2026, achieves approximately 150 nanoseconds from detector input to control output using an RFSoC-based system with a custom analog front-end, providing a concrete benchmark for the latency achievable in current photonic MBQC systems. This adds complexity. In solid-state systems, the speed of classical feed-forward might limit how fast measurements can be done in sequence. Too slow feed-forward could lead to qubits decohering while waiting for the classical signal.
- Consumption of Qubits: Once a qubit is measured, it cannot be used again. This means MBQC tends to use more qubits overall than a gate-based computation for the same algorithm. It’s a one-time usage model, whereas in a circuit model one tries to reuse qubits throughout many gate operations. In MBQC, if you want to apply 100 one-qubit rotations on a logical qubit, you likely need 100 qubits in the cluster lined up, each measured sequentially to enact those rotations. This can be mitigated by clever constructions (you can teleport a state around the cluster rather than have a one-to-one mapping of operations to qubits), but generally the qubit overhead is high.
- Complexity of Design: Mapping an arbitrary algorithm to a sequence of measurements requires some effort. While we know MBQC is universal, designing the measurement pattern (angles and order) for a given circuit is typically done via a mapping: first design a circuit, then translate each gate or block of the circuit into a piece of cluster and measurement pattern. This is systematic but adds an extra compilation layer. Debugging or designing directly in MBQC terms (without referencing circuits) can be unintuitive for those used to thinking in circuits.
- Sensitivity to loss: Particularly in photonic implementations, if a photon is lost (absorbed or not detected) before being measured as part of the cluster, it’s like a qubit that vanished from your cluster. Loss in MBQC can be catastrophic unless the cluster is built with redundancy or some fault-tolerance. Some cluster state proposals incorporate fusion gates that can tolerate a certain loss rate (trading success probability). But generally, MBQC demands high efficiency in state distribution and detection. In other hardware (like ions), “loss” might correspond to qubit dropping out due to decoherence, which similarly needs handling via error correction if it happens.
Cybersecurity Implications
MBQC itself doesn’t change the quantum threat model – it’s another way to achieve a universal quantum computer. Any computation done via circuit model (breaking cryptography, running Shor’s algorithm, etc.) can equally be done on a measurement-based quantum computer given a large enough cluster state. So if photonic MBQC machines scale quickly, they could become the platform that breaks RSA and so forth. For the security community, the rise of MBQC-based efforts (like PsiQuantum’s goal of a million-qubit photonic cluster-state quantum computer, now backed by over 2 billion USD in funding and datacenter-scale compute center construction in Australia and the U.S.) is a signal that scalable quantum computing might come from a different technological direction than superconductors or ions. Photonic MBQC machines might have certain advantages in scaling (e.g. no need for extreme cryogenics for the qubits themselves, though detectors often need to be cooled; ability to leverage optical telecommunications technology). If successful, they could potentially accelerate the timeline to a cryptographically relevant quantum computer.
On the other hand, MBQC has interesting angles for quantum communication and cryptography: Since it is so measurement-centric, it dovetails with quantum networks and blind quantum computing protocols. For example, there are protocols for blind (secure) quantum computing where a client prepares single qubits, sends them to a server that creates a cluster state and measures it, and due to the nature of measurements the server cannot tell what computation it performed (this relies on the randomness of certain measurements). MBQC is naturally suited for such protocols where a user encodes their problem into certain measurement angles and the server does a generic cluster-state measurement routine. This could allow cloud quantum computing with privacy. Also, cluster states are useful in quantum network security – e.g. entangled states like cluster states can be used in quantum network protocols, and MBQC could be performed distributedly, which ties into quantum internet ideas.
In summary, MBQC’s main security implication is simply that it’s an alternate path to building a universal quantum computer — one which topologically and resource-wise might scale differently. A cluster-state photonic computer achieving factoring of RSA-2048 would require the same CRQC capabilities as any other platform attempting it. Whether the resources needed are 20 million physical qubits (the 2021 estimate) or approximately 4 million (the 2025 Gidney estimate), a photonic MBQC machine would need to demonstrate the capabilities I track in my CRQC Quantum Capability Framework. Therefore, security professionals should track MBQC efforts as closely as circuit-based efforts. On the positive side, MBQC contributes to quantum cryptographic protocols and might enable more flexible quantum-secure cloud computing.
Who’s Pursuing
PsiQuantum (Palo Alto) is the most heavily capitalized photonic MBQC company. PsiQuantum is building a fusion-based photonic quantum computer using single-photon qubits manufactured at GlobalFoundries on 300 mm silicon wafers, and has raised over 2 billion USD including a 1 billion USD Series E in September 2025. PsiQuantum broke ground on datacenter-scale quantum compute centers in Brisbane, Australia, and Chicago in 2025, and signed a 100 million USD CHIPS Act Letter of Intent with the U.S. Department of Commerce in May 2026. Their approach targets a million-qubit photonic cluster-state machine using MBQC with topological error correction.
Xanadu (Toronto) went public in March 2026 (Nasdaq/TSX: XNDU) through a SPAC merger generating 302 million USD in gross proceeds, becoming the first publicly traded pure-play photonic quantum computing company. While Xanadu’s early work focused on continuous-variable Gaussian boson sampling, its roadmap has shifted toward universal fault-tolerant photonic QC using GKP-encoded qubits in a measurement-based architecture. Xanadu’s Aurora system (Nature, January 2025) demonstrated 12 logical GKP qubits with real-time error-correction decoding in a modular, networked four-rack architecture interconnected by 13 km of optical fiber across 35 integrated photonic chips. In June 2025, Xanadu published a second Nature paper demonstrating the first on-chip generation of GKP states on a scalable 300 mm wafer platform. The company’s published roadmap targets up to 100,000 physical qubits and 500 logical qubits by 2029–2030, and a quantum data center by approximately 2030.
QuiX Quantum (Netherlands/Germany), a University of Twente spin-off, announced Carina in July 2026, a discrete-variable measurement-based universal photonic quantum computer designed for customer deployment. Carina was developed as part of the Universal Photonic Quantum Computer (UPQC) project of the DLR Quantum Computing Initiative (DLR QCI), funded by the German Federal Ministry of Research, Technology and Space. The system uses single-photon qubits generated via spontaneous four-wave mixing (SFWM) in silicon micro-ring resonators, on-chip GHZ-state cluster generation, and a custom Feed-Forward Control Unit (FFCU) with 150 ns measured latency. At eight input photonic qubits and four computational photonic qubits, Carina is an architecture demonstration rather than a computationally capable machine, but QuiX positions it as the first customer-deployable universal photonic quantum computer. The company’s next-generation Dedalo architecture targets logical qubits and loss-error tolerance.
Quandela (France) is pursuing gate-based photonic quantum computing using quantum-dot single-photon sources rather than MBQC, but its photonic integration work contributes to the broader photonic QC ecosystem.
In academia, the University of Bristol’s Quantum Engineering group and University of Oxford have strong photonic MBQC research, as does the University of Vienna and USTC in China (Jian-Wei Pan’s team), which has demonstrated some of the largest entangled photon states. The University of Tokyo’s Furusawa group continues to advance continuous-variable cluster state generation.
Beyond photonics, measurement-based ideas are relevant in trapped ions and superconducting circuits. Researchers have created small cluster states of ions in a trap and executed one-way logic on them; however, the circuit model is currently more natural for those platforms. Distributed quantum computing initiatives (like the EU’s quantum network projects) consider MBQC for linking remote processors, since entangled states across a network can be used via measurements to perform joint computations.
Quantum Computing Modalities Within This Category
Photonic Cluster-State Computing
Photonic Cluster-State Computing is a specialized approach to quantum computing that leverages measurement-based quantum computing (MBQC) using photonic qubits. Instead of executing quantum logic gates sequentially as in traditional circuit-based quantum computing, this model begins by creating a highly entangled cluster state of photons, which serves as a computational resource. Computation is then performed by adaptive single-qubit measurements, where each measurement steers the remaining entangled photons in a way that implements quantum operations.
Ion Trap/Neutral Atom Implementations of MBQC
Trapped ions and neutral atoms have emerged as highly versatile platforms for measurement-based quantum computing (MBQC), a method where entangled resource states are prepared first and then consumed through a sequence of adaptive measurements to perform logical operations.
