ARIA1.0
TRUSTLAYER FOUNDATION A.C. · NOVEMBER 2026

ARIA

Agent Registry for Identity & Authorization
ARIA here means Agent Registry for Identity & Authorization. It is unrelated to WAI-ARIA (accessibility).
ARIA 1.0, edition of 1 November 2026. It revises the edition of 7 September 2026 with the texts TrustLayer Foundation adopted on 1 November 2026.
ARIA 1.04 levels · L0 issuedML-DSA + Ed25519did:aria12 sections · 6 appendicesNIST-2025-0035
0SECTIONnormative

Status & Conformance

ARIA 1.0 — first stable release September 7, 2026; this edition, November 1, 2026. Verification Requirements as the normative basis, four levels derived from evidence, ARIA AP for admission (§8; ATP/1, deprecated, is kept in Appendix F), issuer = TrustLayer Foundation. CC-BY-4.0 (documentation) + Apache 2.0 (code).
ℹ
Changed from the edition of 7 September 2026. §3: issuance under the federation contract 1.0.0, with one _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.
ℹ
Public previews (no production adoption): Apr 1, 2026 (labeled 1.0) · Apr 28 (1.1) · May (1.2). Preview credentials are distinguished by issuer DID and are sunset at cutover. External references to 1.1/1.2 — the W3C CG thread, the FIDES submission, npm @aria-registry/verify 1.x — refer to the preview line.
⚠
[PLANNED]Issuance cutover. Credentials under ARIA 1.0 will carry 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.

TermMeaning
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 FileThe append-only evidentiary record a registry keeps for every L1+ credential (EXP-01). Never in the AID.
FlagA recorded doubt on a Case File that blocks issuance or renewal until a human reviews it.
Authoritative SourceThe public register of the jurisdiction of incorporation against which an entity is confirmed.
Route A / Route BDirect 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.
ControllerWhoever 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 keyThe 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 OfficerA natural person with proven power to bind the entity, evidenced by public instrument (L3).
Preview lineCredentials and texts labeled 1.0–1.2 between April and August 2026. No production adoption; distinguished by issuer DID; sunset at cutover.
1SECTIONinformative

Protocol Overview

Six composable layers, each on a proven standard. DNS is the root; nothing below introduces a new cryptographic primitive.

LayerStandardFunction
P1 AnchorW3C DID Core / did:ariaEvery agent gets a DID. Resolution: DNS TXT pointer + HTTPS AID endpoint.
P2 CertifyW3C VC Data Model 2.0Signed, portable, independently verifiable credentials. Offline-capable.
P3 PresentARIA AP over RFC 9421 HTTP Message SignaturesA request signed with the agent’s holder key, admitted by the receiver and answered with a signed receipt (§8).
P4 ProtectFIPS 204 + RFC 8032ML-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 RevokeW3C Bitstring Status List v1.0 + Trust LedgerRevocation 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 GovernTrustLayer Foundation A.C.Nonprofit stewardship. Apache 2.0 + CC-BY-4.0. Anti-capture. Community governed.
2SECTIONnormative

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 verifiedEntity confirmed
Person not verifiedL0not permitted
Person verifiedL1L2 · 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.

