# WAI > WAI is an open media transport and execution standard (Apache-2.0 code, CC-BY specification text). Its quantum stack runs quantum programs on classical hardware: every result names the method that produced it, how accurate it is, and carries a signature anyone can check. ## Run quantum programs - [Quantum job service](https://wai.transaction.science/quantum-jobs/v1): an HTTP API. Send an OpenQASM 3 or 2 program; get measurement counts, Pauli expectation values or amplitudes, optionally under a noise model. No account and no key. - [MCP endpoint](https://wai.transaction.science/quantum-jobs/mcp): the same service as Model Context Protocol tools over streamable HTTP, with no key. Tools: run_quantum_circuit, get_quantum_job, verify_quantum_receipt, quantum_service_info, quantum_circuit_examples. - [OpenAPI description](https://wai.transaction.science/quantum-jobs/v1/openapi.json) - [Worked examples](https://wai.transaction.science/quantum-jobs/v1/examples): ready-to-run jobs, each with what it shows. - [The console](https://wai.transaction.science/quantum-run/): the service from a browser, or the same engine run in the browser tab. - [Quantum Studio](https://wai.transaction.science/quantum-studio/): an editor that checks a program as it is typed and runs it in the tab or on the service with the same engine; every receipt is checked in the page. Its assistant uses a model on the reader's own machine through any chat-completions server, with the engine as its tools. - The command line, `cargo install wai-quantum-cli` (binary `wai-quantum`): `run` plans and runs a job here as the service does and signs it with the user's key; `submit` sends it to the service; `verify` checks any receipt from either; `mcp` serves run, plan, lint, draw and verify to an agent over stdio. Run a job: `POST https://wai.transaction.science/quantum-jobs/v1/run` with `{"qasm": "OPENQASM 3.0; qubit[2] q; h q[0]; cx q[0], q[1];", "shots": 1000, "observables": ["Z0 Z1"]}`. It waits up to 25 s; a longer job answers 202 with an `id` to poll at `GET /v1/jobs/{id}`. Conventions: counts are keyed by the program's classical bits, the highest bit first (with no measurement, every qubit is read into the bit of its own index). Amplitudes take bit strings with one character per qubit, qubit n−1 first. Pauli strings name qubits from 0: "Z0 Z1", "X2 Y3". Methods, chosen automatically unless named: an exact state vector (the same bits on every machine, for dyadic angles), a double-precision state vector, a single-precision state vector on a GPU, a stabilizer tableau for Clifford circuits (also with Pauli noise), matrix product states, sparse Pauli dynamics for expectation values (each with an error bound), tensor networks for amplitudes (controlled and diagonal gates split, input and output projections fixed through diagonal gates), a cut-rank sum for a Clifford circuit followed by one layer of one-qubit gates at any angles (exact samples and amplitudes, at a cost set by the state's cut-rank along an order of the qubits rather than by their number; its amplitudes carry the circuit's own global phase, and where tracking that would cost more than about a minute the result says the phase is not fixed), an exact density matrix and trajectories for noise. `GET /v1/methods` gives each one's limits. Supported OpenQASM: registers and broadcast over them; gates h x y z s sdg t tdg sx sxdg rx ry rz p u cx cy cz ch swap iswap cp crx cry crz cu ccx ccz cswap rxx ryy rzz; the control modifiers ctrl @, ctrl(n) @, negctrl @ and negctrl(n) @ on x y z h s sdg t tdg p and on cx cy cz ch cp ccx ccz; user gate definitions; angle expressions with pi; measurement and reset anywhere in a program; and classical control on measured bits: if (c[0]), if (!c[0]), if (c == n) and if (c != n), with a block or one statement and else, and OpenQASM 2's if(c==n). A program that measures a qubit and then acts on it, resets one after its first gate, or uses if runs on statevector or stabilizer. Its shots split at each measurement or reset, binomially in the outcome's probability, so the counts have the law of independent runs; its expectation values are exact, the mixture over every branch (at most 4096), of the state before the final measurements; and the result's dynamic member reports the branches run and weighed. Noise in such a program, and its amplitudes, are refused. Loops, inv @ and pow @ are refused, with the line and what to write instead. Whole numbers in a request must be within ±(2^53 − 1). Receipts: every result carries an Ed25519 signature, by the key `GET /v1` publishes (a run in a browser tab or on the command line carries the same form, signed by that browser's or that user's key), over the BLAKE3 digest of the RFC 8785 canonical text of the request and of the result without its receipt. Check one with `POST /v1/verify` and `{"request": ..., "result": ...}`, or offline; it holds after any JSON reader has carried the result. `GET /v1/jobs/{id}` returns the job's request as submitted, so the id alone is enough to check its receipt. Energy: every result carries `energy`, inside the body the receipt seals. It is the CPU energy the job's worker process spent, from its start to its exit, read from the kernel's per-process count after the process has exited. It is given as `joules_micro`, with the acquisition class `OnChipCounter`, a declared uncertainty (`energy_uncertainty`: `relative_ppm`, `window_us`), the counter's filtering state, `coverage` (`whole`, or `partial` for a GPU job, whose GPU the counter does not read) and what it `excludes`. A job the service cannot meter carries `{"unmetered": ""}`, never zero joules. ## Learn and build - [The quantum IDE](https://wai.transaction.science/quantum-ide/): build circuits in the browser tab and inspect them. - [The course](https://wai.transaction.science/quantum-learn/): quantum algorithmic design on classical hardware. - [Source](https://git.transaction.science/Transaction-Science/open-standards): the reference implementation, including the wai-quantum crate and the service.