The evidence layer for AI assurance

A log records that a check ran. Asciron measures it: a floor on the distinct key-holders behind each action your policy requires one for (in the sample, the critical ones). It signs a list of what it doesn't measure.

Verify a governed AI decision What we don't claim

Provably bounded · Measurably independent

Statement issued 31 October 2026
14 measured
9 not measured
2 pending

What you get

Measured floors on distinct signing keys and reviewer blind spots

Not a checkbox: a measured floor on the distinct cryptographic key-holders behind each decision your policy requires one for (signer distinctness on a single host, not party independence; see the scope statement), plus a signed Measurement Scope Statement.

Critical actions can also face an adversarial AI review panel whose blind-set divergence is measured and enforced as a floor, not assumed. In the sample bundle that floor is set to 0 and the panel's seats are scripted stand-ins. Five reviewers declaring the same underlying model count as one, not five: the floor is capped at the number of distinct declared substrates.

A signed receipt for every decision

Each approval carries the engine's signature. With a refusal signer configured, as in the sample, every refusal is a signed certificate of what was blocked; if signing itself fails, the record says so and the verifier checks the count. Both re-verify offline. When an adversarial review panel is what blocks an action, the receipt also carries the panel's engine-signed ground: the specific objection.

Re-verification without access to us

An auditor or underwriter re-verifies a receipt offline, at $0, with no access to our internals. A working prototype, not yet production-hardened, not in this bundle and not yet bound to a receipt's own commitment, can also prove the floor's computation in zero-knowledge: proof it was computed correctly from committed inputs, without disclosing them.

Check it yourself

Download the sample bundle
Run one command
Auditor key (Part A.2): pass it as --auditor-key so a re-signed bundle fails:

python verify_offline.py --bundle . --auditor-key 7da05647303e776538caa0761c6fa4a628cb4098a11b29f6621d85315e002e75

Runs on any stock Python 3.8 or later. No repo, no install.
Re-verify it offline
exit 0 · sample-bundle.zip · sha256 093482f4c4e08588db111fbdf73c30f201a1388d14120021092bf6f03f7607ee

How an Asciron receipt is produced and re-checked

AI action A tool call or agent decision enters the gate.
Governed gate chain A chain of governed checks (sense, govern, prove, refute, authorise, seal), with one attested record per action naming the check that decided it.
Signed receipt One sealed, tamper-evident record, approval or refusal alike.
Re-verified by anyone Offline · $0 · no access to internals.

The verifier's own output for the zip on this page. Unedited; one clause per line.

PASS (standalone):