L0Self-declared
Does this agent exist?
Cryptographic existence of the agent. Nothing more. No identity of any person or organization is asserted; every declared name is marked self-declared.
L0-01 · L0-02 · L0-03 · L0-04 · COM-01 · COM-07 ↗
TLS analogy: Self-signed
L1Identified
Is there a person who answers for it?
A verified natural person answers for the agent, and the agent controls its domain. Nothing is asserted about the organization: it remains self-declared.
L1-PER-01…10 · L1-DOM-01…03 · COM-04 · EXP-01…06 ↗
TLS analogy: DV
L2Certified
Does the organization legally exist?
L1, plus: the entity exists and is active per its Authoritative Source, the verified person is linked to it, and neither appears on sanctions lists.
L2-ENT-01…10 · L2-VIN-01…05 · L2-SAN-01…03 ↗
TLS analogy: OV
L3Sovereign
Can someone bind the entity?
L2, plus: a person with the power to bind the entity backs the agent, keys live in certified hardware, and signed legal accountability exists and is producible as evidence.
L3-SOB-01…10 · EXP-03 (RFC 3161) ↗
TLS analogy: EV+
LevelTLS analogyValidityRenewal
L0Self-signed366 daysE-mail re-verification. Fully automatic.
L1DV366 daysDomain and e-mail re-verification. The person is re-verified only on document expiry or Flag.
L2OV200 daysStatus at source + sanctions + domain + link.
L3EV+180 daysSemi-automatic: source + sanctions + instrument validity + confirmation by the named human.
⚠
[PLANNED]Live vs. planned. L0 is issued today. L1, L2 and L3 are specified and not yet issued: no registry has been evaluated by TLF for those levels (AUD-04). L0 issuance predates the Requirements, and what AUD-04 still lacks is the method, the evaluator and the criteria, not the run: none of the three exists yet.
ℹ
Equivalent legal-entity credentials. ARIA accepts entity credentials verifiable to a root of trust, non-revoked and fully corroborated, under schemes listed in TLF’s acceptance list (separate, revisable document). No scheme is named in this specification.
3SECTIONnormative

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 ▾
did:aria — ABNF grammar
did-aria = "did:aria:" method-specific-id method-specific-id = agent-id / principal-id ; ── Agents ───────────────────────────────────────────── agent-id = agent-domain-form / agent-registry-form agent-domain-form = domain ":" agent-slug agent-registry-form = registry-host ":" registry-account ":" agent-slug ; ── Principals (organizations) ──────────────────────── principal-id = principal-domain-form / principal-registry-form principal-domain-form = domain ":org" principal-registry-form = registry-account ":org" ; ── Terminals ───────────────────────────────────────── domain = dns-label *("." dns-label) registry-host = dns-label *("." dns-label) dns-label = 1*63(ALPHA / DIGIT / "-") ; MUST start with ALPHA / DIGIT, MUST NOT end with "-" registry-account = "u-" 8(ALPHA / DIGIT) ; case-sensitive 8-character nanoid over [0-9a-zA-Z] agent-slug = 1*64(lowercase / DIGIT / "-") ; MUST start with lowercase / DIGIT, MUST NOT end with "-" lowercase = %x61-7A

Four identifier shapes result from combining the two subject kinds (agent, principal) with the two anchoring modes (verified DNS domain, registry-namespaced fallback):

