01
A record for every run
Refused and failed runs are recorded like completed ones. The outcome field says which, and the execution item keeps the error. An audit trail with gaps is not one.
QCOS Ledger
QCOS writes one evidence record per job: circuit, parameters, execution, result and runtime, each hashed with SHA-256 and sealed under an RFC 9162 Merkle root. Anyone holding the record can rebuild the root and compare it, without asking SoftQuantus.
5
items in every record: circuit, parameters, execution, result and runtime
SHA-256
over each item and over the canonical record (the bundle hash)
RFC 9162
Merkle tree, 0x00 leaf and 0x01 node prefixes, root stored with the record
4
outcomes a record can carry: COMPLETED, FAILED, REFUSED, TIMEOUT
2
claim levels, each stating exactly what the seal proves
3
ways to verify a record, one of them with no SoftQuantus service at all
What the seal gives you
01
Refused and failed runs are recorded like completed ones. The outcome field says which, and the execution item keeps the error. An audit trail with gaps is not one.
02
A verifier recomputes the five item hashes, rebuilds the tree and compares the root. It needs the record and a SHA-256 implementation. It does not need SoftQuantus to be online, or to exist.
03
SEALED_UNSIGNED means the hashes hold. SEALED_ATTESTED means a signature is attached as well. A record never says more than its claim level, and this page does not either.
How a system is audited
The renders below are computed from the protocol itself: real SHA-256 hashes over a sample record, laid out as the tree the verifier rebuilds.

One record, one tree
Each item is serialised canonically (sorted keys, no whitespace), hashed, and placed as a leaf. Pairs are hashed upward with the RFC 9162 split rule until one root remains. That root is written into the record as merkle_root; the hash of the whole canonical record is written as bundle_hash.
Change one byte of the result and the result leaf, every node above it and the root all change.

Inclusion proof
To show that a result belongs to a sealed record, the holder hands over the result item and the sibling hashes along its path to the root: for five items, three hashes. The checker recomputes upward and compares. The circuit text, the parameters and the tenant stay private.
The same proof shape lets a regulator check a result and a vendor check a backend id, from the same record, without seeing each other’s half.

Records stand apart
The protocol does not link one record to the previous one. A record is complete on its own and is verified on its own. Deleting or altering a record never invalidates its neighbours, so a tenant can hand a single record to a reviewer and that record carries its whole proof.
Ordering comes from created_at and record_id, both inside the sealed content. Claims of a hash-chained ledger were removed from this site; the record format never had one.
The record
This is the whole format. An auditor who has seen it once can read any record QCOS writes.
record_id | Identifier of the record, inside the sealed content |
|---|---|
tenant_id | The workspace the run belonged to |
created_at | When the record was written |
outcome | COMPLETED, FAILED, REFUSED or TIMEOUT |
merkle_root | Root of the five-leaf tree |
bundle_hash | SHA-256 of the canonical record |
claim_level | SEALED_UNSIGNED or SEALED_ATTESTED |
circuitwhat program was submitted, exactly as submittedqasm, qubit_count, submitted_artifact_hash
parameterswhat was asked for, before any routing decisionprimitive, backend_requested, method, shots_requested, observables
executionwhat actually ran, where, when, and whether the provider’s raw output was keptexecuted_backend_id, provenance, shots_executed, submitted_at, started_at, completed_at, wall_time_s, compiled_artifact_hash, provider_job_id, raw_provider_result_hash, binding_note, error
resultwhat the caller receivedthe measurement or expectation data returned to the caller
runtimewhich build of QCOS wrote the recordapi_contract_version, revision, commit, build_date
What an auditor asks
| Question | Where the record answers it |
|---|---|
| Which circuit ran? | circuit.qasm and circuit.submitted_artifact_hash |
| Was the backend requested the backend used? | parameters.backend_requested against execution.executed_backend_id |
| Did every shot execute? | parameters.shots_requested against execution.shots_executed |
| How long did it take, and when? | execution.submitted_at, started_at, completed_at, wall_time_s |
| Was the provider’s own output retained? | execution.provider_job_id and execution.raw_provider_result_hash |
| Simulator or hardware? | execution.provenance |
| Which software wrote this? | runtime.commit, runtime.revision, runtime.build_date |
| Has it been altered since? | Recompute merkle_root and bundle_hash; both must match |
Verification
POST /api/v1/runtime/evidence/verify
Send a record; QCOS recomputes the hashes and the root and returns the comparison, field by field.
client.evidence.verify_offline(record)
The same recomputation inside your process. Nothing leaves the machine.
softquantus-verify report.json
An MIT-licensed command-line tool for published reports. Its source is public so that the check itself can be audited.
Not available today
Who the record is written for
Each review below asks, in its own language, what ran and whether it can be shown. The fields listed are the ones that answer it.

Model-risk reviews ask which inputs produced a figure and whether the run can be repeated.
circuit, parameters, execution.provenance

Dispatch and grid studies must show the solver, the backend and the time the answer was produced.
execution.executed_backend_id, completed_at

Data-integrity rules want results that are attributable, contemporaneous and unaltered.
tenant_id, created_at, merkle_root

Procurement wants evidence that can be checked by a third party without vendor access.
offline verification, claim_level

Allocation reviews ask what each project ran and how many shots it consumed.
shots_executed, wall_time_s, outcome

Conformance programmes need the compiled artefact and the raw device output tied to one job.
compiled_artifact_hash, raw_provider_result_hash
Frameworks
QCOS Ledger is not certified against any framework. It produces the kind of record these reviews ask to see.
ISO/IEC 27001
Logging of events, protection of log information, and the ability to show who did what.
EU AI Act, Article 12
Automatic record-keeping over the lifetime of a high-risk system, sufficient to trace its operation.
SOC 2 processing integrity
Evidence that processing was complete, accurate, timely and authorised.
GxP data integrity (ALCOA+)
Records that are attributable, legible, contemporaneous, original and accurate.
Bring a circuit. We run it on a simulator, hand you the record, and you verify it on your laptop before the call ends.
Changes to the record format, verification tools and claim levels.
Film and renders computed by SoftQuantus from the qcos-evidence/1 protocol over sample records. No stock footage.