open-standards/wai/changes/2026-11-05-job-service-writes-program-for-task.md

The job service writes a program for a task, on its own model

POST /v1/write and the MCP tool write_circuit: a service started with a model (WAI_QSVC_MODEL) writes an OpenQASM program for a task, an exercise in the course's form, with wai-quantum-writer's loop, the engine checking each attempt.

• The result is the transcript (wai.quantum.write/1), sealed with the service's receipt as every result is, the writer's energy inside it, so POST /v1/verify checks it. Each attempt's timing is beside it, outside the signed body, and each attempt is an attempt event on GET /v1/jobs/{id}/events as it lands.
• The writer process (wai-quantum-service writer) starts with the service and serves every write, so the model loads once; one that ends is started again, and a write it was running fails, saying so. It reads every byte of the model against its manifest as it starts, and loads exactly the files the manifest lists, so a transcript's model digest names the weights that ran ("checked": "blake3"). On macOS it runs sandboxed as a worker does, reading its model. Its resident memory is held to WAI_QSVC_WRITER_GB (96), a write to WAI_QSVC_WRITE_SECS (3600), and the engine's checks in it to one job's memory, which the transcript records (check_memory_bytes).
• Admission. Writes run one at a time, in the queue's order, beside the circuit jobs and holding none of their memory budget; each kind fills the queue up to WAI_QSVC_MAX_QUEUE alone, so a backlog of writes refuses no circuit job. A client holds one queued or running write, checked and taken under one lock, so writes sent at once admit one. A write cancelled while the writer starts is never sent to it, and one cancelled while it runs stops the writer. Idempotency-Key works as for a job, and a write the service was running when it stopped runs again once, to the same transcript.
• What a task may hold. A task is held to the course's form before it is queued (check_task, through engine::course::exercise_form): every bound whole numbers, every constraint one the course names, a job of shots, seed and noise alone, at most 16 cases and 8 intents in one place, every case giving the same inputs or none. Its canonical form is at most 64 KiB, what the model is first told of it at most 8 KiB, and a program an intent compares with is held to the equivalence bounds a job's intent is (J031). Admitted in a job's order: the cheap checks first, and what refuses whatever is sent (a write held, unread results, a full queue of writes, a spent window) uncounted; then a turn to be read and the client's window (a write refused after it still counts); then the programs, each read once and all within one budget (wai_quantum::qasm::within_steps, 1 000 000 statements), in the reading child a job's programs are read in, its memory and time capped. The writer process starts from the service's kept image, as workers do, and is the first the kernel ends under memory pressure.
• The queue and its lock. A write cancelled while queued holds no place in it, and no lock is held across the store's writes: a client's write is reserved in memory while it is admitted, and a job's record is kept before it is queued (and taken back if the queue, or the cap on results not yet read, then refuses it).
• The same transcript, in the same arithmetic. The task reaches the model in its canonical form, so the same model, task, options and engine give the same transcript on a host whose arithmetic the transcript's model names (architecture, operating system, maths library, matmul kernel).
• Refusals: J080 (no model here, 503), J081 (a task that does not read), J082 (options out of range).
• Discovery: GET /v1 and quantum_service_info give write: the model's name, licence and digest once it is loaded, or that there is none. The OpenAPI document has the route, and smoke.sh writes a Bell pair's program with SMOKE_WRITE=1.
• wai-quantum-writer: the scripted model is public (scripted::Scripted, read from a JSON script), write_with hands on each attempt as it lands, and check_task holds a task to having something to check, and its canonical form to the course's form: a case without an intent, in a task with none, or a task a check would read as asking nothing, is refused before the model is asked.
• wai-quantum: the refusal codes J080 to J082; a course check's lesson may be null, as check_exercise gives it.
• The verdict get_quantum_job and tasks/result state for a write is the last program's, checked against the task's constraints as well as its intents: a program whose intent holds and whose constraint does not is holds: false, saying which. A write with no attempt yet has no verdict.