Internet-Draft AI Attestation Receipts July 2026
Chueayen Expires 26 January 2027 [Page]
Workgroup:
Network Working Group
Internet-Draft:
draft-chueayen-attestation-receipts-01
Published:
Intended Status:
Informational
Expires:
Author:
A. Chueayen
Aqta Technologies Limited

Enforcement Attestation Receipts for AI Inference Decisions

Abstract

This document specifies a compact JSON attestation receipt for an AI inference decision. A receipt binds an outcome to a request hash under a published Ed25519 public key, so a party that does not trust the issuer's infrastructure can still verify offline what was decided. The format is intentionally small and version-selected, so independent verifiers stay easy to implement and audit. It is intended for settings where an operator-controlled log is not, on its own, sufficient evidence of the decision.

Status of This Memo

This Internet-Draft is submitted in full conformance with the provisions of BCP 78 and BCP 79.

Internet-Drafts are working documents of the Internet Engineering Task Force (IETF). Note that other groups may also distribute working documents as Internet-Drafts. The list of current Internet-Drafts is at https://datatracker.ietf.org/drafts/current/.

Internet-Drafts are draft documents valid for a maximum of six months and may be updated, replaced, or obsoleted by other documents at any time. It is inappropriate to use Internet-Drafts as reference material or to cite them other than as "work in progress."

This Internet-Draft will expire on 26 January 2027.

Table of Contents

1. Introduction

AI systems that take or influence consequential actions are increasingly deployed in regulated settings. When such a decision is later questioned, the party being questioned is frequently also the party that produced the record of the decision. A log an operator controls does not, on its own, let an independent reviewer confirm what was asked and what was decided.

This document defines a compact receipt that an issuer signs for an LLM inference decision. The receipt is verifiable offline by any holder of the issuer's public key. The verifier need not contact the issuer at verification time.

1.1. Relationship to Other Work

Related Internet-Drafts address neighbouring problems. [I-D.marques-asqav-compliance-receipts] profiles signed action receipts for AI agents. [I-D.farley-acta-signed-receipts] defines signed decision receipts for machine-to-machine access control. Those documents are broader profiles. This document specifies one fixed receipt shape for the LLM inference decision case, with an explicit verification algorithm, a version-selected signature suite, and published conformance vectors. Implementations MAY also implement the related drafts; this document does not redefine them.

1.2. Non-Goals

This document does not:

  • Claim that a decision was correct, safe, lawful, or free of model error.

  • Define policy language, agent tool protocols, or model evaluation methods.

  • Require a Trusted Execution Environment, hardware root of trust, or qualified timestamp authority.

  • Define deployment topology, commercial packaging, or product features beyond the receipt bytes.

  • Replace platform attestation documents (for example TEE quotes). A receipt is application-layer evidence of a decision, not hardware evidence of the runtime.

A receipt that verifies proves only what Section 4 states.

1.3. Requirements Language

The key words "MUST", "MUST NOT", "REQUIRED", "SHALL", "SHALL NOT", "SHOULD", "SHOULD NOT", "RECOMMENDED", "NOT RECOMMENDED", "MAY", and "OPTIONAL" in this document are to be interpreted as described in BCP 14 [RFC2119] [RFC8174] when, and only when, they appear in all capitals, as shown here.

1.4. Terminology

Issuer:

The system that produces and signs a receipt.

Subject:

The organisation, identified by org_id, for which the decision was made.

Verifier:

Any party that checks a receipt's signature against a public key it trusts for the issuer.

Trusted public key:

The Ed25519 public key the verifier has obtained out of band for the issuer. It is not sufficient to trust only the public_key field embedded in a receipt.

2. Receipt Structure

A receipt is a single JSON object [RFC8259]. Version 1 defines the required fields in Section 2.1 and the optional fields in Section 2.2.

Unless a field is listed in this document for version 1, it MUST NOT appear at the top level. Verifiers MUST reject receipts that contain unknown top-level fields. This closed set keeps independent verifiers simple and prevents silent semantic drift.

2.1. Required Fields

