13.1 / Technical insight

Why autonomous AI services need verifiable receipts.

Autonomous software can discover, purchase and use a service in seconds. Accountability must be able to travel at the same speed.

Project statusLive public MVPPVTY tokenLive on Solana
Evidence boundary:A receipt can prove what inputs were supplied, which rules ran and what result followed. It does not prove that every supplied fact was true or that a service is universally trustworthy.

01 / The gap

A promise is not a machine-checkable outcome.

The problem

Traditional service agreements are written for people, interpreted after the event and supported by evidence scattered across dashboards, logs and emails. That model becomes fragile when software agents buy APIs, data, compute or specialised models without a person reviewing every transaction.

An autonomous buyer needs a narrower answer: what was promised, what evidence was produced, which checks ran and can another system reproduce the result? A marketing page or private dashboard cannot provide that answer on its own.

02 / Agreement

Start with terms a computer can evaluate.

The strongest verification begins before delivery, by expressing the relevant part of the agreement as explicit thresholds and identifiers.

01

Define

Record the service, measurement period, expected output and thresholds such as latency, uptime or freshness.

02

Observe

Supply evidence in a documented structure, including the measured values and any output commitment.

03

Evaluate

Run versioned deterministic rules so the same valid inputs produce the same conclusion.

03 / Evidence

Preserve what was checked, not just the verdict.

Portable record

A useful assurance receipt should identify the agreement and evidence, record the checker version, list the rules and their individual outcomes, and bind the final record with a stable cryptographic hash. This makes the result portable: a buyer, provider, auditor or later service can inspect the same record without relying on the original interface.

That portability matters because dashboards change, accounts close and vendors disappear. A self-contained receipt does not eliminate every trust assumption, but it makes those assumptions visible and gives independent systems a common object to verify.

  • Canonical identifiers prevent one service or agreement being confused with another.
  • Explicit rule versions show exactly which evaluation logic was used.
  • Per-rule outcomes preserve why a final result passed or failed.
  • Stable hashing exposes later modification of the receipt content.

04 / Rechecking

Independent verification is the point.

A receipt is most valuable when it can be rechecked outside the system that created it.

Trust minimisation

The verifier should reconstruct the canonical payload, recompute its hash and compare the result with the recorded commitment. It should also repeat the rule evaluation where the evidence is available. If either step differs, the receipt has not survived independent verification.

This architecture separates the user interface from the assurance result. A project may provide a convenient browser tool and API, but the receipt format and verification process should remain inspectable. Public schemas, OpenAPI documentation and reproducible examples help integrators test that boundary.

05 / Limits

Receipts improve accountability; they are not truth oracles.

They can show

Process integrity

Which data was supplied, which documented rules executed, which checks passed and whether the portable record was later changed.

They cannot alone show

Source truth

Whether every external measurement was honest, whether omitted evidence existed or whether the service is suitable for every purpose.

Stronger deployments can reduce those remaining assumptions with authenticated measurement sources, signed observations, independent monitors and clear dispute procedures. Each additional layer should be described as deployed only when it is actually operational.

06 / PactVerity

A public implementation you can test now.

PactVerity Proof Engine v1 accepts caller-supplied service terms and evidence, performs deterministic checks and produces a portable assurance receipt. The public Receipt API is a beta interface to the same bounded model. Planned settlement, custody and dispute components are separate future layers and are not represented as live.

Run a receipt

Use the public browser interface to create, export and independently recheck a receipt.

Open Proof Engine

Inspect the implementation surface

Review the API documentation, receipt schema and public developer repository.

Open GitHub