ShapeExampleUsed when
Agent · domain-formdid:aria:example.com:ordering-agentPrincipal has verified control of the DNS domain (trust level L1+).
Agent · registry-formdid:aria:aria.bar:u-0dhNSrC9:commerce-searchAgent lives under a registry namespace (L0, or L1+ before the principal's domain is verified).
Principal · domain-formdid:aria:example.com:orgOrganizational identity for a principal that has verified its domain.
Principal · registry-formdid:aria:u-0dhNSrC9:orgOrganizational identity for a principal without a verified domain — namespaced only by registry-account, no host prefix, stable across registry migrations.
ℹ
The literal suffix ":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 ▾
DID Document — derived from the AID
{ "@context": [ "https://www.w3.org/ns/did/v1", "https://w3id.org/security/multikey/v1" ], "id": "did:aria:example.com:ordering-agent", "controller": "did:aria:example.com:org", "verificationMethod": [{ "id": "did:aria:example.com:ordering-agent#holder-key-1", "type": "Multikey", "controller": "did:aria:example.com:ordering-agent", "publicKeyMultibase": "z6MkpTHR8VNsBxYAAWHut2Geadd9jSwuBV8xRoAnwWsdvktH" }], "authentication": ["did:aria:example.com:ordering-agent#holder-key-1"], "assertionMethod": ["did:aria:example.com:ordering-agent#holder-key-1"], "service": [{ "id": "did:aria:example.com:ordering-agent#aid", "type": "AriaAgentIdentityDocument", "serviceEndpoint": "https://example.com/.well-known/aria/ordering-agent.json" }] }

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 ▾
  1. id — credentialSubject.id from the AID.
  2. controller — computed from id: for agent-domain-form, replace the agent-slug component with the literal org; for agent-registry-form, keep only the registry-account:org tail (drop the registry-host), matching how the registry issues principal identifiers.
  3. verificationMethod — a single Multikey entry that translates the AID's credentialSubject.holderKey. The AID carries that key in ARIA's own encoding (§4), not as Multikey, so the derivation converts it: decode publicKeyMultibase to the raw 32 bytes, prefix the multicodec 0xed01 and encode again as z + base58btc, which gives the z6Mk… form. id and controller are derived from the agent DID.
  4. authentication and assertionMethod — both reference the single verification method: the agent authenticates as itself and asserts on its own behalf using the holder key.
  5. service — a single AriaAgentIdentityDocument entry whose serviceEndpoint is the HTTPS URL from which the AID was retrieved (present in the DNS TXT pointer, §3.4).
ℹ
Why derive instead of serve. The AID is the authoritative artifact and is what the composite signature covers, so making the DID Document a projection of it eliminates the risk of the two drifting apart. A resolver that only needs authentication material can stop after the derivation; a resolver that needs the full credential (trust level, scopes, principal metadata, signed intent, revocation status) has it already, since the AID is what it just retrieved.
ℹ
Holder-key algorithm choice. The 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.
ℹ
Forward compatibility. A future revision of this specification MAY define an HTTPS endpoint that serves a signed DID Document directly, alongside or in place of the derivation-from-AID model. Because the derivation is deterministic and the AID contains all the material the DID Document needs, adding such an endpoint is an additive change — an existing consumer that follows the derivation rules above continues to obtain the same DID Document.

§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.

_aria.example.com TXT record
v=ARIA1; did=did:aria:example.com:agent-alpha; hash=sha256:a1b2c3d4e5f6...; aid=https://example.com/.well-known/aria/agent-alpha.json

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.

The pointer is optional, and it is not the domain binding. Issuance requires no pointer. The binding an L1 credential rests on is one _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 ▾
  1. 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.
  2. 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.
  3. 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.
  4. 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.
  5. Issuance. The registry redeems the reservation token and issues the AID: a W3C VC 2.0 credential whose credentialSubject.id is the DID, carrying the holder key, principal reference, level and scopes, secured by the composite mldsa65-ed25519-2026 proof (§5). The top-level id is the credential-instance URL. A status list position is allocated and written into credentialStatus. Issuance is terminal for the identifier: it never returns to the pool, even if the credential is later revoked.
  6. 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).
  7. 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 ▾
  1. Parse. Validate against §3.1. Failure → invalidDid.
  2. 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.
  3. Check the pointer. The TXT MUST carry v=ARIA1, a did= equal to the input, a hash= and an aid= HTTPS URL. Mismatched DID → pointerMismatch.
  4. Fetch. GET the AID over HTTPS. The response is treated as opaque bytes.
  5. Pin. SHA-256 of the fetched bytes MUST equal hash=. Mismatch → hashMismatch; the document MUST NOT be evaluated further.
  6. Bind. credentialSubject.id MUST equal the input DID → else subjectMismatch.
  7. Verify the proof. Canonicalize the credential minus proof (§5.1); decode proofValue (§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).
  8. Check validity. validFrom ≤ now < validUntil, else expired or notYetValid.
  9. Check status. Fetch credentialStatus.statusListCredential, verify its own proof, read the bit at statusListIndex. Set → revoked. Status evidence older than the caller's freshness bound, measured from the list's signed validFrom (§7: each verifier sets it; ARIA AP's default is 3600 seconds) → statusStale.
  10. 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_from and its distrust_after cut-off (§5.2, AUD-02).
  11. 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.

did:aria resolution result — shape (values illustrative)
{ "didDocument": { "@context": ["https://www.w3.org/ns/did/v1", "https://w3id.org/security/multikey/v1"], "id": "did:aria:…", "…": "derived per §3.2" }, "didDocumentMetadata": { "created": "2026-05-29T17:25:29Z", "updated": "2026-05-29T17:25:29Z", "deactivated": false, "versionId": "019e74c5-0595-74a7-99b2-f0e488c71eb8", "aria": { "aid": "https://api.aria.bar/v1/aids/did:aria:…", "contentHash": "sha256:159c7b…", "trustLevel": "L0", "statusCheckedAt": "2026-09-07T18:02:11Z" } }, "didResolutionMetadata": { "contentType": "application/did+ld+json", "dnssec": "insecure" } }
⚠
[PLANNED]Deployed resolver. The public API returns the AID at /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/).

