Atlas · Execution economics · TRIAGE-COST

Execution Economics — what each circuit costs, classically vs on a QPU. Audited.

Every other tool answers "run my method." Atlas also answers the money question: what would this circuit cost on a real QPU, and what does the classical route cost instead? The number is built from a formula you can see, with assumptions you can edit — labeled published / measured / derived, never a black box.

TRIAGE-COST v3 · pricing snapshot ~2026 (verify at the vendor links below) · deploy/app/economics.py
The one-line answer. Across 111 published/community circuits, the classical route — when it exists — costs between fractions of a cent and a few dollars per evaluation; the same circuits on a QPU cost $800–$17,000+. Where no classical route exists (the genuine frontier), a QPU is the only option — and Atlas tells you which side you're on.
Read this first. Every QPU figure here is a counterfactual — the spend you avoid by not mis-routing a tractable circuit, not a realized saving. Figures are dated, representative examples (published pricing snapshot 2026-06-25, IonQ Forte via AWS Braket, ε=1e-2); the real number depends on circuit, vendor and target precision. Decision-support estimates only — not financial advice; verify pricing at the vendor before any spend. See Terms.
The Spend Frontier: per-circuit classical cost vs QPU cost across 111 published and community circuits, log scale, with the classical-tractable band and the escalate frontier marked
The Spend Frontier. Real per-circuit data from Atlas's engine routes: measured/modeled classical cost vs published QPU pricing (IonQ Forte via AWS Braket, ε=1e-2, PEC mitigation overhead included). 115 circuits in the corpus, 111 plotted, 4 unpriceable excluded and logged. Reproducible from benchmarks/spend_frontier/ in the repo · pricing snapshot 2026-06-25 · counterfactual framing applies to every QPU figure.
Price your own circuit → Download a decision memo from any verdict

The $17,560 you don't spend

multiplier_n45 (QASMBench, 45 qubits) carries #T = 2,646 — on paper, a hard circuit. Atlas routes it CPU: the engine runs it at MPS bond dimension 1, measured classical cost $0.000177/eval. The same job on a QPU: $17,560.86. Magic ≠ hardness.

Counterfactual: spend you avoid by not mis-routing — not a realized saving.

The middle band

mqt_randomcircuit_n24 (MQT Bench, 24 qubits): Atlas's own estimators hit their budget — yet the TENSOR route still prices the classical side at $3.91e-4/eval (modeled contraction cost at HPC rates) vs $10,853.50 on a QPU.

The classical figure here is modeled from contraction FLOPs, not wall-clock measured — labeled as such in the data.

Where a QPU is warranted

sycamore_rcs_53q_depth20 (Sycamore-scale RCS): route ESCALATE — no classical price exists in Atlas's measured reach. The QPU side prices at $1,381.34/eval; the 127-qubit kicked-Ising utility circuit at $4,504. Atlas escalates them instead of pretending.

Escalate is an indication — beyond Atlas's measured classical reach — not a proof that no classical algorithm exists.

For auditors — the formula behind every number

Everything above is computed, not asserted. This section is the full derivation: shots from precision, mitigation overhead, per-device calibration, vendor billing models, the measured classical side, and where this sits against other cost tools. Every term labeled published / measured / derived.

The defensible figure. For a tractable circuit a laptop settles in milliseconds, the avoided QPU job at casual precision (ε=1e-2, ~10,060 shots) costs ≈ $805 on IonQ Forte — derived exactly: $0.30 task + 10,060 shots × $0.08/shot, published Braket pricing. At research-grade precision (ε=3e-3, ~112k shots) the same job is ≈ $8,900. Open the panel and recompute — that is the point. See also the corpus-wide exhibit above — the $805-class job appears there as mqt_cdkm_ripple_carry_adder_n18 at $801.26/eval.
Read this first. $805 / $8,900 are a representative published-pricing example for ONE circuit; the real number depends on circuit, vendor and target precision. Pricing snapshot as of 2026-06 — verify at the vendor. Decision-support estimate only — not financial advice; the pricing snapshot may be stale; verify before any spend. See Terms.

1 Shots from precision

To pin an expectation value to additive error ε you need shots that beat shot-noise (error ~ 1/√N):

N_base = ⌈ 1 / ε² ⌉

ε=1e-1 → 100 · ε=1e-2 → 10,000 · ε=3e-3 → ~111,111. derived (textbook shot-noise). Vendor floors apply (e.g. IonQ error-mitigation minimum 2,500 shots).

2 Mitigation overhead — the sensitive heart

Real hardware is noisy, so a usable expectation value needs error mitigation, whose sample overhead grows exponentially with circuit volume × noise (probabilistic error cancellation):

N = N_base · γ², γ² = e^(4·λ), λ = ε_g · n₂q

