How Do You Check a Quantum Computer's Answer? 3 New Methods Explained
Quantum computers are outgrowing classical checks. Here are 3 new verification methods from Google, QuEra and Innsbruck, and what they teach AI agents.

You verify a quantum computer’s answer in three main ways: check small versions against exact classical calculations before scaling up, attach measured error bars to each result, or run tasks with a provable classical limit and beat it. November 2026 research from QuEra and NERSC, TUM and Innsbruck, and Google Quantum AI shows each method working on real hardware.
On this page
- Key takeaways
- What is the quantum verification problem?
- How did researchers put error bars on a quantum simulator?
- How did QuEra and Berkeley Lab trust a 180-qubit result?
- How did Google prove its quantum chip beat classical limits?
- How do the three verification methods compare?
- What does quantum verification teach us about AI agents?
- Why does verified accuracy matter more than speed?
- What happens next in quantum verification?
- Frequently asked questions
Key takeaways
- The quantum verification problem is that useful quantum results are, by design, too big for classical computers to recheck.
- TUM and Innsbruck gave a 51-ion quantum simulator real error bars by learning how the machine actually behaves, including its noise.
- QuEra and NERSC trusted 180-qubit results by first checking small versions against exact supercomputer calculations.
- Google’s Willow won the magic square game 98.3% of the time against a provable classical ceiling of 88.9%.
- The same three moves apply to AI agents: test on known cases, report confidence, and enforce hard rules in code.
Here is an awkward problem nobody warned you about in the quantum computing brochures. The moment a quantum computer does something genuinely useful, nobody can check its homework.
That’s not a joke. It’s the whole point. If a classical supercomputer could recompute the answer, you wouldn’t have needed the quantum machine. So as these machines grow, scientists are stuck with a strange question: how do you trust an answer that nothing else can reproduce?
Over the past fortnight, three research teams made headlines with answers. None of them is "just trust us." Each one is a clever, practical trick, and all three are worth understanding even if you never touch a qubit. Because, as we’ll get to, the same problem is now sitting on the desk of every company that hands real work to AI.
What is the quantum verification problem?#
The quantum verification problem is the challenge of confirming that a quantum computer’s output is correct once the computation is too large for classical computers to repeat. Small quantum experiments are easy to check: you run the same physics on a laptop or a supercomputer and compare. Past a few dozen strongly interacting particles, that comparison breaks down.
The University of Innsbruck put it plainly in its announcement this month: "Where classical simulation is still feasible, results can be cross-checked against it directly; beyond that regime, other methods are needed."
Think of a new hire who is far better at maths than anyone in the office. Wonderful. Also slightly terrifying. Who signs off on their spreadsheet?
There are a few reasons this is hard:
- Exponential growth. Each added qubit roughly doubles what a classical computer must track.
- Noise. Real quantum hardware is imperfect. Stray interactions and environmental noise nudge results in ways that are hard to spot.
- No answer key. For the most interesting problems, there’s no known "right answer". That’s why you ran the experiment.
How did researchers put error bars on a quantum simulator?#
A team from the Technical University of Munich (TUM) and the University of Innsbruck built a method that makes a quantum simulator report its result with error margins, derived from the machine’s own measured behaviour. The work is published in Physical Review X as "Bounded-Error Quantum Simulation via Hamiltonian and Lindbladian Learning."
The team was led by Tristan Kraft (TUM) and Peter Zoller (University of Innsbruck and the Institute for Quantum Optics and Quantum Information), with Barbara Kraus (TUM). The experiments ran on an ion-trap simulator in Innsbruck, led by Manoj Joshi and Christian Roos.
Here’s the clever bit. Instead of assuming the simulator behaves exactly as designed, they watch it and learn how it really behaves, including its noise. Then they push the uncertainty in that learned model all the way through to the final answer.
"The quantum simulator thus provides not just a single value, but a result with error margins that quantify its accuracy," Kraft said, as quoted by ScienceDaily.