Issuance. Issuance follows the federation contract (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.
Recovery. A successful answer is recorded with the request. An RA that did not receive an answer, or received 500, 503 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.
4SECTIONnormative

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:

RoleMaps toDescription
Registrantaccount_holderHuman who opens the account and accepts ToS. One registrant per account.
PrincipalcredentialSubject.principalLegal entity or person in the AID. The authority behind the agent.
Account Adminplatform userManages AIDs day-to-day. May differ from registrant. Analogy: DNS registrant vs. admin contact.
ℹ
principal.verificationStatus (required). Machine-readable provenance of 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.
principal.type (required on issuance). The kind of principal, as a schema.org type: 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.
holderKey.publicKeyMultibase 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 ▾
AID — complete example
{ "id": "https://api.aria.bar/v1/credentials/019e74c5-0595-74a7-99b2-f0e488c71eb8", "type": [ "VerifiableCredential", "ARIAIdentityDocument" ], "issuer": "did:aria:registry.aria.bar", "@context": [ "https://www.w3.org/ns/credentials/v2", "https://aria.bar/ns/v1" ], "validFrom": "2026-05-29T17:25:29.663Z", "validUntil": "2027-05-30T17:25:29.663Z", "credentialStatus": { "id": "https://api.aria.bar/v1/status/1#42", "type": "BitstringStatusListEntry", "statusPurpose": "revocation", "statusListIndex": "42", "statusListCredential": "https://api.aria.bar/v1/status/1" }, "credentialSubject": { "id": "did:aria:aria.bar:u-a1b2c3d4:ordering-agent", "spec_version": "1.2", "agentName": "ordering-agent", "version": "1.0.0", "trustLevel": "L0", "principal": { "did": "did:aria:u-a1b2c3d4:org", "legalName": "Example Corp", "jurisdiction": "US", "verificationStatus": "self-declared" }, "holderKey": { "id": "did:aria:aria.bar:u-a1b2c3d4:ordering-agent#holder-key-1", "type": "Ed25519VerificationKey2020", "publicKeyMultibase": "zF3xFtomJS7KN4ddhzUG1fPbprAE2tz5RFnt5i3nd17Zx" }, "scope": [ "communication:human:read", "communication:human:write" ], "hitlRequired": [], "delegationDepth": 0, "maxDelegationDepth": 4, "enrollmentAttestation": { "attestedAt": "2026-05-29T17:25:29.666Z", "termsVersion": "1.2.0", "privacyVersion": "1.2.0", "userAgentAgreement": true } }, "proof": { "type": "DataIntegrityProof", "created": "2026-05-29T17:25:29.694Z", "proofValue": "AAAM7TSQEPZgA2cNDhuV22GY0sDJ...HnttyM7oygzY_YQA", "cryptosuite": "mldsa65-ed25519-2026", "proofPurpose": "assertionMethod", "verificationMethod": "did:aria:registry.aria.bar#key-1" } }
5SECTIONnormative

Cryptography

Post-quantum from the first credential, not retrofitted: the Harvest-Now-Decrypt-Later threat makes retroactive protection the requirement.

AlgorithmNIST StandardUsageSecurity Level
ML-DSA-65FIPS 204Primary signing for all AIDsLevel 3 (AES-192)
ML-KEM-768FIPS 203[PLANNED] Session key establishmentLevel 3
SLH-DSAFIPS 205[PLANNED] Long-lived registry recordsConservative (hash-based)
Ed25519RFC 8032Composite classical (AND with ML-DSA)Classical (~128-bit)
Composite signature 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.

  1. Transformation. Take the credential as a JSON object, remove the proof member, and serialize it as canonical JSON: object members sorted by key (UTF-16 code-unit order, as Array.prototype.sort orders JavaScript strings, recursively at every depth), arrays in document order, no whitespace, strings escaped as JSON.stringify does (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 as JSON.stringify renders 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 in aria-protocol/conformance/, not against RFC 8785.
  2. 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.
  3. Proof serialization. proofValue is the unpadded base64url (RFC 4648 §5) encoding of u32be(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. Suite 1.0 emits it multibase-encoded: the prefix u (base64url, no padding) per the multibase registry, because the VC v2 context types proofValue as sec:multibase and 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 always 0x00000CED, so a bare proofValue always begins AAAM and never u. A verifier MUST validate the header against the byte count that follows it rather than trusting the first character. The proof object carries type: DataIntegrityProof, cryptosuite: mldsa65-ed25519-2026, created, verificationMethod and proofPurpose: assertionMethod.
  4. Verification. Decode proofValue; a value that is not base64url, shorter than four bytes, or whose declared length exceeds the remainder is MALFORMED. 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).
  5. 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.
ℹ
Known gaps, recorded rather than hidden. The suite has no context string and no domain-separation tag, so the same key MUST NOT be reused to sign any other message type. The transformation is defined by deployed behaviour and vectors rather than by reference to RFC 8785. Both are candidates for a successor suite; neither can change for 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/verify 1.x embeds the keys of did: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.bar at api.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/aria answers 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/keyset serves 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 names demo; 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_from and any distrust_after cut-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.
⚠
[PLANNED]Key compromise recovery. TLF emergency revocation with out-of-band identity verification, 3-of-5 secret sharing and an HSM-generated root key, modeled on the DNSSEC root ceremony. Not deployed.
6SECTIONnormative

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
readQuery or retrieve data
writeCreate or update data
deleteRemove data permanently
executeRun a process or workflow
approveAuthorize a pending action
exportExtract data outside the system
subscribeRegister for ongoing notifications
delegatePass a narrower set of scopes to another agent
Namespace examples · 10 namespacesshow ▾
commerce:
purchase_orderinvoicecatalogpricingcheckoutwallettapucpspt
finance:
transactionauditreportcompliancemicropayment
communication:
emailmessagecalendarmeetinga2a
data:
generalsensitiveclassifiedaggregate
identity:
principalagentdelegationcredential
infrastructure:
dnscertificatedeploymentmonitorhsm
health:
patientclinicalconsenthipaa
legal:
contractevidencecompliancefiling
government:
procurementpermitreportregulation
robotics:
actuatorsensorsafetygeofence

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).

⚠
[PLANNED]Sub-agent issuance. No registry issues sub-agent credentials with a signed chain yet; every issued credential carries 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.

7SECTIONnormative

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:

StateMeaningTransitionsReversible?
activeCredential valid. Agent operating normally.Can become: suspended, revoked, expiredStarting state
suspendedTemporarily paused. Principal change, investigation, or policy violation.Can become: active (reinstated) or revokedYes
revokedPermanently invalidated. Compromise, termination, or breach.Terminal stateNo. Ever.
expiredCredential TTL exceeded. Must renew to resume.Can become: active (after renewal)Yes (renewal)
tombstonedOrganization dissolved or acquired. Permanent archive.Terminal stateNo
supersededReplaced by a new credential. Old DID permanently points to new one (301 redirect pattern).Terminal state. Pointer to successor.No
Broken link (L2-VIN-04). The AID belongs to the entity, not the person. Departure of the responsible person does not by itself revoke; on a credible notice the credential enters 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).