Table 1
Field Type Description
v integer Format and suite version. MUST be 1 for this document.
attestation_id string UUID string, unique per receipt. Production issuers SHOULD use UUID version 4.
trace_id string Issuer-assigned identifier for the LLM call.
org_id string Identifier of the subject organisation.
request_hash string SHA-256 [RFC6234] digest of the canonicalised request body, 64 lowercase hex characters.
model string Provider-qualified model identifier.
outcome string One of the values in Section 3.
policy_applied array Lexicographically sorted array of UTF-8 string policy identifiers. MAY be empty.
cost_prevented_eur number Non-negative number. MUST be 0 when not computed. See Section 2.3.
timestamp string RFC 3339 datetime with an explicit timezone offset.
public_key string base64url-encoded raw 32-byte Ed25519 public key, no padding.
signature string base64url-encoded 64-byte Ed25519 signature, no padding. Omitted from the canonical payload.

2.2. Optional Fields

The following fields MAY appear. If present, they MUST match the types below. They are ignored by signature verification except that they participate in the canonical payload when present (see Section 5).

Table 2
Field Type Description
prev_attestation_id string attestation_id of a prior receipt in an issuer-defined chain.
prev_attestation_hash string SHA-256 hex digest binding this receipt to prior receipt bytes, as defined by the issuer.
spec_version string If present, MUST be the ASCII string "ATTESTATION-v1".

If prev_attestation_id is present, prev_attestation_hash MUST also be present. Verifiers that do not implement chaining MUST still accept well-formed receipts that include these fields, and MUST still enforce the signature and required field checks.

2.3. cost_prevented_eur

cost_prevented_eur is retained for wire compatibility with existing version-1 issuers. It is an issuer estimate only. It is not part of the security claim of the receipt. New issuers SHOULD emit 0. Verifiers MUST NOT treat a non-zero value as proof of savings, risk reduction, or policy quality.

3. Outcome Values

The outcome field MUST be one of:

ALLOWED:

The request was permitted to proceed to the model provider.

BLOCKED:

The request was not sent to the model provider.

SUPPRESSED:

The request was not sent because the issuer detected a runaway or loop condition.

PASSED:

A synonym of ALLOWED retained for backward compatibility. New issuers SHOULD emit ALLOWED.

4. What a Verified Receipt Proves

A receipt that verifies under a trusted public key proves that the holder of the corresponding private key attested the included fields, including outcome and request_hash, at the stated timestamp. It does not prove that the underlying model output was correct, that the policy identifiers were appropriate, or that the issuer's process was fair.

5. Canonical Payload and Signing

The canonical payload is produced by:

  1. Removing the signature field, if present.

  2. Serialising the remaining fields to JSON with all object keys sorted lexicographically and no whitespace between tokens.

  3. Encoding the result as UTF-8, with non-ASCII characters emitted literally as UTF-8 and never as \uXXXX escapes (see Section 5.3).

  4. Serialising every integer-valued number, including a float such as 1.0, as an integer with no decimal point or trailing zero, and every other number as the shortest decimal representation that round-trips to the same value.

A number whose shortest representation requires exponential notation, meaning a magnitude below 1e-4 or at or above 1e21, is outside the range that common implementations serialise identically. An issuer MUST NOT sign such a value directly; where one would arise it MUST first be rounded into the safe range (for cost_prevented_eur, to two decimal places). This canonicalisation aligns in intent with the JSON Canonicalization Scheme [RFC8785] but does not adopt its number serialisation. A later version of this format MAY adopt RFC 8785 fully; such a change requires a new v value.

5.1. Signature Suite and Algorithm Agility

The version field v identifies the complete cryptographic suite, not only the field layout. In version 1 the suite is Ed25519 [RFC8032] over the canonical payload. The issuer signs the canonical payload bytes and places the base64url-encoded signature, without padding, in the signature field.

A verifier MUST select the signature algorithm from v and MUST NOT infer it from the length or contents of the signature field. A future version MAY define a post-quantum suite. A verifier that does not implement the suite named by v MUST reject the receipt rather than guess.

5.2. Request Hash