5 receipt signatures valid;
1 refusal certificate(s) valid;
measurement scope statement signature valid;
headline (expected.json) signature valid;
whole-bundle root recomputes;
auditor key MATCHES the value given with --auditor-key;
existed-by anchor: rfc3161 token (https://freetsa.org/tsr): the sealed epoch_hash existed by 2026-10-31T00:08:38Z (verified against the pinned tsa_pub -- self-shipped; compare out-of-band);
rekor anchor: no rekor anchor (knob 0);
seal chain recomputes (3 links);
record count matches expected.json (6);
RLAA verdict RECOMPUTED: certified -- 4/5 sampled records redrawn from the content-committed population all reconcile (reconcile_seal+verify_independence+refutation_floor_verify+reconcile_refutation_coverage+reconcile_policy_digest_cross_source);
bound 1/5 at alpha 0.05.

WHAT THIS PASS COVERS:

the Ed25519-signed surfaces (every archive/run.db receipt, every refusal certificate, the Measurement Scope Statement, AND the headline in expected.json -- verdict, bound, alpha, oracle_provenance) verify against the pinned keys;
the whole-bundle root in epoch_seal.json recomputes from that headline plus the pinned public keys;
the seal hash-chain recomputes link-by-link;
the archive record count matches expected.json;
every record's top-level outcome is bound to its OWN execution_result (non-allowed -> none) and to a refusal_certificate (unless honestly refusal_unsigned) -- relabelling an allowed/executed record's outcome to a denial is caught;
AND the RLAA verdict itself RECOMPUTES: the risk-limited sample is redrawn from the content-committed population, every sampled record reconciles through the certificate's exact oracle set (mock-engine floor recomputes included, against the shipped PUBLIC keys), and the alpha-bound arithmetic reproduces the signed headline numbers.

WHAT IT DOES NOT COVER (use the full tools/verify_bundle.py for these):

the drand/BLS verification of the epoch anchor (the root is recomputed here, but stdlib cannot do BLS12-381; a verified round shows the root was sealed after that beacon round, not when the evidence inside was made);
the reconcile_budget oracle (no budget ledger ships in the bundle);
the probe-pack envelope binding (sealed_pack_hash);
the quorum demonstration (archive/quorum_run.db is not opened here);
re-deriving audit_coverage_statement.json and denial_census_statement.json (their digests are pinned in the signed headline and checked here);
and non-signed files (report.html, this script).
NEITHER verifier authenticates a record field that sits outside the signed receipt, the refusal certificate and the RLAA content commitment (created_at is one: it can be edited and this still PASSes; the governed block of any record is another), and a denial's receipt, where one exists, is not bound by its refusal certificate, so its removal is not detected.
The auditor key matched the value you supplied, and the signed headline pins the main engine and refusal keys, so a re-issue of those under fresh keys is caught -- this is exactly as trustworthy as the source you took that value from;
the refuter key, the quorum demonstration's key, the approver and refuter registries, the time-stamp and transparency-log keys when present, and this script still ship in-bundle, unpinned.

HONEST SCOPE:

tamper-evidence + recompute-as-emitted. NOT a measured-independence claim (offline mock engine, declared floors, measured independence = 0 for archive/run.db; a quorum demonstration, where shipped, carries measured single-host key-distinctness floors, which are not independence) and NOT proof the underlying decisions were semantically correct.

Status

Working system
Sample receipt bundle re-verifies offline today
Live end-to-end run: a measured review-panel floor, enforced in-line, then re-certified offline after the action (staged evidence: Sonnet 5 seats at low effort, a 9-canary battery we wrote, distinct keys on one host)
Zero-knowledge floor proof: working prototype (not yet production-hardened), not yet bound to a receipt
Two Australian provisional patent applications filed
No testimonials on this page, by design. Re-verify the receipt instead of taking our word for it

Pilot fee

AU$22,000 Australia

USD 15,000 Outside Australia

The scope statement

Every receipt ships with this statement attached: what was measured, what was declared out of scope, what's still pending.

Receipts aren't checked once and filed: a risk-limited audit samples receipts across the whole stream under a declared statistical risk bound (α = 0.05): bounded, not a spot-check. (That audit runs in our own post-execution domain, not a third party's.)

One thing you won't find below: the contents of the probe battery itself. That's withheld by design: a published battery is a learnable target. It's committed by content hash and declared in scope instead, so tampering is still detectable without publishing the target.

Counts are read from the signed statement in the bundle below, not typed here.

Measured

Policy digest registry

Governing policy digests are independently recomputable and chain-anchored; a silent threshold relaxation is detectable, and so is a self-consistent rewrite made after the fact, if you hold the canonical digest from somewhere other than the bundle.

Refutation coverage

The share of the policy-required refutation checks the battery actually examined, tracked as a real, recomputable count.

Measurement coverage

How much of an authorisation's authority signals were actually measured, versus only declared, tracked as a count.

Counterparty probe coverage

The share of the buyer-supplied refutation checks the battery actually examined, tracked as a real count. The pack is content-hashed and anchor-sealed before the run; it carries no counterparty signature.

Seal priority chain

The sealed battery's priority ordering is hash-chained and reconcilable within a session: the chain is keyed on a session id the caller supplies, and a new id starts a fresh chain.

External time anchor

A public time-beacon round can be folded into the seal chain, and its presence is measured. (A round folded into the chain has its signature checked only on the live path, with the anchor floor set above 0: see External anchor signature verification. The sample's chain folds mock rounds. The bundle's separate epoch anchor is BLS-checked by the full verifier.)