ℹ
COM-05 and this edition. The draft wording of COM-05 in the Verification Requirements (Appendix E) also bounds how old the status evidence a verifier accepts may be. This edition reads COM-05 as the issuer's publication latency only; the age a verifier accepts is its own choice, as above.

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 ▾
EventWhat is loggedRetention
IssuanceDID, trust level, issuing authority, delegation chain, timestamp7 years
RevocationRevoking authority, reason code, cascade scope7 years
State changePrevious state, new state, triggering event, authority7 years
DelegationDelegating DID, receiving DID, scope granted, depth, approval config7 years
⚠
[PLANNED]Agent Interaction Log. A central log of admissions and refusals was planned for ATP/1, now deprecated; under ARIA AP each party keeps its own signed receipts. The Trust Ledger records lifecycle only. No committed date.
⚠
[PLANNED]CAEP push revocation. Signed Security Event Tokens to enterprise IAM within seconds of revocation. Not deployed.
8SECTIONnormative

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.

  1. Receiver identity. Before sending anything, the agent fetches the receiver's signed identity statement (GET /.well-known/aria/identity, schema aria-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.
  2. 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.
  3. 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.
  4. One execution per operation. An admitted operation is claimed once and answered with an aria-ap-receipt/1 receipt, 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.
  5. 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.