The request_hash field is the SHA-256 digest [RFC6234], encoded as 64 lowercase hexadecimal characters, of the request body serialised by the canonicalisation of Section 5, including its number rule. Request bodies often carry non-integer sampling parameters such as temperature or top_p, so an issuer whose requests can contain numbers in the exponential range SHOULD round them before hashing.

The digest is computed over the request body as received from the caller, before any redaction, so that a verifier holding the original request can reproduce it. A verifier that does not hold the original request treats request_hash as an opaque commitment.

5.3. String Canonicalisation

Strings MUST be serialised as literal UTF-8. Escaping non-ASCII characters as \uXXXX produces different canonical bytes and MUST NOT be done; only the escapes required by [RFC8259] are permitted. Mainstream JSON serialisers disagree by default on this point. Issuers and verifiers MUST both emit literal UTF-8.

6. Verification

A verifier that holds a trusted public key for the issuer:

  1. Confirms all required fields are present and well-typed for Section 2.1, including: request_hash is 64 lowercase hex characters; public_key and signature decode as unpadded base64url to 32 and 64 bytes respectively; cost_prevented_eur is a non-negative number; timestamp is an RFC 3339 datetime with an explicit timezone offset; and policy_applied is an array of strings in lexicographic order.

  2. Confirms no unknown top-level fields exist.

  3. Confirms optional fields, if present, satisfy Section 2.2.

  4. Confirms outcome is one of the values in Section 3.

  5. Confirms the embedded public_key equals the trusted public key.

  6. Reconstructs the canonical payload per Section 5.

  7. Verifies the signature over the canonical bytes using the suite named by v and the trusted public key.

Verifying only against the embedded public_key, without an out-of-band trust decision, proves integrity of the object but not issuer identity.

7. Conformance

An implementation claiming conformance to this document MUST:

Informative interoperability artefacts, including valid and invalid receipts and a fixed test public key, are published with the ATTESTATION-v1 specification repository. Those vectors are not normative text of this document; if a vector and this document disagree, this document prevails, and the vector set SHOULD be corrected.

8. Security Considerations

8.1. Issuer Identity

A receipt proves that the holder of a private key signed the stated fields. It does not, on its own, prove which organisation that key represents. Verifiers MUST pin the issuer's public key out of band (for example via a published key URL, an enterprise configuration, or a trust list).

8.2. Confidentiality of Requests

Receipts contain no plaintext prompt or response, only a request hash. For a high-entropy request body the hash reveals nothing useful by inversion. Where the request body is low-entropy or guessable, an attacker can hash candidates and match. Deployments MUST treat request_hash as potentially personal data and apply their own data-protection controls. Issuers that require pseudonymity SHOULD hash with a key kept secret from verifiers, at the cost of offline reproducibility by third parties.

8.3. Integrity Versus Correctness

Signature verification establishes integrity and issuer attribution under a pinned key. It does not establish that the decision was the right decision.

8.4. Post-Quantum Considerations

Ed25519 is not post-quantum secure. An adversary with a cryptographically relevant quantum computer could forge signatures under an issuer key that was active before migration, which matters where long audit retention intersects that horizon. SHA-256 request binding remains useful as a tamper-detection commitment for detecting alteration of past receipt bytes under known attacks on hashes. Because v selects the whole suite (Section 5.1), a later version can introduce a post-quantum signature suite without changing the field names. This document does not define such a suite.

9. IANA Considerations

This document has no IANA actions. A future revision may request registration of a media type for the receipt object.

10. References

10.1. Normative References

