Skip to content

Site search

Type to search Pages

Product

Query a claim, verify the proof, keep the evidence.

Signura gives your agents five things to work with: attestations, reliance events, reliance policy, escalation cases and evidence records — each one signed, checkable at decision time, and logged.

One decision, end to end

A single reliance decision, from publication to audit.

The path a claim travels when an agent needs to act on it — stage by stage, as it happens in the product.

Publish an attestation

An issuer's governor approves what facts and liability the organisation will stand behind. An AI colleague then issues a signed Attestation against verified source facts, sets its scope and expiry, and publishes it to the exchange.

Rely at decision time

A relying agent queries the exchange for a counterparty claim, verifies the cryptographic proof together with its freshness and revocation status, then proceeds within its governor's configured limits or escalates the case.

Revoke and propagate

When an underlying fact changes, the issuer revokes the Attestation and the engine propagates the change, so no agent continues to act on a claim the issuer no longer stands behind.

Assemble evidence

For any past decision, a governor retrieves the Evidence Record from the ledger to show exactly which attestations were verified and that they were unaltered — for compliance, liability or a dispute.

Five modules, one exchange.

Issuer attestation service

Create signed Attestations against verified source facts, attach explicit scope and liability terms, and revoke them when a fact changes. AI colleagues run issuance against issuer-approved policy; a human governor decides what the organisation will stand behind.

Reliance and verification API

A relying agent queries the exchange for a counterparty claim, verifies the cryptographic proof, and either proceeds or escalates per policy-as-code. Each Reliance Event is priced per reliance, because the checking work has already been done and signed for.

Freshness and revocation engine

Applies freshness and revocation semantics — extending the proven OCSP status pattern to assertions — so a relying agent distinguishes a currently valid claim from a stale one in real time, rather than from a cache.

Evidence and audit ledger

Records every Reliance Event as a tamper-evident Evidence Record showing what underpinned each decision. A governor retrieves it later for governance, liability and dispute resolution.

Where the boundaries sit

What an agent may do, and what a human approves.

Bounded agent discretion

Agents proceed only within configured scope, value thresholds and expiry. Anything outside those bounds is routed to an accountable human as an Escalation Case; no material commitment is made on agent discretion alone.

Signed, verifiable, logged

Attestations are cryptographically signed and verifiable on the ratified W3C Verifiable Credentials 2.0 substrate with a revocation mechanism, and every reliance event lands in a tamper-evident ledger.

Operator limits

The integrity Signura stands behind is narrow and stated: the correctness of the proof it verifies and the accuracy of the freshness and revocation status it reports. It does not vouch for the underlying fact — that responsibility stays with the named issuer.

How the work is divided, and where it goes next.

Who does the operating work

AI colleagues operate the recurring, high-frequency work: issuing attestations against verified source facts, propagating revocations, running freshness and validity checks, and assembling the evidence records that accompany each reliance event. Relying-side agents query the exchange, verify proofs, and either proceed or escalate according to policy-as-code set by their governors.

The architecture is layered as a network-level utility. It sits above identity and credentialing primitives and beneath the application-level commerce, negotiation and settlement layers, so both the issuer and relying functions are shared infrastructure rather than bespoke per-integration plumbing. That placement is deliberate: the reliance decision belongs in one checkable place, not scattered across every downstream system your agents touch.

Where humans stay accountable

The design keeps the consequential decisions with people. Issuers' human governors define which claims the organisation will attest to and accept liability for. Relying-party governors define which issuers and attestation types are admissible, under what scope, value thresholds and expiry, and receive escalations on ambiguous or high-risk reliance. Agents act only inside those limits.

The audit trail exists to make that accountability practicable rather than nominal. When a decision is later questioned, a governor does not reconstruct scattered logs from memory; the reliance record shows which attestations were verified, under whose scope, and against which liable party. Liability terms are attached to each attestation before any reliance occurs, so who stands behind a claim is settled in advance of an agent acting on it — not argued after the fact.

What is enforced, and what is not yet built

Access is governed by policy-as-code with explicit scope and value thresholds. Attestations carry a revocation mechanism, and for EU adoption the work is aligned to eIDAS 2.0 electronic-attestation-of-attributes conformance. We are plain about the current state: this is early infrastructure proven against a narrow set of high-frequency common facts — licence validity, policy status, certification and granted permissions — with a small group of design-partner issuers and relying parties, not a finished ecosystem.

From there the direction is incremental. Early on, a working issuer-to-relying-party flow for one or two attestation types, with verification and revocation live and every reliance event recorded. Then multiple attestation types and a growing roster of issuers and relying parties, with the governance console supporting thresholds, scope, expiry and escalation routing. Later, a self-serve issuer onboarding path, standardised attestation schemas for common facts, and audit exports that feed external governance and dispute-resolution processes. These are the intended sequence, stated as direction rather than a promise of dates.

Working with the product

What operators ask before building on it.

How does my agent tell a currently valid claim from a stale one?

The freshness and revocation engine extends the proven OCSP status pattern to assertions. Your agent checks freshness and revocation status at the moment it acts, so a currently valid attestation is distinguishable from a stale one in real time rather than from a cache.

What happens when a reliance request falls outside its configured limits?

It is not acted on by discretion. A request outside its scope, value threshold or expiry is routed to a human governor as an Escalation Case, who approves or refuses the reliance. Agents commit nothing material on their own judgement.

How does this fit the agent stack I already build on?

Relying agents integrate through the reliance and verification API and evaluate results with policy-as-code. Attestations land on the ratified W3C Verifiable Credentials 2.0 substrate, so the exchange sits above your identity and credentialing primitives rather than replacing them.

Who is on the hook when a relied-upon claim turns out wrong?

Each attestation carries explicit, scoped liability terms and names the party that stands behind the claim, fixed before any reliance occurs. The record retains which liable party the decision rested on, so accountability is documented rather than reconstructed after a dispute.

What is retained, and who can see it?

Every reliance event is recorded as a tamper-evident Evidence Record — the claim, its scope, the liable party and the proof verified. A relying-party governor retrieves those records for governance, liability and dispute resolution.

What can an operator actually do on day one?

Set admissible issuers, attestation types, value thresholds and expiry in the governance console, then have your agents rely on a narrow set of common facts — licence validity, policy status, certification, granted permissions — verified at decision time against design-partner issuers.

See a reliance decision run against your own claims.

Bring one counterparty claim your agents depend on. We will walk through verification, escalation and the evidence record with you.