published bound — Quek/Eisert arXiv:2210.11505, Takagi arXiv:2109.04457. n₂q = two-qubit gate count, ε_g = per-gate error (next section).

Where a reviewer will push — and we agree. This exponent is the single most assumption-sensitive number in the whole panel: small changes in ε_g or the mitigation model move the QPU cost by orders of magnitude. That is exactly why Atlas exposes ε_g and the formula as editable and sourced — the honest answer to "why this model?" is "PEC, published, and you can swap it," not "trust us." We label it published, never measured.

3 Per-device gate error ε_g — the calibration

The exponent rides on ε_g, so Atlas uses per-device values, not one generic number:

Deviceε_g (2-qubit)Provenance
IBM (Heron r2)2.0e-3measured — Atlas's own ibm_kingston RB (2.02e-3 isolated; 3.42e-3 EPLG layered)
Rigetti5.0e-3published — 99.5% 2q fidelity
IQM (Garnet/Emerald)5.0e-3published — 99.51%
IonQ (Forte/Aria)3e-4vendor-claimed — no hard public 2q figure; optimistic, flagged uncertain

The IBM number is measured on our own hardware runs — and that calibration data ships in the repo (kingston_calibration.json). Note: IBM Quantum device data (job IDs, calibration, results) is IBM's data, used under IBM Quantum's terms — NOT licensed under Apache-2.0; only Atlas's own code/corpus/scripts are. The rest are published/claimed and editable.

4 Two pricing families — billed how the vendor bills

Most naïve estimators invent a $/shot for IBM. IBM doesn't bill per shot — it bills per minute of QPU time. Atlas branches:

per-shot (AWS Braket): cost = task_fee + N · per_shot per-minute (IBM): cost = runtime_min · rate_per_min

published tariffs — AWS Braket (IonQ $0.08/shot + $0.30/task; Rigetti $0.000425; IQM/AQT/QuEra) · IBM plans (Open free · Pay-As-You-Go $96/min · Flex $72/min · Premium $48/min). Verify: AWS Braket pricing · IBM Quantum plans.

Two honest caveats. (1) Pricing is the most perishable data on the panel — published ~2026, snapshot-dated, verify at the links. (2) IBM "Open" is genuinely free ($0/min, quota-limited); plan minimums (Flex's 400 min/month) are monthly commitments and are not applied per-circuit (an earlier build did, inflating Flex — fixed).

5 The classical side — measured, not estimated

The whole verdict is a comparison, so the classical cost is measured, not guessed: Atlas times the real MPS/tensor contraction (quimb) for the circuit and prices the wall-clock at a cloud-CPU rate. The reference machine is a dev Apple M4 (24 GB) — see the per-estimator ceilings on the Evidence page.

avoided $ = QPU_cost − classical_cost (when a classical route is certified)

A laptop that settles the circuit in milliseconds at near-zero cost, versus the QPU job above, is the "don't spend" verdict in dollars.

6 Worked example (reproducible)

IonQ Forte, a small tractable circuit a laptop runs in ms:

Precision εShots (incl. mitigation)QPU $/job
1e-1 / 3e-22,500 (vendor floor)$200.30
1e-2 (casual)~10,060≈ $805
3e-3 (research-grade)~111,781≈ $8,900

Every row is recomputable from §1–4 with the published pricing; the panel lets you change vendor, ε and campaign size and watch the number move.

7 Where this sits vs other cost tools

Vendor pricing tools — AWS Braket, IBM Quantum, IonQ — price their own hardware: useful once you've decided to run, silent on whether you should. Fault-tolerant resource estimators — Microsoft's Azure Quantum Resource Estimator and BenchQ — answer a different, future question: the physical qubits and runtime a large algorithm would need on a fault-tolerant machine that does not yet exist. Work on quantum economic advantage and the QEA online calculator estimate theoretical crossover points by algorithm class, not the measured cost of your circuit today. Atlas fills the near-term gap between them: it triages whether this specific circuit is classically simulable, measures what running it classically actually costs, and sets that against published QPU pricing — one auditable spend-or-don't-spend verdict for the hardware you can rent right now. We are not aware of another tool that combines all three.

Pricing shown is a dated snapshot under declared assumptions; classical time is measured, QPU cost is published pricing; decision support, not financial advice.

Where the moat actually is (stated plainly). Not the formulas — shot-noise, the PEC overhead and the pricing tables are all public, and anyone could code an estimator. The defensible edge is the same one as the rest of Atlas: (1) the integration — measured classical cost vs calibrated QPU cost as a single spend / don't-spend verdict (vendor calculators only price their own hardware; none tell you a laptop does it for free); (2) measured device calibration (ε_g from our own QPU runs); (3) per-shot-vs-per-minute modeled correctly; (4) full auditability — every term labeled and sourced. The page you are reading is the moat: a cost number you can recompute, versus a black-box calculator you can't.
Open the cost panel → How the verdict is produced