Quantum programs return probability distributions, not values — and the same job costs $6 on one vendor, $961 on another. Qontinuum is the platform for quantum software engineering: statistical testing, cost & execution intelligence that reasons about where to run, provider-agnostic plugins, and offline observability — from your terminal to CI.
Run a perfect Bell pair twice at 4,000 shots. You get two different answers — both correct. Every classical test runner calls that a failure. Regression testing quantum programs is a statistics problem, and your toolchain doesn't speak statistics.
Decorate a circuit factory, attach checks. Assertions are statistical tests — total variation distance, chi-squared, fidelity, two-sample snapshot baselines — and every one is shots-aware: if your threshold is below the sampling noise floor, Qontinuum refuses to run a test that would be flaky by construction, and tells you the shot count that fixes it.
$ qont test✓ q_test_bell.py::bell_pair aer, 4000 shots, 30 ms ✓ is_maximally_entangled TVD 0.011 < 0.05 ✓ no_odd_parity_leakage✓ q_test_ghz.py::ghz_5 aer, 4000 shots ✓ snapshot two-sample p = 0.44! q_test_deep.py::qaoa_layer ! tvd_threshold=0.01 is below the sampling noise floor 0.0289 at 4000 shots. Use ≥ 33380 shots or threshold ≥ 0.0289. 2 passed, 0 failed, 1 statistically unsound
@qtest(shots=4000, backend="ibm:manila") # real calibration snapshotdef bell_under_noise(): ... @qtest(shots=4000, backend="ibm:brisbane@live") # today's noisedef bell_today(): ... ✓ survives_real_calibration_noise TVD 0.041 < 0.2 under ibm:manila
IBM publishes per-device calibration data — gate errors, readout errors, T1/T2. Qontinuum turns it into local noise models, so every push answers "does my circuit still survive realistic noise?" without accounts, queues, or bills. Live calibration is one @live suffix away.
Providers price by shots, by seconds, by gate-shots, by credits. Qontinuum encodes every model in a verified, source-linked catalog and prices your whole suite before you spend a cent.
the identical 12,000-shot suite, cheapest vs priciest device
| PROVIDER | DEVICE | MODEL | EST. COST |
|---|---|---|---|
| AWS Braket | Rigetti Cepheus | per-shot | $6.00 |
| IBM Quantum | Heron (PAYG) | per-second | $9.61 |
| AWS Braket | IQM Garnet | per-shot | $18.30 |
| Azure Quantum | IonQ Aria 1 | gate-shot formula | $63.29 |
| AWS Braket | IonQ Forte | per-shot | $960.90 |
| Azure Quantum | Quantinuum H2 | HQC credits | 137.4 HQC |
One sticky comment per PR, updated in place: every statistical check with its actual statistic, and what the suite would cost on real hardware. Like Infracost did for Terraform — a 100× price decision stops hiding in the invoice.
✅ 5 passed · 0 failed · 0 errors (5 tests, 20,000 shots, seed 42)
| Provider | Device | Est. cost |
|---|---|---|
| AWS Braket | Rigetti Cepheus | $10.00 |
| IBM Quantum | Heron (PAYG) | $16.01 |
| AWS Braket | IonQ Forte | $1,601.50 |
qont route ranks devices by estimated success probability × price — cheap-but-noisy vs pricey-but-clean, resolved with one number. And when you do run on real QPUs, qont run prices the entire suite before the first shot is submitted. The default budget is $0: spending is always an explicit decision.
$ per successful shot batch — lower is better
$ qont run --on braket:rigetti_cepheusspend guard: estimated cost $10.00 exceeds the --max-costbudget $0.00; nothing was submitted.Re-run with --max-cost 10.00 or higher to proceed. $ qont run --on braket:rigetti_cepheus --max-cost 12ran on braket:rigetti_cepheus; estimated cost $10.00✓ bell_pair hw:braket:rigetti_cepheus, 4000 shots ✓ is_maximally_entangled TVD 0.078 < 0.2
Running a circuit is an engineering decision, not a coin flip — the same job can cost 100×, run 10× slower, or return noise instead of signal on the wrong device. qont recommend, qont plan, and qont health turn the evidence you already have — the cost catalog, published calibration, and your local run history — into ranked, explained execution decisions. Rule-based, provider-agnostic, fully offline. No AI model, no hardcoded vendors.
$ qont recommend --strategy balanced# optimizing for balanced # device success cost runtime reliab. 1 IBM Heron (PAYG) 93% $16.01 6s 99% 2 IonQ Aria 1 95% $106.70 24s 99% 3 Rigetti Cepheus 71% $10.00 24s 94% Why: IBM Heron is the balanced pick for this workload. • best balance of fidelity, value, reliability, speed • reliability 99% (catalog) • est. runtime ~6s (queue time not modeled) assumes: success is a per-shot survival estimate confidence: 70%
Every run appends to a versioned local execution database. qont dashboard renders it as a single self-contained HTML file — status timeline, every check's statistic trending against its threshold, hardware cost over time, provider usage, and per-provider success rates. No server, no JS dependencies. And those same records feed the reliability scores the recommendation engine reasons with — the platform gets smarter as you use it.
Assertions refuse thresholds that shot noise can't resolve — flaky-by-construction tests are config errors, not failures.
Canonical hashing ignores register names & formatting. qont diff shows only semantic changes.
Golden baselines compared with two-sample tests; circuit changes flag the snapshot stale — exactly like Jest.
Providers, simulator backends & SDKs are plugins. Qiskit, QASM 2/3, Cirq, PennyLane, IBM & Braket ship built in — add your own via entry points, no fork.
Qontinuum is built in the open, one releasable phase at a time. Everything below the line is shipped and tested today; above it is the honest trajectory — no vaporware, no hype.
Statistical testing & snapshots · multi-provider cost intelligence · noise-aware CI · hardware routing & the $0 spend guard · a provider/SDK plugin architecture · execution intelligence (recommend / plan / health) with a full engineering report · a versioned execution history DB and self-contained dashboards.
An opt-in, privacy-first way to pool anonymous execution metadata into community hardware-reliability, queue, and cost signals that sharpen recommendations. Off by default, fully functional offline; circuits, results, and identity never leave your machine.
Deeper deployment automation on top of the planner, actual-vs-estimated cost variance, reproducibility-aware scheduling, and — if the community wants it — a hosted aggregation endpoint (the client already speaks a documented, host-agnostic contract).
from qiskit import QuantumCircuitfrom qontinuum import qtest, assert_distribution @qtest(shots=4000)def bell_pair(): qc = QuantumCircuit(2) qc.h(0); qc.cx(0, 1); qc.measure_all() return qc @bell_pair.checkdef is_entangled(result): assert_distribution(result, {"00": .5, "11": .5}, tvd_threshold=0.05)