Not part of 1.0. Delegation (a delegated credential is refused), holding an operation for approval, a credential sent by value, and the WIMSE binding. The retrieval rules beyond the receipt format are not yet decided.

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.

⚠
[PLANNED]Holder proof. Under ARIA AP each receiver issues its own single-use challenge and the agent signs the request with its holder key; nothing on api.aria.bar admits requests.
9SECTIONnormative

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.

10SECTIONinformative

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 layerMechanism
Scope containmentA receiver admits only operations whose scope the agent declared and the receiver accepts, even if the agent is prompt-injected
Delegation ceilingCompromised agent cannot escalate beyond delegated authority
Rapid revocationCompromised agent credentials revoked in the issuer’s signed status list, which each receiver reads as fresh as it requires
Signed requestsEach request is signed for one receiver, operation and content: an altered or replayed request is refused
Audit trailComplete cryptographic record for incident response
AdmissionReceivers admit each signed request by level, declared scope, human approval and their own rule
11SECTIONnormative

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.

Appendices · A–D informative, E normative, F historical
AAPPENDIXinformative

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.

LayerProtocolARIA’s role
Commerce CheckoutVisa TAP / Mastercard Agent PayVerified agent identity BEFORE issuing payment credentials
Agent CommunicationGoogle A2AVerified identity embedded in Agent Cards
Commerce ProtocolStripe ACP / SPTsLegal entity verification for B2B + regulated commerce
Micropaymentsx402 (USDC/Coinbase)Agent identity for autonomous spend authorization
Tool ConnectionAnthropic MCPCross-org identity layer MCP doesn't supply
Agent DiscoveryShopify UCPTrust signal for agent ranking. UCP Level 3 = ARIA L2+
Internal WorkloadSPIFFE/SPIREExternal-facing bridge when agents cross org boundaries
Bot AuthenticationCloudflare Web Bot AuthIdentity content that HTTP signatures transport
Auth FrameworkIETF AIMS (WIMSE+OAuth)Cross-org identity + authorization
Identity StandardsOIDF AIIM CGParticipation in the community group; no recommendation process is implied
Enterprise IAMSCIM / IPSIE / AuthZENLifecycle bridge for agent provisioning/deprovisioning
Cloud IdentityMicrosoft Entra Agent IDCross-org portable identity outside Azure trust domain
Cloud IdentityAWS Bedrock AgentCoreCross-org portable identity outside AWS trust domain
Access ControlNGAC / GNAP (RFC 9635)Delegation chain maps to GNAP multi-party model
Request SigningIETF RFC 9421 HTTP Message SignaturesThe transport ARIA AP signs each request with, under the agent’s holder key
Credential IssuanceOpenID4VCI / OpenID4VPVC issuance and presentation compatible with OIDF specs
Agent InteropFIPA ACLARIA credential headers embeddable in FIPA messages
Governance FrameworkToIP MetamodelTLF governance maps to ToIP four-layer trust stack

MCP surfaces.

#SurfaceHow it works
1ARIA 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.
2Trust level discoveryMCP servers declare minimum trust level per tool
3ARIA as MCP tool[PLANNED] No MCP server on the current API; a tool can call the public read API over HTTP
4Cross-org callsIdentity layer MCP assumes but does not supply
5Scope alignmentThree-segment scopes can name MCP tool operations
6Delegation chainsEnd-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.

