Managed quantum infrastructure for research institutions, national programs, and enterprise R&D. Connect every framework and vendor, run the full pipeline under governance and cost control, and read the hardware landscape in data — no vendor lock-in, no rewrites per provider.
Bring your circuit once. UQH detects the framework, optimizes and noise-checks it, applies error mitigation and error correction, prices it across vendors, and runs it on the backend you choose — then turns every run into operational intelligence.
Nine SDK frameworks and eight hardware vendors across superconducting, trapped-ion, neutral-atom, and photonic — behind one interface.
Noise simulation, readout + ZNE mitigation, Pauli-check postselection, and QEC analysis make results trustworthy — with cost known before you submit.
Accumulated jobs become benchmarks and device intelligence; per-domain policy, billing, and an AI-agent interface make it run as a service.
Domain modules you can run today — each comparable across CPU, GPU, and real QPU backends.
Quantum-kernel outlier detection benchmarked against a classical baseline — upload your own CSV; advantage is dataset-dependent.
QAOA portfolio optimization versus exact and greedy baselines.
VQE ground-state energy with noise and mitigation comparison.
QAOA for max-cut, independent set, and vertex cover.
Most wasted quantum spend is decided before submission — the wrong device, a circuit too deep for it, or a run you already made last month. UQH answers all three up front.
An error-budget calculation from the device's measured 1q, 2q and readout error rates against your circuit's gate counts. No noise simulation, so no qubit ceiling and no wait — it answers for a 100-qubit circuit as fast as a 2-qubit one.
The same circuit scored across every connected processor — expected fidelity, 2q error, coherence headroom, queue depth and cost, side by side. Pick on evidence, not on which vendor you happen to have an account with.
Submissions are matched by circuit content, not filename, so earlier runs of the same circuit surface before you pay for another one — and an edited circuit correctly stops matching. Re-running is a choice, not an accident.
Run it on dedicated GPU simulation hosts before it ever reaches hardware. Logic bugs, wrong observables and bad ansätze are cheaper to find on a GPU than in a QPU queue.
Drop in a circuit and UQH detects its framework, previews the metadata, and runs the whole pipeline — analyze, optimize, noise-check, mitigate, submit — without leaving the page.
A broad, composable feature set — use any piece on its own, or the whole pipeline end to end.
Write in your SDK of choice and submit to any supported processor — no per-vendor rewrites.
Analyze, optimize, noise-simulate, QEC, GPU-execute, QPU-submit — each step runs standalone, with an emulator dry-run option.
Transpile and route with multiple engines, mapped to the target device's physical layout — and compare every option side by side on resulting complexity, optimization time, and analytical fidelity. Every candidate is verified mathematically equivalent to your original circuit — large circuits offloaded to GPU — and comparisons run in isolation, so timings stay honest and the platform stays responsive.
Readout-error mitigation and zero-noise extrapolation as one resilience level, plus spacetime Pauli-check postselection for Clifford circuits — standard techniques, applied consistently.
Calibration-based fidelity and TVD with a cross-engine consistency check (Qiskit vs PennyLane), plus error-correction analysis and code application with threshold and logical-error estimates.
See qubits, depth, gates, and what each vendor bills — in that vendor’s own unit — before submitting. No surprise spend.
Offload heavy simulation to dedicated GPU hosts and compare CPU, GPU, and QPU on the same problem.
Ask in your own words — that is the whole interface. Hybrid dense + sparse retrieval, re-ranking, and cited answers over the platform's own accumulated runs: measured results, refusals and workarounds, not a document corpus. Findings distilled from them are anonymised and searchable by everyone; individual records stay with their owner. What the corpus contains is curated by your administrators, not chosen per query.
Full parity across UI, REST API, and CLI — plus an MCP server so AI agents orchestrate runs directly.
A scheduled autonomous layer tracks every device's fidelity and error rates over time and flags the ones drifting away from spec, watches SDK releases against your pinned versions, and picks up new hardware as vendors bring it online. Reversible actions auto-apply and log; anything irreversible waits for admin approval.
Algorithm files already run on remote compute hosts, and the backend a program names is swapped at run time — a script written for a simulator reaches a GPU host or real hardware without being edited. When tightly coupled GPU-QPU machines arrive, they join as one more target on that same path rather than as a new architecture.
Export one self-describing file per run: the circuit, the observable, the calibration exactly as it stood at submit time, the result, the noiseless reference and SDK versions. Anything unavailable is named rather than quietly omitted, so the number stays checkable years later — attach it to a paper or hand it to a reviewer.
Reserve a device and batch many jobs in one session to minimize re-queuing between iterations — in the spirit of vendor runtime sessions. On the roadmap.
Every job you run feeds a living view of the hardware landscape — so researchers and decision-makers act on measured reality.
Every step is independent and scriptable. Run it in the UI, call the REST API, or drive it from the CLI and your CI.
$ uqi estimate --file bell.py ibm_fez $0.00 iqm_garnet $0.30 rigetti $0.74 ionq_forte1 $82.22 # cheapest first $ uqi catalog optimize --graph cycle6 --compare --resilience full CPU optimal · GPU optimal QPU(iqm_emerald) fid 0.74 · valid 100% readout-mitigated approx 100% # post-processed, no re-run
UQH ships an MCP server, so Claude and other AI agents use it as a tool — analyzing, optimizing, mitigating, pricing, and submitting across vendors from a single natural-language request.
You: optimize bell.py, pick the cheapest backend, then mitigate agent → uqi_analyze 2 qubits · depth 2 → uqi_resource_estimate ibm_fez $0.00 (cheapest) → uqi_optimize SABRE-routed → uqi_qpu_submit submitted ✓ → uqi_mitigate_readout approx 100%
Reach superconducting, trapped-ion, neutral-atom, and photonic processors — and compare and run across them from a single place.
| Vendor | Modality | Qubits | Access |
|---|---|---|---|
| IBM Quantum | Superconducting | 133+ | Open plan |
| IQM | Superconducting | 20–150 | Credits |
| IonQ | Trapped-ion | 36 | AWS Braket · IonQ Cloud |
| Rigetti | Superconducting | 108 | AWS Braket |
| QuEra | Neutral-atom | 256 | AWS Braket |
| Pasqal | Neutral-atom | 100 | PCS · Azure |
| Quandela | Photonic | — | Free tier |
| Quantinuum | Trapped-ion | 20–56 | Azure · HQC |
Write in the framework you already use. Gate-based circuits reach every gate-based vendor; photonic and analog work stays with the hardware that can express it.
| SDK | IBM | IQM | IonQ | Rigetti | QuEra | Pasqal | Quandela | GPU sim |
|---|---|---|---|---|---|---|---|---|
| Qiskit | ● | ● | ● | ● | · | · | · | ●qiskit-aer GPU |
| PennyLane | ● | ● | ● | ● | · | · | · | ●lightning.gpu |
| Cirq | ● | ● | ● | ● | · | · | · | ●qsimcirq |
| Qrisp | ● | ● | ● | ● | · | · | · | ●qiskit-aer GPU |
| Qadence | ● | ● | ● | ● | · | · | · | ●torch CUDA |
| CUDA-Q | ● | ● | ● | ● | · | · | · | ●nvidia target |
| Perceval | · | · | · | · | · | · | ● | · |
| Pulser | · | · | · | · | · | ● | · | · |
| Braket-AHS | · | · | · | · | ● | · | · | · |
The primary fit — national programs, research institutes, and enterprise R&D. One governed, white-label control plane over every vendor: spend safeguards, code and data isolation, curated knowledge scope, security audit of every refused upload, and data sovereignty — with Leaders boards and real cost-vs-fidelity to ground hardware and budget decisions.
Individual researchers aren't shut out — everything up to the point of spending money is self-serve and needs no credential, and once you register your own vendor key the same workspace runs it: compare CPU, GPU and real QPUs, watch noise appear, and recover signal with mitigation.
Work from the environment you know. Circuit-complexity analysis, optimization, cost estimates, and runs over API and CLI — script them or wire them into CI.
Multi-tenant controls, spend safeguards, and isolation are enforced server-side across UI, API, CLI, and MCP.
Everything that costs nothing to run is open to everyone, with no credential at all. What costs money — quantum processor time, AI calls — runs on credentials you bring yourself. There is no shared platform allowance to draw on: a vendor allowance is issued to a person, so lending ours would breach that vendor's terms for the holder.
| Capability | No credentials | Bring your own | Institution |
|---|---|---|---|
| Analysis, optimization, noise simulation, QEC | ● | ● | ● |
| Vendor-neutral device ranking | ● | ● | ● |
| Reproducibility bundle | ● | ● | ● |
| API, CLI and MCP access | ● | ● | ● |
| Credential registration | · | ● | ● |
| Restrict a registered key to named devices | · | ● | ● |
| Submit to a real QPU | · | ● | ● |
| Per-submission cost cap and audit trail | · | · | ● |
| Institutional usage report | · | · | ● |
| Bring your own AI key | · | ● | ● |
| GPU simulation on shared hosts | ● | ● | ● |
| Unmetered use of a GPU host you provide | · | ● | ● |
Individually, these capabilities exist elsewhere. UQH brings them into a single flow.