[RFC2119]
Bradner, S., "Key words for use in RFCs to Indicate Requirement Levels", BCP 14, RFC 2119, DOI 10.17487/RFC2119, , <https://www.rfc-editor.org/rfc/rfc2119>.
[RFC6234]
Eastlake 3rd, D. and T. Hansen, "US Secure Hash Algorithms (SHA and SHA-based HMAC and HKDF)", RFC 6234, DOI 10.17487/RFC6234, , <https://www.rfc-editor.org/rfc/rfc6234>.
[RFC8032]
Josefsson, S. and I. Liusvaara, "Edwards-Curve Digital Signature Algorithm (EdDSA)", RFC 8032, DOI 10.17487/RFC8032, , <https://www.rfc-editor.org/rfc/rfc8032>.
[RFC8174]
Leiba, B., "Ambiguity of Uppercase vs Lowercase in RFC 2119 Key Words", BCP 14, RFC 8174, DOI 10.17487/RFC8174, , <https://www.rfc-editor.org/rfc/rfc8174>.
[RFC8259]
Bray, T., Ed., "The JavaScript Object Notation (JSON) Data Interchange Format", STD 90, RFC 8259, DOI 10.17487/RFC8259, , <https://www.rfc-editor.org/rfc/rfc8259>.

10.2. Informative References

[I-D.farley-acta-signed-receipts]
Farley, T., "Signed Decision Receipts for Machine-to-Machine Access Control", Work in Progress, Internet-Draft, draft-farley-acta-signed-receipts-02, , <https://datatracker.ietf.org/doc/html/draft-farley-acta-signed-receipts-02>.
[I-D.marques-asqav-compliance-receipts]
Marques, J. A. G., "Compliance Profile of Signed Action Receipts for AI Agents", Work in Progress, Internet-Draft, draft-marques-asqav-compliance-receipts-07, , <https://datatracker.ietf.org/doc/html/draft-marques-asqav-compliance-receipts-07>.
[RFC8785]
Rundgren, A., Jordan, B., and S. Erdtman, "JSON Canonicalization Scheme (JCS)", RFC 8785, DOI 10.17487/RFC8785, , <https://www.rfc-editor.org/rfc/rfc8785>.

Appendix A. Example Receipt

The following informative example is vector valid/001-allowed.json from the conformance set in Appendix B. A verifier that pins the test public key in Appendix B MUST accept it. The author regenerated and re-checked this object against that key before publishing this revision; if verification fails, the vector set or this figure is wrong and MUST be corrected before relying on either.

Field order in this figure is for readability; canonical signing order is defined in Section 5. The signature value is shown on two lines for document formatting only; in the vector file it is a single base64url string with no whitespace.

{
  "v": 1,
  "attestation_id": "00000000-0000-0000-0000-000000000001",
  "trace_id": "trace-tv-001",
  "org_id": "org-test-vectors",
  "request_hash":
    "8f3a7e2b9c4d5f6a1b0c9d8e7f6a5b4c3d2e1f0a9b8c7d6e5f4a3b2c1d0e9f8a",
  "model": "gpt-4o",
  "outcome": "ALLOWED",
  "policy_applied": ["budget_guard"],
  "cost_prevented_eur": 0,
  "timestamp": "2026-04-23T10:15:30.000000+00:00",
  "public_key": "alWzEnrA_z9McN9z_MFfQCnH9mVgOwRZ26wrI7oix4E",
  "signature":
    "gXA2GNEvACSGDtOk9KMEeHDUQMPUhHJHeLFMbbrwKlEI"
    "XY9UkvI5gWQ201Lm3Tkh7K3luXwQtqcua6vv4HmAAg"
}

Pinned test public key for this example and the vector set:

alWzEnrA_z9McN9z_MFfQCnH9mVgOwRZ26wrI7oix4E

Appendix B. Conformance Vectors

Informative conformance vectors (valid receipts, invalid receipts, and the fixed test public key) are published at:

https://github.com/Aqta-ai/attestation-spec/tree/main/test-vectors

A conformant verifier that pins that test public key MUST accept every receipt in the valid set and MUST reject every receipt in the invalid set. Those vectors are generated from a fixed seed documented in that repository so third parties can reproduce the signatures.

Appendix C. Reference Implementations

Open-source reference verifiers implementing this format are published as aqta-verify-receipt on the Python Package Index and on the npm package registry. Those packages are informative aids. Conformance is defined by this document and the vector set in Appendix B, not by any single implementation.

Appendix D. Changes From draft-chueayen-attestation-receipts-00

Author's Address

Anya Chueayen
Aqta Technologies Limited
Dublin
Ireland