BAPPENDIXinformative

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 levelVerificationTLS analogyEU AI ActColorado SB 26-189
L0 Self-declaredE-mail challenge + key possessionSelf-signedRisk mappingN/A
L1 IdentifiedVerified person (ICAO 9303 · ISO/IEC 30107-3 · biometric match · human review) + domain via DoH + RDAPDVRisk mappingDesigned to support
L2 CertifiedAuthoritative Source (Route A / Route B ≥20 % spot-check) + person–entity link + sanctions ≤7 dOVRisk mappingDesigned to support
L3 SovereignPrimary register + Binding Officer + FIPS 140-3 L2+ / CC EAL4+ keys + signed accountabilityEV+Risk mappingDesigned 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).

ArticleARIA 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
ℹ
Colorado. SB 24-205 was repealed and re-enacted by SB 26-189 (signed May 14, 2026) as a narrower, notice-based automated-decision framework, effective January 1, 2027 (leg.colorado.gov/bills/sb26-189). ARIA L2/L3 verifiable identity and accountability chains are designed to support its notice and record-keeping duties.
CAPPENDIXinformative

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.

CategorySealsMinimum level
SectorHealthcare, Finance, Government, Legal, EducationL2 (Education: L1+)
ComplianceSOC2, ISO 27001, ISO 42001, PCI-DSS, EU AI Act, HIPAAL2+
CapabilityHSM-bound keys, Offline-capable, Multi-agent orchestratorL2+

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.

DAPPENDIXinformative

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.

EAPPENDIXnormative

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.

FAPPENDIXinformative

ATP/1 (historical, deprecated)

ℹ
Deprecated. ATP/1 is deprecated in favour of ARIA AP (§8). This appendix keeps the ATP/1 text of the edition of 7 September 2026, where it was §8, as history: it binds no implementation, and its cross-references are to that edition. The _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 ▾
ARIA gives agents a passport. ATP/1 was customs.

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.

ℹ
Two TXT records, never the same one. _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.

FieldRequiredDescription
purposeMUSTHuman-readable statement of operational purpose
action_requestedMUSTARIA scope, three segments (e.g. commerce:order:read)
principal_refMUSTDID of the principal (did:aria:…:org). MUST NOT be a name (ATP-13, COM-09).
target_resourceSHOULDSpecific resource or endpoint the agent intends to access
dataUsageSHOULDW3C DPV purpose categories (dpv:TransactionManagement, etc.)
retentionSHOULDMaximum data retention duration (ISO 8601, e.g. P90D)
constraintsMAYSelf-declared operational constraints
session_idMAYUnique 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”.

_aria-policy.bank.com — Agent Trust Policy
v=ATP1; min=L2; enforce=strict; req=commerce:order:*,finance:invoice:read; deny=identity:principal:*; intent=purpose,principal_ref; depth=3; fresh=300s; rua=https://bank.com/atp-reports
Agent Trust Policy parameters · normative, informative and reserved · defaults · show tableshow ▾
ParameterClassDefaultSemantics
vnormative—Version. Mandatory, first. Always ATP1.
minnormativeL0Minimum level, derived from the evidence, never read from a label. L0 < L1 < L2 < L3.
reqnormativeemptyRequired scopes, AND semantics. Three segments, colon-separated; wildcard only in the last (commerce:order:*).
freshnormative3600sMaximum age of the AID status evidence at decision time and during the session. Floor 60s (COM-05); lower values are a configuration error.
enforcenormativestrictmonitor (evaluate, log, admit all) · warn (admit, add warning) · strict (deny). Mandatory in a published record; absent in configuration = strict.
denynormativeemptyProhibited scopes. Any intersection with the agent effective set denies.
intentnormativeemptyFields the signed Intent Declaration must carry. principal_ref is a DID, never a name.
depthnormativeunlimitedMaximum delegation depth: credentialSubject.delegationDepth ≤ depth.
ruainformative—URI for aggregate evaluation reports (DMARC rua= pattern). Does not affect admission.
rateinformative—Declared call limit. Not evaluated: rate enforcement is receiver infrastructure, outside admission.
qualifyreserved—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.

