Skip to content

WAI Quantum job service MCP server

science.transaction.wai/quantum-jobswai.transaction.sciencestreamable-httpv0.2.2Scanned

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

37 tools: 1 do something that can't be undone, 32 change things and 4 only read.

Tools: 0 delete, 1 irreversible, 32 write, 4 read.
  • Reads private data · 0
  • Reads text others write · 0
  • Can send data out · 1
  • 11 findings

Tools listed without sign-in. Remote posture

With Anlyon

1 tool here does something that can't be undone. Govern it.

  • Anlyon lists the tools and adopts none.
  • Each tool you adopt gets approvals and receipts.
  • Your agent never holds the key.
Govern this server →

A tool your agent calls directly is not routed through Anlyon and is not governed by it. Anlyon Radar only lists and labels, and these labels are the same either way.

What the WAI Quantum job service MCP server can do

The WAI Quantum job service MCP server is published by wai.transaction.science, a domain the MCP Registry verified. It has 37 tools. It can do things that cannot be undone, such as sending, paying or publishing (convert_program) and create or change data (32 tools: run_quantum_circuit, run_quantum_set, dry_run_quantum_job, verify_quantum_receipt and 28 more), but cannot delete data. 4 tools only read.

1 tool can send data out of your system (convert_program).

The fixed checks matched 11 findings (annotation-conflict and tool-shadowing). Each one comes with the text it matched.

Its remote endpoint lists its tools without sign-in, and its tools changed 3 times since Anlyon Radar first saw them.

Last scanned Nov 18, 2026, version 0.2.2.

Tools

Grouped by what each tool does, most consequential first. Open one for its reasons and full description; descriptions are the publisher's own words.

37 tools

Can't be undone 1Claude Code: ask
  • convert_programCarry 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).Can send data out2 findings

    Why it is in this group

    • The name "convert_program" says "convert": a word for a change.
    • The input addresses people (input.to): what it sends cannot be taken back.
    • The server marks it read-only (readOnlyHint: true), but an annotation never lowers a class.

    What it can reach

    • outboundThe input takes a destination (input.to): what the tool writes goes there.

    Findings

    • Warn

      The description contains "every other tool", wording about other tools or servers.

      Matched text

      description: "...ritten, the program as OpenQASM 3 (what every other tool takes), each note with its code (a rota..."

      What this check looks for
    • Warn

      The server marks "convert_program" read-only (readOnlyHint: true), and its own name, description or input give the class "irreversible".

      Matched text

      annotations: {"readOnlyHint":true}; The name "convert_program" says "convert": a word for a change.

      What this check looks for
    Description, as the server wrote it
    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.

    Annotations the server declares

    • readOnlyHint: true
