Rigetti vs IonQ vs IQM vs AQT

Every comparison of quantum processors is assembled from specification sheets: qubit counts, published gate fidelities, a price per shot. None of those tell you what the machine returns when you submit a circuit to it, which is the only question a person choosing one actually has.

So we submitted the same circuit to all five processors reachable through a single cloud account, from four different manufacturers, and recorded what came back.

The experiment

A three-qubit GHZ state: one Hadamard, two CNOTs, measure everything. It is the simplest circuit whose output is unambiguous. A perfect machine returns only `000` and `111`, split evenly. Every other bitstring is the device telling you about its own noise, which makes the fraction of shots landing in those two states a direct, if crude, fidelity measure.

Shot counts differ because the devices impose different floors and ceilings, and we used small counts deliberately: this is what a first exploratory run costs, not a benchmark campaign. That constrains what the numbers can support, and the statistics section below says exactly how much.

What came back

device                modality          qubits  shots   in GHZ   fidelity   queue+run   cost
Rigetti Cepheus       superconducting      108     50    40/50      80%      0.6 min  $0.3213
IQM Garnet            superconducting       20     50    48/50      96%      0.4 min  $0.3725
IQM Emerald           superconducting       54     50    48/50      96%     59.7 min  $0.3800
AQT IBEX Q1           trapped ion           12     20    20/20     100%     79.9 min  $0.7700
IonQ Forte Ent 1      trapped ion           36    100   95/100      95%      5.2 min  $8.3000

Cost is the provider's list price passed through without markup: a flat $0.30 per task plus the device's own per-shot rate, which runs from $0.000425 on Rigetti to $0.08 on IonQ. Queue+run is wall-clock time from submission to result, so it includes waiting for the device's availability window rather than only the execution.

Price does not predict accuracy

The received wisdom is that superconducting processors are cheap and noisy while trapped-ion processors are expensive and accurate. The first half survives this test and the second does not.

IonQ costs 26 times what the Rigetti run cost and returned a slightly *lower* fidelity than IQM Garnet, which is superconducting and cost $0.37. Garnet was simultaneously the cheapest device to reach 96%, the fastest to return, and within noise of both trapped-ion machines. If price bought accuracy, that row could not exist.

What does separate cleanly is Rigetti, at 80% against 95 to 100% for everything else. It is the largest processor in the group at 108 qubits and the cheapest per shot by a factor of three, and on this circuit it is also the least accurate. That is a coherent engineering trade rather than a defect, but it is not the trade the spec sheet advertises.

Queue time varies by 200x and tracks nothing

The column nobody publishes is the one that changes how you work. IQM Garnet returned in 0.4 minutes. AQT IBEX returned in 79.9 minutes, and a separate single-shot task on the same device took 178.6 minutes.

That is a 200-fold spread, and it does not correlate with price, modality or qubit count. IQM Emerald and IQM Garnet are the same manufacturer at nearly the same price, and one returned in 24 seconds while the other took an hour. The difference is availability windows: several of these devices accept work only during scheduled periods, so a task submitted outside one waits for the next.

For an interactive session that distinction matters more than the price. A device you can iterate against in under a minute is a different tool from one that answers the next morning, even when both cost thirty cents.

What these numbers will not support

The honest limits, because a comparison that omits them is advertising.

Rigetti's 80% against IQM's 96% at 50 shots each is a two-proportion z of 2.46, so that gap is statistically real. Nothing else here is. The 95% confidence interval on a 50-shot run at 96% is roughly plus or minus 5 points, and AQT's 20 for 20 has a lower bound near 83% despite reading as a perfect score. IQM Garnet, IQM Emerald, AQT and IonQ are not distinguishable from one another on this data, and any article that ranked them from these figures would be inventing precision it does not have.

One circuit is also not a benchmark. A three-qubit GHZ uses two entangling gates and finishes almost immediately, so it barely probes decoherence and says nothing about connectivity, which is where trapped-ion machines earn their price. A deeper circuit needing gates between distant qubits would compile into long SWAP chains on the superconducting devices and run natively on the ion traps, and the ordering above could invert entirely.

Queue times are a snapshot of one afternoon, not a service level.

Choosing one

On this evidence, for a first run on real hardware: IQM Garnet. It returned in under a minute, matched every other device on fidelity, and cost thirty-seven cents. Its ceiling is 20 qubits, which is the actual constraint.

If the circuit needs more qubits than that, Rigetti at 108 is the only one in this group that will take it, and the 80% figure is the price of admission. If it needs deep all-to-all connectivity, the ion traps are worth their cost for reasons this circuit is too shallow to demonstrate. If you simply want to know whether your circuit compiles and runs on real hardware, that is a 10-shot Rigetti task for about thirty cents.

And the answer that is true more often than any of the above: if what you want is the correct output rather than a measurement of hardware noise, none of these is the right purchase. A simulator returns the exact distribution for a tenth of a cent with no queue, and the full cost comparison sets out when hardware is worth paying for.

Reproducing this

Every run above is a job on this service and can be repeated with a different engine name:

import qsim_sdk
c = qsim_sdk.Client(token="...")

for engine in ("qpu.rigetti", "qpu.iqm.garnet", "qpu.iqm.emerald",
               "qpu.aqt.ibex", "qpu.ionq"):
    est = c.estimate(ghz_circuit, shots=50, engine=engine)
    print(engine, est["predicted_cost_usd"])

The estimate is free and returns the exact charge before anything is submitted, which on hardware is worth checking: the same 50-shot request is $0.32 on one device and would be refused outright on IonQ, whose floor is 100 shots. The engine reference lists every device's bounds, and why quantum circuits get rejected covers the refusals you will meet first.