They did the sensible thing first: test on 10 ions, a size a normal computer can still handle, and compare against independent measurements. Only then did they scale up to a chain of 51 ions.
The most interesting line comes from Zoller, about how we should judge quantum machines in future: "It’s not just a matter of which one delivers a result faster. What’s also crucial is which one can solve the problem with a smaller, verifiable margin of error."
A faster answer you can’t bound is worth less than a slower one you can. That applies well beyond physics.
How did QuEra and Berkeley Lab trust a 180-qubit result?#
QuEra Computing and the National Energy Research Scientific Computing Center (NERSC) at Lawrence Berkeley National Laboratory trusted their large result by first checking small versions of the same experiment against exact classical calculations. Their study, "Observation of prethermal dynamical phase transitions and resonant melting," was announced as published in Nature on 18 November.
The team paired Aquila, QuEra’s analog neutral-atom quantum computer on Amazon Braket, with NERSC’s Perlmutter supercomputer. Perlmutter ran exact calculations for small systems, and those shaped the larger runs: chains of up to 52 atoms and two-dimensional grids of up to 180.
NERSC quantum adviser Katie Klymko summed up the logic neatly: "Calculations on Perlmutter gave us confidence in Aquila’s results at small scales, so we could trust the new physics it revealed at larger ones."
And the physics was genuinely new. According to the team’s write-up on the AWS Quantum Technologies blog, the atoms held stable patterns far longer than expected, a behaviour called prethermalization. Those patterns "melted" at sharp, predictable points. In two dimensions, the team found a first-order dynamical phase transition with no counterpart in the system’s equilibrium phase diagram.
In plain English: quantum matter can change abruptly in how it evolves over time, not just in what state it’s in. Lovely, slightly mind-bending stuff.
How did Google prove its quantum chip beat classical limits?#
Google Quantum AI proved its result by picking tasks with a mathematically known ceiling for any classical strategy, then beating that ceiling on hardware. The study appeared in Science around 19 November, with the preprint on arXiv under the title "Quantum-Classical Separation in Bounded-Resource Tasks Arising from Measurement Contextuality."
The headline experiment is a puzzle called the magic square game. Two players each get part of a three-by-three grid. One fills in a row, the other a column, using +1 or −1. The row must contain an even number of minus signs, and the column an odd number. They win if they agree on the one square they share. They can plan beforehand, but they can’t talk once the game starts.
Here’s the catch. No fixed cheat sheet can work, because the row rule makes the grid total even and the column rule makes it odd. The best classical strategy wins on eight of nine assignments, which is 88.9%. That number isn’t an estimate. It’s a proof.
Google gave each player qubits from entangled pairs. Running each of the nine assignments 100,000 times on its Willow processor, the team won 98.3% of the time, as The Quantum Insider reports.

The team also reported:
- A contextuality score of 5.59 on a related test, where any fixed-value classical model tops out at 4 and an ideal quantum system reaches 6.
- A win above the classical limit in a GHZ game with up to 71 qubits, each acting as a player.
- A 105-qubit run on a "hidden linear function" problem that returned a valid answer more than half the time. Here the team is honest: the classical comparison rests on a conjecture, so the size of any advantage at that scale is still an open question.
That honesty deserves credit. The firm claims are the ones with a provable bar.
How do the three verification methods compare?#
The three methods compare as three different answers to one question: what do you check against when you can’t recompute the answer? Here they are side by side.
| Method | Who | How it builds trust | Main limit |
|---|---|---|---|
| Check small, then scale | QuEra + NERSC (Nature) | Exact classical results at small sizes calibrate the big run | Assumes behaviour at scale follows from small cases |
| Report error bars | TUM + Innsbruck (Physical Review X) | Learns the real machine, then bounds the error on each result | Not yet shown on 2D simulators, the team’s next step |
| Beat a provable limit | Google Quantum AI (Science) | The task has a mathematically known classical ceiling | Only works for tasks with a provable ceiling |

