ψcatstate
get started

$ pip install catstate

Your QPU accounts.
One control plane.

CatState is the control plane and observability layer for quantum computing. Store provider credentials in an envelope-encrypted vault, route circuits to the best eligible device, track every experiment — and fan out access with capped, revocable sub-keys.

get started →view pricing
3
providers · IBM, IonQ, Braket
1
key for every device you own
$0
compute markup — pure passthrough
departures--:--:--
timeexperiment

cs_run_8f9a2b1c · routed by cs("best")synthetic demo data

bring your own account

You already own the hardware access.
Keep it.

CatState proxies every job through the provider credentials you store — no CatState-owned accounts, no credit resale, no markup on shots. The platform layers routing, governance, and reproducibility on top of the grants you already have.

01

Store your credentials once

Drop your IBM Quantum, IonQ, and AWS Braket API keys into the CatState vault. Each credential is sealed with AES-256-GCM under its own per-credential data-encryption key, wrapped by a KMS master key. Plaintext exists only in worker RAM, and only for the duration of a dispatch.

AES-256-GCM · per-credential DEK · KMS envelope

02

Route every circuit intelligently

A live device catalog — calibration, queue depth, and pricing per device — feeds a five-stage routing pipeline. Ask for cs("best"), cs("cheapest"), or cs("fastest"), or pin an exact device. Every run records why the router picked it.

best · cheapest · fastest · pinned

03

Pay your provider directly

CatState is a pure control plane. Your jobs execute on accounts you already own, and your provider bills you straight from your existing grant or account. We never hold compute funds, never resell hardware time, and never sit in the financial path.

zero custody · BYOA-only

delegated sub-keys

Never share the root credential again.

Fan a stored provider credential out into scoped cs_sub_* keys — one per student, teammate, or CI pipeline — each with its own spend cap, device allowlist, and expiry. The root credential never leaves the vault.

Hard spend caps
A strict dollar ceiling per key. Reserve-then-reconcile accounting holds funds for in-flight jobs, so fifteen students can submit concurrently without blowing past the cap.
Scoped allowlists
Each sub-key permits a subset of the parent credential's devices — enforced server-side at mint time, not by convention. ibm:brisbane yes, ibm:kyoto no.
Expiry & revocation
Semester ends, keys expire. Intern leaves, one click revokes. Runs already in flight complete; nothing new starts.
Bulk issuance
Mint a classroom of scoped keys in one atomic call — per-student overrides included, partial batches rejected.
mint_sub_key.pypy
# Mint a capped sub-key for one student
sub = cs.vault.create_sub_key(
    parent="ibm-production",
    label="student:jane_doe",
    spend_cap_usd=25.00,
    allowed_devices=["ibm:brisbane", "simulator:*"],
    cap_hit_behavior="HARD_BLOCK",
    expires_at="2026-12-15T23:59:59Z",
)
 
print(sub.token_hint)
# cs_...b5c4  (plaintext shown exactly once)
$25.00 cap · jane_doe spent $24.80 · next job → SUBKEY_SPEND_CAP_EXCEEDED (402)

smart hardware router

Stop reading calibration tables by hand.

A dedicated catalog worker polls every provider for calibration, queue depth, pricing, and device lifecycle — so the router always decides against fresh data, and your runs are reproducible against the calibration snapshot they actually executed on.

cs("best")

BEST

Composite fidelity score across 2Q gate fidelity, readout error, SWAP overhead, and a normalized queue penalty.

cs("cheapest")

CHEAPEST

Minimizes task base fee plus shots × per-shot rate, from live per-device pricing data.

cs("fastest")

FASTEST

Minimizes estimated queue wait plus execution duration for your circuit and shot count.

// Pin an exact device with cs("ibm:brisbane") — or pass cs() and let the key's configured default decide.

framework adapters

Keep the stack you already write in.

Superfermion-native, a Qiskit BackendV2 provider, or a PennyLane device plugin — the same vault, router, and spend governance underneath all three.

bell_state.pypy
import superfermion as sf
import catstate
 
cs = catstate.connect()  # reads CATSTATE_API_KEY
 
circuit = sf.Circuit(4).h(0).cx(0, 1).cx(1, 2).cx(2, 3)
 
with cs.experiment("ghz_benchmark"):
    result = sf.run(circuit, device=cs("best"), shots=4096)
 
print(result.counts)
# {'0000': 1013, '1111': 1029, ...}
first_run.pypy
import superfermion as sf
import catstate
 
cs = catstate.connect()  # reads CATSTATE_API_KEY
 
circuit = sf.Circuit(2).h(0).cx(0, 1)
 
with cs.experiment("bell_benchmark"):
    result = sf.run(circuit, device=cs("best"), shots=4096)
 
print(result.counts)
# {'00': 2041, '11': 2055}

$ catstate.connect()

Your next 4,096 shots are one API key away.

Store a credential, mint a sub-key, and route your first circuit in under five minutes.

read the docssee pricing