LayerWhenCostSource
Local SDKEvery callNo networkCredential and scopes cached by hash; both signature halves verified in-process
FreshnessWhen the status evidence is older than fresh=One cacheable requestThe issuing registry’s Status List (COM-05)
ReaffirmationCold start, dispute, audit, a receiver’s own spot-checkOne request, outside the admission pathA TrustLayer Foundation API returning signed, dated answers
Central reaffirmation MUST NOT sit in the admission path (ATP-09). A default SDK resolver does not call it during evaluation. Concentrating per-call queries on the authority would create a single point of failure for the ecosystem and the most sensitive metadata log in it — who asks about whom, the phone-home the W3C credential model warns against. Its query log stays small and justifiable: disputes and audit, not traffic. Freshness is answered by the issuing registry’s aggregate list, which does not identify the agent being checked.

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.

⚠
[PLANNED]Wire binding for the presentation. The ATP/1 presentation binding was never published. ARIA AP’s transport, a request signed with the holder key under RFC 9421 with a receiver’s challenge, is decided and replaces it (/protocol). Do not invent a header and treat a bare AID as an authenticated presentation — an AID is a public document.

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.

#CheckWhat it establishesCode on failure
1ConfigurationThe configured policy parses, implements every parameter it carries and every critical one it was sent.configuration error, not a per-call code
2PresentationThe presentation is authenticated and fresh: the caller proves possession of the holder key now.ATP-401 / SIG
3AudienceThe presentation names this receiver. One built for someone else cannot be replayed here.ATP-421
4AID integrityBoth halves of the composite countersignature verify and the schema conforms.ATP-401 / SIG · MALFORMED
5ValidityNow falls between validFrom and validUntil.ATP-401 / EXPIRED
6Status · networkThe 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
7LevelThe level derived from the evidence meets min=. A level label inconsistent with its own facts is malformed, not insufficient.ATP-403
8ScopesThe effective scope set covers every req= and intersects no deny=.ATP-406
9DelegationThe signed delegationDepth is within depth=.ATP-462
10IntentThe signed Intent Declaration carries every field intent= requires, and principal_ref is a DID.ATP-451
11AdmitBound to this audience and this DID, opening a session.ATP-200
Enforcement does not change what is checked. All eleven steps run and the result is recorded in every mode. In 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 ▾
CodeNameMeaningreason
ATP-200AdmittedAll policy checks passedADMIT · in monitor/warn: ADMIT-FLAGGED(<code that would have denied>)
ATP-401Credential invalidSignature fails, malformed, or expiredSIG · MALFORMED · EXPIRED
ATP-410Credential revoked or suspendedStatus evidence shows the credential is not activeREVOKED · SUSPENDED(<reason>)
ATP-412Status evidence staleStatus evidence older than fresh and not renewableSTALE
ATP-421Audience mismatchPresentation not bound to this receiverAUDIENCE
ATP-403Trust insufficientEvidence-derived level below policy minimumLEVEL
ATP-406Scope mismatchMissing a required scope or carries a denied oneSCOPE-MISSING · SCOPE-DENIED
ATP-451Intent incompleteIntent Declaration missing or malformedINTENT-MISSING(<field>) · INTENT-MALFORMED
ATP-462Delegation too deepdelegationDepth exceeds policy depthDEPTH
ATP-429Rate limitedEmitted by receiver infrastructure, outside the algorithm (rate is informative)—
ATP-460Qualifier missingReserved: qualify= is not part of ATP/1—

Enforcement modes — graduated adoption, the pattern DMARC established:

ModeBehaviorUse
monitorLog everything. Admit all agents. Non-compliant agents flagged but not blocked.First deployment. Turn on the lights.
warnAdmit all agents. Non-compliant agents receive warning header + logged.Transition phase. Training wheels.
strictReject non-compliant agents. ATP error response. No access.Full enforcement. Default when enforce= is absent in configuration.
⚠
[PLANNED]ATP/1 standalone document: withdrawn. ATP/1 is deprecated, and ARIA AP’s reference is its API contract, explained at /protocol.
TrustLayer Foundation A.C. · aria.bar · trustlayer.foundation
Apache 2.0 (code) + CC-BY-4.0 (documentation) · Copyright 2026 TrustLayer Foundation A.C.