Notice what none of them say: "the machine is very advanced, so the answer is probably fine." Each builds a specific, inspectable reason to believe the output. The field is maturing from "look how big our chip is" to "look how sure we can be."
What does quantum verification teach us about AI agents?#
Quantum verification teaches us that the more capable a system gets, the more deliberately you have to design how its work gets checked. That’s exactly the position businesses are in with AI agents right now.
An AI agent is software that takes a goal, makes decisions and carries out multi-step work across your tools, like reading an invoice, matching it to a purchase order and booking it. (We wrote a plain-English guide to agentic automation if you want the longer version.) Nobody re-does every task by hand, because then why have the agent? So you have the same problem the physicists have. You need trust that doesn’t depend on repeating the work.
When we build specialised agents for operations teams at Incube, we lean on the same three moves, almost one for one:
- Check small, then scale. Before an agent touches live work, we run it against a set of past cases where the right answer is already known. Your own history is the "Perlmutter" here. Only when it passes do we widen the scope.
- Report error bars. A good agent shouldn’t just give an answer. It should say how sure it is, and route low-confidence cases to a person. That’s the TUM and Innsbruck idea, translated into an approval queue.
- Check against hard rules. Some things have a provable bar. An invoice total either matches the line items or it doesn’t. A refund either sits inside policy or it doesn’t. We encode those as deterministic checks the agent can’t talk its way around.
Take our invoice processing agent as an example of how that looks in practice. The arithmetic and the PO match are hard checks. Odd vendors or unusual amounts go to a human with the reason attached. Every action is logged, so you can see what happened and why. And there’s always a way to pause the whole thing, which we covered in our piece on AI agent kill switches.
This is also why we think specialised agents beat do-everything ones for real operations work. A narrow job has a clear answer key. A narrow job can be tested properly. "Handle all of finance" can’t be checked. "Match supplier invoices to POs and flag exceptions" can.
Why does verified accuracy matter more than speed?#
Verified accuracy matters more than speed because an answer you can’t trust has to be checked by hand, and that wipes out the time you saved. Zoller made this point about quantum simulators. It’s just as true for an agent closing tickets or triaging an inbox.
Here’s a quick test for any AI system someone wants to build for you:
- What did you test it on before it went live? "Our demo" is not an answer. Real past cases with known outcomes are.
- How does it show uncertainty? Look for confidence levels and a clear path to a human.
- Which rules are hard-coded? Policies, limits and maths should be checked by code, not judged by a model.
- Can you see what it did? Every action should leave a trail you can audit.
- Who is in control? A person should be able to pause, override or roll back at any time.
If a system can answer all five, it’s in the same spirit as this month’s quantum research: capable and checkable. If it can’t, it’s a brilliant new hire with no manager.
What happens next in quantum verification?#
Next, the TUM and Innsbruck team plans to bring its error-bar method to two-dimensional simulators, where classical checks get much harder. Google frames contextuality games as a new way to benchmark processors and catch hardware errors other checks miss.
The common thread is useful for all of us. As machines get smarter, "is it powerful?" becomes a less interesting question than "how do we know it’s right?"
So here’s a question to take to your team this week: for the work you’re thinking of handing to AI, what is your answer key? If you can name one, you’re ready to automate it safely. If you can’t, that’s the first thing to build.
And if you’d like a specialised agent that’s tested against your own cases and checked at every step, that’s what we do at Incube. You can see the rest of our agent services here.
Frequently asked questions#
What is the quantum verification problem?
The quantum verification problem is the difficulty of confirming that a quantum computer’s output is correct once the task is too large for classical computers to repeat. Small experiments can be cross-checked on ordinary hardware, but past a few dozen strongly interacting particles that comparison becomes impractical, so researchers need other ways to build trust in the result.
How did Google’s Willow chip beat the classical limit?
Google Quantum AI ran the magic square game, where the best possible classical strategy wins 88.9% of the time. Using entangled qubits on its Willow processor, and running each of the nine assignments 100,000 times, the team won 98.3% of the time. The results appeared in Science in November 2026.
What are error bars on a quantum simulator?
Error bars on a quantum simulator are measured limits on how far a result could be from the truth. Researchers at TUM and the University of Innsbruck learned how their ion-trap simulator really behaves, including noise, then propagated that uncertainty into each result. They validated the method on 10 ions and applied it to 51.
Can quantum computers be trusted today?
Some quantum results can be trusted today when they come with a clear verification method, such as a provable classical limit, a small-scale classical cross-check, or measured error bounds. Claims without such a method deserve caution. Google’s own team, for example, notes that its 105-qubit advantage estimate rests on an unproven conjecture.
How do you verify the work of an AI agent?
You verify an AI agent much like a quantum computer: test it on past cases with known answers before going live, have it report confidence and route uncertain cases to people, and enforce hard rules such as totals and policy limits in code. Incube builds its specialised agents around these checks, with every action logged.
Put your first agent to work
Start with one workflow, clear guardrails and a measured pilot. We handle the audit, the build and the running.
Start a Pilot

