Experimental — the macro value is a Dyno-Sim run under active development. The classical target the QAE reproduces is a research-grade, disclosed-dial simulation figure, not a calibrated forecast; the quantum method result below — QAE recovers the encoded amplitude — is independent of it and stands on its own. Capability + methods demonstration. This describes a shipped prototype run on a classical statevector simulator of a quantum circuit; the result re-runs from a single command against a hash-pinned ground truth. Explicitly not a claim of quantum speedup, and not investment advice.
Updated 2026-08-13. Editorial-only softening: the classical target the QAE reproduces is now described as a committed classical value (hash-pinned) rather than a number "we already know is correct." This decouples the quantum method result — QAE recovers the encoded amplitude to 0.0003, which stands on its own — from any future revision of the underlying macro figure. No numbers changed (the 0.4703 flip is itself a dt-converged, confirmed value). Added an "experimental / under active development" lead scoped to the macro value, leaving the quantum-method claim intact.
Quantum computing reaches most technology leaders as a slide before it reaches any stack: quadratic speedup on Monte Carlo, therefore risk calculations get dramatically faster, therefore be worried or excited — and budget accordingly. If you own an architecture roadmap, an innovation budget, or an investment thesis, that slide leaves your actual problem unsolved: you have to decide what to fund, watch, or ignore, and nothing in the pitch tells you what's real today.
It also skips the part that matters — that on today's hardware, for the problems most firms actually run, there is no speedup yet. The honest work, the work that supports a spend/watch/ignore decision, is to show where the line is.
So Comuvia's system did the unglamorous version. It took the quantum algorithm behind the speedup story, pointed it at a committed classical value from our own simulator, and checked one thing: does it recover that committed value from scratch? What follows is the run, the numbers, and the transferable method for putting any frontier-tech claim through the same test.
The claim under test
Quantum Amplitude Estimation (QAE) is the real basis for the "quantum speeds up Monte Carlo" story. Classical Monte Carlo estimates a probability with error that shrinks like 1/√N in the number of samples; QAE's error shrinks like 1/N in the number of queries — a quadratic improvement, in principle. That "in principle" is doing enormous work, and most coverage never tests it on anything real.
The test: take a probability we'd already computed and verified classically, encode it into a quantum circuit, and see whether QAE recovers it — with the error scaling the theory promises.
The run
From Comuvia's economic simulator, Dyno-Sim, we had a committed, classically computed value: a 47.0% probability that a recommended policy stance flips under a 20,000-replica shock ensemble (the subject of a companion piece). The system hashed that classical result so the comparison couldn't drift, encoded the probability as a quantum circuit amplitude, and ran QAE to recover it from scratch.
Flow diagram: Dyno-Sim's classical risk number is hash-pinned, encoded into a quantum circuit as an amplitude, recovered by quantum amplitude estimation, and checked against the pinned truth — absolute error 0.0003 vs a 0.0010 classical standard error, with no speedup claim
The validation loop: the truth is computed classically and frozen first, then the quantum algorithm has to earn its number back from scratch — and the check runs against the pinned value, not a moving target.
| Quantum Amplitude Estimation vs. the classical ground truth | Result |
|---|---|
| Classical probability (the truth) | 0.4703 |
| QAE estimate (from the circuit) | 0.4700 |
| Absolute error | 0.0003 |
| Classical standard error at the same query budget | 0.0010 |
| Did QAE beat the classical error rate? | Yes — error below the 1/√N standard error at equal budget |
The algorithm works: it recovered the real number to within three ten-thousandths, with error below what classical sampling achieves at the same budget — the quadratic-scaling property, demonstrated against ground truth we had already verified.
Dyno-Sim quantum-ready risk estimation view: QAE estimates vs. hash-pinned classical ground truth for three tail-risk estimands, with the recommendation-flip row reading 0.4703 classical vs 0.4700 QAE
The validation as it appears in Dyno-Sim's live operator dashboard (screenshot). The
recommendation_flip row is the headline number above: classical truth 0.4703, QAE estimate
0.4700 with a [0.4700, 0.4704] 95% interval — absolute error 0.00033 against a classical
standard error of 0.00097 at the same 266,000-query budget. Ground truth is the hash-pinned
classical tail-risk surface from a Minsky–Keen macro scenario driven by historically calibrated
1990–2020 productivity shocks, and the view carries its own disclaimer: not a speedup, no
quantum-advantage claim.
The honest caveat (this is the whole point)
Here is the sentence the hype slides omit:
This ran on a classical simulation of a quantum circuit, and for a problem this size, classical GPU Monte Carlo is still faster. There is no quantum speedup here — and we will not claim one.
Today's quantum hardware can't load a realistic risk distribution into a circuit efficiently (the "state preparation" problem is the well-known blocker), and simulating the circuit classically is, by definition, not faster than computing the answer classically. Anyone selling you a quantum risk speedup in 2026 is selling the destination as if it were the directions.
So why build it at all? Three honest reasons, none of them "faster":
- The algorithm is validated against a result we already trust — so when hardware matures, we're extending something proven, not starting a science project.
- The stack is ready. The same circuit is built to run on NVIDIA's cuQuantum / CUDA-Q GPU quantum-simulation stack — forward-readiness on hardware we already operate.
- Credibility through honesty. Showing exactly where the frontier tech doesn't help is how you earn trust on where it eventually will.
The transferable method: validate against ground truth you already own
Strip away the word "quantum" and this is a general discipline for evaluating any frontier-tech claim — agentic AI, neuromorphic, a new accelerator, a vendor's benchmark:
- Reproduce a result you can already check. The quantum estimate is only "right" because it matched a classical number we had independently verified. A frontier capability that can't reproduce a known answer is a demo, not evidence.
- Pin the ground truth. The system hashed the classical surface so the comparison couldn't quietly move. If the target shifts to fit the result, it isn't a test.
- State where it loses, not just where it wins. "Validated, and here is exactly where it does and doesn't beat what you run today" is a more useful — and more trustworthy — answer than a speedup number with no conditions.
Run a claim through those three steps and it lands in one of three buckets — and each bucket has a different price tag:
Framework diagram: three validation steps — reproduce a known answer, pin the ground truth, name where it loses — leading to three verdicts: NOW (adopt), WATCH (forward-ready, where QAE for risk sits in 2026), and HYPE (walk away)
The frontier-claim triage. Quantum risk estimation in 2026 lands in WATCH: the algorithm is validated and the stack is ready, but the spend trigger — hardware that loads real distributions — hasn't fired. That verdict costs a prototype; believing the hype slide costs a program.
The whole validation re-runs from one command against the pinned surface, so the verdict can be checked rather than taken on faith:
python scripts/quantum/run-qae-validation.py --surface <pinned-tail-risk-surface.json>
What a leader does with this
If quantum — or any frontier technology — is in your vendor pitches, on your roadmap, or in your diligence pipeline, the question isn't "is it impressive?" It's "does it reproduce something I can already verify, and where exactly is the line between real and not-yet?" Answering that with the run attached is a frontier-tech readiness assessment, and Comuvia does it in two forms: continuously, as a fractional AI advisor who owns your watch-list and re-tests claims when their triggers fire; or as a bounded architecture review when one decision needs the validation bench now.
And this is the AI-managed organization speaking about its own work: the validation harness we would build for you is the one we run on ourselves — the same discipline behind our simulation-backed decision support, documented end-to-end at /company-ai-system. The advisor who tells you where a technology loses is the one to trust on where it wins.
Bottom line. Achieved: a quantum-amplitude-estimation prototype recovers a committed classical value against owned ground truth (0.4700 vs 0.4703 classical) — with no production speedup claim. Business value: a vendor-neutral team that validates frontier tech on its own stack and tells you, with the run attached, whether it's now, watch, or hype — before you spend on it.
Comuvia evaluates frontier technology the way it builds everything else: validated against owned ground truth, with the limits named. This prototype runs on a classical circuit simulator to demonstrate the algorithm and the readiness; it is not a quantum speedup claim. This run cost roughly $0. Not investment advice.
Quantum Computing for Risk, Without the Hype — cover