Changes things 32Claude Code: ask
  • attest_quantum_jobSign off a job another host sealed (the job service, a provider, another person's machine), after verifying it: its receipt and every rule of its form, any verdict or compile it se…No findings

    Why it is in this group

    • Nothing in its name or description says what it does, so it is counted as a write.
    • The server marks it read-only (readOnlyHint: true), but an annotation never lowers a class.
    Description, as the server wrote it
    Sign off a job another host sealed (the job service, a provider, another person's machine), after verifying it: its receipt and every rule of its form, any verdict or compile it seals worked out again, and, given a trust list and a time, its key held to them (the provider protocol's section 8.8). A job that is not valid is refused and nothing is sealed. Then what its answer must do (`intent`) is checked against it by the strongest layer the engine has, and the job's digest, the intent and the verdict are sealed with the service's key (wai.quantum.signoff/1). `attested`, beside the sign-off and outside its seal, says what the job was checked against. verify_quantum_result works the sign-off out again. Verifying the job and checking the intent are held to the service's bounds, and an attestation past them is refused with the local command (`wai-quantum attest`).

    Annotations the server declares

    • readOnlyHint: true
    • idempotentHint: true
    • openWorldHint: false
  • build_algorithmAn 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 bui…1 finding

    Why it is in this group

    • The description's first verb is "open": a word for a change.
    • The server marks it read-only (readOnlyHint: true), but an annotation never lowers a class.

    Findings

    • Warn

      The server marks "build_algorithm" read-only (readOnlyHint: true), and its own name, description or input give the class "write".

      Matched text

      annotations: {"readOnlyHint":true,"idempotentHint":true,"openWorldHint":false}; The description's first verb is "open": a word for a change.

      What this check looks for
    Description, as the server wrote it
    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.

    Annotations the server declares

    • readOnlyHint: true
    • idempotentHint: true
    • openWorldHint: false
  • check_equivalentWhether 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, …No findings

    Why it is in this group

    • Nothing in its name or description says what it does, so it is counted as a write.
    • The server marks it read-only (readOnlyHint: true), but an annotation never lowers a class.
    Description, as the server wrote it
    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.

    Annotations the server declares

    • readOnlyHint: true
  • check_quantum_programOne call for the inner loop: the program read (whether it reads, the reader's diagnostics with their lines and codes, its measures and smells); where the reader refuses it, the mec…No findings

    Why it is in this group

    • Nothing in its name or description says what it does, so it is counted as a write.
    • The server marks it read-only (readOnlyHint: true), but an annotation never lowers a class.
    Description, as the server wrote it
    One call for the inner loop: the program read (whether it reads, the reader's diagnostics with their lines and codes, its measures and smells); where the reader refuses it, the mechanical fixes the engine would make on the flagged lines and what needs a person; and given what it must do (`intent`, or a `task` with cases and constraints), each case run and graded passed, failed or unchecked by the strongest layer the engine has for its intent, with the verdict, its layer and that layer's limits, each constraint measured, what went wrong and where to look. `next` says what to do next. Nothing is sealed: when every case passes, grade_quantum_program seals the grade. Never call a program correct past what its verdict's level and layer say. Each case's intent is held to the service's bounds before it runs, and a case past them is refused with the local command (`wai-quantum check`).

    Annotations the server declares

    • readOnlyHint: true
    • idempotentHint: true
    • openWorldHint: false
  • classical_shortcutsEvery 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 …No findings

    Why it is in this group

    • Nothing in its name or description says what it does, so it is counted as a write.
    • The server marks it read-only (readOnlyHint: true), but an annotation never lowers a class.
    Description, as the server wrote it
    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.

    Annotations the server declares

    • readOnlyHint: true
  • compile_qasmCompile an OpenQASM program through named passes (lowering, checked rewrites, phase folding, regions of CNOT and phase gates written again with fewer T gates, one- and two-qubit re…No findings

    Why it is in this group

    • Nothing in its name or description says what it does, so it is counted as a write.
    • The server marks it read-only (readOnlyHint: true), but an annotation never lowers a class.
    Description, as the server wrote it
    Compile an OpenQASM program through named passes (lowering, checked rewrites, phase folding, regions of CNOT and phase gates written again with fewer T gates, 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. With basis cz, zz or xx the program is written instead as one-qubit gates around a device basis's own two-qubit gate, each pair's block around at most three of it, nothing approximated, placed or routed. Returns the compiled program and a certificate sealed with the service's key: each pass's counts before and after, the digests of the circuit it was given and the circuit it gave (they chain from the program to the output), the layer its check stands on (stabilizer and exact_arithmetic are proofs, exact_simulation a comparison in doubles, bounded within a stated distance), its check and verdict (proof, exact or approximate with its distance), the budget and the bound the distances add to, and the layer of the strongest check the whole output passed. verify_quantum_receipt checks its receipt and compiles it again. Quote the bound; an approximate compile is not exact. A large or very fine compile is refused with the local command.

    Annotations the server declares

    • readOnlyHint: true
  • critique_qasmA 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 e…No findings

    Why it is in this group

    • Nothing in its name or description says what it does, so it is counted as a write.
    • The server marks it read-only (readOnlyHint: true), but an annotation never lowers a class.
    Description, as the server wrote it
    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.

    Annotations the server declares

    • readOnlyHint: true
  • dry_run_quantum_jobWhat 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 r…1 finding

    Why it is in this group

    • The name "dry_run_quantum_job" says "run": a word for a change.
    • The server marks it read-only (readOnlyHint: true), but an annotation never lowers a class.

    Findings

    • Warn

      The server marks "dry_run_quantum_job" read-only (readOnlyHint: true), and its own name, description or input give the class "write".

      Matched text

      annotations: {"readOnlyHint":true}; The name "dry_run_quantum_job" says "run": a word for a change.

      What this check looks for
    Description, as the server wrote 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, and plans it as they run it, its verdict asked: what it says they take, they take. It counts as one submission.

    Annotations the server declares

    • readOnlyHint: true
  • estimate_resourcesWhat a fault-tolerant quantum computer would need to run a program.No findings

    Why it is in this group

    • Nothing in its name or description says what it does, so it is counted as a write.
    • The server marks it read-only (readOnlyHint: true), but an annotation never lowers a class.
    Description, as the server wrote it
    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, the budget and the clock, 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.

    Annotations the server declares

    • readOnlyHint: true
  • grade_quantum_programGrade a program against a task (wai.quantum.grade/1, quantum-providers.md §8.10): each case run with its intent and graded passed, failed or unchecked, with the verdict that decide…No findings

    Why it is in this group

    • Nothing in its name or description says what it does, so it is counted as a write.
    • The server marks it read-only (readOnlyHint: true), but an annotation never lowers a class.
    Description, as the server wrote it
    Grade a program against a task (wai.quantum.grade/1, quantum-providers.md §8.10): each case run with its intent and graded passed, failed or unchecked, with the verdict that decided it and that verdict's layer and limits; each constraint measured; what went wrong with where to look; and whether the program passes. The grade is a job sealed with the service's key, the task and the program in its request, so anyone can run it again and get the same answer: verify_quantum_result works it out again. Quote each case's grade and layer; a case decided by evidence is not proved. Each case's intent is held to the service's bounds before any case runs, and a grade past them is refused with the local command (`wai-quantum grade`).

    Annotations the server declares

    • readOnlyHint: true
    • idempotentHint: true
    • openWorldHint: false
  • gradient_qasmThe 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 d…No findings

    Why it is in this group

    • Nothing in its name or description says what it does, so it is counted as a write.
    • The server marks it read-only (readOnlyHint: true), but an annotation never lowers a class.
    Description, as the server wrote it
    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.

    Annotations the server declares

    • readOnlyHint: true
    • idempotentHint: true
    • openWorldHint: false
  • improve_qasmThe 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.No findings

    Why it is in this group

    • Nothing in its name or description says what it does, so it is counted as a write.
    • The server marks it read-only (readOnlyHint: true), but an annotation never lowers a class.
    Description, as the server wrote it
    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.

    Annotations the server declares

    • readOnlyHint: true
  • optimize_qasmMinimise 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 step…No findings

    Why it is in this group

    • Nothing in its name or description says what it does, so it is counted as a write.
    • The server marks it read-only (readOnlyHint: true), but an annotation never lowers a class.
    Description, as the server wrote it
    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.

    Annotations the server declares

    • readOnlyHint: true
    • idempotentHint: true
    • openWorldHint: false
  • pulse_checkCheck 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 requ…No findings

    Why it is in this group

    • Nothing in its name or description says what it does, so it is counted as a write.
    • The server marks it read-only (readOnlyHint: true), but an annotation never lowers a class.
    Description, as the server wrote it
    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.

    Annotations the server declares

    • readOnlyHint: true
    • idempotentHint: true
    • openWorldHint: false
  • pulse_scheduleRead a pulse program (OpenPulse calibrations: ports, frames, waveforms, play, delay, shift_phase, set_phase, shift_frequency, set_frequency, captures and barriers) into its schedul…1 finding

    Why it is in this group

    • The name "pulse_schedule" says "schedule": a word for a change.
    • The server marks it read-only (readOnlyHint: true), but an annotation never lowers a class.

    Findings

    • Warn

      The server marks "pulse_schedule" read-only (readOnlyHint: true), and its own name, description or input give the class "write".

      Matched text

      annotations: {"readOnlyHint":true,"idempotentHint":true,"openWorldHint":false}; The name "pulse_schedule" says "schedule": a word for a change.

      What this check looks for
    Description, as the server wrote it
    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".

    Annotations the server declares

    • readOnlyHint: true
    • idempotentHint: true
    • openWorldHint: false
  • qaoa_maxcutMax-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…No findings

    Why it is in this group

    • Nothing in its name or description says what it does, so it is counted as a write.
    • The server marks it read-only (readOnlyHint: true), but an annotation never lowers a class.
    Description, as the server wrote it
    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.

    Annotations the server declares

    • readOnlyHint: true
    • idempotentHint: true
    • openWorldHint: false
  • qasm_diagnosticsEvery 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…1 finding

    Why it is in this group

    • The input takes a statement or command to run (input.code), which can change anything it can reach.
    • The server marks it read-only (readOnlyHint: true), but an annotation never lowers a class.

    Findings

    • Warn

      The server marks "qasm_diagnostics" read-only (readOnlyHint: true), and its own name, description or input give the class "write".

      Matched text

      annotations: {"readOnlyHint":true}; The input takes a statement or command to run (input.code), which can change anything it can reach.

      What this check looks for
    Description, as the server wrote it
    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.

    Annotations the server declares

    • readOnlyHint: true
  • qec_codeShow 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 adm…1 finding

    Why it is in this group

    • The description's first verb is "show": a word for reading.
    • The input takes a statement or command to run (input.code), which can change anything it can reach.
    • The server marks it read-only (readOnlyHint: true), but an annotation never lowers a class.

    Findings

    • Warn

      The server marks "qec_code" read-only (readOnlyHint: true), and its own name, description or input give the class "write".

      Matched text

      annotations: {"readOnlyHint":true,"idempotentHint":true,"openWorldHint":false}; The description's first verb is "show": a word for reading.

      What this check looks for
    Description, as the server wrote it
    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.

    Annotations the server declares

    • readOnlyHint: true
    • idempotentHint: true
    • openWorldHint: false
  • qec_decodeDecode with the engine's decoders.1 finding

    Why it is in this group

    • The input takes a statement or command to run (input.code), which can change anything it can reach.
    • The server marks it read-only (readOnlyHint: true), but an annotation never lowers a class.

    Findings

    • Warn

      The server marks "qec_decode" read-only (readOnlyHint: true), and its own name, description or input give the class "write".

      Matched text

      annotations: {"readOnlyHint":true,"idempotentHint":true,"openWorldHint":false}; The input takes a statement or command to run (input.code), which can change anything it can reach.

      What this check looks for
    Description, as the server wrote it
    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.

    Annotations the server declares

    • readOnlyHint: true
    • idempotentHint: true
    • openWorldHint: false
  • qec_thresholdMeasure 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*)^…No findings

    Why it is in this group

    • Nothing in its name or description says what it does, so it is counted as a write.
    • The server marks it read-only (readOnlyHint: true), but an annotation never lowers a class.
    Description, as the server wrote it
    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.

    Annotations the server declares

    • readOnlyHint: true
    • idempotentHint: true
    • openWorldHint: false
  • quantum_circuit_examplesWorked 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 qubi…No findings

    Why it is in this group

    • Nothing in its name or description says what it does, so it is counted as a write.
    • The server marks it read-only (readOnlyHint: true), but an annotation never lowers a class.
    Description, as the server wrote it
    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.

    Annotations the server declares

    • readOnlyHint: true
  • quantum_service_infoThe 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 c…No findings

    Why it is in this group

    • Nothing in its name or description says what it does, so it is counted as a write.
    • The server marks it read-only (readOnlyHint: true), but an annotation never lowers a class.
    Description, as the server wrote it
    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).

    Annotations the server declares

    • readOnlyHint: true
  • repair_qasmRepair a program the reader refuses, changing only the lines its diagnostics flag.No findings

    Why it is in this group

    • Nothing in its name or description says what it does, so it is counted as a write.
    • The server marks it read-only (readOnlyHint: true), but an annotation never lowers a class.
    Description, as the server wrote it
    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.

    Annotations the server declares

    • readOnlyHint: true
  • run_landscapeRun an energy-landscape job (wai.quantum.landscape/1): no circuit, but an energy over variables of three states (+, - and 0, where 0 is left out at its own cost), written in epuML,…1 finding

    Why it is in this group

    • The name "run_landscape" says "run": a word for a change.
    • The server marks it read-only (readOnlyHint: true), but an annotation never lowers a class.

    Findings

    • Warn

      The server marks "run_landscape" read-only (readOnlyHint: true), and its own name, description or input give the class "write".

      Matched text

      annotations: {"readOnlyHint":true,"idempotentHint":true,"openWorldHint":false}; The name "run_landscape" says "run": a word for a change.

      What this check looks for
    Description, as the server wrote it
    Run an energy-landscape job (wai.quantum.landscape/1): no circuit, but an energy over variables of three states (+, - and 0, where 0 is left out at its own cost), written in epuML, and a state of low energy found by the settling model's reference kernels, a classical emulator, in software. The answer gives the state, its exact energy, every arrangement checked where the program has at most 16 variables (truth, reached), the program's own checks, a verdict (solved, missed, failed or unchecked) with its reason, the work counted, the joules priced at rates measured elsewhere (never metered: say priced), and a replay digest anyone can reproduce. Sealed with the service's key; verify_quantum_receipt checks it, its form included (quantum-landscape §5.4). With "protocol": "wai.quantum.landscape/2" in the request it runs the second version (a cost for each variable, of either sign, and the constraints exactly and atmost, so colouring and assignment run): its joules are priced at temperature 0 only, and a sampling run's are stated unpriced, with why and no figure. Nothing here is a quantum effect. Quote the verdict and the numbers; a program refused is refused with its line.

    Annotations the server declares

    • readOnlyHint: true
    • idempotentHint: true
    • openWorldHint: false
  • run_on_targetRun 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 again…No findings

    Why it is in this group

    • The name "run_on_target" says "run": a word for a change.
    Description, as the server wrote it
    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.

    Annotations the server declares

    • readOnlyHint: false
    • idempotentHint: false
    • openWorldHint: false
  • run_quantum_circuitRun an OpenQASM program and return measurement counts, Pauli expectation values and/or amplitudes.No findings

    Why it is in this group

    • The name "run_quantum_circuit" says "run": a word for a change.
    Description, as the server wrote it
    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.

    Annotations the server declares

    • readOnlyHint: false
    • idempotentHint: false
    • openWorldHint: false
  • run_quantum_setRun 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": …No findings

    Why it is in this group

    • The name "run_quantum_set" says "run": a word for a change.
    Description, as the server wrote it
    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.

    Annotations the server declares

    • readOnlyHint: false
    • idempotentHint: false
    • openWorldHint: false
  • run_quditRun a qudit job (wai.quantum.qudit/1, quantum-sim.md §9): a register of qudits of dimension 2, 3, 4 or 6, a program of shift, clock, fourier, csum and phase gates run on it from |0…1 finding

    Why it is in this group

    • The name "run_qudit" says "run": a word for a change.
    • The server marks it read-only (readOnlyHint: true), but an annotation never lowers a class.

    Findings

    • Warn

      The server marks "run_qudit" read-only (readOnlyHint: true), and its own name, description or input give the class "write".

      Matched text

      annotations: {"readOnlyHint":true,"idempotentHint":true,"openWorldHint":false}; The name "run_qudit" says "run": a word for a change.

      What this check looks for
    Description, as the server wrote it
    Run a qudit job (wai.quantum.qudit/1, quantum-sim.md §9): a register of qudits of dimension 2, 3, 4 or 6, a program of shift, clock, fourier, csum and phase gates run on it from |0…0⟩ in whole numbers at 2^-30, and the register measured with a seed. The answer gives the counts keyed by the qudits' digits (highest qudit first), the amplitudes asked for as integers, the state's BLAKE3 and norm, the digest of the constants its dimension reads, the work, and the accuracy: bit-exact, the same integers on every host, with a bound on the state's distance from the ideal and on the outcomes' total variation. Sealed with the service's key; verify_quantum_receipt checks the seal, and anyone can run the request again for the same bits. A request past a bound is refused before anything runs (J090, J091, J092).

    Annotations the server declares

    • readOnlyHint: true
    • idempotentHint: true
    • openWorldHint: false
  • run_wasmqRun a wasmQ envelope (wai.quantum.wasmq/1 or /2, extensions/quantum-wasmq.md): an OpenQASM 3 program and the WebAssembly modules its `extern`s call between gates, in one content-ad…1 finding

    Why it is in this group

    • The name "run_wasmq" says "run": a word for a change.
    • The server marks it read-only (readOnlyHint: true), but an annotation never lowers a class.

    Findings

    • Warn

      The server marks "run_wasmq" read-only (readOnlyHint: true), and its own name, description or input give the class "write".

      Matched text

      annotations: {"readOnlyHint":true,"idempotentHint":true,"openWorldHint":false}; The name "run_wasmq" says "run": a word for a change.

      What this check looks for
    Description, as the server wrote it
    Run a wasmQ envelope (wai.quantum.wasmq/1 or /2, extensions/quantum-wasmq.md): an OpenQASM 3 program and the WebAssembly modules its `extern`s call between gates, in one content-addressed envelope. The quantum part is simulated here (the stabilizer tableau, or the second version's whole-number state vector for t, Toffoli and dyadic angles), each callout a metered call of its module; the run is the same bytes on every host and engine. The job gives the counts, the calls and the fuel each used, the modules' digests, the digest of every call, and the fault that stopped the run if one did (a fault is sealed, not an error). A second-version run's energy is what the service read of the worker that ran it: the process's CPU energy on macOS, the processor packages' over its window on Linux, or the unmetered form with the reason where the host reads none, never zero; the first version states only that it is unmetered. The run is a job: past the answer's wait its id comes back to poll with get_quantum_job, and an envelope past what the service takes is refused, naming the local command. Sealed with the service's key; verify_quantum_receipt holds the job to the profile's form (section 6.5). Give the envelope as base64, or name an example; an envelope the profile refuses is refused with its code (W001 to W017).

    Annotations the server declares

    • readOnlyHint: true
    • idempotentHint: true
    • openWorldHint: false
  • verify_quantum_receiptWhether a result's receipt (an Ed25519 signature) seals exactly that request and that result, and every rule of its form holds (`reasons` names what does not).No findings

    Why it is in this group

    • Nothing in its name or description says what it does, so it is counted as a write.
    • The server marks it read-only (readOnlyHint: true), but an annotation never lowers a class.
    Description, as the server wrote it
    Whether a result's receipt (an Ed25519 signature) seals exactly that request and that result, and every rule of its form holds (`reasons` names what does not). 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.

    Annotations the server declares

    • readOnlyHint: true
  • vqe_ground_stateThe 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, …No findings

    Why it is in this group

    • Nothing in its name or description says what it does, so it is counted as a write.
    • The server marks it read-only (readOnlyHint: true), but an annotation never lowers a class.
    Description, as the server wrote it
    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.

    Annotations the server declares

    • readOnlyHint: true
    • idempotentHint: true
    • openWorldHint: false
  • write_circuitHave the service's own model write an OpenQASM 3 program for a task, the engine checking each attempt against what the task asks exactly as it checks a lesson's answer, and what we…No findings

    Why it is in this group

    • The name "write_circuit" says "write": a word for a change.
    Description, as the server wrote it
    Have the service's own model write an OpenQASM 3 program for a task, the engine checking each attempt against what the task asks exactly as it checks a lesson's answer, and what went wrong going back to the model for another attempt, up to `rounds` repairs. The task is an exercise in the course's form (wai.quantum.exercise/1): a title and task in words, an optional starter program, and what the program must do, as an `intent` (an exact distribution, a reference program it must equal or whose state it must prepare) or `cases` that each have one, with optional constraints (gates allowed, counts, T count, smells), at most 16 cases and 8 intents in one place, its canonical form at most 64 KiB. The answer is a job whose result is the transcript (wai.quantum.write/1): the model by name, licence and the digest of its files, every byte checked, and the arithmetic it ran in, the prompt, each attempt's program and the engine's check, and whether one passed and at what level, signed (verify_quantum_receipt checks it with the job's request). Decoding is greedy, so the same task gives the same transcript in the same arithmetic (architecture, operating system, maths library, matmul kernel). Writes take minutes and run one at a time; a client holds one queued or running write. Call it as a task, or it waits 50 s and answers with status running and an id for get_quantum_job. A service without a model refuses it (J080); quantum_service_info says under `write` whether this one has one. Each call is a new write unless it gives idempotency_key.

    Annotations the server declares

    • readOnlyHint: false
    • idempotentHint: false
    • openWorldHint: false
Only reads 4Show 4 read-only tools
  • get_quantum_jobA job's status, and its result when it is done.No findings

    Why it is in this group

    • The name "get_quantum_job" says "get": a word for reading.
    Description, as the server wrote it
    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.

    Annotations the server declares

    • readOnlyHint: true
  • list_componentsEvery 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 versi…No findings

    Why it is in this group

    • The name "list_components" says "list": a word for reading.
    Description, as the server wrote it
    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.

    Annotations the server declares

    • readOnlyHint: true
  • list_targetsThe 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…No findings

    Why it is in this group

    • The name "list_targets" says "list": a word for reading.
    Description, as the server wrote it
    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.

    Annotations the server declares

    • readOnlyHint: true
  • show_targetA 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 co…No findings

    Why it is in this group

    • The name "show_target" says "show": a word for reading.
    Description, as the server wrote it
    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.

    Annotations the server declares

    • readOnlyHint: true

This is not a safety rating, and no finding is not a safety guarantee. The groups and findings come from fixed checks of the tool definitions the server returned on the date shown, not from its code or what it does when called. How the checks work.

Exfil surface

Which tools read private data, which read text someone else can write, and which can send data out. One of each is a path a prompt injection can use.

No private-data, untrusted-input, outbound path in this server alone: no tool is tagged private-data or untrusted-input.

Reads private data0
Reads files, mail, messages, databases, secrets, calendars or repositories.
Reads text others write0
Brings in text someone else can write: web pages, inbound email, messages, issues and comments.
Can send data out1
Can carry data to people or systems: it sends, posts or publishes, or takes a recipient, channel or URL.

Other servers in the same agent add their own tools to these paths. Audit your whole setup to see them together.

Remote posture

What anyone on the internet sees at the remote endpoint: an anonymous initialize and tools/list, and the public OAuth metadata.

Tools listed without sign-in

Looked at Nov 20, 2026, 18:24 UTC, unchanged since Nov 20, 2026. No credentials were sent and no tool was called. What is looked at.

Reachable
yes
HTTP status of an anonymous initialize
200
tools/list served without credentials
yes
Tools that change things, listed without credentials
33
Protocol version
2025-06-18
WWW-Authenticate on 401
not observed
resource_metadata in WWW-Authenticate
not observed
RFC 9728 protected resource metadata
not observed
Authorization servers
not observed
Legacy HTTP+SSE transport
no
Dynamic client registration
not observed
Client ID metadata documents
not observed
  • HighThe whole server

    The endpoint served tools/list without credentials, and the list has 33 tools that change things (1 irreversible, 32 write). Whether a call also works without credentials was not tested: tools are never called.

    Matched text

    https://wai.transaction.science/quantum-jobs/mcp: tools/list returned 37 tools to an anonymous client, including convert_program (irreversible), run_quantum_circuit (write), run_quantum_set (write), dry_run_quantum_job (write), verify_quantum_receipt (write) and 28 more

    What this check looks for

Posture changes

  1. Nov 20, 2026
    • Tools that change things, listed without credentials: 28 to 33
  2. Nov 13, 2026
    • Tools that change things, listed without credentials: 26 to 28
  3. Nov 6, 2026
    • Tools that change things, listed without credentials: 18 to 26

Findings

Matches of fixed checks, with the text they matched.

11 warn
  • The server marks "dry_run_quantum_job" read-only (readOnlyHint: true), and its own name, description or input give the class "write".

    Matched text

    annotations: {"readOnlyHint":true}; The name "dry_run_quantum_job" says "run": a word for a change.

    What this check looks for
  • The description contains "every other tool", wording about other tools or servers.

    Matched text

    description: "...ritten, the program as OpenQASM 3 (what every other tool takes), each note with its code (a rota..."

    What this check looks for
  • The server marks "convert_program" read-only (readOnlyHint: true), and its own name, description or input give the class "irreversible".

    Matched text

    annotations: {"readOnlyHint":true}; The name "convert_program" says "convert": a word for a change.

    What this check looks for
  • The server marks "qasm_diagnostics" read-only (readOnlyHint: true), and its own name, description or input give the class "write".

    Matched text

    annotations: {"readOnlyHint":true}; The input takes a statement or command to run (input.code), which can change anything it can reach.

    What this check looks for
  • The server marks "qec_code" read-only (readOnlyHint: true), and its own name, description or input give the class "write".

    Matched text

    annotations: {"readOnlyHint":true,"idempotentHint":true,"openWorldHint":false}; The description's first verb is "show": a word for reading.

    What this check looks for
  • The server marks "qec_decode" read-only (readOnlyHint: true), and its own name, description or input give the class "write".

    Matched text

    annotations: {"readOnlyHint":true,"idempotentHint":true,"openWorldHint":false}; The input takes a statement or command to run (input.code), which can change anything it can reach.

    What this check looks for
Show 5 more findings
  • The server marks "pulse_schedule" read-only (readOnlyHint: true), and its own name, description or input give the class "write".

    Matched text

    annotations: {"readOnlyHint":true,"idempotentHint":true,"openWorldHint":false}; The name "pulse_schedule" says "schedule": a word for a change.

    What this check looks for
  • The server marks "build_algorithm" read-only (readOnlyHint: true), and its own name, description or input give the class "write".

    Matched text

    annotations: {"readOnlyHint":true,"idempotentHint":true,"openWorldHint":false}; The description's first verb is "open": a word for a change.

    What this check looks for
  • The server marks "run_landscape" read-only (readOnlyHint: true), and its own name, description or input give the class "write".

    Matched text

    annotations: {"readOnlyHint":true,"idempotentHint":true,"openWorldHint":false}; The name "run_landscape" says "run": a word for a change.

    What this check looks for
  • The server marks "run_qudit" read-only (readOnlyHint: true), and its own name, description or input give the class "write".

    Matched text

    annotations: {"readOnlyHint":true,"idempotentHint":true,"openWorldHint":false}; The name "run_qudit" says "run": a word for a change.

    What this check looks for
  • The server marks "run_wasmq" read-only (readOnlyHint: true), and its own name, description or input give the class "write".

    Matched text

    annotations: {"readOnlyHint":true,"idempotentHint":true,"openWorldHint":false}; The name "run_wasmq" says "run": a word for a change.

    What this check looks for

History

Changes to its tool definitions and to its remote endpoint, newest first.

  1. PostureRemote posture changed. Tools that change things, listed without credentials: 28 -> 33.View diff
    • Tools that change things, listed without credentials: 28 to 33
  2. Tools7 added, 7 changed.+7 added~7 changedView diff
  3. PostureRemote posture changed. Tools that change things, listed without credentials: 26 -> 28.View diff
    • Tools that change things, listed without credentials: 26 to 28
  4. PostureRemote posture changed. Tools that change things, listed without credentials: 18 -> 26.View diff
    • Tools that change things, listed without credentials: 18 to 26
  5. Tools4 changed.~4 changedView diff
  6. Tools9 added, 4 changed.+9 added~4 changedView diff

Install

Pinned to version 0.2.2. Values in angle brackets are yours to fill in.

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

Run in a terminal.

Claude Code permissions

Allow the reads, ask before a change or a way out, deny the deletes. Paste into .claude/settings.json.

.claude/settings.json
{
  "permissions": {
    "allow": [
      "mcp__quantum-jobs__get_quantum_job",
      "mcp__quantum-jobs__list_components",
      "mcp__quantum-jobs__list_targets",
      "mcp__quantum-jobs__show_target"
    ],
    "ask": [
      "mcp__quantum-jobs__run_quantum_circuit",
      "mcp__quantum-jobs__run_quantum_set",
      "mcp__quantum-jobs__dry_run_quantum_job",
      "mcp__quantum-jobs__verify_quantum_receipt",
      "mcp__quantum-jobs__critique_qasm",
      "mcp__quantum-jobs__check_equivalent",
      "mcp__quantum-jobs__convert_program",
      "mcp__quantum-jobs__improve_qasm",
      "mcp__quantum-jobs__classical_shortcuts",
      "mcp__quantum-jobs__compile_qasm",
      "mcp__quantum-jobs__estimate_resources",
      "mcp__quantum-jobs__repair_qasm",
      "mcp__quantum-jobs__quantum_service_info",
      "mcp__quantum-jobs__qasm_diagnostics",
      "mcp__quantum-jobs__run_on_target",
      "mcp__quantum-jobs__quantum_circuit_examples",
      "mcp__quantum-jobs__qec_code",
      "mcp__quantum-jobs__qec_decode",
      "mcp__quantum-jobs__qec_threshold",
      "mcp__quantum-jobs__pulse_schedule",
      "mcp__quantum-jobs__pulse_check",
      "mcp__quantum-jobs__gradient_qasm",
      "mcp__quantum-jobs__optimize_qasm",
      "mcp__quantum-jobs__vqe_ground_state",
      "mcp__quantum-jobs__qaoa_maxcut",
      "mcp__quantum-jobs__build_algorithm",
      "mcp__quantum-jobs__run_landscape",
      "mcp__quantum-jobs__run_qudit",
      "mcp__quantum-jobs__run_wasmq",
      "mcp__quantum-jobs__check_quantum_program",
      "mcp__quantum-jobs__grade_quantum_program",
      "mcp__quantum-jobs__attest_quantum_job",
      "mcp__quantum-jobs__write_circuit"
    ],
    "deny": []
  }
}

Tools that only read are allowed, tools that change things ask first, tools that delete or cancel are denied. A read that can send data out (it takes a URL, say) asks first too. It assumes the server is installed as quantum-jobs. Review it before you use it.

Capability tags behind 1 rule
  • mcp__quantum-jobs__convert_program outbound

Pin

Keep the decision: fail CI when the tools change, follow every change, or show a badge.

Pin in CI

Fail a build when the tools you reviewed are not the tools the server serves today.

curl -s "https://radar.anlyon.com/api/v1/servers/science.transaction.wai/quantum-jobs/verify?hash=2ed39d5ff4b7cbc91966eecb1578652a5f42e5789e1017007f9ea3a16694aa83" | jq -e '.changed == false'

Pinned hash 2ed39d5ff4b7, from Nov 18, 2026, 21:17 UTC.

Watch

Get told when its tools change: a new tool, a new description, a new class.

https://radar.anlyon.com/servers/science.transaction.wai/quantum-jobs/changes.xml

An Atom feed. Works in any feed reader or Slack's RSS app.

Badge

Anlyon Radar badge for science.transaction.wai/quantum-jobs
[![Anlyon Radar](https://radar.anlyon.com/badge/science.transaction.wai/quantum-jobs.svg)](https://radar.anlyon.com/servers/science.transaction.wai/quantum-jobs)

Source: MCP Registry. Synced Nov 5, 2026, 02:18 UTC.

WAI Quantum job service MCP server: questions and answers

Answered from the scan above, not from the publisher's description.

Is the WAI Quantum job service MCP server safe?

No scan can promise that. What its definitions show: 37 tools, 33 of which can change, send or delete something, and 11 findings from fixed checks. Allow the reads, ask before each change, and deny the deletes; the permissions block on this page does that.

Can the WAI Quantum job service MCP server delete data?

No tool is classed as destructive: going by their definitions, none of them deletes, cancels or revokes anything.

Can the WAI Quantum job service MCP server do things that cannot be undone?

Yes. 1 tool can send, pay, publish or merge: convert_program.

What tools does the WAI Quantum job service MCP server have?

37 tools: 1 irreversible, 32 write, 4 read. convert_program, run_quantum_circuit, run_quantum_set, dry_run_quantum_job, verify_quantum_receipt, critique_qasm, check_equivalent, improve_qasm and 29 more.

Does the WAI Quantum job service MCP server need sign-in or OAuth?

Its remote endpoint listed its tools to an anonymous client, without sign-in.

Does the WAI Quantum job service MCP server send data to outside services?

1 tool can carry data out (it sends, posts or publishes, or takes a recipient, channel or URL): convert_program.

Has the WAI Quantum job service MCP server changed its tools?

Yes, 3 times since Anlyon Radar started tracking it, most recently on Nov 18, 2026. Every change is on this page and in its Atom feed.