ARIA
Status & Conformance
_aria-bind record per account and domain for all its agents, and recovery after a lost answer (§3.6); the per-agent pointer of §3.4 is optional. §3.2 and §4: the holder key in ARIA’s own encoding, not Multikey. §5: both signature halves required for as long as a credential is valid, judged as one; no end date. §6: the scope grammar, and human approval refused when missing. §7: a status list valid 24 hours and re-signed hourly, with the freshness each verifier accepts. §8: ARIA AP is the admission protocol; ATP/1 moves to Appendix F, deprecated.@aria-registry/verify 1.x — refer to the preview line.spec_version: "1.0" and be issued by TrustLayer Foundation (issuer DID TBD). Until then, preview credentials remain resolvable and are distinguished by their issuer.What is normative here. Sections labeled normative define verifiable behaviour; MUST, MUST NOT, SHOULD and MAY are RFC 2119 keywords. Sections labeled informative and every appendix except E explain and position; nothing in them binds an implementation. Precedence: this specification → the Verification Requirements → their JSON representation. Where the deployed behaviour and this text disagree on the wire format, the conformance vectors in aria-protocol/conformance/ decide and the text is a bug.
Terminology. Defined once, here; used without redefinition below.
| Term | Meaning |
|---|---|
| Registry (Registration Authority) | The operator that performs verification, holds the Case File and the customer relationship, and attests to the result under its own signature. Today: registry.aria.bar. |
| Authority (TLF) | TrustLayer Foundation: stewards the specification, arbitrates namespace uniqueness, signs on the registry’s attestation. Never sees personal data. |
| Case File | The append-only evidentiary record a registry keeps for every L1+ credential (EXP-01). Never in the AID. |
| Flag | A recorded doubt on a Case File that blocks issuance or renewal until a human reviews it. |
| Authoritative Source | The public register of the jurisdiction of incorporation against which an entity is confirmed. |
| Route A / Route B | Direct query of the Authoritative Source (Class 1 jurisdictions) / documentary route with reinforced spot-check where no direct query exists (Class 2). Class 3 has no reliable source: ceiling L1. |
| Controller | Whoever holds the agent’s holder key — normally the Account Admin acting for the Principal (§4). The party that performs the did:aria operations in §3, and that may publish an agent’s optional DNS pointer (§3.4). |
| Holder key | The agent’s Ed25519 keypair (RFC 8032), generated by the controller on its own machine; the key that signs the agent’s requests under ARIA AP, each with a receiver’s challenge. Distinct from the issuer’s composite key (§5). |
| Binding Officer | A natural person with proven power to bind the entity, evidenced by public instrument (L3). |
| Preview line | Credentials and texts labeled 1.0–1.2 between April and August 2026. No production adoption; distinguished by issuer DID; sunset at cutover. |
Protocol Overview
Six composable layers, each on a proven standard. DNS is the root; nothing below introduces a new cryptographic primitive.
| Layer | Standard | Function |
|---|---|---|
| P1 Anchor | W3C DID Core / did:aria | Every agent gets a DID. Resolution: DNS TXT pointer + HTTPS AID endpoint. |
| P2 Certify | W3C VC Data Model 2.0 | Signed, portable, independently verifiable credentials. Offline-capable. |
| P3 Present | ARIA AP over RFC 9421 HTTP Message Signatures | A request signed with the agent’s holder key, admitted by the receiver and answered with a signed receipt (§8). |
| P4 Protect | FIPS 204 + RFC 8032 | ML-DSA-65 + Ed25519 composite (AND). Post-quantum native. Both halves required for as long as a credential is valid; no date disables either (§5). |
| P5 Revoke | W3C Bitstring Status List v1.0 + Trust Ledger | Revocation in a signed status list, valid 24 hours and re-signed hourly; each verifier sets the age it accepts (§7). Append-only Trust Ledger. CAEP push notifications [PLANNED]. |
| P6 Govern | TrustLayer Foundation A.C. | Nonprofit stewardship. Apache 2.0 + CC-BY-4.0. Anti-capture. Community governed. |
Trust Levels
Four levels, two independent axes: the person who answers and the entity represented. The level is not declared; it is recalculated from the evidence. An AID never guarantees the present or future conduct of the agent or its holder; it states what was verified, how, against which source and when (DPV-02).
| Entity not verified | Entity confirmed | |
|---|---|---|
| Person not verified | L0 | not permitted |
| Person verified | L1 | L2 · L3 |
The normative basis is the Verification Requirements (Appendix E). Each card cites the IDs it rests on; the cards state what a level asserts, the Requirements state what it demands.
| Level | TLS analogy | Validity | Renewal |
|---|---|---|---|
| L0 | Self-signed | 366 days | E-mail re-verification. Fully automatic. |
| L1 | DV | 366 days | Domain and e-mail re-verification. The person is re-verified only on document expiry or Flag. |
| L2 | OV | 200 days | Status at source + sanctions + domain + link. |
| L3 | EV+ | 180 days | Semi-automatic: source + sanctions + instrument validity + confirmation by the named human. |
DID Method: did:aria
Canonical method: did:aria. Compatibility bridge: did:web. Self-generated. Zero cost. No permission required to create.
§3.1 — Method Syntax (ABNF). The did:aria method-specific identifier follows this grammar, using ABNF as defined in RFC 5234 with the ALPHA and DIGIT core rules.
did:aria — ABNF grammar (RFC 5234)show ▾
Four identifier shapes result from combining the two subject kinds (agent, principal) with the two anchoring modes (verified DNS domain, registry-namespaced fallback):
| Shape | Example | Used when |
|---|---|---|
| Agent · domain-form | did:aria:example.com:ordering-agent | Principal has verified control of the DNS domain (trust level L1+). |
| Agent · registry-form | did:aria:aria.bar:u-0dhNSrC9:commerce-search | Agent lives under a registry namespace (L0, or L1+ before the principal's domain is verified). |
| Principal · domain-form | did:aria:example.com:org | Organizational identity for a principal that has verified its domain. |
| Principal · registry-form | did:aria:u-0dhNSrC9:org | Organizational identity for a principal without a verified domain — namespaced only by registry-account, no host prefix, stable across registry migrations. |
":org" is reserved: an agent-slug MUST NOT equal org, so that principal identifiers remain unambiguously distinguishable from agent identifiers by inspection. domain and registry-host labels are case-insensitive (per DNS); registry-account and agent-slug are case-sensitive.§3.2 — Resolution and the DID Document. The result of did:aria resolution is a DID Document in the sense of W3C DID Core 1.0 §5. It is not stored anywhere: a resolver derives it deterministically from the Agent Identity Document (AID) defined in §4 — a W3C Verifiable Credential secured by the composite mldsa65-ed25519-2026 proof — after obtaining the AID through the DNS TXT pointer (§3.4) and verifying its SHA-256 hash and composite signature. The AID is the signed source artifact; the DID Document is its projection, and the AID travels alongside it in the DID Document Metadata (§3.5.2). This is the same pattern as did:key (derived from the identifier) and did:webvh (derived from a log): derivation is resolution, the derived document is the result.
The derivation, applied to the currently-active AID:
DID Document — derived from the AID · JSON exampleshow ▾
Derivation rules — given an AID retrieved via §3.4 and the URL from which it was served:
§3.2 — Resolution and the DID Document · algorithm · 5 stepsshow ▾
id—credentialSubject.idfrom the AID.controller— computed fromid: for agent-domain-form, replace theagent-slugcomponent with the literalorg; for agent-registry-form, keep only theregistry-account:orgtail (drop theregistry-host), matching how the registry issues principal identifiers.verificationMethod— a single Multikey entry that translates the AID'scredentialSubject.holderKey. The AID carries that key in ARIA's own encoding (§4), not as Multikey, so the derivation converts it: decodepublicKeyMultibaseto the raw 32 bytes, prefix the multicodec0xed01and encode again asz+ base58btc, which gives thez6Mk…form.idandcontrollerare derived from the agent DID.authenticationandassertionMethod— both reference the single verification method: the agent authenticates as itself and asserts on its own behalf using the holder key.service— a singleAriaAgentIdentityDocumententry whoseserviceEndpointis the HTTPS URL from which the AID was retrieved (present in the DNS TXT pointer, §3.4).
verificationMethod publishes only the Ed25519 holder key because the operations that reference this material — requests signed under ARIA AP with a receiver’s challenge, presentation binding — sign ephemeral payloads whose exposure window is measured in minutes, and because Ed25519 verification is universally deployed. The AID's issuer signature, where post-quantum protection matters (AIDs are long-lived and verifiable retroactively), uses the composite mldsa65-ed25519-2026 suite (§5) and is not re-stated in the DID Document. Any future PQ-native VerificationMethod type (e.g. Mldsa65VerificationKey2026) may be added to verificationMethod alongside the Multikey entry without any change to the resolution algorithm.§3.3 — Compatibility bridge: did:web. A did:web MAY act as a bridge for verifiers that already support did:web but not did:aria. The principal publishes the derived DID Document at https://<domain>/.well-known/did.json, which allows did:web:<domain> to resolve to the same document as did:aria:<domain>:org. The bridge is a compatibility measure; the canonical identifier remains did:aria.
§3.4 — DNS TXT pointer model. ML-DSA-65 public keys are 1,952 bytes raw (~2,603 bytes base64) — too large for a DNS TXT record (255 bytes per string). ARIA uses a two-component model: a TXT pointer at _aria.<domain> carrying the DID, a SHA-256 hash of the expected AID, and the HTTPS URL where the AID is served.
The hash pins the served AID to the TXT record — an adversary that substitutes the HTTPS response cannot match the hash the domain owner published, so tampering is detected before signature evaluation. TXT pointers for registry-form identifiers are published by the registry under its own zone (e.g. _aria.aria.bar); a TXT pointer for a domain-form identifier MAY be published by its controller under that domain. A name MAY hold several pointer records — one per agent anchored there (e.g. several agents under _aria.example.com, or every registry-form agent under _aria.aria.bar); a resolver selects the record whose did= equals the identifier being resolved and ignores the rest.
_aria-bind record per account and domain, published once for all its agents and read by the authority (§3.6); it names no agent and is not a pointer. Pointer records that resolve today continue to resolve.§3.5 — Method operations. did:aria defines the four DID Core operations. The registry holds the namespace and signs; the controller holds the keys. No operation requires the controller to reveal a private key to anyone.
§3.5.1 — Create.
§3.5.1 — Create · algorithm · 7 stepsshow ▾
- Key generation. The controller generates, on its own machine, an Ed25519 holder keypair (RFC 8032) for authentication and presentation binding. Private material never leaves the controller: the agent generates its key pair, and the registry and the authority receive only the public key, in the encoding of §4.
- Reservation. The controller (or its registry, on its behalf) asks the namespace to reserve the target identifier. The registry validates it against the ABNF of §3.1 — an identifier that does not parse MUST NOT occupy a slot — and checks uniqueness. Reservation is exclusive, held for 15 minutes, and returned as a single-use token. Two callers asking for the same identifier at the same instant receive exactly one success; the check and the claim are one atomic operation at the namespace, never a read followed by a write.
- Manifest. The controller builds an enrollment manifest — agent name, requested scopes, holder public key, principal DID — and signs it with the holder key over canonical JSON (§5.1). The registry MUST reject a manifest whose signature does not verify against the enclosed holder key.
- Verification. The registry performs the checks the requested level demands (§2) and records the Case File; at L1 the domain must also be bound, which the authority reads before reserving and at issuance (§3.6). This step is where L0 stays automatic and L1+ is not.
- Issuance. The registry redeems the reservation token and issues the AID: a W3C VC 2.0 credential whose
credentialSubject.idis the DID, carrying the holder key, principal reference, level and scopes, secured by the compositemldsa65-ed25519-2026proof (§5). The top-levelidis the credential-instance URL. A status list position is allocated and written intocredentialStatus. Issuance is terminal for the identifier: it never returns to the pool, even if the credential is later revoked. - Pointer (optional). The controller MAY publish the TXT pointer of §3.4 at
_aria.<domain>: DID, SHA-256 of the served AID, HTTPS URL. For registry-form identifiers the registry may publish it under its own zone. No level requires a per-agent record: an L1 credential rests on the domain binding (§3.6). - Record. Reservation and issuance are written to the append-only, hash-chained issuance record (§7) in the same transaction as the state change. A registry MUST NOT hold a signature it has no record of making.
Errors. malformed (fails §3.1), alreadyIssued (terminal), heldByAnother (live reservation by a different caller), reservationExpired, manifestSignatureInvalid, levelNotPermitted (the registry is not accredited for the requested level).
§3.5.2 — Read (Resolve). Input: a did:aria string. Output: a DID Resolution result — the derived DID Document (§3.2) as didDocument, the verified AID and its provenance in didDocumentMetadata, and didResolutionMetadata. The DID Document is the result; the AID is metadata. A resolver that returns the AID without the DID Document has not resolved the DID. A conforming resolver MUST perform every step; skipping one is a resolution failure, not a degraded success.
§3.5.2 — Read (Resolve) · algorithm · 11 stepsshow ▾
- Parse. Validate against §3.1. Failure →
invalidDid. - Locate. Domain-form: query
_aria.<domain>TXT over DNS-over-HTTPS (RFC 8484); DNSSEC validation SHOULD be performed and its result reported. Registry-form: query_aria.<registry-host>, or GET the registry resolver directly. No TXT and no resolver →notFound. - Check the pointer. The TXT MUST carry
v=ARIA1, adid=equal to the input, ahash=and anaid=HTTPS URL. Mismatched DID →pointerMismatch. - Fetch. GET the AID over HTTPS. The response is treated as opaque bytes.
- Pin. SHA-256 of the fetched bytes MUST equal
hash=. Mismatch →hashMismatch; the document MUST NOT be evaluated further. - Bind.
credentialSubject.idMUST equal the input DID → elsesubjectMismatch. - Verify the proof. Canonicalize the credential minus
proof(§5.1); decodeproofValue(§5.1); verify the ML-DSA-65 half against the issuer's post-quantum key and the Ed25519 half against the classical key. Both MUST verify. The composite is judged as one (§5.1): a failure of either half →signatureInvalid, and neither half is accepted or reported alone. Verifying only the classical half is a failure, not a fallback (ATP-11). - Check validity.
validFrom ≤ now < validUntil, elseexpiredornotYetValid. - Check status. Fetch
credentialStatus.statusListCredential, verify its own proof, read the bit atstatusListIndex. Set →revoked. Status evidence older than the caller's freshness bound, measured from the list's signedvalidFrom(§7: each verifier sets it; ARIA AP's default is 3600 seconds) →statusStale. - Check accreditation. The issuer MUST have been accredited to assert the credential's level at the time of issuance. Withdrawal of an accreditation is forward-only: it does not invalidate issuances made while the accreditation was valid, i.e. between the registry's
accredited_fromand itsdistrust_aftercut-off (§5.2, AUD-02). - Derive. Apply the §3.2 rules to the verified AID to produce the DID Document, and assemble the resolution result below. This step is mandatory.
Resolution metadata. A resolver returns, alongside the document: retrieved (timestamp), source (dns | registry), dnssec (secure | insecure | bogus | indeterminate), statusChecked (timestamp of the status evidence), credentialId and, when present, previousCredentialId. A historical instance is resolvable by its credential-instance URL (GET /v1/credentials/{id}) so a verifier can walk the issuance chain.
Resolution result. Every field of DID Core §7 is present. didDocument carries the derivation of §3.2. didDocumentMetadata carries the AID and what was checked: versionId is the credential id, created and updated are the validFrom of the first and of the current credential at this DID, deactivated reflects §3.5.4, and the aria map names the URL the AID was fetched from, its SHA-256, the derived level and the age of the status evidence used. A client whose important artifact is the AID dereferences didDocumentMetadata.aria.aid, or passes the resolution option aria-aid=embed to receive the full credential inside that map; in both cases didDocument is returned. didResolutionMetadata carries contentType, the DNSSEC outcome of step 2, and on failure exactly one error from the codes above.
/v1/aids/{did} and the MCP tool resolve_did returns the AID as well; neither returns a DID Resolution result yet. A conforming resolver endpoint is planned; until it ships, verifiers derive the DID Document client-side per §3.2.§3.5.3 — Update. The DID is stable; the credential is not. Every update is a re-issuance at the same DID: a new credential instance with a new top-level id, credentialSubject.previousCredentialId pointing to the superseded instance, and the superseded instance moved to superseded (§7). What MAY change: holder key (rotation), scopes, level (upward after verification, downward on Flag), principal metadata. What MUST NOT change: credentialSubject.id. Where the controller of a domain-form identifier published a TXT pointer (§3.4), it MUST update its hash=; a resolver that fetches the new document against the old hash fails at step 5, which is the intended behaviour until the pointer is updated. The registry records the re-issuance in the issuance record with both credential ids.
§3.5.4 — Deactivate. Two independent, non-exclusive signals; a verifier MUST honour either.
- Status list. The registry sets the credential's bit in the W3C Bitstring Status List v1.0 credential it publishes (§7). The new list is published within the COM-05 bound (§7). This is the authoritative signal: it works for every identifier form and survives the loss of the controller's DNS.
- Pointer removal. The controller of a domain-form identifier that published a pointer removes or empties
_aria.<domain>. Resolution fails at step 2. This signal is under the controller's sole authority and needs no registry.
Deactivation is terminal for the identifier: a deactivated DID is never re-issued to a different controller, so a new agent cannot inherit the history or the trust of a retired one. The registry records the event with the revoking authority and reason code. Cascade — deactivating everything one registry ever vouched for — is never automatic; it is a distinct, human-authorized decision reserved for a proven compromise of the registry's attestation key.
Security and privacy of the operations. Reservation tokens are single-use, expire, and are stored only as a digest. The namespace never learns who the customer is — only which registry asked. No operation transmits a private key. Hash pinning (step 5) defeats substitution of the served document; the composite proof (step 7) defeats forgery even by a party able to alter DNS; accreditation-at-issuance (step 10) bounds the damage of a misbehaving registry to the window in which it was trusted.
§3.6 — Issuance and recovery under the federation contract. A registry (Registration Authority) asks the authority to reserve, sign and revoke through a published contract; the authority never receives personal data. The contract and its shared exchanges are in the protocol repository (federation/, conformance/federation/).
federation/openapi.yaml, exchange.schema.json, version 1.0.0). An L1 credential names a domain the principal has bound: the authority issues a token, the principal publishes _aria-bind.<domain> TXT "v=ARIABIND1; b=<token>" once for all its agents, and the authority reads it over authenticated DNS-over-HTTPS before reserving and, unless a read that found it is younger than 300 seconds, again at issuance. Under the default policy a DNSSEC-authenticated answer is required only where the zone is signed. A binding lasts 366 days; domain-check requires an RA accredited for L1. Bindings are not published.unavailable or none, MUST treat the outcome as unknown and resend the same request with the same request_id and payload; it MUST NOT treat the request as not done.The AID Document
The Agent Identity Document (AID) is ARIA's core data structure — the passport. A W3C Verifiable Credential containing everything a counterparty needs to verify an agent's identity, authorization, and intent.
ARIA defines three identity roles — analogous to DNS registrant vs. admin contact:
| Role | Maps to | Description |
|---|---|---|
| Registrant | account_holder | Human who opens the account and accepts ToS. One registrant per account. |
| Principal | credentialSubject.principal | Legal entity or person in the AID. The authority behind the agent. |
| Account Admin | platform user | Manages AIDs day-to-day. May differ from registrant. Analogy: DNS registrant vs. admin contact. |
principal.legalName: self-declared (L0, L1 — registrant-asserted, no external check), registry-confirmed (L2 — confirmed against the Authoritative Source of the jurisdiction), or legal-verified (L3 — primary register plus a Binding Officer). Verifiers MUST consult this field before treating legalName as authoritative. legalName is an organization name — see §9.Person for a natural person, Organization for any legal entity. It decides the next field: an Organization carries legalName, a Person MUST NOT (COM-09). The schema enforces both directions from this field. Credentials issued before type existed omit it and carry legalName whatever the principal was; a verifier reads an absent type as an organization, which is how they were issued, not a statement about who the principal is.z followed by the base58btc encoding of the raw 32-byte Ed25519 public key. This is ARIA's own encoding: it is not the Multikey encoding, whose form of the same key is prefixed with the multicodec 0xed01, and a verifier that expects Multikey MUST convert it. The key MUST be canonically encoded, of large order and torsion-free. The agent generates its key pair; the registry and the authority receive only the public key. A later spec_version may issue Multikey; verifiers will then read both encodings. Credentials already issued keep theirs. The key's type, Ed25519VerificationKey2020 in the example below, names the key; it does not make this encoding that type's standard one, and signed credentials keep the label.AID — complete example (preview-line credential, spec_version 1.2) · 60 linesshow ▾
Cryptography
Post-quantum from the first credential, not retrofitted: the Harvest-Now-Decrypt-Later threat makes retroactive protection the requirement.
| Algorithm | NIST Standard | Usage | Security Level |
|---|---|---|---|
| ML-DSA-65 | FIPS 204 | Primary signing for all AIDs | Level 3 (AES-192) |
| ML-KEM-768 | FIPS 203 | [PLANNED] Session key establishment | Level 3 |
| SLH-DSA | FIPS 205 | [PLANNED] Long-lived registry records | Conservative (hash-based) |
| Ed25519 | RFC 8032 | Composite classical (AND with ML-DSA) | Classical (~128-bit) |
mldsa65-ed25519-2026: both signatures MUST verify. Live today: FIPS 204 + RFC 8032. Both halves of the composite signature are required for as long as a credential is valid. No date disables either half. A successor suite, if any, is introduced by a new spec_version, and credentials already issued are verified under their own.§5.1 — Cryptosuite mldsa65-ed25519-2026. A W3C Data Integrity cryptosuite is defined by its transformation, hashing and proof-serialization algorithms. What follows is what the deployed issuer and the published verifier implement; credentials in the wild are signed this way and cannot be re-signed, so this text is descriptive of the wire format, not aspirational.
- Transformation. Take the credential as a JSON object, remove the
proofmember, and serialize it as canonical JSON: object members sorted by key (UTF-16 code-unit order, asArray.prototype.sortorders JavaScript strings, recursively at every depth), arrays in document order, no whitespace, strings escaped asJSON.stringifydoes (the two mandatory characters, the five short escapes, and remaining control characters below U+0020 as\u00xx; all other characters, including non-ASCII, emitted literally), numbers asJSON.stringifyrenders them. Encode as UTF-8. This form is intentionally narrower than RFC 8785 (JCS): for every credential ARIA issues the two coincide, but conformance is defined against the golden vectors inaria-protocol/conformance/, not against RFC 8785. - Hashing. None. Both algorithms sign the transformed bytes directly. ML-DSA-65 is used in pure mode with an empty context string; Ed25519 is pure Ed25519 (RFC 8032 §5.1, SHA-512 internal) with no pre-hash and no context. There is no additional domain-separation tag.
- Proof serialization.
proofValueis the unpadded base64url (RFC 4648 §5) encoding ofu32be(pq_len) ‖ pq_signature ‖ ed_signature: a four-byte big-endian length of the ML-DSA-65 signature (3,309 bytes for FIPS 204 ML-DSA-65), the ML-DSA-65 signature, then the 64-byte Ed25519 signature. Suite1.0emits it multibase-encoded: the prefixu(base64url, no padding) per the multibase registry, because the VC v2 context typesproofValueassec:multibaseand a bare base64 string declaring that datatype is not one. Credentials issued before the 1.0 cutover carry the same bytes with no prefix; a verifier MUST accept both. The two are decidable without guessing: the length header of this suite is always0x00000CED, so a bareproofValuealways beginsAAAMand neveru. A verifier MUST validate the header against the byte count that follows it rather than trusting the first character. Theproofobject carriestype: DataIntegrityProof,cryptosuite: mldsa65-ed25519-2026,created,verificationMethodandproofPurpose: assertionMethod. - Verification. Decode
proofValue; a value that is not base64url, shorter than four bytes, or whose declared length exceeds the remainder isMALFORMED. Recompute the transformation. Verify the ML-DSA-65 half against the issuer's ML-DSA-65 public key (1,952 bytes) and the Ed25519 half against the issuer's Ed25519 public key (32 bytes). Both MUST verify. A verifier judges the composite signature as one: it is valid only when both halves are; it does not accept or report one half alone (ATP-11). - Determinism. FIPS 204 permits deterministic and hedged signing; the two produce different bytes for the same input. Byte-identical signatures across implementations are therefore not required and MUST NOT be asserted as a conformance property; what is required is that a signature produced by either variant verifies under the other's verifier.
mldsa65-ed25519-2026 without breaking issued credentials (invariant #2).§5.2 — Trust bootstrap: issuer keys and accreditation. Verification in §3.5.2 needs two inputs that are not in the credential: the issuer's public keys (step 7) and evidence that the issuer was accredited for the level at issuance time (step 10). This is ARIA's equivalent of a root store.
- Today. A credential is genuine only if it verifies under an issuer the verifier trusts, and the verifier states which. The ARIA SDK 1.0 embeds no issuer key and trusts no issuer by default;
@aria-registry/verify1.x embeds the keys ofdid:aria:registry.aria.bar, overridable at runtime, and they do not verify the current authority’s credentials. The issuer that runs today,did:aria:registry.aria.baratapi.aria.bar, is a demonstration: its credentials are not a production guarantee, and production ARIA 1.0 will use a new TrustLayer Foundation issuer and keys. There is no discovery document (api.aria.bar/.well-known/ariaanswers 404). No signed accreditation list is published: a verifier decides for itself which issuer it trusts and up to which level. - Consequence (invariant #4). Every published 1.x SDK version carries its keys compiled in, so for as long as those versions are in use their issuer key cannot rotate for them. A published key set must ship before rotation is a first-class operation.
- The demonstration issuer's key set.
https://api.aria.bar/v1/keysetserves every key that issuer has signed with, append-only: the first is the anchor, and each later key is introduced by a composite signature of the key before it, so rotation chains from the anchor. An adopter takes keys from it only under the anchor fingerprint it pinned out of band,sha256:4117aaac21272740756d02305a9fa7e2d84398fdd859d390b476539d57ec67b3, in a trust profile it namesdemo; being listed in a key set grants no trust. - [PLANNED] Accreditation list. A TLF-signed list of accredited registries carrying, per registry, its attestation public key, ceiling level,
accredited_fromand anydistrust_aftercut-off — the data step 10 evaluates. Verifiers fetch it like a status list: cacheable, with a freshness bound. - [PLANNED] TLF root distribution. The TLF root key that signs the accreditation list, distributed out of band (pinned in SDK releases, published fingerprint, offline ceremony record) so the chain closes at a key nobody obtains from the network it is meant to protect.
Scopes & Delegation
Scopes. A scope names one capability as namespace:resource:action: three segments, each a lower-case letter followed by lower-case letters, digits or underscores, at most 64 characters in all. Scopes carry no version. An authority MUST NOT issue a scope of another form. A verifier MUST accept, in a 1.0 credential, any scope of two or more such segments, since credentials issued before this rule may carry them, and MUST compare scopes exactly. A receiver's policy MAY use a pattern namespace:resource:*, which matches every three-segment scope with that prefix; a matching deny prevails over any allow. A scope declares what the agent intends to do; it authorizes nothing by itself.
The vocabulary is open to any activity: this specification fixes the grammar, not the words. The actions and namespaces below are examples in common use, not a closed list.
| Action (example) | Meaning |
|---|---|
| read | Query or retrieve data |
| write | Create or update data |
| delete | Remove data permanently |
| execute | Run a process or workflow |
| approve | Authorize a pending action |
| export | Extract data outside the system |
| subscribe | Register for ongoing notifications |
| delegate | Pass a narrower set of scopes to another agent |
Namespace examples · 10 namespacesshow ▾
Delegation. Authority flows from a human. An agent MAY delegate to a sub-agent; when it does, every hop MUST be signed, scope can only narrow, and the original principal stays traceable. Maximum depth: 4. credentialSubject.delegationDepth is signed by the issuer and is what ATP/1’s depth= compared against (ATP/1 is deprecated; ARIA AP does not support delegation yet).
delegationDepth: 0. The rule above is the contract such issuance will meet.Human approval. When an operation's scope is listed in hitlRequired, a receiver MUST refuse the attempt unless a valid approval accompanies it (aria.approval_required). Holding an operation for approval is not part of 1.0.
Lifecycle, Revocation & Trust Ledger
A person authorizes an agent on Tuesday and resigns on Wednesday; on Thursday the agent must not be acting with nobody behind it. On principal change the credential is suspended pending re-authorization. A designated successor principal is [PLANNED]: schema 1.0 has no field for it yet.
Every credential is in exactly one of six states:
| State | Meaning | Transitions | Reversible? |
|---|---|---|---|
| active | Credential valid. Agent operating normally. | Can become: suspended, revoked, expired | Starting state |
| suspended | Temporarily paused. Principal change, investigation, or policy violation. | Can become: active (reinstated) or revoked | Yes |
| revoked | Permanently invalidated. Compromise, termination, or breach. | Terminal state | No. Ever. |
| expired | Credential TTL exceeded. Must renew to resume. | Can become: active (after renewal) | Yes (renewal) |
| tombstoned | Organization dissolved or acquired. Permanent archive. | Terminal state | No |
| superseded | Replaced by a new credential. Old DID permanently points to new one (301 redirect pattern). | Terminal state. Pointer to successor. | No |
suspended with reason: broken-link, and the entity has 30 calendar days to accredit a new responsible person. If the window lapses, the credential is revoked.Validity and renewal per level: §2.
Revocation. A revocation sets the credential’s bit in the W3C Bitstring Status List v1.0 credential its issuer publishes. The issuer publishes a signed Bitstring Status List, valid for 24 hours and re-signed hourly, and republishes it when it revokes. A verifier decides how old the status evidence it accepts may be; ARIA AP's default is 3600 seconds from the list's signed validFrom. COM-05 measures the issuer's publication latency, not each verifier's. The list credential is signed with the same composite suite as an AID and carries the id that issued credentials name in credentialStatus.statusListCredential; its validFrom is the moment that version was signed, which is the age a verifier measures against the freshness it accepts. A verifier MUST check the list credential’s proof before reading a bit from it: an unsigned list is a revocation claim over transport security, not evidence. Revocation is terminal for the credential; the identifier never returns to the pool (§3.5.1) and may be re-issued only to the same controller (§3.5.4).
Trust Ledger. The permanent, append-only, SHA-256 hash-chained record of every credential lifecycle event — issuance, renewal, suspension, revocation, expiry, tombstone — modeled on Certificate Transparency (RFC 9162). One event, one Trust Record; every record carries the delegation-chain snapshot at the time of the action. It records the registry that asked and the identifier concerned, never who the customer is (§9).
Trust Ledger events and retention · issuance, renewal, suspension, revocation, expiry, tombstone · show tableshow ▾
| Event | What is logged | Retention |
|---|---|---|
| Issuance | DID, trust level, issuing authority, delegation chain, timestamp | 7 years |
| Revocation | Revoking authority, reason code, cascade scope | 7 years |
| State change | Previous state, new state, triggering event, authority | 7 years |
| Delegation | Delegating DID, receiving DID, scope granted, depth, approval config | 7 years |
Admission: ARIA AP
ARIA AP is the admission protocol of ARIA 1.0: the exchange between an agent and the service it calls, the receiver. It replaces ATP/1, which is deprecated and kept as history in Appendix F. It has five steps.
- Receiver identity. Before sending anything, the agent fetches the receiver's signed identity statement (
GET /.well-known/aria/identity, schemaaria-ap-identity-1), with the receiver's credential, and checks it against the DID it expects at that origin. The statement carries a single-use challenge for the next request. - A signed request. The agent signs each request with its holder key (§4) under RFC 9421 HTTP Message Signatures, covering the method, the target, the body digest, the operation id, the exact credential by reference (URL and digest) and the receiver's DID as audience, with the receiver's challenge. A copied credential cannot sign, and an altered or replayed request does not verify. These failures are unsigned answers: nothing can be attributed to a key that proved nothing.
- Admission. The receiver verifies the credential and the current status of that exact document (§3.5.2, §7), then audience, level, scope (§6), delegation and human approval (§6), then its own rule. The first failure ends it, and only an allow runs. Each refusal after authentication is a signed receipt for that attempt only, and claims nothing.
- One execution per operation. An admitted operation is claimed once and answered with an
aria-ap-receipt/1receipt, which carries the decision's HTTP status and code. A retry of the same operation gets the original receipt; a lost answer never causes a second execution or an invented rejection. - Recovery. After a lost answer, the agent signs a lookup and gets the operation's receipts back. Each party keeps its own evidence; no central service records the exchange.
The detail — the request profile, the admission order and its codes, operations and receipts — is the ARIA AP API contract with its conformance vectors in the protocol repository (sdk/aria-ap-ts/API.md, conformance/ap/). The explanatory guide is at /protocol.
Privacy & Data Governance
Agent identity metadata is organizational, not personal. Agent DIDs identify software entities. The principal identity is held by the registry operator that performed the verification, under data controller obligations; TrustLayer Foundation stewards the standard and does not hold it. The authority’s own records name the registry that asked and the identifier issued, never the customer.
legalName is an organization name. Natural-person principals at any level MUST NOT populate legalName; the public AID never carries a natural person’s name (COM-09, L0-03). principal.type (§4) makes the rule checkable: the schemas require legalName for an Organization and refuse it for a Person. The same rule binds every public surface of a registry, not only the credential — an API that answers from its database MUST NOT return a natural person’s name either.GDPR tension: the right to erasure (Article 17) conflicts with the Trust Ledger’s append-only immutability. Resolution: Trust Ledger entries can be redacted — the event record remains, personally identifiable fields are replaced with a redaction marker. Because the ledger never holds personal data in the first place (§7), redaction is a safeguard, not the design.
Security Considerations
Spoofing. Cryptographic identity replaces self-reported user-agent strings; a DID resolves identically across clouds, so the identity fabric does not depend on any provider’s trust domain.
Accountability, as a design statement. ARIA is designed so that when a regulator, a court or a board asks “who authorized this agent to do this?” there is a signed, timestamped answer whose provenance can be checked. It is a property of the records, not a legal guarantee.
Prompt injection. ARIA’s contribution is not prevention (a model-layer problem) but damage containment through identity infrastructure:
| Defense layer | Mechanism |
|---|---|
| Scope containment | A receiver admits only operations whose scope the agent declared and the receiver accepts, even if the agent is prompt-injected |
| Delegation ceiling | Compromised agent cannot escalate beyond delegated authority |
| Rapid revocation | Compromised agent credentials revoked in the issuer’s signed status list, which each receiver reads as fresh as it requires |
| Signed requests | Each request is signed for one receiver, operation and content: an altered or replayed request is refused |
| Audit trail | Complete cryptographic record for incident response |
| Admission | Receivers admit each signed request by level, declared scope, human approval and their own rule |
Versioning & Governance
Semantic versioning (major.minor). Minor changes (1.x) are backward-compatible; major changes (vN.0) may break. TLF supports all credentials under supported major versions for a minimum of 36 months. Preview-line credentials (labeled 1.0–1.2, April–August 2026) are outside this commitment and are sunset at the issuance cutover. API: v1 endpoints stable for a minimum of 5 years.
TrustLayer Foundation A.C. is the independent nonprofit that stewards the protocol, issues credentials from the issuance cutover (today the operating registry issues), maintains the Trust Ledger and governs the open standard under Apache 2.0 (code) and CC-BY-4.0 (documentation). Composition of the Technical Steering Committee, decision process and anti-capture provisions: /governance.
Integration Map
18 integration surfaces · MCP, enterprise IAM, commerce, A2Ashow ▾
ARIA is the identity layer the protocols below reference but do not define: MCP handles connectivity, ARIA AP handles admission, ARIA handles identity. ARIA is to A2A what a passport is to an airline.
| Layer | Protocol | ARIA’s role |
|---|---|---|
| Commerce Checkout | Visa TAP / Mastercard Agent Pay | Verified agent identity BEFORE issuing payment credentials |
| Agent Communication | Google A2A | Verified identity embedded in Agent Cards |
| Commerce Protocol | Stripe ACP / SPTs | Legal entity verification for B2B + regulated commerce |
| Micropayments | x402 (USDC/Coinbase) | Agent identity for autonomous spend authorization |
| Tool Connection | Anthropic MCP | Cross-org identity layer MCP doesn't supply |
| Agent Discovery | Shopify UCP | Trust signal for agent ranking. UCP Level 3 = ARIA L2+ |
| Internal Workload | SPIFFE/SPIRE | External-facing bridge when agents cross org boundaries |
| Bot Authentication | Cloudflare Web Bot Auth | Identity content that HTTP signatures transport |
| Auth Framework | IETF AIMS (WIMSE+OAuth) | Cross-org identity + authorization |
| Identity Standards | OIDF AIIM CG | Participation in the community group; no recommendation process is implied |
| Enterprise IAM | SCIM / IPSIE / AuthZEN | Lifecycle bridge for agent provisioning/deprovisioning |
| Cloud Identity | Microsoft Entra Agent ID | Cross-org portable identity outside Azure trust domain |
| Cloud Identity | AWS Bedrock AgentCore | Cross-org portable identity outside AWS trust domain |
| Access Control | NGAC / GNAP (RFC 9635) | Delegation chain maps to GNAP multi-party model |
| Request Signing | IETF RFC 9421 HTTP Message Signatures | The transport ARIA AP signs each request with, under the agent’s holder key |
| Credential Issuance | OpenID4VCI / OpenID4VP | VC issuance and presentation compatible with OIDF specs |
| Agent Interop | FIPA ACL | ARIA credential headers embeddable in FIPA messages |
| Governance Framework | ToIP Metamodel | TLF governance maps to ToIP four-layer trust stack |
MCP surfaces.
| # | Surface | How it works |
|---|---|---|
| 1 | ARIA AP over MCP | [PLANNED] ARIA AP is defined over HTTP (RFC 9421); how it travels over MCP is not defined. A bare AID in tool-call metadata is not an authenticated presentation. |
| 2 | Trust level discovery | MCP servers declare minimum trust level per tool |
| 3 | ARIA as MCP tool | [PLANNED] No MCP server on the current API; a tool can call the public read API over HTTP |
| 4 | Cross-org calls | Identity layer MCP assumes but does not supply |
| 5 | Scope alignment | Three-segment scopes can name MCP tool operations |
| 6 | Delegation chains | End-to-end accountability in multi-tool flows |
Enterprise. SCIM lifecycle bridge for agent provisioning, OIDC bridge for existing IAM, AuthZEN PEP/PDP and GNAP (RFC 9635) delegation compatibility, SP 800-207 zero-trust alignment. SDK: TypeScript (the ARIA SDK and ARIA AP 1.0; @aria-registry/verify 1.1.0, for preview-line credentials, is no longer served by npm); Python and Rust [PLANNED], verification-only.
Regulatory Mapping
Selected frameworks: NIST SP 800-63A-4, EU AI Act, Colorado SB 26-189, TLS analogiesshow ▾
How ARIA relates to selected frameworks. Aligned to NIST SP 800-63A-4; no conformance assessment is claimed. No legal conclusion is claimed anywhere in this appendix.
| ARIA level | Verification | TLS analogy | EU AI Act | Colorado SB 26-189 |
|---|---|---|---|---|
| L0 Self-declared | E-mail challenge + key possession | Self-signed | Risk mapping | N/A |
| L1 Identified | Verified person (ICAO 9303 · ISO/IEC 30107-3 · biometric match · human review) + domain via DoH + RDAP | DV | Risk mapping | Designed to support |
| L2 Certified | Authoritative Source (Route A / Route B ≥20 % spot-check) + person–entity link + sanctions ≤7 d | OV | Risk mapping | Designed to support |
| L3 Sovereign | Primary register + Binding Officer + FIPS 140-3 L2+ / CC EAL4+ keys + signed accountability | EV+ | Risk mapping | Designed to support |
EU AI Act — Regulation (EU) 2024/1689, final numbering; general application began August 2, 2026. ARIA’s human-approval rule (§6) is designed to support human oversight (Art. 14); the AID’s declared principal, scopes and signed intent support transparency (Art. 50).
| Article | ARIA mapping |
|---|---|
| Article 9 (Risk management) | Trust levels provide risk-proportional identity |
| Article 14 (Human oversight) | Human approval for the scopes a credential lists in hitlRequired is designed to support oversight (see §6) |
| Article 50 (Transparency obligations) | AID declares principal, scopes and signed intent |
| Article 72 (Post-market monitoring) | Trust Ledger provides the audit trail |
| Article 99 (Penalties) | L2/L3 verification documents the compliance effort |
Trust Seals
Optional sector, compliance and capability attestations · qualify= reservedshow ▾
Trust Seals are optional attestations embedded in the AID’s attestations field, once referenced by the qualify= rules of ATP/1, now deprecated. L2+ required (Education: L1+). They are not trust levels; they enable sector-specific policy. [PLANNED] — qualify= was reserved in ATP/1 and never evaluated, and ARIA AP has no equivalent yet.
| Category | Seals | Minimum level |
|---|---|---|
| Sector | Healthcare, Finance, Government, Legal, Education | L2 (Education: L1+) |
| Compliance | SOC2, ISO 27001, ISO 42001, PCI-DSS, EU AI Act, HIPAA | L2+ |
| Capability | HSM-bound keys, Offline-capable, Multi-agent orchestrator | L2+ |
An Insured seal (proof of E&O or professional liability insurance covering AI operations) is one candidate qualification for L2+ agents; the Trust Ledger’s lifecycle records are the underwriting data layer such insurers currently lack.
Deployment Patterns
Offline and QR verification · optional blockchain anchor · multi-principal, robotic and SPIFFE patternsshow ▾
Offline. Credentials are self-contained: a verifier with a cached issuer key and status list validates any AID without network access (subject to the freshness it requires of the status list, §7). QR presentation enables physical-world verification.
Blockchain (optional). DNS remains the primary trust anchor; did:ethr, did:ion or did:sol may serve as secondary anchors.
Patterns. Multi-principal agents: separate AIDs per principal context. Model provenance: a modelAttestation field for AI Act transparency. Robotic identity: the same framework, with L3 hardware keys bound to a specific device. SPIFFE bridge: ARIA L2+ wraps a SPIFFE SVID with cross-organization verification.
Verification Requirements
The 80 citable requirements that §2 rests on are published at aria.bar/requirements: version 1.3-draft, 10 requirements changed from v1.2, each marked with its reason; adoption by TLF [PLANNED]. The canonical text is Spanish; an English translation is [PLANNED], and until it is published the Spanish text governs. Every ID cited in this specification resolves there.
ATP/1 (historical, deprecated)
_aria-policy records with v=ATP1, the ATP- codes and the schemas atp-policy-v1.json and intent-declaration-v1.json remain at their published locations only as compatibility identifiers, and ARIA AP reads none of them.ATP/1 text of the edition of 7 September 2026 · deprecated, historical · showshow ▾
ATP defines what happens when an agent presents its credential to a receiving system: a three-phase handshake — Declare (the agent presents its AID and a signed Intent Declaration), Evaluate (the receiver checks both against its configured admission policy, the same one it publishes as a DNS TXT record), Admit (a result code, with a literal reason). The published record informs agents in advance and MUST match the configured policy. The explanatory guide, with deployment patterns and the DMARC parallel, is at /protocol; this section is the normative reference.
_aria.<domain> is published by the agent’s holder and answers “does this domain back this agent?” (§3.4, L1+). _aria-policy.<host> is published by the receiver — looked up host first, then apex — and answers “whom does this service admit?”. The policy record never demands anything of the agent: an L0 agent has no domain and is admissible by any policy with min=L0.Intent Declaration. An Intent Declaration MUST be present in the Declare phase (ATP/1 §6.1) and is signed by the holder key. The three MUST fields below are the protocol minimum for it to be valid at all; a receiver’s intent= parameter adds required fields on top of that minimum, never below it.
| Field | Required | Description |
|---|---|---|
| purpose | MUST | Human-readable statement of operational purpose |
| action_requested | MUST | ARIA scope, three segments (e.g. commerce:order:read) |
| principal_ref | MUST | DID of the principal (did:aria:…:org). MUST NOT be a name (ATP-13, COM-09). |
| target_resource | SHOULD | Specific resource or endpoint the agent intends to access |
| dataUsage | SHOULD | W3C DPV purpose categories (dpv:TransactionManagement, etc.) |
| retention | SHOULD | Maximum data retention duration (ISO 8601, e.g. P90D) |
| constraints | MAY | Self-declared operational constraints |
| session_id | MAY | Unique session ID for correlating multiple interactions |
Agent Trust Policy — the DNS record. ATP/1 grammar (RFC 5234): v=ATP1 first; enforce= mandatory in a published record; an unknown parameter is ignored unless written !name= (critical), in which case a processor that does not understand it MUST treat the policy as unsatisfiable. A record that fails to parse, or is absent, means “no usable published policy”.
Agent Trust Policy parameters · normative, informative and reserved · defaults · show tableshow ▾
| Parameter | Class | Default | Semantics |
|---|---|---|---|
| v | normative | — | Version. Mandatory, first. Always ATP1. |
| min | normative | L0 | Minimum level, derived from the evidence, never read from a label. L0 < L1 < L2 < L3. |
| req | normative | empty | Required scopes, AND semantics. Three segments, colon-separated; wildcard only in the last (commerce:order:*). |
| fresh | normative | 3600s | Maximum age of the AID status evidence at decision time and during the session. Floor 60s (COM-05); lower values are a configuration error. |
| enforce | normative | strict | monitor (evaluate, log, admit all) · warn (admit, add warning) · strict (deny). Mandatory in a published record; absent in configuration = strict. |
| deny | normative | empty | Prohibited scopes. Any intersection with the agent effective set denies. |
| intent | normative | empty | Fields the signed Intent Declaration must carry. principal_ref is a DID, never a name. |
| depth | normative | unlimited | Maximum delegation depth: credentialSubject.delegationDepth ≤ depth. |
| rua | informative | — | URI for aggregate evaluation reports (DMARC rua= pattern). Does not affect admission. |
| rate | informative | — | Declared call limit. Not evaluated: rate enforcement is receiver infrastructure, outside admission. |
| qualify | reserved | — | Depends on Trust Seals (Appendix C, not implemented). Never evaluated in ATP/1. |
Freshness. All checks are local after the first hash-pinned fetch. Status evidence MUST be no older than fresh (default 3600 s, floor 60 s): the receiver-side consumer of the COM-05 bound (§7).
Deployment layers. A conforming receiver runs three layers that add up; they are not alternatives to choose between. Every admission runs on the first; the second is reached only when the status evidence has aged past fresh; the third never participates in an admission at all.
| Layer | When | Cost | Source |
|---|---|---|---|
| Local SDK | Every call | No network | Credential and scopes cached by hash; both signature halves verified in-process |
| Freshness | When the status evidence is older than fresh= | One cacheable request | The issuing registry’s Status List (COM-05) |
| Reaffirmation | Cold start, dispute, audit, a receiver’s own spot-check | One request, outside the admission path | A TrustLayer Foundation API returning signed, dated answers |
Presented material. The evaluator receives an authenticated presentation: the agent’s DID, the audience it is presenting to, a fresh proof of possession, and the signed Intent Declaration, alongside the AID and the status evidence (ATP/1 §6.1). Steps 2 and 3 of the algorithm check the proof and the audience before the credential is looked at, which is what makes a copied AID useless to a third party.
Evaluation algorithm. Eleven checks in fixed order, cheapest and most local first, state-dependent last. Every check MUST be performed; the first failure ends the evaluation and its code is the result. The order is not a preference: a receiver that checked scopes before the signature would be reasoning about a document it has not authenticated.
| # | Check | What it establishes | Code on failure |
|---|---|---|---|
| 1 | Configuration | The configured policy parses, implements every parameter it carries and every critical one it was sent. | configuration error, not a per-call code |
| 2 | Presentation | The presentation is authenticated and fresh: the caller proves possession of the holder key now. | ATP-401 / SIG |
| 3 | Audience | The presentation names this receiver. One built for someone else cannot be replayed here. | ATP-421 |
| 4 | AID integrity | Both halves of the composite countersignature verify and the schema conforms. | ATP-401 / SIG · MALFORMED |
| 5 | Validity | Now falls between validFrom and validUntil. | ATP-401 / EXPIRED |
| 6 | Status · network | The status evidence is no older than fresh=. Older and not renewable is a refusal, never a pass: stale evidence does not admit. | ATP-412 · ATP-410 / REVOKED · SUSPENDED |
| 7 | Level | The level derived from the evidence meets min=. A level label inconsistent with its own facts is malformed, not insufficient. | ATP-403 |
| 8 | Scopes | The effective scope set covers every req= and intersects no deny=. | ATP-406 |
| 9 | Delegation | The signed delegationDepth is within depth=. | ATP-462 |
| 10 | Intent | The signed Intent Declaration carries every field intent= requires, and principal_ref is a DID. | ATP-451 |
| 11 | Admit | Bound to this audience and this DID, opening a session. | ATP-200 |
strict a failure denies. In warn the agent is admitted with ATP-200 and reason=ADMIT-FLAGGED(<code that would have denied>), plus a notice in the response. In monitor the same, without the notice. No mode admits a failure of integrity, presentation or audience.Result codes. Every denial carries exactly one code — the first failing step — and a literal reason; both are part of the conformance contract.
Result codes · 2xx admit, 4xx refuse · one code per denial, first failing step · show tableshow ▾
| Code | Name | Meaning | reason |
|---|---|---|---|
| ATP-200 | Admitted | All policy checks passed | ADMIT · in monitor/warn: ADMIT-FLAGGED(<code that would have denied>) |
| ATP-401 | Credential invalid | Signature fails, malformed, or expired | SIG · MALFORMED · EXPIRED |
| ATP-410 | Credential revoked or suspended | Status evidence shows the credential is not active | REVOKED · SUSPENDED(<reason>) |
| ATP-412 | Status evidence stale | Status evidence older than fresh and not renewable | STALE |
| ATP-421 | Audience mismatch | Presentation not bound to this receiver | AUDIENCE |
| ATP-403 | Trust insufficient | Evidence-derived level below policy minimum | LEVEL |
| ATP-406 | Scope mismatch | Missing a required scope or carries a denied one | SCOPE-MISSING · SCOPE-DENIED |
| ATP-451 | Intent incomplete | Intent Declaration missing or malformed | INTENT-MISSING(<field>) · INTENT-MALFORMED |
| ATP-462 | Delegation too deep | delegationDepth exceeds policy depth | DEPTH |
| ATP-429 | Rate limited | Emitted by receiver infrastructure, outside the algorithm (rate is informative) | — |
| ATP-460 | Qualifier missing | Reserved: qualify= is not part of ATP/1 | — |
Enforcement modes — graduated adoption, the pattern DMARC established:
| Mode | Behavior | Use |
|---|---|---|
| monitor | Log everything. Admit all agents. Non-compliant agents flagged but not blocked. | First deployment. Turn on the lights. |
| warn | Admit all agents. Non-compliant agents receive warning header + logged. | Transition phase. Training wheels. |
| strict | Reject non-compliant agents. ATP error response. No access. | Full enforcement. Default when enforce= is absent in configuration. |
Apache 2.0 (code) + CC-BY-4.0 (documentation) · Copyright 2026 TrustLayer Foundation A.C.