Every quantum computer maker likes to lead with a big number. So many qubits, up from so many last year. It is the easiest figure to print and the least honest, because a qubit that decoheres halfway through a calculation contributes nothing to the answer. IonQ's response to that problem is a metric it calls the algorithmic qubit, written with a hash mark as #AQ. The idea is blunt: stop counting the qubits you built and start counting the ones that can survive a real program.
What the number is trying to capture
A raw qubit tally tells you how many physical two-level systems sit inside the machine. It says nothing about how deep a circuit those qubits can run before noise scrambles the result. Two gates deep, most machines look great. A few hundred gates deep, many collapse into random noise. The useful question is not how many qubits exist, but how large a genuine computation the hardware can complete with an answer you can trust.
#AQ tries to answer exactly that. The number is defined so that a machine rated at, say, #AQ 20 can run circuits that use 20 qubits with roughly the gate count a real algorithm at that width would demand, and still return a result above a fidelity threshold. Crucially, the gate depth scales with the width. Wider circuits are expected to be deeper, which is where noise does its damage. So climbing one point on the #AQ scale is harder than adding one physical qubit. You are being asked to preserve coherence across more operations at once.
Where it comes from
IonQ did not invent the underlying tests in isolation. The metric draws on a suite of application-oriented benchmarks developed through the Quantum Economic Development Consortium, a group that includes national labs, universities, and companies trying to standardize how these machines get graded. Instead of a single abstract score, the suite runs recognizable algorithmic building blocks: quantum Fourier transforms, amplitude estimation routines, small optimization and chemistry kernels. Each is run at a range of widths, and the machine's fidelity on each is measured against the ideal output.
The philosophy differs sharply from earlier scores. Quantum volume, popularized by IBM, uses random square circuits and reports a single exponential figure. CLOPS measures speed, how many circuit layers per second the system can chew through. #AQ instead asks a workload question: given the kinds of circuits people actually want to run, how far can this hardware go before the answer stops being meaningful?
Why trapped ions look good on this test
The metric flatters IonQ's technology for a real reason, not just marketing. Trapped-ion qubits share a data bus, the collective motion of the ion chain, which lets any qubit interact with any other. That all-to-all connectivity means a circuit does not need a long chain of swap operations to bring distant qubits together, the way a superconducting chip with only nearest-neighbor links often does. Fewer swaps means fewer gates, and fewer gates means less accumulated error at a given circuit width. When your benchmark rewards deep circuits that stay accurate, connectivity pays off directly.
Ion qubits also boast long coherence times and high two-qubit gate fidelities, both of which push the #AQ figure up. The tradeoff is speed. Ion gates are slower than superconducting ones, which is precisely why a company strong on fidelity would favor a fidelity-weighted metric over a speed-weighted one.
The catch every buyer should notice
No single number escapes gaming. Because #AQ is defined against a specific benchmark suite with a specific fidelity cutoff, vendors optimize for the tests that count. A machine tuned to score well on quantum Fourier transforms may behave differently on a chemistry problem that stresses a different gate pattern. The threshold itself is a choice; move it, and scores shift. And error mitigation, the software tricks that clean up noisy outputs after the fact, can lift a score without any change to the underlying hardware. That is not cheating, but it does blur what the number represents.
The honest way to read #AQ is as one useful lens among several. Pair it with raw qubit count, gate fidelity, connectivity, and clock speed, and you get a rounded picture. On its own, it does what it was designed to do: puncture the fantasy that a headline qubit tally tells you what a machine can compute. The qubits that matter are the ones still standing when the last gate fires.
