Skip to main content
Introducing The Quantum Infrastructure Cloud Learn more

QCOS Ledger

Every quantum run, sealed as evidence an auditor can recompute

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

Three properties, each one checkable

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.

02

Verification without trust

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

A claim level that does not overstate

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

From five items to one root, and back

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.

Rendered Merkle tree of one QCOS evidence record: five labelled leaves, two inner nodes and the merkle_root, each with the first eight hex digits of its hash

One record, one tree

The five items become one root

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.

Rendered tree with the proof path for one item lit: the item, its sibling hashes and the root

Inclusion proof

Prove one item, disclose nothing else

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.

Several rendered record trees receding into the distance, each a separate structure with its own root

Records stand apart

No chain between records, on purpose

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

Seven fields on top, five items underneath

This is the whole format. An auditor who has seen it once can read any record QCOS writes.

record_idIdentifier of the record, inside the sealed content
tenant_idThe workspace the run belonged to
created_atWhen the record was written
outcomeCOMPLETED, FAILED, REFUSED or TIMEOUT
merkle_rootRoot of the five-leaf tree
bundle_hashSHA-256 of the canonical record
claim_levelSEALED_UNSIGNED or SEALED_ATTESTED
  • circuitwhat program was submitted, exactly as submitted

    qasm, qubit_count, submitted_artifact_hash

  • parameterswhat was asked for, before any routing decision

    primitive, backend_requested, method, shots_requested, observables

  • executionwhat actually ran, where, when, and whether the provider’s raw output was kept

    executed_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 received

    the measurement or expectation data returned to the caller

  • runtimewhich build of QCOS wrote the record

    api_contract_version, revision, commit, build_date

What an auditor asks

Eight questions, and the field that answers each

QuestionWhere 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

Three ways to check a record

In the API

POST /api/v1/runtime/evidence/verify

Send a record; QCOS recomputes the hashes and the root and returns the comparison, field by field.

In the SDK

client.evidence.verify_offline(record)

The same recomputation inside your process. Nothing leaves the machine.

With no SoftQuantus code at all

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

  • Signature verification. A SEALED_ATTESTED record carries a signature, but the public trust bundle holds no keys, so no verifier can check one. Until it does, treat every record as SEALED_UNSIGNED: the hashes hold, authorship is not proven.
  • Confidentiality. The seal proves integrity. Records are not encrypted by the ledger; keep them where your own access controls apply.
  • Cost and budget reporting. Money lives in the Softquantus Research Platform, not in the record.

Who the record is written for

Six reviews that ask the same question

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.

Financial services

Model-risk reviews ask which inputs produced a figure and whether the run can be repeated.

circuit, parameters, execution.provenance

Energy and utilities

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

execution.executed_backend_id, completed_at

Pharmaceutical and clinical

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

tenant_id, created_at, merkle_root

Public sector and defence

Procurement wants evidence that can be checked by a third party without vendor access.

offline verification, claim_level

HPC centres and cloud providers

Allocation reviews ask what each project ran and how many shots it consumed.

shots_executed, wall_time_s, outcome

Hardware and firmware vendors

Conformance programmes need the compiled artefact and the raw device output tied to one job.

compiled_artifact_hash, raw_provider_result_hash

Frameworks

What the reviews ask for

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.

See a record from your own run

Bring a circuit. We run it on a simulator, hand you the record, and you verify it on your laptop before the call ends.

Evidence and governance updates

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.