Budget accounting

Session-scoped risk-accumulation limits are tracked and recomputable within a session: the session id is caller-supplied, so a new id resets the count. No budget ledger ships in the sample bundle.

Refutation floor

The refutation battery runs and produces a result count: this measures that the battery ran and what it found, not who or what performed the review. The panel's independence floor is measured separately, below.

Reviewer independence floor

A measured floor on how far the review panel's blind spots diverge, checked against a seeded defect battery, engine-signed and independently recomputable. It's a point estimate from a single run, not a statistically bounded average; run-to-run sampling noise can inflate it, and reviewer identity itself is declared, not verified.

External anchor signature verification

Live-only: the time-beacon's own cryptographic signature is verified with real, unsimplified cryptography. Closes one class of backdating, not backdating that happens upstream, before evidence reaches the seal. Off by default in the offline bundle.

Independence floor audit re-verification

A risk-limited audit pass can re-derive the approval engine's independence-floor commitment and signature for each sampled receipt that carries a floor. It checks the commitment and the signature only; it does not measure independence. In this bundle the critical actions carry a floor of 2, declared by a mock engine.

Distinct-key custody

On a single host, the number of distinct cryptographic key-holders who signed a given instance is independently recomputable: forge, drop, or duplicate one signature and the recompute fails. Measures signer distinctness on one host: not party independence, not human-reviewer or model independence, and not independent transport.

Refutation floor audit re-verification

A risk-limited audit pass re-drives the refutation floor over each sampled receipt and its evidence, checking signed-record integrity and registered-reviewer validity end-to-end. Runs against our own scripted stand-in reviewers only: measures record integrity, not reviewer realness.

Reviewer substrate diversity

A count of distinct declared reviewer substrates (vendor / model family / weights lineage) across the panel, auditor-recomputable, and used to cap how much independence can be claimed: five reviewers on one substrate can attest independence of at most one. Measured over self-declared labels only (not proof a label is true), and it degrades to merely declared if the panel is unlabelled or the battery only partially ran.

Not measured

Operational independence

Single-host cryptographic key distinctness is measured (see Distinct-key custody); genuine party, human, or model independence, and independent transport, are not.

Role enforcement

Which authoriser roles actually signed is enforced internally, not independently measured; single-host key distinctness is measured, but role-to-party independence is not.

Training-data correlation

Shared provenance or correlation across model training data is not measured.

Reviewer model identity

Which model or vendor is truly behind a review seat is not measured; substrate labels are self-declared, and label truthfulness is not verified.

Reviewer seat reality

Whether review seats are live models with genuine blind spots, versus scripted stand-ins, is not measured on the default offline path.

Sensor input integrity

The authenticity of the upstream input signal that triggers governance is not measured.

Planner correctness

Whether the AI's proposed plan is correct or a hallucination is not measured; only that it's bound to a fixed claim, so a later change shows.

Outcome correctness

Process integrity is measured; whether the authorised action was actually the right call is not. Process integrity isn't loss.

Reviewer resistance to adversarial input

Whether the review panel can be steered by the content it is reviewing is not measured. Reviewers see the action and its justification as text and report their own verdicts; the seeded-defect battery that measures blind-spot divergence runs over fixed stored probes, never over the live request, so a crafted input that sways several reviewers the same way is a correlated failure the measured floor cannot see.

+ 2 pending: Independent transport. Real independent key-holders and an independent transport path are planned, not yet built. Approver model-seat diversity. The mechanism is built and runs end to end, but no measurement has yet passed its pre-registered protocol: the first run (6 Sep 2026) was unstable and was withdrawn.

What we don't claim

Asciron measures process integrity, not loss outcomes. Independence is a measured floor, not a proof: only as strong as its probe battery and threshold, and blind to unprobed dimensions. Semantic ground-truth and single-shot common-mode failure are out of scope. Multi-party independence is not what today's measurement claims. The honesty is the point: a declared, signed boundary you can price and audit around beats a confident claim you can't check.

Jacob Crittenden
Founder, Asciron

Who it serves

AI governance platforms

