# WAI Quantum job service (remote · wai.transaction.science)

A free quantum job service: OpenQASM 3 run, checked and signed, with no account or key.

- Trust score: 64/100 (medium)
- Change this week: +4
- Registry status: active
- Liveness: live
- Owner verified: no
- Last scored: 2026-11-05

## Components

- remote · `wai.transaction.science`: 64/100 (this document), [markdown](https://verifymcp.io/servers/science-transaction-wai-quantum-jobs/quantum-jobs-mcp.md), [page](https://verifymcp.io/servers/science-transaction-wai-quantum-jobs/quantum-jobs-mcp)

## Channel facts

- Endpoint: `https://wai.transaction.science/quantum-jobs/mcp`
- Transports: `streamable-http`
- Auth: `none`
- Version: `0.2.2`

## Trust breakdown

How this component scores in each security and reliability category. Every signal is checked automatically against the live server, and we only credit what we can confirm. Scores are 0–100 per category. Scoring method: https://verifymcp.io/docs/scoring (what has changed: https://verifymcp.io/docs/scoring/changelog)

Scored 2026-11-05.

- **Endpoint Security**: 51/100
  - The endpoint's TLS certificate is valid, in date, and uses a strong key.
  - Authorisation not fully verified: no authorisation is required to call this server, and 3 tool(s) never declared a destructiveHint. The MCP spec treats an absent hint as destructive by default, so we cannot call this surface safe.
  - HTTPS enforcement could not be verified: the plaintext port answered with HTTP 405, which proves neither a plaintext path nor enforcement.
  - The HSTS (Strict-Transport-Security) header is present.
  - DNSSEC check failed: this domain isn't protected by DNSSEC.
- **Transport & Reachability**: 100/100
  - Verified streamable-http transport via a live MCP handshake.
- **Schema Quality & AI Usability**: 68/100
  - 100% of prompts and resources have a non-trivial description (not blank, and not just the item's name).
  - AI-judged instruction clarity (good).
  - Context-footprint check failed: tool/resource definitions use about 13683 tokens (~350/item across 39 items; 30 tools + 9 resources), over budget; trim descriptions and params.
  - Usage-examples check failed: none of the tools include examples.
- **Stability & Change Management**: 23/100
  - Stability observed for 7 of 30 days with no destabilising changes; credit accrues until the full window elapses.
- **Tool Coverage**: 98/100
  - 100% of tools have a non-trivial description (not blank, and not just the tool's name).
  - 92% of tool parameters carry a description.
  - Structured output schemas are declared (100% of tools); any adoption earns full credit.
- **Tool Safety**: 100/100
  - No prompt-injection markers were found in the server instructions, tool names or descriptions we captured.
  - We read all 30 captured tool definition(s), and no name or description among them implies an irreversible operation.
  - An AI judge read all 32 captured unit(s) of tool text and found none that tries to manipulate the model reading it.
- **Capabilities**: 100/100
  - Implements a supported MCP spec version (2025-11-25); the latest is 2026-07-28.

## Install

### How do I install the WAI Quantum job service MCP server?

WAI Quantum job service is a hosted endpoint at https://wai.transaction.science/quantum-jobs/mcp, so there is nothing to install locally. Ready-made configuration for Claude, Cursor, VS Code, Codex and 5 more is on this page, copied from each client's own documentation.

### Claude

```bash
claude mcp add --transport http science-transaction-wai-quantum-jobs 'https://wai.transaction.science/quantum-jobs/mcp'
```

### Cursor

```json
{
  "mcpServers": {
    "science-transaction-wai-quantum-jobs": {
      "url": "https://wai.transaction.science/quantum-jobs/mcp"
    }
  }
}
```

### VS Code

```json
{
  "servers": {
    "science-transaction-wai-quantum-jobs": {
      "type": "http",
      "url": "https://wai.transaction.science/quantum-jobs/mcp"
    }
  }
}
```

### Codex

```toml
[mcp_servers.science-transaction-wai-quantum-jobs]
url = "https://wai.transaction.science/quantum-jobs/mcp"
```

### opencode

```json
{
  "$schema": "https://opencode.ai/config.json",
  "mcp": {
    "science-transaction-wai-quantum-jobs": {
      "type": "remote",
      "url": "https://wai.transaction.science/quantum-jobs/mcp",
      "enabled": true
    }
  }
}
```

### OpenClaw

```bash
openclaw mcp add science-transaction-wai-quantum-jobs --url 'https://wai.transaction.science/quantum-jobs/mcp' --transport streamable-http
```

### Hermes

```yaml
mcp_servers:
  science-transaction-wai-quantum-jobs:
    url: "https://wai.transaction.science/quantum-jobs/mcp"
```

### Netclaw

```json
{
  "McpServers": {
    "science-transaction-wai-quantum-jobs": {
      "Transport": "http",
      "Url": "https://wai.transaction.science/quantum-jobs/mcp"
    }
  }
}
```

### Vellum

```bash
assistant mcp add science-transaction-wai-quantum-jobs -t streamable-http -u 'https://wai.transaction.science/quantum-jobs/mcp'
```

### Other

```json
{
  "mcpServers": {
    "science-transaction-wai-quantum-jobs": {
      "type": "http",
      "url": "https://wai.transaction.science/quantum-jobs/mcp"
    }
  }
}
```

The mcpServers block is a cross-client convention. Remote transports vary, so check your client's docs.

## Changelog

Every change recorded for this component, newest first. Days that predate change tracking, or that we cannot explain, say so: "we were watching and nothing happened" and "we were not watching" are different claims.

### 2026-11-05 (score 64, +1)

- [security] The server rewrote its instructions, which are the text every model session reads
- [security] Tool “get_quantum_job” rewrote its description, which is the text the model reads
- [security] Tool “run_on_target” rewrote its description, which is the text the model reads
- [security] Tool “run_quantum_circuit” rewrote its description, which is the text the model reads
- [security] Tool “run_quantum_set” rewrote its description, which is the text the model reads
- [functional] Server version: 0.2.1 → 0.2.2
- [cosmetic] “run_on_target” added an optional parameter “idempotency_key”
- [cosmetic] “run_quantum_circuit” added an optional parameter “idempotency_key”
- [cosmetic] “run_quantum_set” added an optional parameter “idempotency_key”

### 2026-11-03 (score 63, +1)

No change was recorded against any check on this day. Stability & Change Management went from 13 to 17. That category is still filling its 30-day observation window: 4 days of observed history at the previous scan, 5 at this one. The score rises as the window fills, whether or not the server changes.

### 2026-11-02 (score 62, 0)

- [functional regression] Schema quality: 294 → 339
- [functional] Server version: 0.2.0 → 0.2.1
- [functional] New tool “build_algorithm”
- [functional] New tool “convert_program”
- [functional] New tool “gradient_qasm”
- [functional] New tool “list_components”
- [functional] New tool “optimize_qasm”
- [functional] New tool “pulse_check”
- [functional] New tool “pulse_schedule”
- [functional] New tool “qaoa_maxcut”
- [functional] New tool “vqe_ground_state”
- [cosmetic] “dry_run_quantum_job” added an optional parameter “fabric”
- [cosmetic] “dry_run_quantum_job” added an optional parameter “params”
- [cosmetic] “dry_run_quantum_job” added an optional parameter “pulse”
- [cosmetic] “dry_run_quantum_job” added an optional parameter “source”
- [cosmetic] “run_on_target” added an optional parameter “fabric”
- [cosmetic] “run_on_target” added an optional parameter “params”
- [cosmetic] “run_on_target” added an optional parameter “pulse”
- [cosmetic] “run_on_target” added an optional parameter “source”
- [cosmetic] “run_quantum_circuit” added an optional parameter “fabric”
- [cosmetic] “run_quantum_circuit” added an optional parameter “params”
- [cosmetic] “run_quantum_circuit” added an optional parameter “pulse”
- [cosmetic] “run_quantum_circuit” added an optional parameter “source”
- [cosmetic] “run_quantum_set” added an optional parameter “fabric”
- [cosmetic] “run_quantum_set” added an optional parameter “params”
- [cosmetic] “run_quantum_set” added an optional parameter “pulse”
- [cosmetic] “dry_run_quantum_job” reworded the description of “method”
- [cosmetic] “run_quantum_circuit” reworded the description of “method”
- [cosmetic] “run_quantum_set” reworded the description of “method”
- [cosmetic] “run_on_target” made “qasm” optional
- [cosmetic] “run_quantum_circuit” made “qasm” optional

### 2026-11-01 (score 62, +1)

No change was recorded against any check on this day. Stability & Change Management went from 7 to 10. That category is still filling its 30-day observation window: 2 days of observed history at the previous scan, 3 at this one. The score rises as the window fills, whether or not the server changes.

### 2026-10-30 (score 61, +1)

- [functional improvement] Stability: unverified → 0.03

### 2026-10-29 (score 60)

First indexed and scored.

## MCP tools (30)

### `run_quantum_circuit` (~1656 tokens)

Run a quantum circuit

Run an OpenQASM program and return measurement counts, Pauli expectation values and/or amplitudes. The service chooses the method (bit-exact or double-precision state vector up to 32 qubits, single precision on a GPU to 33, stabilizer tableau for Clifford circuits up to 32768 qubits, matrix product states up to 4096, sparse Pauli dynamics for expectation values up to 1024 with an error bound, an exact density matrix or trajectories for noise), reports why and how accurate, and signs the result. Give `intent` (an exact distribution, or a reference program it must equal or whose state it must prepare) and the engine checks it with the run. Every answer carries `verdict`: the level the engine checked to (proof, evidence, executed, parsed, refused), whether the intent holds and a plain statement, sealed in the receipt. Waits up to 50 s; a longer job answers with status running and an id for get_quantum_job. Each call is a new job unless it gives idempotency_key, which makes sending it again safe.

Input parameters:

- `amplitudes` (array): Basis states to give amplitudes of: one character per qubit, qubit n-1 first, e.g. "0011".
- `compile` (object): Compile the program first (as compile_qasm does) and run the compiled circuit: with basis clifford_t it runs bit-exact, and the result's `compiled` states its distance from the program.
- `fabric`: Where the statevector method's state runs: auto (the default: on a member only where the committed measurements show it faster than the host's CPU for the job's size and fusion, otherwise the CPU), c…
- `idempotency_key` (string): A key of your making that names this run, so that a call sent again is not a second job: the same key with the same arguments answers with the job it names, for as long as the job is kept, rather tha…
- `intent`: What the program must do, checked by the engine with the run: the result's `verdict` states how far it checked (proof, evidence, executed, parsed, refused) and whether the intent holds, sealed by the…
- `method` (string): Leave as auto unless you need a particular method; pulse runs a pulse program (OpenPulse calibrations on physical qubits, see pulse_schedule) under the pulse options, its error bounded.
- `mitigate`: Mitigate the job's expectation values (or, for readout, its counts) under its own noise: zne (the whole program folded U(U†U)^k and extrapolated), pea (the noise learned as a sparse Pauli–Lindblad mo…
- `noise` (object): Optional noise, each a probability: depolarizing_1q, depolarizing_2q, amplitude_damping, dephasing (after each gate on its qubits), readout (each measured bit).
- `observables` (array): Pauli strings to take expectation values of, e.g. ["Z0", "Z0 Z1", "X2 Y3"]. Qubits count from 0.
- `options` (object): Advanced, per method: max_bond (mps), threshold and max_terms (pauli), fusion (statevector), trajectories.
- `params` (object): A value for each of the program's parameters (input float theta;, input angle phi;), as {"theta": 0.3}: bound exactly before the program is read; a parameter left without one is refused (J050). In a…
- `pulse` (object): A pulse run's options (method "pulse"): the sample period, the levels kept, the tolerance on the stated error, the steps a sample is divided into, each qubit's parameters, static couplings, and ports…
- `qasm` (string): The program, OpenQASM 3 (or 2), read as the whole language: registers, aliases and slices; the standard gates, `U` and `gphase`; user `gate` definitions and `def` subroutines, inlined; every modifier…
- `repair`: Repair the program first, on the lines its diagnostics flag alone (as repair_qasm does): true, or the choices {"max_iterations": N, "dyadic_bits": K, "sizes": {"q": 3}}. The result's `repaired` holds…
- `seed` (integer): Sampling seed (default 1); the same job and seed give the same counts.
- `shots` (integer): Measurement shots. Default 1024 when no observables or amplitudes are asked for.
- `source` (object): The program in another format, in place of qasm: read to the job's qasm before the job is read (a module that does not read is refused with the reader's code, Q700 to Q721), the request keeping its s…
- `target`: A device target: a built-in target's name (list_targets) or a target document (wai.quantum.target/1). The program is then compiled to its gates, placed where it is most likely to succeed and simulate…

### `run_quantum_set` (~1380 tokens)

Run a set of quantum programs, or one over a grid

Run several OpenQASM programs as one set (`programs`: each a program's text or a job), or one program over a grid of its inputs (`qasm` with `sweep`, as {"theta": [0.1, 0.2], "n": [2, 3]}: every combination; integer inputs written out, float and angle inputs bound to the double given). The set's other fields (shots, observables, seed, intent, …) apply to every item. Each item gets its own result and receipt, each stating its verdict, and one receipt over the set binds every item through a Merkle root; verify_quantum_receipt checks it whole. At most 100 items, run one after another in one job. Waits up to 50 s; a longer set answers with status running and an id for get_quantum_job. Each call is a new job unless it gives idempotency_key, which makes sending it again safe.

Input parameters:

- `amplitudes` (array): Basis states to give amplitudes of: one character per qubit, qubit n-1 first, e.g. "0011".
- `compile` (object): Compile the program first (as compile_qasm does) and run the compiled circuit: with basis clifford_t it runs bit-exact, and the result's `compiled` states its distance from the program.
- `fabric`: Where the statevector method's state runs: auto (the default: on a member only where the committed measurements show it faster than the host's CPU for the job's size and fusion, otherwise the CPU), c…
- `idempotency_key` (string): A key of your making that names this run, so that a call sent again is not a second job: the same key with the same arguments answers with the job it names, for as long as the job is kept, rather tha…
- `intent`: What the program must do, checked by the engine with the run: the result's `verdict` states how far it checked (proof, evidence, executed, parsed, refused) and whether the intent holds, sealed by the…
- `method` (string): Leave as auto unless you need a particular method; pulse runs a pulse program (OpenPulse calibrations on physical qubits, see pulse_schedule) under the pulse options, its error bounded.
- `mitigate`: Mitigate the job's expectation values (or, for readout, its counts) under its own noise: zne (the whole program folded U(U†U)^k and extrapolated), pea (the noise learned as a sparse Pauli–Lindblad mo…
- `noise` (object): Optional noise, each a probability: depolarizing_1q, depolarizing_2q, amplitude_damping, dephasing (after each gate on its qubits), readout (each measured bit).
- `observables` (array): Pauli strings to take expectation values of, e.g. ["Z0", "Z0 Z1", "X2 Y3"]. Qubits count from 0.
- `options` (object): Advanced, per method: max_bond (mps), threshold and max_terms (pauli), fusion (statevector), trajectories.
- `params` (object): A value for each of the program's parameters (input float theta;, input angle phi;), as {"theta": 0.3}: bound exactly before the program is read; a parameter left without one is refused (J050). In a…
- `programs` (array): The set's programs: each a program's text, or a job ({"qasm", …}) whose own fields win over the set's.
- `pulse` (object): A pulse run's options (method "pulse"): the sample period, the levels kept, the tolerance on the stated error, the steps a sample is divided into, each qubit's parameters, static couplings, and ports…
- `qasm` (string): With sweep: the program, which declares the inputs the sweep gives values (`input uint n;`, `input float theta;`, `input angle phi;`).
- `repair`: Repair the program first, on the lines its diagnostics flag alone (as repair_qasm does): true, or the choices {"max_iterations": N, "dyadic_bits": K, "sizes": {"q": 3}}. The result's `repaired` holds…
- `seed` (integer): Sampling seed (default 1); the same job and seed give the same counts.
- `shots` (integer): Measurement shots. Default 1024 when no observables or amplitudes are asked for.
- `sweep` (object): Each input of qasm and its values: every combination runs, the names in sorted order, the first varying slowest; an integer input's values are whole numbers.
- `target`: A device target: a built-in target's name (list_targets) or a target document (wai.quantum.target/1). The program is then compiled to its gates, placed where it is most likely to succeed and simulate…

### `dry_run_quantum_job` (~1515 tokens)

Plan a quantum job or set without running it

What the service would do with a job or a set, running nothing: the method and why, the memory, the estimated time and energy (each with its basis: this service's own timings and readings where it has them, otherwise the planner's nominal rate, and no energy figure without readings), the bounds that apply, where you stand against your limits, and whether the service would take it now, or the refusal it would give, with its code. Takes what run_quantum_circuit or run_quantum_set takes. It counts as one submission.

Input parameters:

- `amplitudes` (array): Basis states to give amplitudes of: one character per qubit, qubit n-1 first, e.g. "0011".
- `compile` (object): Compile the program first (as compile_qasm does) and run the compiled circuit: with basis clifford_t it runs bit-exact, and the result's `compiled` states its distance from the program.
- `fabric`: Where the statevector method's state runs: auto (the default: on a member only where the committed measurements show it faster than the host's CPU for the job's size and fusion, otherwise the CPU), c…
- `intent`: What the program must do, checked by the engine with the run: the result's `verdict` states how far it checked (proof, evidence, executed, parsed, refused) and whether the intent holds, sealed by the…
- `method` (string): Leave as auto unless you need a particular method; pulse runs a pulse program (OpenPulse calibrations on physical qubits, see pulse_schedule) under the pulse options, its error bounded.
- `mitigate`: Mitigate the job's expectation values (or, for readout, its counts) under its own noise: zne (the whole program folded U(U†U)^k and extrapolated), pea (the noise learned as a sparse Pauli–Lindblad mo…
- `noise` (object): Optional noise, each a probability: depolarizing_1q, depolarizing_2q, amplitude_damping, dephasing (after each gate on its qubits), readout (each measured bit).
- `observables` (array): Pauli strings to take expectation values of, e.g. ["Z0", "Z0 Z1", "X2 Y3"]. Qubits count from 0.
- `options` (object): Advanced, per method: max_bond (mps), threshold and max_terms (pauli), fusion (statevector), trajectories.
- `params` (object): A value for each of the program's parameters (input float theta;, input angle phi;), as {"theta": 0.3}: bound exactly before the program is read; a parameter left without one is refused (J050). In a…
- `programs` (array): The set's programs: each a program's text, or a job ({"qasm", …}) whose own fields win over the set's.
- `pulse` (object): A pulse run's options (method "pulse"): the sample period, the levels kept, the tolerance on the stated error, the steps a sample is divided into, each qubit's parameters, static couplings, and ports…
- `qasm` (string): The program, OpenQASM 3 (or 2), read as the whole language: registers, aliases and slices; the standard gates, `U` and `gphase`; user `gate` definitions and `def` subroutines, inlined; every modifier…
- `repair`: Repair the program first, on the lines its diagnostics flag alone (as repair_qasm does): true, or the choices {"max_iterations": N, "dyadic_bits": K, "sizes": {"q": 3}}. The result's `repaired` holds…
- `seed` (integer): Sampling seed (default 1); the same job and seed give the same counts.
- `shots` (integer): Measurement shots. Default 1024 when no observables or amplitudes are asked for.
- `source` (object): The program in another format, in place of qasm: read to the job's qasm before the job is read (a module that does not read is refused with the reader's code, Q700 to Q721), the request keeping its s…
- `sweep` (object): Each input of qasm and its values: every combination runs, the names in sorted order, the first varying slowest; an integer input's values are whole numbers.
- `target`: A device target: a built-in target's name (list_targets) or a target document (wai.quantum.target/1). The program is then compiled to its gates, placed where it is most likely to succeed and simulate…

### `get_quantum_job` (~83 tokens)

Read a quantum job

A job's status, and its result when it is done. The service keeps every job across its restarts for its retention (a day on the public service); a job that was running when it stopped is run again once from its request (its interruptions say when), and stopped again it comes back interrupted, with the reason.

Input parameters:

- `id` (string, required)

### `verify_quantum_receipt` (~91 tokens)

Verify a result's receipt

Whether a result's receipt (an Ed25519 signature by the service) seals exactly that request and that result. Pass the job's own `request` (as run_quantum_circuit or get_quantum_job returns it: a run here asks for its verdict, so the request it seals says so) and its result.

Input parameters:

- `request` (object, required)
- `result` (object, required)

### `critique_qasm` (~101 tokens)

Critique a quantum program

A program's measures, computed by the engine: gates by kind, two-qubit gates, depth and two-qubit depth, T count, whether it is a Clifford circuit, and a fidelity under reference error rates (a model, not a run). Also its smells, each with its lines: gates that cancel, rotations that merge or do nothing, idle qubits, and qubits acted on but never measured.

Input parameters:

- `qasm` (string, required)

### `check_equivalent` (~148 tokens)

Check two quantum programs are the same circuit

Whether two programs are the same circuit up to a global phase, and how the engine knows: Clifford circuits by their tableaus at any size, others on every basis state to 8 qubits, then by checked rewrites of one followed by the other's inverse to nothing (a proof at any width), then on random product states to 22 (evidence, not proof), otherwise unchecked with the reason. Its `verdict` is that decision; `verification` is the level it reached, as every tool's verdict states it. A check that would take long here is refused with the command that runs it locally.

Input parameters:

- `a` (string, required)
- `b` (string, required)

### `convert_program` (~288 tokens)

Convert a program between formats

Carry a program between OpenQASM 3, QIR (LLVM text, read under its base and adaptive profiles, written as QIR 2.0) and jeff (its Cap'n Proto message, as base64). The answer is the program written, the program as OpenQASM 3 (what every other tool takes), each note with its code (a rotation at an arbitrary angle, a custom gate read by its name, what a format leaves out), what was read and written, and the check: the output read back and held to the program by the equivalence ladder. A construct a reader cannot hold exactly is refused with its code (Q700 to Q721) and its place: quote the code, and never guess around it. A conversion larger than the service takes is refused with the command that runs it locally.

Input parameters:

- `check` (boolean): false: write it without the check.
- `from` (string): Its format; found from its bytes when not given.
- `profile` (string): QIR's profile to write: by default base when the program's measurements all come at the end, else adaptive.
- `program` (string): The program's text: OpenQASM or QIR.
- `program_base64` (string): The program's bytes as base64: jeff.
- `to` (string, required): The format to write.

### `improve_qasm` (~62 tokens)

Improve a quantum program

The program with its smells fixed in its own text (all of them, and each alone), each candidate with its measures and the equivalence check's verdict against the program. A candidate the check finds different is never returned.

Input parameters:

- `qasm` (string, required)

### `classical_shortcuts` (~116 tokens)

Find a quantum program's classical shortcuts

Every exact classical route to simulating a program, priced on it: the stabilizer tableau, the cut-rank sum, an exact matrix product state at a rigorous bond bound, the light cone of a one-qubit expectation value, and the state vector. The cheapest is named for each question. A cheap route proves the program classically easy; none being cheap proves nothing about hardness. A thorough search, with a contraction tree, runs locally: wai-quantum shortcuts --thorough.

Input parameters:

- `qasm` (string, required)

### `compile_qasm` (~272 tokens)

Compile a quantum program, every pass checked

Compile an OpenQASM program through named passes (lowering, checked rewrites, phase folding, one- and two-qubit resynthesis, and every rotation off the multiples of π/4 written as a Clifford+T word within its share of the ε budget), each checked where it acts. Returns the compiled program and a certificate sealed with the service's key: each pass's counts before and after, its check and verdict (proof, exact or approximate with its distance), the budget and the bound the distances add to. verify_quantum_receipt checks it. Quote the bound; an approximate compile is not exact. A large or very fine compile is refused with the local command.

Input parameters:

- `basis` (string): clifford_t (default): every rotation off the multiples of π/4 written as a Clifford+T word within its share of epsilon; standard: nothing approximated.
- `epsilon` (number): The most the output may differ from the program in the operator norm, up to a global phase, shared by its rotations (default 1e-6).
- `level` (integer): 0: lower and approximate; 1 (default): also checked rewrites and phase folding; 2: also one- and two-qubit resynthesis.
- `qasm` (string, required)

### `estimate_resources` (~533 tokens)

Estimate a quantum program's fault-tolerant resources

What a fault-tolerant quantum computer would need to run a program. First its logical counts: T gates, Toffolis, rotations (each costed at the T count of its own synthesised Clifford+T word, within its share of the budget), measurements, T depth and total depth, and logical qubits with the ancillas that gates under several controls need. Then, on a physical qubit, the planar model's code distance (the gate-based surface code's model fitted to this engine's own decoders), T factories, physical qubits and runtime, and the frontier of estimates trading qubits for time. Takes a program, or a logical-counts or routine document. Every estimate is sealed in the resource-estimate receipt family, binding the program's digest and the ε budget; the answer's notes state the model's assumptions. Quote the figures with the qubit and the budget, and call them an estimate. Sealed with the service's key; verify_quantum_receipt checks the seals and re-runs it. A program with more than 256 distinct rotation angles, or a budget too fine for its rotations, is refused with the local command.

Input parameters:

- `budget` (number): The probability the run may fail, shared by logical errors, distillation and the rotations' synthesis (default 1e-3).
- `calibration` (string): The gate-based surface code's model: fitted to this engine's exact-matching decoder (default) or its union-find decoder, or the planar model's assumed one.
- `counts` (object): A logical-counts document instead of a program: numQubits, tCount, rotationCount, rotationDepth, cczCount, ccixCount, measurementCount.
- `export` (string): Also give the program's counts as a logical-counts or a routine document, under export.
- `max_slowdown` (integer): The most the frontier slows the program by to need fewer factories (default 256).
- `name` (string): The program's name in a routine document.
- `qasm` (string): The program, OpenQASM 3 or 2. Give this, counts or routine.
- `qubit`: The physical qubit: a reference qubit (ns-e4, the default: 50 ns gates, 1e-4 error; us-* are 100 µs gates, meas-* measurement-based), or one described.
- `routine` (object): A routine document instead of a program (version v1: routines with their ports, resources, children and connections).

### `repair_qasm` (~293 tokens)

Repair a quantum program on its flagged lines

Repair a program the reader refuses, changing only the lines its diagnostics flag. The engine makes the fixes that are mechanical (a missing `;`, an undeclared register's size, a measurement with no target, an unbounded while given the bound chosen, an angle the bit-exact method refuses rounded to the bits chosen with its rounding stated), and holds a fix you propose (`proposed`) to the flagged lines: any change to another line is rejected (J021) and nothing is changed. Returns the repaired program, each repair with its code and every line it changed, what needs a person with the reader's advice, and the verdict.

Input parameters:

- `diagnostics` (array): Codes you saw that reading the text does not raise (Q500).
- `dyadic_bits` (integer): Round each angle the bit-exact method refuses (Q500) to the nearest multiple of 2π/2^K.
- `max_iterations` (integer): The bound for an unbounded `while` on measured bits (Q310), as the person chose it.
- `proposed` (string): Your repaired version: taken only if every changed line is a flagged one (or a line added beside one).
- `qasm` (string, required)
- `rules` (boolean): false: only check the proposal.
- `sizes` (object): A register's size, for one used before it is declared (Q102).

### `quantum_service_info` (~57 tokens)

What the quantum service can do

The methods with their qubit limits and what each answers, the accuracy classes, the per-client limits, the current load, how jobs are kept and metered, the receipt keys, and the conventions (bit order, Pauli strings).

### `qasm_diagnostics` (~128 tokens)

The reader's diagnostic codes

Every code the OpenQASM reader gives (each refusal and warning carries one, as `[Q103]` at the end of its message): its outcome (refused, lowered, carried, preserved or warned) and its meaning; and beside them, under job_codes, the codes of what is asked of a program (`[J011]`: the request, the method, an intent, a repair, the host). A code never changes meaning once released. Give `code` for one of either.

Input parameters:

- `code` (string): One code, as Q103 or J011.

### `list_components` (~82 tokens)

List the engine's components

Every component the service plans, runs, compiles and converts through: the simulation methods, the compiler passes, the noise channels and the program formats, each with its version, its origin and the BLAKE3 digest of its descriptor, which is the identity a result is sealed with. The service runs the built-ins alone and never loads a component from a request.

### `list_targets` (~69 tokens)

List the device targets

The device targets the service knows by name: synthetic, made up in the shapes of published formats, each with its qubits, pairs, the gates a program compiles to, the spread of its T1 and readout errors, and its hash. A job may give its own target document instead.

### `show_target` (~102 tokens)

Show a device target

A device target's qubits, pairs, native gates with the spread of their errors and durations, its calibration snapshot and its hash; with view, each qubit's place for drawing its coupling map with its readout and one-qubit errors, and each pair's two-qubit error. Give a built-in target's name or a target document.

Input parameters:

- `target` (required): A built-in target's name, or a target document.
- `view` (boolean)

### `run_on_target` (~1527 tokens)

Run a program as a device would

Run an OpenQASM program as it would run on a device target: compiled exactly to its gates, placed on its most reliable qubits and routes (the expected success given), checked against the circuit, and simulated under the noise its calibration gives, on the density matrix or by trajectories. Counts and expectation values with their distance from the ideal distribution, the noise derived, and a receipt that binds the target's hash. A model of the device, not a run on it. Every angle must be a dyadic multiple of 2π. Waits up to 50 s, as run_quantum_circuit does, and like it, each call is a new job unless it gives idempotency_key.

Input parameters:

- `amplitudes` (array): Basis states to give amplitudes of: one character per qubit, qubit n-1 first, e.g. "0011".
- `compile` (object): Compile the program first (as compile_qasm does) and run the compiled circuit: with basis clifford_t it runs bit-exact, and the result's `compiled` states its distance from the program.
- `fabric`: Where the statevector method's state runs: auto (the default: on a member only where the committed measurements show it faster than the host's CPU for the job's size and fusion, otherwise the CPU), c…
- `idempotency_key` (string): A key of your making that names this run, so that a call sent again is not a second job: the same key with the same arguments answers with the job it names, for as long as the job is kept, rather tha…
- `intent`: What the program must do, checked by the engine with the run: the result's `verdict` states how far it checked (proof, evidence, executed, parsed, refused) and whether the intent holds, sealed by the…
- `mitigate`: Mitigate the job's expectation values (or, for readout, its counts) under its own noise: zne (the whole program folded U(U†U)^k and extrapolated), pea (the noise learned as a sparse Pauli–Lindblad mo…
- `noise` (object): Optional noise, each a probability: depolarizing_1q, depolarizing_2q, amplitude_damping, dephasing (after each gate on its qubits), readout (each measured bit).
- `observables` (array): Pauli strings to take expectation values of, e.g. ["Z0", "Z0 Z1", "X2 Y3"]. Qubits count from 0.
- `options` (object): Advanced, per method: max_bond (mps), threshold and max_terms (pauli), fusion (statevector), trajectories.
- `params` (object): A value for each of the program's parameters (input float theta;, input angle phi;), as {"theta": 0.3}: bound exactly before the program is read; a parameter left without one is refused (J050). In a…
- `pulse` (object): A pulse run's options (method "pulse"): the sample period, the levels kept, the tolerance on the stated error, the steps a sample is divided into, each qubit's parameters, static couplings, and ports…
- `qasm` (string): The program, OpenQASM 3 (or 2), read as the whole language: registers, aliases and slices; the standard gates, `U` and `gphase`; user `gate` definitions and `def` subroutines, inlined; every modifier…
- `repair`: Repair the program first, on the lines its diagnostics flag alone (as repair_qasm does): true, or the choices {"max_iterations": N, "dyadic_bits": K, "sizes": {"q": 3}}. The result's `repaired` holds…
- `seed` (integer): Sampling seed (default 1); the same job and seed give the same counts.
- `shots` (integer): Measurement shots. Default 1024 when no observables or amplitudes are asked for.
- `source` (object): The program in another format, in place of qasm: read to the job's qasm before the job is read (a module that does not read is refused with the reader's code, Q700 to Q721), the request keeping its s…
- `target` (required): A device target: a built-in target's name (list_targets) or a target document (wai.quantum.target/1). The program is then compiled to its gates, placed where it is most likely to succeed and simulate…

### `quantum_circuit_examples` (~88 tokens)

Ready-to-run quantum examples

Worked examples, each a complete job (OpenQASM program and arguments) with what it shows: a Bell pair, a rotation, QAOA, noise, a 1000-qubit GHZ state, 100-qubit dynamics, 200 qubits as a matrix product state. Pass an example's job to run_quantum_circuit as it is, or adapt it.

### `qec_code` (~326 tokens)

Show an error-correcting code and certify its distance

Show an error-correcting code and certify its distance: its checks (Z-type: they see X errors) and stabilizers (X-type), k counted by rank, a layout to draw it, the decoders it admits, and its distance certificate. In each sector the certificate gives the least weight of a logical found, a witness of that weight, and every lighter support ruled out by an exhaustive search over connected supports (a bivariate-bicycle code's translations checked as symmetries before use), re-checkable node for node. Give `certificate` to check one: its witnesses and the search run again. Sealed with the service's key. Quote the certificate's distance and its reading; a search stopped by `bound` settles nothing past it.

Input parameters:

- `bound` (integer): The heaviest support to search (default the code's nominal distance).
- `certificate` (object): A certificate (wai.quantum.distance/1) to check against the code.
- `certify` (boolean): Certify the distance (default true).
- `code` (required): A code by name: surface:D (the rotated surface code, odd D from 3 to 15), toric:L (2 to 12), steane, color:D (the triangular 6.6.6 colour code, odd D from 3 to 15), bb:72, bb:90, bb:108, bb:144 (or g…

### `qec_decode` (~618 tokens)

Decode a syndrome or a circuit's detectors

Decode with the engine's decoders. At code capacity, give `code` and a `syndrome` (the violated checks) or an `error` (the flipped qubits: its syndrome is taken and its residual judged, logical or not): matching (exact) and union_find for codes whose qubits sit in at most two checks; color for colour codes (restriction to matching on the three restricted lattices, lifted at each colour, completed below half the distance by an exact search); relay_bp for any code (it can stall on a degenerate error of a topological code, and then says it did not converge); search for the lightest error with the syndrome up to max_weight. At circuit level, give `memory` ({distance, rounds, p}: the rotated surface-code memory experiment), `circuit` (the circuit text: tags, Pauli-target observables and coordinates read) or `model` (detector error model text, decompositions with ^ read), with the fired `detectors` (the prediction: which observables flipped) or `shots` (sampled and decoded: the failure rate and its standard error): matching (exact), correlated (exact matching twice through the model's decomposed faults, the second answer kept only when the model's mechanisms explain it more cheaply), union_find, bp_osd, or window (a sliding window: `window` {commit, buffer} rounds; every edge set below half the distance is corrected once the buffer is at least (d + 1)/2). Sealed with the service's key.

Input parameters:

- `circuit` (string): A noisy Clifford circuit in the circuit text.
- `code`: A code by name: surface:D (the rotated surface code, odd D from 3 to 15), toric:L (2 to 12), steane, color:D (the triangular 6.6.6 colour code, odd D from 3 to 15), bb:72, bb:90, bb:108, bb:144 (or g…
- `decoder` (string): The decoder (default: matching, or color for a colour code, relay_bp for a bivariate-bicycle code).
- `detectors` (array): The detectors that fired.
- `error` (array): The flipped qubits, by index.
- `max_weight` (integer): search: the heaviest error to try.
- `memory` (object): The rotated surface-code memory experiment at circuit level.
- `model` (string): A detector error model in its text.
- `seed` (integer): The sampling seed (default 1).
- `shots` (integer): Sample this many shots of the circuit and decode each.
- `syndrome` (array): The violated checks, by index.
- `window` (object): window: rounds each window commits and the rounds after them it sees.

### `qec_threshold` (~230 tokens)

Measure logical failure rates over distances

Measure logical failure rates over distances and physical error rates: family surface at circuit level (decoders matching, correlated or union_find; the code model P(d) = a·(p/p*)^((d+1)/2) per round fitted to the points), or color, toric or surface_capacity at code capacity. Each point gives its shots, failures, rate and standard error; below_threshold says, at each p, whether every larger distance failed less. Sealed with the service's key. Report rates with their errors: a crossing measured on few shots is not a threshold.

Input parameters:

- `decoder` (string): surface: the decoder (default matching).
- `distances` (array): Odd distances (default 3, 5, 7).
- `family` (string): surface (circuit level, the default) or a code at code capacity.
- `p` (array): Physical error rates.
- `rounds` (integer): surface: rounds (default the distance).
- `seed` (integer)
- `shots` (integer): Shots at each point (default 10000).

### `pulse_schedule` (~328 tokens)

Read a pulse program into its schedule

Read a pulse program (OpenPulse calibrations: ports, frames, waveforms, play, delay, shift_phase, set_phase, shift_frequency, set_frequency, captures and barriers) into its schedule on frames: every instruction at its sample, each waveform's samples (gaussian, drag, gaussian_square, constant, sech, sine, or explicit), each gate call with the samples its calibration spans, and the digests a pulse run's receipt binds (the program, its calibrations, the schedule). Durations are whole samples of dt (pulse.dt_ns, default 0.5 ns) or refused. A construct the reader does not take is refused with a Q code and its line. Sealed with the service's key. To run it, give the program to run_quantum_circuit with method "pulse".

Input parameters:

- `pulse` (object): A pulse run's options (method "pulse"): the sample period, the levels kept, the tolerance on the stated error, the steps a sample is divided into, each qubit's parameters, static couplings, and ports…
- `qasm` (string, required): A pulse program: OpenQASM 3 with `defcalgrammar "openpulse";`, `cal` blocks declaring ports (d0 drives qubit 0, m0 is its measurement port, a0 its acquisition port), frames (newframe(port, frequency…

### `pulse_check` (~144 tokens)

Check a pulse run by running it again

Check a pulse job as a host returned it ({"request", "result"}, the result with its receipt): the receipt's signature, the program's digest against the request's text, and the request run again here with the result held to the one given field by field (the density matrix's digest among them), each difference named. A pulse run is the same bits on every platform, so a result that does not reproduce was not made from that request by this engine. Sealed with the service's key. Quote `verified` and the statement.

Input parameters:

- `request` (object, required): The pulse job's request.
- `result` (object, required): Its result, with its receipt.

### `gradient_qasm` (~371 tokens)

The exact gradient of a Hamiltonian's expectation by a program's parameters

The expectation E = ⟨ψ|H|ψ⟩ of a Hamiltonian at a program's parameters, and its gradient by each parameter, exactly: by adjoint differentiation or the parameter-shift rule on the double-precision state vector (at most 20 qubits, no noise, measurements only at the end). The reader follows each parameter into the gates, so an argument may be any expression of the built-in functions. The answer states its method, that it is f64 and approximate, and a bound on the rounding of the value and of each component (precision.rounding_bound). Sealed with the service's key. Quote the gradient with its bound.

Input parameters:

- `gradient`: adjoint (the default: one pass forward, one back) or parameter_shift (each gate a parameter moves run at shifted angles: two terms, four for a controlled rotation); both exact up to f64 rounding.
- `hamiltonian` (array, required): A Hamiltonian as Pauli terms summed: "Z0 Z1", "0.5 X2", "-1.5" (a constant), or {"pauli": "Y0 Y1", "coeff": -0.7}; qubit 0 is q[0].
- `params` (object, required): A value for each parameter, by name, as {"theta": 0.3}: bound exactly. Every parameter the program declares needs one (J050).
- `qasm` (string, required): The program, OpenQASM 3: its parameters declared `input float theta;` (or `input angle theta;`) and used in gates' arguments, through arithmetic, the built-in functions and gate definitions (not unde…

### `optimize_qasm` (~515 tokens)

Minimise a Hamiltonian's expectation over a program's parameters

Minimise E = ⟨ψ|H|ψ⟩ over a program's parameters from the given params, deterministically: gradient descent with a fixed step, Adam, or SPSA from a seeded stream (at most 2000 steps). Every step's parameters and value (and gradient, or SPSA's perturbation and estimate) are listed, each step a link of a digest chain from the request, best and final given; the same request gives the same bytes on every platform. Sealed with the service's key: the receipt binds the program, every step, the method and the seed, and verify_quantum_result (or wai-quantum verify) re-runs it. A minimum found is a minimum along this path, not a proof of the global one.

Input parameters:

- `gradient`: adjoint (the default: one pass forward, one back) or parameter_shift (each gate a parameter moves run at shifted angles: two terms, four for a controlled rotation); both exact up to f64 rounding.
- `hamiltonian` (array, required): A Hamiltonian as Pauli terms summed: "Z0 Z1", "0.5 X2", "-1.5" (a constant), or {"pauli": "Y0 Y1", "coeff": -0.7}; qubit 0 is q[0].
- `optimizer`: gradient_descent (θ ← θ − step·∇E), adam (default; beta1, beta2, epsilon), or spsa (two evaluations a step along a ±1 perturbation from the seeded stream; c, A, alpha, gamma).
- `params` (object, required): A value for each parameter, by name, as {"theta": 0.3}: bound exactly. Every parameter the program declares needs one (J050).
- `qasm` (string, required): The program, OpenQASM 3: its parameters declared `input float theta;` (or `input angle theta;`) and used in gates' arguments, through arithmetic, the built-in functions and gate definitions (not unde…
- `seed` (integer): SPSA's seed (default 1).
- `step_size` (number): The step (gradient descent 0.1, Adam 0.05) or SPSA's gain a (0.2).
- `steps` (integer): Steps to take (default 100).

### `vqe_ground_state` (~516 tokens)

Find a Hamiltonian's ground energy by the variational eigensolver

The variational eigensolver: an ansatz (the program given as qasm with params, or ansatz {"layers": L}: layers of ry and rz on every qubit and a ring of cx, its parameters t0, t1, … from 0.1) optimised on the Hamiltonian as optimize_qasm does. At most 8 qubits the answer sets the energy found beside the exact ground energy by diagonalisation (reference.ground_energy and gap); the energy found is never below it. Sealed with the service's key. Report the gap: an ansatz that cannot reach the ground state stops above it.

Input parameters:

- `ansatz` (object): The built-in ansatz in place of qasm (layers default 2, qubits the Hamiltonian's).
- `gradient`: adjoint (the default: one pass forward, one back) or parameter_shift (each gate a parameter moves run at shifted angles: two terms, four for a controlled rotation); both exact up to f64 rounding.
- `hamiltonian` (array, required): A Hamiltonian as Pauli terms summed: "Z0 Z1", "0.5 X2", "-1.5" (a constant), or {"pauli": "Y0 Y1", "coeff": -0.7}; qubit 0 is q[0].
- `optimizer`: gradient_descent (θ ← θ − step·∇E), adam (default; beta1, beta2, epsilon), or spsa (two evaluations a step along a ±1 perturbation from the seeded stream; c, A, alpha, gamma).
- `params` (object): A value for each parameter, by name, as {"theta": 0.3}: bound exactly. Every parameter the program declares needs one (J050).
- `qasm` (string): The program, OpenQASM 3: its parameters declared `input float theta;` (or `input angle theta;`) and used in gates' arguments, through arithmetic, the built-in functions and gate definitions (not unde…
- `seed` (integer): SPSA's seed (default 1).
- `step_size` (number): The step (gradient descent 0.1, Adam 0.05) or SPSA's gain a (0.2).
- `steps` (integer): Steps to take (default 100).

### `qaoa_maxcut` (~352 tokens)

Solve Max-Cut on a graph by QAOA

Max-Cut by the quantum approximate optimisation algorithm: the program (|+⟩ⁿ, then for each layer rzz(gamma·w) on every edge and rx(2·beta) on every qubit) and its cost Hamiltonian built from the graph (at most 20 vertices, 16 layers), optimised as optimize_qasm does from the params or a linear ramp, and read against the maximum cut found by brute force: the expected cut and its ratio to the maximum, the likeliest assignment and whether it is optimal, and the probability of an optimal one. Sealed with the service's key.

Input parameters:

- `gradient`: adjoint (the default: one pass forward, one back) or parameter_shift (each gate a parameter moves run at shifted angles: two terms, four for a controlled rotation); both exact up to f64 rounding.
- `graph` (object, required)
- `layers` (integer): QAOA's p (default 1).
- `optimizer`: gradient_descent (θ ← θ − step·∇E), adam (default; beta1, beta2, epsilon), or spsa (two evaluations a step along a ±1 perturbation from the seeded stream; c, A, alpha, gamma).
- `params` (object): gamma_0, beta_0, … to start from.
- `seed` (integer): SPSA's seed (default 1).
- `step_size` (number): The step (gradient descent 0.1, Adam 0.05) or SPSA's gain a (0.2).
- `steps` (integer): Steps to take (default 100).

### `build_algorithm` (~399 tokens)

Write the program for a standard algorithm, checked against its reference

An OpenQASM 3 program for a standard algorithm, with how to read its result, what it gives, and the equivalence ladder's verdict on it against a reference matrix or truth table built from the definitions (check: exact on every basis state up to 8 qubits, the adder's up to 16; past that unchecked). qpe: the phase φ of p(2πφ) on counting qubits; amplitude_estimation: the amplitude a that A = ry(2·arcsin √a) gives the good state, by phase estimation of the Grover operator; adder: the ripple-carry adder of bits-bit integers in place (with a and b, prepared and measured); qsvt: quantum signal processing from phases, of a signal x or of a real symmetric 2 × 2 matrix through its block encoding (all phases zero give the Chebyshev polynomial). Sealed with the service's key. Run the program with run_quantum_circuit.

Input parameters:

- `a` (integer): adder: the first addend, prepared.
- `algorithm` (required)
- `amplitude` (number): amplitude_estimation: the good state's probability a.
- `b` (integer): adder: the second, which the sum replaces.
- `bits` (integer): adder: the integers' width.
- `carry_in` (boolean): adder: a carry in.
- `counting` (integer): qpe, amplitude_estimation: counting qubits (default 4).
- `matrix` (array): qsvt: [[a, b], [b, c]], real and symmetric, its eigenvalues within [-1, 1].
- `phase` (number): qpe: the phase φ, in turns.
- `phases` (array): qsvt: φ₀ … φ_d, radians.
- `x` (number): qsvt: the signal.

## Diagnostics

Captured diagnostic sections: TLS, DNSSEC, Authorisation, Transports. The full working is on the page: https://verifymcp.io/servers/science-transaction-wai-quantum-jobs/quantum-jobs-mcp#diagnostics

## Score history

- 2026-11-05: 64
- 2026-11-04: 63
- 2026-11-03: 63
- 2026-11-02: 62
- 2026-11-01: 62
- 2026-10-31: 61
- 2026-10-30: 61
- 2026-10-29: 60

## Common questions

### What is the WAI Quantum job service MCP server?

WAI Quantum job service is an MCP server listed in the public MCP registry as science.transaction.wai/quantum-jobs. A free quantum job service: OpenQASM 3 run, checked and signed, with no account or key. This page covers its hosted endpoint (https://wai.transaction.science/quantum-jobs/mcp).

### Is the WAI Quantum job service MCP server safe to use?

WAI Quantum job service scores 64 out of 100 on VerifyMCP. That is a record of what we were able to check automatically, not an endorsement. The category breakdown on this page shows every signal behind the number, including the ones we could not confirm.

### What tools does the WAI Quantum job service MCP server expose?

WAI Quantum job service exposes 30 tools: run_quantum_circuit, run_quantum_set, dry_run_quantum_job, get_quantum_job, verify_quantum_receipt, and 25 more. Their descriptions and schemas cost roughly 12,390 tokens of context every time the server is loaded.

### Does the WAI Quantum job service MCP server require authentication?

No. We connected to WAI Quantum job service without credentials and it answered, so anything it exposes is reachable by anyone who knows the address.

### Is the WAI Quantum job service MCP server still maintained?

WAI Quantum job service is still listed as active in the MCP registry. We last reached this channel on 5 November 2026. Those dates come from our own scans of the registry and the channel itself, not from anything the publisher announced.

### What did VerifyMCP test on the WAI Quantum job service MCP server?

VerifyMCP ran 11 checks on WAI Quantum job service, covering TLS certificate, HSTS header, DNSSEC, Transport and 7 more. 2 items could not be completed, a gap on our side rather than a finding about WAI Quantum job service: Authorization and HTTPS. Supply Chain Security and Provenance & Transparency do not apply to a hosted endpoint, so they were not tested. The score does not measure everything, and the scoring documentation lists what it leaves out.

## Links

- Remote endpoint: https://wai.transaction.science/quantum-jobs/mcp
- Website: https://wai.transaction.science/quantum-run/
- Changelog RSS feed: https://verifymcp.io/servers/science-transaction-wai-quantum-jobs/quantum-jobs-mcp.xml
- Changelog JSON feed: https://verifymcp.io/servers/science-transaction-wai-quantum-jobs/quantum-jobs-mcp/changelog.json
- Trust report (JSON): https://verifymcp.io/servers/science-transaction-wai-quantum-jobs/quantum-jobs-mcp.json
- HTML version of this page: https://verifymcp.io/servers/science-transaction-wai-quantum-jobs/quantum-jobs-mcp