QAOA at 100 Qubits: Real Benchmarks from a Laptop CPU

Everything here is runnable on your own circuit. Try it in the console

QAOA, the Quantum Approximate Optimization Algorithm, is among the most widely run algorithms in quantum computing research and the standard testbed for claims about quantum optimization. One figure is worth stating plainly at the outset: a 100-qubit, depth-304 QAOA MaxCut circuit simulates in 5.9 seconds on a consumer laptop CPU, fully converged, with an accuracy statement attached.

No cluster and no GPU were involved. The GPU on the test machine was idle throughout.

What QAOA is

QAOA addresses combinatorial optimization by encoding the objective as a Hamiltonian whose ground state is the optimal solution, then preparing an approximation to that ground state with a fixed-depth circuit.

The construction alternates two operations. A cost layer applies exp(-i gamma H_C), where H_C is the problem Hamiltonian, phasing each basis state in proportion to its objective value.

A mixer layer applies exp(-i beta H_B) with H_B the sum of X operators, driving transitions between basis states. Repeating this pair p times gives 2p variational parameters, tuned by a classical optimizer.

For MaxCut on a graph, H_C is a sum of ZZ terms over the edges, so the cost layer is a set of RZZ rotations and the mixer is an RX on every qubit. The p = 1 case has a known analytic performance guarantee on 3-regular graphs; beyond that the behaviour is studied numerically, which is why simulation carries the field.

Benchmark setup

The benchmark family is QAOA for MaxCut on ring graphs: n qubits, a layer of Hadamards, then p rounds of RZZ gates along the ring alternated with RX rotations. This is a canonical structured workload with meaningful entanglement, non-Clifford gates and realistic depth. At n = 100, p = 3, the circuit reaches 304 layers of depth as Qiskit counts it.

The engine is a matrix product state simulator built on the open-source quimb library, run at bond dimension 64 with a convergence check. Every run is repeated at bond dimension 128 and the leading outcome probabilities compared.

Circuit                    Qubits  p   Wall time  Converged (deviation)
QAOA MaxCut ring             50    2   4.1 s      yes (0.0)
QAOA MaxCut ring             80    2   4.4 s      yes (0.0)
QAOA MaxCut ring            100    3   5.9 s      yes (0.0)
Exact reference (ansatz)     26    -   2.7 s      exact (ground truth)

Why the circuits compress

The reason a 100-qubit QAOA circuit is tractable is structural rather than incidental, and it generalises.

A ring graph is one-dimensional, so every RZZ gate acts between neighbours and the entanglement generated is local. Entanglement across any cut of the chain grows with the number of layers that have crossed it, which is bounded by p, so the required bond dimension grows with depth rather than with width. At p = 3 the state remains representable at bond dimension 64.

This has a consequence for how such results should be reported. The favourable case is low p on sparse, near-planar graphs.

Dense graphs, or high p, produce entanglement that no bond dimension in reach can hold, and the same engine will report a wide bound rather than a fast answer. The 5.9-second figure describes this circuit family and does not generalise claim about 100 qubits, and the distinction is developed in Tensor networks explained.

Interpreting the result

The result changes the economics of QAOA research. A 100-qubit, 1,000-shot QAOA job on a superconducting QPU costs roughly $0.725 in device fees before queue time, and returns results affected by two-qubit gate error rates near 1 percent across a depth-304 circuit, at which point the surviving signal is minimal. The equivalent simulation costs a fraction of a cent, returns a noise-free value, and carries a convergence record.

The comparison is more lopsided than the per-run figures suggest, because QAOA is a variational algorithm and one run is not the workload. Optimising 2p parameters takes hundreds of circuit evaluations.

A 150-iteration SPSA run is 301 submissions, which is $352.29 on hardware and about thirty cents in simulation. The arithmetic is set out in What does it cost to rent a quantum computer?.

The same algorithm at a size hardware will take

Every run above is simulation, because no available device accepts a 100-qubit QAOA circuit. This is the same algorithm at a size that fits: satellite observation tasking as a 14-qubit QAOA, one circuit at 500 shots, sent to a tensor network, two exact statevector engines and two superconducting quantum processors from IQM.

Run on our engines

Satellite observation tasking at 14 requests, seed 20260902, whose exact optimum is value 32.5128. On 25 September the same instance ran on exact.tpu, a Google TPU, which returned 31.2164 and the smallest gap on the table. Submitted to each kind of compute we offer, on 16 and 25 September 2026 at 500 shots. Every figure below is a real job on the service, priced as any customer would be priced.

Device	Engine	Kind	Qubits	Result	Cost
	mps.quimb.cpu	CPU	14	25.1546, gap 7.36 certificate	$0.0001
	exact.cpu	CPU	14	20.0569, gap 12.46 certificate	$0.0001
	exact.gpu	GPU	14	25.1546, gap 7.36 certificate	$0.0001
	qpu.iqm.garnet	QPU	14	26.8778, gap 5.64 certificate	$1.025
	qpu.rigetti	QPU	14	27.0176, gap 5.49 * certificate	$0.5125
	qpu.iqm.emerald	QPU	14	26.9421, gap 5.57 certificate	$1.100
	exact.tpu	TPU	14	31.2164, gap 1.30 certificate•best outcome	$0.0776
	neural.tpu	TPU	—	the tasking QUBO is diagonal, which is not the shape a neural ansatz is for	—

* The Rigetti row is a separate sample of ours on this same instance, with the QAOA angles re-optimised for it. The steps are in the docs.

A note on the hardware certificates: they state Hellinger fidelity against the exact distribution. For an optimisation circuit that distribution is spread across many outcomes rather than concentrated on one, so the figure is low by construction and is not a measure of whether the device found a good answer. The result column above is.

The same problem is yours to run: every instance here is seeded, so it rebuilds exactly. Open the console and a cost estimate is free before anything executes.

This is the comparison the 100-qubit runs cannot make, because at 100 qubits there is no hardware column to put beside them. At 14 qubits there is, and on this instance the two IQM devices returned the better objective values, for about a thousand times the cost of the simulator rows. One instance at one shot count is not a general result, and the method, the classical baseline and the optimum are on the space and satellites benchmark.

What this does not show

None of this makes QAOA on hardware pointless, and the honest statement of the position is narrower than either enthusiasts or sceptics usually give.

It relocates the interesting scientific question. Whether QAOA outperforms classical optimizers at problem sizes beyond classical simulation requires either substantially larger hardware or instances with entanglement dense enough that tensor-network methods stop converging. The second condition is detectable. The engine reports when its bound has widened past usefulness, and that report is the signal that a genuine hardware experiment is warranted.

It is also worth recording that classical approximation algorithms for MaxCut are strong. Goemans-Williamson guarantees a 0.878 approximation ratio in polynomial time, and QAOA at low p does not beat it on the instances where both have been compared. A quantum optimization result is interesting when it is measured against the best classical algorithm for the same problem, not against brute force.

Reproducing it

Every figure above states the circuit, the engine and the machine, so the run is specified precisely enough to be set up again rather than taken on trust. Each accuracy statement is exported as a public certificate that resolves without an account, and the validation data behind the convergence protocol is published with the protocol paper.

The circuit family is a dozen lines of Qiskit, and the useful exercise is to run it at increasing p and watch the reported deviation move off zero. The point at which it does is the point at which the method's assumptions stop holding, and knowing where that boundary sits for your own problem class is worth more than any single benchmark figure.