Governance tooling documents and monitors AI risk. Asciron sits beneath it, producing the tamper-evident, re-verifiable evidence that the governed controls ran as configured.

Insurers & underwriters

Agentic AI priced on unverifiable self-attestation reads as unpriceable. A signed, re-verifiable scope boundary maps to a carve-out: a declared exclusion you can check and price around, not a hidden unknown.

Auditors & assessors

Portable supporting evidence toward a subset of ISO/IEC 42001 and NIST AI RMF controls, re-checkable without redoing the work. Coverage is partial (see the standards map).

The numbers, if you want to check them

These aren't marketing figures. Each comes from the sample bundle you can download below: the scope counts and the recomputed count from its signed statements, the key count from what the zip holds, and the check count from its verifier, which is not itself signed.

93: distinct tamper checks in the verifier we ship to you
7: of the 14 measured signals recomputed in the shipped audit, including the refutation floor
0: private signing keys in the bundle: you recompute the floor holding nothing that could mint a receipt
14/9/2: signals measured / not measured / pending

Where this statement maps, and where it doesn't yet

As declared in the shipped bundle's Measurement Scope Statement: its own standards_map. Rows marked "not yet mapped" aren't in that declaration: we're not stretching this to look more complete than it is. (The bundle's audit coverage statement carries a separate map for a different job: scope of audit, not scope of measurement. So the two aren't expected to match.)

Open the full standards map ISO/IEC 42001 · NIST AI RMF · EU AI Act, including the rows we do not map

Standard	Reference	Supported by
ISO/IEC 42001	SoA	The measured / not-measured / pending split is itself a per-signal applicability declaration: cross-reference the signal names above against your own Statement of Applicability control IDs.
ISO/IEC 42001	§9.1	Of the measured signals, the shipped audit re-derives those its coverage statement marks recomputed; it marks the rest measured but unaudited here, or checked out of band. That re-derivation is the evaluation step.
ISO/IEC 42001	§8.4	The full measured / not-measured / pending split feeds directly into an AI system impact assessment record.
NIST AI RMF	MEASURE	The entire scope statement (what's measured, what's declared out of scope, what's pending) is direct documentation of the MEASURE function.
NIST AI RMF	MAP	The declared scope boundary (what's in bounds vs excluded) supports MAP's context-and-boundary documentation.
EU AI Act	Art.13 limitations	Where the system is high-risk, Art.13 requires its instructions for use to state the limitations of its performance. The not-measured list is an input to that.
ISO/IEC 42001	§9.2	Out of scope for a vendor artifact: internal audit is your own governance activity over your whole AIMS. This statement can be evidence into it, never a substitute for it.
ISO/IEC 42001	§9.3	Out of scope for a vendor artifact: management review is a leadership act we have no visibility into and cannot attest.
ISO/IEC 42001	§10	Not yet mapped: no linkage from a refused gate to a corrective-action record is captured in this statement.
ISO/IEC 42001	Annex A	Not yet mapped: the shipped `standards_map` doesn't reference specific Annex A control IDs.

What happens next

Pilot fee

AU$22,000 Australia

USD 15,000 Outside Australia

A fixed fee for a fixed eight-week engagement on one governed use-case: not a retainer, not a subscription, not billed by the hour.
Half on signature, half on delivery.

Downloading answers one question: can this be re-checked without access to us? It can: that is why it ships at $0 with no signup. How far that check reaches rests on the key you check it against, and that key comes from us too. What a sample bundle cannot tell you is whether the boundary holds on your actions, under your policy, with your auditor helping draw the scope statement.

That is a pilot, and pilots here are paid: a scoped engagement with a price attached is the only honest test of whether this is worth building on. Today every key that signs a receipt, a refusal or a statement is minted on our host; a pilot asks you to name a second signing custodian who is independent of us.

What the fee buys

You keep:

evidence bundles over your cases, each with a signed scope statement
the stdlib-only re-verifier
a short written report against each agreed criterion, including what the pilot did not show

Start a pilot conversation Re-verify the bundle first

Sydney-based · replies come from me, not a sales team.