Neither of us is a physicist. Tonight we went from logging in to a free quantum cloud account to a result off a real 20-qubit chip in under ten minutes, with the code written by an AI agent. Then we ran a small optimisation problem on it and graded every answer against a known right one. The hardware did better than we expected, and nothing it did was faster than a laptop. Both halves of that sentence matter.
What we set up
Alfred picked up a leaflet for IQM Resonance at a conference in Berlin. It is the cloud front door to IQM's superconducting quantum computers, with a free tier of real hardware time. The dashboard showed three machines: Garnet (20 qubits), Emerald (54) and Sirius (16), all idle, no queue.
The setup on our side was small: a Python environment with IQM's client library and Qiskit (the most common open-source toolkit for writing quantum circuits), and an access token created with permission to run jobs and nothing else, expiring in a month. That token lives in a file only one user on the box can read. The part that took longest was finding the token page, so we had a browser agent do that too.
Test one: two qubits that should always agree
The standard first circuit is a Bell state. You put one qubit into superposition, entangle a second with it, and measure both. A perfect machine gives back 00 or 11, roughly half each, and never 01 or 10, because the two qubits always agree. Every 01 or 10 is the machine's noise showing, which makes it a clean first measurement. We ran it 1,000 times on each backend.
| backend | agree (00 or 11) | noise (01 or 10) |
|---|---|---|
| IQM's bundled simulator of Garnet | 94.6% | 5.4% |
| Garnet, 20 qubits (real) | 98.5% | 1.5% |
| Emerald, 54 qubits (real) | 98.0% | 2.0% |
The surprise was the first row. We ran the simulator first, as a safe dress rehearsal, and it predicted about 5% noise. The real chip came in at 1.5%, cleaner than IQM's own simulation of it. Our best guess is that the simulator's built-in error model is older and more pessimistic than the machine's current calibration. Each real run took under three seconds end to end.
Test two: a tiny optimisation problem
Max-cut is a classic: split the points of a network into two groups so that as many links as possible cross between the groups. We used five points and six links. That is small enough to check by hand, which was the point: the best possible cut is 5 links, and exactly 4 of the 32 possible splits achieve it. So every answer the machine gave could be graded.
The method is QAOA, a hybrid approach: a short quantum circuit with two tuning knobs. We tuned the knobs on an ordinary computer using an exact simulation, then ran the tuned circuit once on the real chip, 2,000 times.
| average cut | shots that found a best answer | |
|---|---|---|
| random guessing | 3.00 | 12.5% |
| perfect noiseless circuit (the ceiling) | 4.11 | |
| IQM's simulator | 3.94 | about 36% |
| Garnet (real) | 3.96 | 37.6% |
The real chip kept about 96% of what a perfect version of the same circuit would achieve, and it hit a best answer three times as often as guessing. Its four most frequent answers were exactly the four optimal splits. The first wrong one came fifth.
What's still off
None of this is useful work. A laptop solves a five-point max-cut instantly by trying all 32 options, and no quantum machine today beats ordinary computers on problems this size, or on anything we actually run. This was a worked, graded example of the workflow (tune on a normal computer, run once on real hardware, check against ground truth), not a speed-up, and we would be suspicious of anyone who told you otherwise. It was also two experiments on one evening's calibration: the noise figures are a snapshot, and the simulator result moves by a couple of points from run to run.
What it does show is how short the distance has become between curious and hands-on. The whole thing used about eight seconds of machine time, the free tier, and an evening.
What's now in the stack
bell.pyandqaoa_maxcut.py: both run on IQM's local simulator for free, or on a real machine with one flag. They grade their own output and save raw results.- The raw results from all five runs, and the setup steps, on GitHub.