| Internet-Draft | AIID Runtime Control Status | November 2026 |
| Sogomonian | Expires 19 May 2027 | [Page] |
Autonomous software agents increasingly take consequential actions on behalf of people and organizations. Existing identity systems (OAuth 2.0, SPIFFE, and the WIMSE workload identity architecture) authenticate such agents, but they do not define a common, vendor-neutral way for an accountable owner to place a running agent into a restricted state, nor a common way for a relying party to check that state immediately before acting.¶
This document defines AIID: a durable identifier for an autonomous agent, a small runtime control state machine (active, safe_mode, suspended, revoked), an asymmetric authority model in which automated monitors may only tighten state and only the accountable owner may loosen it, a namespace-wide freeze, and a pre-action status check with fail-closed semantics. AIID is designed to bind to, not replace, existing identity: it defines an "aiid" claim for OAuth 2.0 access tokens and corresponding token introspection members, bindings for SPIFFE and WIMSE identifiers, a mapping onto the OAuth Token Status List, and change notification using the OpenID Shared Signals Framework. It also defines compact signed action receipts, and an OPTIONAL enforcement gateway deployment profile.¶
This note is to be removed before publishing as an RFC.¶
This document reframes earlier individual work by the author ([I-D.sogomonian-aiip-aiid], [I-D.sogomonian-aiip-core], [I-D.sogomonian-aiid-namespace]) around the identity and control-status component alone. The dedicated access network described in that earlier work is retained only as an OPTIONAL deployment profile (Section 12); it is not a precondition for implementing this specification. Discussion of a suitable venue (for example the WIMSE or OAuth Working Groups, or a dispatch venue) is invited.¶
This Internet-Draft is submitted in full conformance with the provisions of BCP 78 and BCP 79.¶
Internet-Drafts are working documents of the Internet Engineering Task Force (IETF). Note that other groups may also distribute working documents as Internet-Drafts. The list of current Internet-Drafts is at https://datatracker.ietf.org/drafts/current/.¶
Internet-Drafts are draft documents valid for a maximum of six months and may be updated, replaced, or obsoleted by other documents at any time. It is inappropriate to use Internet-Drafts as reference material or to cite them other than as "work in progress."¶
This Internet-Draft will expire on 19 May 2027.¶
Copyright (c) 2026 IETF Trust and the persons identified as the document authors. All rights reserved.¶
This document is subject to BCP 78 and the IETF Trust's Legal Provisions Relating to IETF Documents (https://trustee.ietf.org/license-info) in effect on the date of publication of this document. Please review these documents carefully, as they describe your rights and restrictions with respect to this document. Code Components extracted from this document must include Revised BSD License text as described in Section 4.e of the Trust Legal Provisions and are provided without warranty as described in the Revised BSD License.¶
An autonomous agent is software that selects and executes actions toward a goal with limited or no per-action human approval. Such agents already call APIs, move funds, modify documents, and operate infrastructure. Security vendors have recently reported intrusion operations in which agentic penetration-testing frameworks performed most steps of an attack after a human operator set the goal: one framework (ARTEX) was reported to have been used to target more than 200 organizations in at least 14 countries [BC-ARTEX] and against financial-sector organizations [MS-ARTEX]; one analysis reported more than 1,800 publicly exposed instances of that framework in its key findings and described most observed attacks as autonomous apart from the initial goal setup [CPR-ARTEX]; and another framework (Cairn) was reported to have conducted 25 operations against at least 19 organizations, confirming unauthorized access or data retrieval at 10 [UNIT42-CAIRN]. In such incidents defenders typically see network addresses and stolen credentials, not a durable identity of the acting agent or of the party accountable for it. Whether an agent is misused, compromised, or simply malfunctioning, the operational question is the same: can the party accountable for the agent stop it quickly, everywhere it acts, and keep it stopped until a human decides otherwise?¶
Today the answer depends on the vendor. A platform can disable an API key, revoke an OAuth grant, or delete a workload, but each mechanism is local to one system, is usually coarse (all-or- nothing), and is often reversible by the same automation that triggered it. There is no common vocabulary that a relying party (an API, a payment service, a cloud control plane, another agent) can consult to learn "this agent is currently restricted" before it executes a request.¶
This document specifies AIID, which provides:¶
AIID does not define a transport, a new authentication protocol, an authorization policy language, a payment system, or rules about which models may be built or run. It does not assess whether an agent is behaving well; that is the role of external Monitors, whose detection methods are out of scope.¶
This section is informative. AIID builds on a mature body of work on credentials, workload identity, and security signalling, and composes with it rather than replacing it. The mechanisms below each solve a well-defined problem; the gaps identified are gaps relative to the specific problem of governing an autonomous agent at runtime, not deficiencies of those mechanisms for their intended purposes.¶
Taken together, these mechanisms authenticate agents, constrain their credentials, and propagate signals. For runtime governance of an autonomous agent as an accountable principal, six capabilities are not specified by them, and AIID addresses each:¶
Columns: OA, OAuth token revocation and introspection; JA, JWT access tokens and token exchange; SW, SPIFFE and WIMSE; SS, Shared Signals and CAEP; SL, Token Status List. Entries: "-", outside that mechanism's scope; "reuses", AIID relies on the existing mechanisms; "TD", within one trust domain only; "bin", binary active or inactive; "evt", conveyed as events; "tok", per token.¶
| Capability | OA | JA | SW | SS | SL | AIID |
|---|---|---|---|---|---|---|
| Authenticate agent | yes | yes | yes | - | - | reuses |
| Durable agent ID across issuers | - | - | TD | - | - | yes |
| Accountable Owner | - | - | - | - | - | yes |
| Graded states | bin | - | - | evt | tok | yes |
| Who may tighten or loosen | - | - | - | - | - | yes |
| One status for all bindings | - | - | - | - | - | yes |
| Push of changes | - | - | - | yes | - | reuses |
| Signed action receipts | - | - | - | - | - | yes |
AIID is therefore a layer above these mechanisms: agents continue to authenticate with OAuth, SPIFFE, or WIMSE credentials; status is distributed with Resolve, the Token Status List, and Shared Signals; and revocation and introspection remain the tools for individual tokens (Section 8).¶
The key words "MUST", "MUST NOT", "REQUIRED", "SHALL", "SHALL NOT", "SHOULD", "SHOULD NOT", "RECOMMENDED", "NOT RECOMMENDED", "MAY", and "OPTIONAL" in this document are to be interpreted as described in BCP 14 [RFC2119] [RFC8174] when, and only when, they appear in all capitals, as shown here.¶
JSON [RFC8259] examples are illustrative. Times in examples use NumericDate values as in [RFC7519].¶
Accountable Owner Monitor
(any change; sole release) (active -> safe_mode only)
| |
+-------------+ +-------------+
| |
v v set-state (CAS, logged)
+---------------------------------------------------+
| AIID Registry |
| AIID -> state, version, bindings; scope freezes |
+---------------------------------------------------+
| | |
| Resolve | Status List | SSF/CAEP
| (pull, signed, | (bulk, cached) | (push,
| TTL-bound) | | tighten only)
v v v
+---------------------------------------------------+
| Relying Party / Enforcement Point |
| authenticate agent (OAuth, SPIFFE, WIMSE, ...) |
| map credential -> AIID and freeze scopes |
| enforce effective state; emit signed receipt |
+---------------------------------------------------+
^
| request
|
Agent
The agent authenticates to the RP with whatever mechanism the RP already supports. The RP determines the agent's AIID from that credential (Section 8), obtains the effective state by Resolve, Status List, or pushed events, and refuses consequential actions unless the effective state is active. The Registry is the single source of truth for state; Owners and Monitors change state only through the Registry.¶
An AIID is a URI [RFC3986] with the following syntax, expressed in ABNF [RFC5234]:¶
aiid-uri = "aiid://" namespace "/" local-id
namespace = label *( "." label ) ; DNS name, see below
label = ( ALPHA / DIGIT )
[ *61( ALPHA / DIGIT / "-" ) ( ALPHA / DIGIT ) ]
local-id = segment *( "/" segment )
segment = nodot *seg-char ; not "." or ".."
/ "." nodot *seg-char
/ ".." 1*seg-char
seg-char = nodot / "."
nodot = ALPHA / DIGIT / "-" / "_" / "~"
¶
ALPHA and DIGIT are core rules of [RFC5234] (Appendix B.1). ABNF quoted strings and the ALPHA rule are case-insensitive. The following prose rules therefore apply in addition to the grammar. The scheme name "aiid" SHOULD be generated in lowercase and MUST be compared case-insensitively, as for all URI schemes [RFC3986]. Namespace labels MUST be generated in lowercase (ALPHA restricted to %x61-7A); a receiver MUST lowercase the namespace before comparison. A label is 1 to 63 characters: a single letter or digit is a valid label (the bracketed part of the rule is optional), and a label of two or more characters neither begins nor ends with "-". The namespace is a DNS domain name under the administrative control of the Registry operator. The local-id is assigned by the Registry and is case-sensitive. A segment is never "." or "..": those are dot-segments, which URI normalization removes (Section 5.2.4 of [RFC3986]), so they would change the identifier. The grammar excludes them: a segment consisting of "." alone or ".." alone is invalid, while segments such as "...", "..a", or ".a" are permitted. The total length of an AIID MUST NOT exceed 255 octets. Example:¶
aiid://agents.example.com/finance/invoice-bot-7¶
Two AIIDs are equal if and only if they are identical octet strings after lowercasing the scheme and the namespace. No other normalization is performed.¶
An AIID names an agent as an accountable principal, not an instance, host, model version, or key. The following requirements apply:¶
For each AIID the Registry maintains at least:¶
The following states are defined. They are listed in increasing order of severity.¶
An RP that receives a state value it does not recognize MUST treat it as suspended, unless the RP recognizes and applies a stricter state (registered or local); in no case may it treat an unrecognized state as active or safe_mode. States registered in future (Section 16.1) with a severity rank above that of suspended are, at RPs that do not recognize them, handled the same way as unrecognized states.¶
| From | To | Owner | Monitor (note) |
|---|---|---|---|
| active | safe_mode | yes | yes (a) |
| active | suspended | yes | no |
| active | revoked | yes | no |
| safe_mode | active | yes | no |
| safe_mode | suspended | yes | no |
| safe_mode | revoked | yes | no |
| suspended | active | yes | no |
| suspended | revoked | yes | no |
| revoked | (none) | no | no |
Note (a): only for AIIDs or scopes within the Monitor's enrolled scope, and only while the Monitor's enrollment is enabled (Section 5.3).¶
The transition suspended to safe_mode is not permitted, because it would loosen the restriction without an explicit return to active. Returning an agent to service is always expressed as setting active; there is no separate "clear" operation. A Registry MUST reject any transition not listed in Table 2.¶
The Registry exposes a state change endpoint (advertised in metadata, Section 7.1). Requests are HTTP POST with a JSON body and are authorized with an OAuth 2.0 access token [RFC6749] whose scope includes "aiid:owner" or "aiid:monitor". The body contains:¶
The reason field SHOULD NOT contain personal data; requesters SHOULD use incident or ticket references instead. Registries MUST NOT disclose reason text to RPs.¶
The Registry MUST apply the change only if expected_version equals the stored version (compare and set). Otherwise it MUST reject the request with HTTP status 409 and the current state and version. This prevents a stale set-active from overwriting a newer Monitor action, and the reverse. Each accepted change increments the version by one; versions never decrease.¶
The Registry MUST log every transition, whether accepted or rejected, with a timestamp [RFC3339], the requesting principal and role, the from-state and to-state, the target, and the reason. Logs SHOULD be append-only and retained per the Owner's audit policy. Monitors SHOULD be rate limited per target and per scope.¶
A scope freeze applies a restrictive state to a set of agents at once. It allows an operator to contain an incident before individual AIIDs have been identified, and it applies to agents that have not yet been issued an AIID.¶
A freeze scope has a type, which determines which credentials it matches, and a scope URI whose syntax depends on the type. This document defines the following types:¶
Scope URIs have the following syntax (ABNF [RFC5234]; "namespace" is defined in Section 4.1):¶
scope-uri = ns-scope / spiffe-scope / wimse-scope / oauth-scope ns-scope = "aiid://" namespace ; no path spiffe-scope = "spiffe://" trust-domain ; no path wimse-scope = "wimse://" trust-domain ; no path trust-domain = namespace oauth-scope = issuer "#client_id=" client-id-enc issuer = "https://" authority path-abempty ; RFC 3986 client-id-enc = 1*( unreserved / pct-encoded ) ; RFC 3986¶
The rules "unreserved" and "pct-encoded" are imported from [RFC3986] (Section 2), and "authority" and "path-abempty" from [RFC3986] (Section 3). The issuer rule thus admits an HTTPS URL with no query or fragment, which is the form of an authorization server issuer identifier [RFC8414]. For oauth-scope, the client_id is percent-encoded [RFC3986], and the issuer is the authorization server's issuer identifier [RFC8414], which has no fragment, so the fragment unambiguously carries the client_id. Example scope URIs: "aiid://agents.example.com", "spiffe://prod.example.com", and "https://as.example.com#client_id=invoice-bot".¶
A Registry lists the deployment scopes (all types other than aiid_namespace) for which it is authoritative in its metadata (Section 7.1), each with its type and scope URI. A Registry MUST NOT list a deployment scope unless the operator of that scope (the SPIFFE or WIMSE trust domain authority, or the authorization server for an oauth_client scope) has authorized it to do so. Each deployment scope SHOULD be listed by exactly one Registry; where the Registry is also the issuer of the scope's credentials it MUST be the only one. An RP MUST be configured with which Registry or Registries are authoritative for each deployment scope it relies on. If an RP is nevertheless configured with more than one Registry for the same credential, it MUST apply the most severe applicable freeze. Precedence across Registries is an open question (Appendix C).¶
Each freeze scope has a Scope Owner: the principal that holds the owner role for the scope at the Registry. For an aiid_namespace scope, the Scope Owner is the Registry operator's owner role for that namespace (or, for a sub-namespace delegated within the same Registry, the owner role for that sub-namespace). For a deployment scope, the Scope Owner is the scope operator that authorized the listing (Section 6.1), or a delegate it designates at the Registry.¶
A scope freeze has a state of active (not frozen), safe_mode, or suspended, and a scope_version. revoked cannot be applied by scope. Changes use the state change endpoint of Section 5.4 with the "scope" member set to the scope URI and "expected_version" set to the current scope_version, under the same compare-and-set and logging rules. The asymmetric rule applies unchanged: a Monitor MAY move a scope from active to safe_mode, and only if the scope is within its enrolled scope; only the Scope Owner MAY set suspended or lift a freeze by setting the scope to active. Each accepted change increments scope_version by one. The allowed scope transitions mirror those for AIIDs (Table 2), without revoked:¶
| From | To | Scope Owner | Monitor (note) |
|---|---|---|---|
| active | safe_mode | yes | yes (a) |
| active | suspended | yes | no |
| safe_mode | active | yes | no |
| safe_mode | suspended | yes | no |
| suspended | active | yes | no |
| any | revoked | n/a | n/a |
Note (a) of Table 2 applies. A scope cannot be revoked: revocation applies only to individual AIIDs. As for AIIDs, the transition suspended to safe_mode is not permitted for a scope, and a Registry MUST reject any scope transition not listed in Table 3.¶
The effective state of an agent is the most severe of its own AIID state (if it has one) and the state of every scope that matches the presented credential. Lifting a scope freeze does not change any per-AIID state.¶
An aiid_namespace scope matches sub-namespaces, which may be served by a different Registry (for example "aiid://example.com" and "aiid://agents.example.com"). A Registry whose namespace is a sub-namespace of another Registry's namespace lists the ancestor namespaces it recognizes in the "parent_namespaces" metadata member (Section 7.1). Such a child Registry:¶
An RP MAY additionally query ancestor Registries directly. An ancestor Registry has no authority over a sub-namespace that does not list it in parent_namespaces; RPs that wish to honor such ancestors do so by local configuration.¶
Scope freezes reach RPs by the same three channels as per-AIID state:¶
To map a credential to scopes, the RP extracts the credential's identifiers (trust domain of the SPIFFE ID or workload identifier; issuer and client_id of an access token; namespace of any AIID claim) and matches them against the scopes listed in the metadata of the Registries it is configured to trust. An RP MAY perform this matching locally and then use Status List or Shared Signals for the matching scopes, or it MAY delegate the matching to the Registry by using Resolve by binding.¶
A Registry publishes a JSON metadata document at the well-known URI [RFC8615] "/.well-known/aiid-configuration" on the namespace host, for example "https://agents.example.com/.well-known/aiid-configuration". Members include:¶
RPs MUST ignore metadata members they do not understand. Additional members are registered in the "AIID Registry Metadata" registry (Section 16.6).¶
Resolve is the baseline mechanism and every Registry MUST support it. Status List and Shared Signals are optional optimizations; when a Registry does not advertise status_list_uri or ssf_configuration, or when the RP does not implement them, the RP uses Resolve.¶
Resolve returns the current effective state for one agent. The request is an HTTPS GET to resolve_endpoint with exactly one of the following query parameters:¶
The Registry MAY require RP authentication. A successful response (HTTP 200) is a JWT [RFC7519] signed by the Registry with media type "application/aiid-status+jwt" and JOSE header "typ" value "aiid-status+jwt". Claims:¶
The Registry signs status tokens with "alg" "Ed25519" [RFC9864], which RPs MUST support; "Ed448" MAY also be used. An RP MUST verify that "iss" equals the "issuer" member of the metadata of the Registry it queried (or, for a stapled token, of the Registry authoritative for the AIID's namespace or the scope) and that the signing key is in that Registry's JWKS. Signing the response allows RPs to cache, relay, and audit it, and allows an agent to staple a fresh status token to a request; an RP that accepts a stapled token MUST verify its signature, "sub", and "exp", and apply the version rule of Section 9.3.¶
Error responses use a JSON body with an "error" member:¶
| HTTP | error | Meaning and RP handling |
|---|---|---|
| 200 | (none) | Status token; enforce aiid_effective_state. |
| 400 | invalid_request | Malformed query; treat as unavailable. |
| 401, 403 | unauthorized | RP not authorized to query; treat as unavailable. |
| 404 | unknown_aiid | The namespace exists but the AIID was never issued. Non-active: refuse. |
| 404 | no_binding | Binding query matched no AIID and no freeze scope. Handle as "No AIID" (Section 9.2). A binding that matches only a freeze scope returns 200, not 404. |
| 429, 5xx | (any) | Registry unavailable; see Section 7.3. |
An AIID that is unknown to its Registry MUST be treated as non-active. A Registry MUST NOT return no_binding for a binding that matches a listed freeze scope; instead it returns 200 with "aiid" absent and the effective state of the matching scopes (active if none of them is frozen). Network failures and timeouts are treated as unavailable.¶
The worst-case delay between a state change at the Registry and its enforcement at an RP that relies on pull is the status token lifetime. max_status_ttl SHOULD be no more than 60 seconds for agents that can take consequential actions.¶
This value is a trade-off. A shorter lifetime makes a freeze take effect sooner but increases Registry load and increases the number of consequential actions refused during a Registry outage, because fail-closed RPs exhaust their cached results sooner. A longer lifetime improves availability but lets a frozen agent continue for longer. Registries MAY advertise a larger max_status_ttl for deployments whose consequential actions are low in impact, and RPs MAY apply a shorter local limit for high-impact actions. Stapling and Shared Signals reduce load and latency respectively without changing the bound.¶
An RP distinguishes three cases:¶
Push notification (Section 8.6) can reduce latency below the token lifetime; an RP that receives a restrictive change event MUST discard any cached result for that AIID or scope that is less restrictive. A pushed event MUST NOT be used to loosen state; loosening takes effect only after a successful Resolve or Status List fetch. A pushed event is reconciled with the status token the RP holds by the rules of Section 9.3: an event with a lower version than the token is ignored as stale or replayed; an event with a higher version and an equally or more severe state replaces the token's state for that component and is held until a result at the event's version or later arrives; and an event with a higher version and a less severe state does not change the record, but prompts the RP to obtain a fresh result.¶
An RP needs to determine which AIID, if any, a presented credential belongs to. The mechanisms below are alternatives; a deployment uses those that match the credentials it already accepts. In every case the binding MUST be asserted by a party trusted by the RP (the authorization server, the trust domain authority, or the Registry), never solely by the agent.¶
An authorization server that issues JWT access tokens [RFC9068] to an agent SHOULD include the claim "aiid" whose value is the agent's AIID. When an agent acts on behalf of a user, the token "sub" identifies the user as usual and "aiid" identifies the acting agent; where token exchange [RFC8693] is used, the AIID MAY also appear as the "sub" of the "act" claim. The access token MUST NOT be treated as evidence of current state: tokens are long-lived relative to a freeze, and state is obtained separately.¶
Issuance and refresh: an authorization server MUST check the effective state before issuing or refreshing a token for an AIID. If the effective state is suspended or revoked, the request MUST fail. If it is safe_mode, the request MUST fail unless the resulting token is limited to scopes covering only the diagnostic allow-list.¶
Tokens already issued remain valid until they expire unless revoked. An authorization server SHOULD revoke outstanding tokens and refresh tokens for an AIID that becomes suspended or revoked (see [RFC7009]), and deployments SHOULD use short access token lifetimes. Neither measure replaces the pre-action check of Section 9, which is what bounds the delay to max_status_ttl regardless of token lifetime.¶
An authorization server supporting introspection [RFC7662] SHOULD include the members "aiid", "aiid_effective_state", and "aiid_state_version" in the introspection response for tokens bound to an AIID, and MAY include "aiid_state" (informational). The values reflect the authorization server's most recent status result, which MUST be unexpired.¶
So that RPs unaware of AIID do not fail open, the authorization server MUST return "active": true for an AIID-bound token only if it holds an unexpired status result and the effective state is active, and such a response MUST include "aiid_effective_state". In every other case, including safe_mode, suspended, revoked, an unrecognized state, and the absence of an unexpired status result (for example because the Registry is unreachable), it MUST return "active": false. It MAY include "aiid_effective_state" in an "active": false response to aid diagnosis.¶
Introspection has no safe_mode exception, so that the authorization server does not need to evaluate a Registry's diagnostic allow-list and the property above holds without conditions. The diagnostic allow-list still governs what an agent in safe_mode may do at RPs and gateways that apply AIID state themselves (Section 9), for example with JWT access tokens validated locally; an RP that relies only on introspection treats an agent in safe_mode as inactive.¶
An RP MUST refuse consequential actions when: "aiid_effective_state" is present and not "active"; or "aiid" is present and "aiid_effective_state" is absent. If the response contains neither member, the RP has learned nothing about AIID state from introspection and proceeds as in Section 9.2 (for example by Resolve by binding with the token's issuer and client_id).¶
A SPIFFE ID [SPIFFE-ID] identifies a workload within a trust domain. A Registry MAY record one or more SPIFFE IDs as bindings of an AIID, and Resolve MAY be queried by SPIFFE ID using the query parameter "binding". An RP that authenticates an agent with an X.509-SVID or JWT-SVID determines the AIID by this binding. A SPIFFE trust domain MAY be listed as a freeze scope (Section 6). OAuth clients authenticating with SVIDs [I-D.ietf-oauth-spiffe-client-auth] receive tokens carrying "aiid" as in Section 8.1.¶
The WIMSE architecture [I-D.ietf-wimse-arch] defines workload identifiers [I-D.ietf-wimse-identifier] and workload credentials [I-D.ietf-wimse-workload-creds]. An AIID Registry MAY bind workload identifiers to an AIID, a WIMSE workload credential MAY carry the "aiid" claim, and a WIMSE trust domain MAY be a freeze scope.¶
AIMS [I-D.ietf-wimse-aims] applies WIMSE and OAuth to AI agents. It makes the WIMSE identifier the agent identifier and leaves the registry in which identifiers are allocated out of scope (its Section 6); it describes deprovisioning by stopping credential renewal and signalling status changes (its Section 8); and it calls for remediation on receipt of Shared Signals events and for tamper-evident audit logs (its Section 11). It does not define: (1) a common set of runtime control states, including a reversible containment state short of deprovisioning; (2) a rule separating the principals that may restrict an agent from those that may release it; or (3) a registry interface that an RP in another trust domain queries before acting, with a bounded freshness and a fail-closed rule. AIID specifies these three items and is intended to be used alongside AIMS, with the agent's WIMSE identifier recorded as a binding of its AIID.¶
This binding is OPTIONAL, and it and its IANA registrations (Section 16.7) are the only parts of this document that depend on [I-D.ietf-oauth-status-list], which is not yet an RFC.¶
For RPs that process high request volumes, a Registry MAY publish effective states as a Token Status List [I-D.ietf-oauth-status-list] with "bits" equal to 2. Each entry encodes the effective state of the credential it indexes, as follows:¶
| Effective state | Status Type value | TSL name |
|---|---|---|
| active | 0x00 | VALID |
| revoked | 0x01 | INVALID |
| suspended | 0x02 | SUSPENDED |
| safe_mode | 0x03 | APPLICATION_SPECIFIC |
Because 0x03 is reserved by the Token Status List for application-specific use, an RP has to establish that a list is an AIID list before interpreting its bits. To make this possible:¶
A future revision may request a dedicated Status Type value for safe_mode in the "OAuth Status Types" registry (Specification Required; Section 14.5 of [I-D.ietf-oauth-status-list]), which would remove the need for the distinct reference member.¶
A Registry can reflect a scope freeze only in entries it controls: entries for credentials it issued, or for which the credential issuer has provided it with index mappings. For an aiid_namespace scope this is every entry in its list. For a deployment scope whose credentials are issued by another party (for example access tokens of a third-party authorization server in an oauth_client scope), the Status List is not sufficient: unless the RP knows that the Registry holds index mappings for that issuer, the RP MUST also apply matching deployment-scope freezes obtained through Resolve by binding or Shared Signals (Section 6.4).¶
The status list token's time-to-live MUST NOT exceed max_status_ttl. If the referenced index is outside the list, or the list cannot be fetched or verified and no unexpired copy is held, the RP MUST treat the credential as non-active. An RP that does not implement Status List, or a Registry that does not publish one, uses Resolve (Section 7.1).¶
A Registry MAY act as a Transmitter in the OpenID Shared Signals Framework [OpenID.SSF], delivering Security Event Tokens [RFC8417] by push [RFC8935] or poll [RFC8936]. The subject is identified with the "uri" format of [RFC9493] whose value is the AIID or the freeze scope URI. State changes are conveyed with the CAEP [OpenID.CAEP] "token-claims-change" event whose "claims" member contains, for an AIID subject, "aiid_state", "aiid_state_version", and "aiid_effective_state", and, for a scope subject, "aiid_scope_state" and "aiid_scope_version". Transitions to revoked SHOULD additionally be conveyed with the CAEP "session-revoked" event for receivers that do not process AIID claims. As stated in Section 7.3, a received event can only tighten state at the receiver, and only if it is not stale: an event whose version is lower than the one recorded is ignored under the version rule of Section 9.3, even when it reports a more restrictive state. Shared Signals supplements, and does not replace, Resolve or Status List: an RP that has not received an event still needs an unexpired status result to act.¶
Before performing a consequential action requested by, or on behalf of, an agent, an Enforcement Point MUST:¶
An Enforcement Point distinguishes the following cases, which have different handling:¶
While adoption is partial, the "No AIID" case will be the most common one at most RPs. RPs choose a default accordingly: refusing consequential actions from agents without an AIID gives the strongest attribution (Section 11.6) at the cost of excluding unregistered agents; allowing them preserves compatibility but leaves those actions outside AIID control. The SHOULD in Section 11.1 is the means by which registration becomes a condition of access as adoption grows.¶
RPs MAY apply local policy to non-consequential actions in all three cases.¶
Two independent version counters exist. aiid_state_version is per AIID and changes only when that AIID's own state changes. scope_version is per freeze scope and changes only when that scope's state changes. A scope freeze therefore changes aiid_effective_state without changing aiid_state_version.¶
An RP keeps one record per component: one for each AIID and one for each scope. A record holds the highest version observed in a verified result, the state reported at that version, and the latest "exp" of any result that reported that version. The version and state MUST be kept at least until max_status_ttl has elapsed after that "exp", for replay protection; the state MUST NOT be used for enforcement after that "exp". If a result reports a different state for a component at the version already recorded, the record is in conflict. A conflict is sticky: the RP MUST treat the component, and every credential it applies to, as non-active until a result reports a strictly higher version for that component. A later result at the same version, even one that agrees with either recorded state, MUST NOT clear the conflict.¶
Each result also carries the Registry's own aiid_effective_state, which the RP keeps as a "floor". A floor key is a tagged tuple (iss, kind, value) of strings: kind "aiid" with the AIID as value when the result names an AIID; kind "binding" with the queried credential identifier URI as value when the result is for a binding query with no bound AIID; and kind "oauth" with the pair (client issuer, client_id) from "aiid_query" as value when the result is for an issuer and client_id query with no bound AIID. Keys MUST be compared element by element, with AIIDs compared as in Section 4.1 and other strings compared exactly; the key is therefore hashable and implementations need no further canonicalization. A new result with the same key MUST replace the previous floor for that key only if its "iat" is not earlier than that of the result that set the floor and, when both carry aiid_state_version, its version is not lower; otherwise the floor is kept. This prevents a stale but unexpired result, for example an old "active" token stapled by a compromised agent, from erasing a newer restrictive floor. A floor MUST NOT be applied after the "exp" of the result that set it. For a presented credential, floors(cred) is the set of unexpired floors whose key names, under any trusted Registry "iss": the credential's AIID; any identifier bound to the credential that the RP queried by binding (for example its SPIFFE ID or WIMSE identifier); or the credential's issuer and client_id. The floor is not a component and is never subject to the conflict rule: two results at the same component version may legitimately carry different aiid_effective_state values (because a scope changed), and the floor is then replaced according to "iat", not flagged as a conflict. In the pseudocode, bindings_queried_for(cred) returns the identifiers bound to the credential (for example its SPIFFE ID) for which the RP sent a Resolve query by binding.¶
Clock skew: the RP MUST reject any status result, stapled status token, or Status List token whose "iat" is more than a configured skew in the future (60 seconds is RECOMMENDED), and MUST limit the expiry it records for a floor to at most the time of receipt plus max_status_ttl. Otherwise a future-dated token, for example from a misconfigured Registry, could pin a floor.¶
Pushed events (Section 8.6) carry a version but no "exp". An event MAY create or advance a record only to tighten it: only when the event's version is higher than the recorded one (or no record exists), its state is not active, and its state is at least as severe as the state of any unexpired record. Such a record is held: it has no time expiry and remains in force until a verified result (Resolve, stapled token) reports a version equal to or higher than the event's, which then replaces the hold under the rules above. An event that would loosen state (including any event reporting active) MUST NOT change a record; the RP SHOULD instead obtain a fresh result. A hold has no time limit in this version: if the RP never obtains a verifying result, the agent stays restricted, which is fail closed; an RP that follows Section 9.1 refreshes expired components before acting and so normally ends a hold within max_status_ttl. Whether a hold should also time out is listed as an open question (Appendix C). An event at the recorded version that reports a different state is a conflict, as for results. Events do not set floors.¶
effective() is evaluated only after the procedure of Section 9.1 has obtained results for the credential. If the credential has no AIID and no freeze scope matches it, effective() returns NO_AIID, which is not an effective state and MUST NOT be treated as active: the RP handles it as the "No AIID" case of Section 9.2, which requires refusal under the registration-required profile (Section 11.7) and the gateway profile.¶
The RP processes results and events and computes the effective state as follows; an implementation MUST produce the same decisions:¶
on_result(r, now): # r verified: signature, iss, exp (7.2)
if r.iat > now + SKEW: reject r # SKEW: 60 s suggested
if r has aiid:
update(A[r.aiid], r.aiid_state_version, r.aiid_state, r.exp)
for e in r.aiid_freeze_scopes:
update(S[e.uri], e.scope_version, e.state, r.exp)
key = fkey(r) # hashable tuple
f = floor.get(key)
v = r.aiid_state_version # may be absent
older = f exists and (r.iat < f.iat or
(v present and f.v present and v < f.v))
if not older: # else keep newer floor
floor[key] = (r.aiid_effective_state,
min(r.exp, now + max_status_ttl), r.iat, v)
fkey(r):
if r has aiid: return (r.iss, "aiid", r.aiid)
if r has sub: return (r.iss, "binding", r.sub)
q = r.aiid_query
return (r.iss, "oauth", (q.iss, q.client_id))
update(rec, v, state, exp):
if v < rec.v: return # stale component: ignore
if v == rec.v and state != rec.state:
rec.error = true; return # conflict: sticky
if v > rec.v:
rec.v = v; rec.state = state; rec.exp = exp; rec.error = false
else: # same version, same state:
rec.exp = exp if rec.held else max(rec.exp, exp)
rec.held = false # a result ends a hold
on_event(ev, rec): # ev verified SET; rec = A[...] or S[...]
if rec exists and ev.v < rec.v: return # stale: ignore
if rec exists and ev.v == rec.v:
if ev.state != rec.state: rec.error = true # conflict: sticky
return
if ev.state == active: return # never loosens: re-Resolve
if rec exists and rec.exp > now
and severity(ev.state) < severity(rec.state): return
rec.v = ev.v; rec.state = ev.state; rec.error = false
rec.exp = INFINITY; rec.held = true # hold until a result
effective(cred, now):
parts = []
if cred has aiid: parts += [ A[cred.aiid] ]
parts += [S[u] for u in scopes_matching(cred)]
if parts is empty: return NO_AIID # never treated as active
for rec in parts:
if rec missing or rec.error or rec.exp <= now:
return NON_ACTIVE # fail closed
states = [rec.state for rec in parts]
states += [f.state for f in floors(cred) if f.exp > now]
return most_severe(states)
floors(cred):
keys = []
for i in trusted_registries:
if cred has aiid: keys += [ (i, "aiid", cred.aiid) ]
for b in bindings_queried_for(cred):
keys += [ (i, "binding", b) ]
keys += [ (i, "oauth", (cred.iss, cred.client_id)) ]
return [floor[k] for k in keys if k in floor]
¶
The floor is not a recorded component: it applies only until that result's "exp" and is replaced by the next result with the same key. It therefore cannot hold an agent in a restricted state after the Registry has reported a lift; it only guards against a component the RP has not yet recorded. Loosening happens only when every recorded component, at its newest version, is less restrictive, and no unexpired floor is more restrictive. A difference between aiid_effective_state and aiid_state at the same aiid_state_version is expected (it reflects scope freezes) and is not an error.¶
Status List entries carry no version. For Status Lists the RP MUST order list tokens separately for each pair of list URI and status mechanism ("aiid_status_list" or "status_list") by "iat", and MUST NOT accept a list token whose "iat" is older than one already accepted for the same pair. A Status List value can loosen state only relative to an older list token for the same pair. Where a credential carries both references, an AIID-aware RP uses only the "aiid_status_list" value (Section 8.5). When the RP also holds an unexpired versioned result (Resolve, stapled token, or event) for the same agent, it applies the more severe of the two; a list value never overrides a versioned result toward a less restrictive state, and a versioned result never overrides a list value toward a less restrictive state, with one exception.¶
Exception for an unvalidatable "aiid_status_list" reference (Section 8.5): such a failure concerns the list mechanism for that credential, not the agent. The RP MUST record the time T_fail at which it detected the failure. It MAY then obtain a Resolve result for the credential whose "iat" is not earlier than T_fail; that result's state governs in place of the list-derived non-active state until the earlier of the result's "exp" and the moment the RP accepts a newer list token for that reference, after which list processing resumes. A result whose "iat" is earlier than T_fail MUST NOT be used for this purpose.¶
Combined with the expiry check, these rules prevent an attacker from replaying an older "active" result after a freeze. A worked example appears in Appendix A.7.¶
An RP that refuses an action because of AIID state SHOULD return an error that identifies the reason (for HTTP APIs, status 403 with an error code "aiid_restricted" and the effective state) so that the agent's operator can diagnose the refusal. The response MUST NOT reveal the reason text recorded by the Monitor or Owner.¶
An agent framework that is aware of AIID SHOULD also check its own effective state before initiating actions, and stop initiating consequential actions in safe_mode. Self-checking is a courtesy that reduces wasted work; it is not a substitute for enforcement by RPs, since a compromised agent will not check.¶
Receipts give the Owner, auditors, and RPs verifiable evidence of which agent performed which action under which state. They are OPTIONAL to implement.¶
Receipts and grants are optional features. The requirements in this section apply only to implementations that produce or verify them.¶
A receipt is a JWS [RFC7515] in Compact Serialization, with JOSE header "typ" value "aiid-receipt+jwt", signed by the Enforcement Point (or the gateway of Section 12). Implementations that produce or verify receipts MUST support the fully specified "alg" value "Ed25519" [RFC9864] and MAY support "Ed448" and other algorithms per [RFC8725]. The polymorphic "EdDSA" identifier, deprecated by [RFC9864], SHOULD NOT be used. Keys are represented as OKP JWKs [RFC8037]. The payload is a JWT claims set with:¶
The claims action, target, req_hash, res_hash, outcome, grant_jti, and owner are defined only within JWTs whose "typ" is "aiid-receipt+jwt" and are not registered in the JSON Web Token Claims registry. Verifiers MUST reject a receipt whose JOSE header "typ" is not exactly "aiid-receipt+jwt", and MUST NOT interpret these claims in any other JWT (explicit typing, Section 3.11 of [RFC8725]). Claims prefixed "aiid_" are registered (Section 16.3).¶
Refusals caused by AIID state SHOULD also produce receipts, so that the Owner can see what a restricted agent attempted. A receipt is evidence of what the signer asserts it did; it is not proof that the action had any particular effect.¶
A grant is a signed delegation from a principal permitting an agent to perform a named action at a named RP. When used with AIID, a grant is a JWS in Compact Serialization with "typ" "aiid-grant+jwt" (media type "application/aiid-grant+jwt") and "alg" "Ed25519" (or optionally "Ed448") [RFC9864], signed with a key published for the issuing principal's AIID, containing at least: "iss" (issuing principal AIID), "sub" (authorized agent AIID), "aud" (the RP or executor), "action", "exp", and "jti". As for receipts, the "action" claim is scoped to this "typ", and verifiers MUST reject a grant whose "typ" is not exactly "aiid-grant+jwt". This profile is a JWT-claim-aligned form of the grant format in [I-D.sogomonian-aiip-core] (informative background only). An Enforcement Point relying on a grant MUST verify the signature, check "exp", match "sub", "aud", and "action" to the request, and check that both the issuing principal and the agent are active. Deployments already using OAuth scopes or rich authorization requests need not use grants.¶
The mechanisms in the preceding sections also produce a record of which agent did what, under whose accountability. This section states how deployments use them for attribution and incident reconstruction, and the limits of that use.¶
Attribution depends on agents being registered. An RP cannot compel an agent's operator to register, but it can decline to act for an agent that is not registered. Accordingly:¶
Three records together support attribution:¶
Receipts and transition logs are only useful after an incident if they still exist and have not been altered. Signers SHOULD store receipts in append-only storage with a retention period set by policy and applicable law. Deployments MAY additionally register receipts or receipt digests with a transparency service, for example one following the SCITT architecture [RFC9943], so that later removal or modification is detectable by third parties. Registries SHOULD protect transition logs in the same way. Because receipts are signed, they remain verifiable when copied out of the signer's systems for investigation.¶
After an incident, an investigator with access to the relevant records can establish:¶
A credential that is bound to an AIID but was stolen by a third party will attribute actions to the legitimate agent. Receipts therefore establish which identity acted, not which person controlled it; investigators need to correlate them with other evidence. The Owner's prompt use of safe_mode or suspended after a suspected theft limits further misuse and is itself recorded.¶
An RP that has observed harmful activity by an agent may need to ask the agent's Registry about it. A Registry MAY offer an authenticated incident query interface through which an RP presents receipts or log entries it holds and receives the Owner contact and the relevant transition history. Such interfaces MUST require authentication of the requester, SHOULD require the requester to present evidence of its own involvement (for example, a receipt it signed), MUST disclose only records about the AIIDs concerned, and MUST be logged. Disclosure of personal data is subject to applicable law and to Section 15. Registries MAY notify the Owner of each query. A Monitor or RP that observes harmful activity MAY also request safe_mode through its enrolled Monitor role, where it has one.¶
Operators of malicious agents will not register them voluntarily. AIID does not detect or name such agents. Attribution coverage comes instead from RPs requiring an AIID: at participating services, an unregistered agent cannot perform consequential actions, and a registered agent that misbehaves leaves signed records tied to an accountable owner. Services that do not participate remain outside the scope of this mechanism, and agents acting there are neither prevented nor attributed by it. Coverage therefore grows with adoption by the services whose actions matter most, such as cloud and model API providers and financial and government services.¶
AIID makes registration a condition of access rather than a voluntary declaration. This document defines a registration-required profile. An RP that claims conformance to the registration-required profile, and a gateway that claims conformance to the profile of Section 12, MUST refuse consequential actions from agents whose credential is not bound to a valid AIID with effective state active, as determined by the procedure of Section 9, including its fail-closed rules. This document cannot impose obligations on services that do not claim conformance; other RPs remain subject to the recommendation of Section 11.1.¶
This specification cannot itself compel any agent operator to register. Near-universal coverage of consequential agent activity would depend on two external developments, neither of which this document assumes:¶
The limit stated in Section 11.6 applies: operators of malicious agents will not register voluntarily. The value of mandatory registration lies in two effects that do not depend on their cooperation: unregistered agents cannot reach adopting services for consequential actions, and registered agents that misbehave are attributable through receipts and Registry records (Section 11.2).¶
Adoption is incremental. No census of existing agents is required before a service or platform begins to require AIIDs; each adopter can enforce registration for its own traffic from the day it deploys a Registry or trusts an existing one (Section 13).¶
Some operators, such as cloud and AI infrastructure providers, may wish to guarantee that every consequential action of hosted agents passes through an Enforcement Point. This profile describes such a deployment. It was motivated by the AIIP access plane described in [I-D.sogomonian-aiip-aiid], but has no normative dependency on that document or its protocol framing. Implementing this profile is OPTIONAL; nothing elsewhere in this document depends on it.¶
In this profile:¶
The profile gives the operator a single point at which a freeze is guaranteed to take effect for hosted agents, including when external RPs do not yet implement AIID.¶
Adoption can proceed in stages, each useful on its own:¶
Effects on RPs that do not implement AIID: when an authorization server applies the introspection rules of Section 8.2, or an issuer publishes the conservative Status List of Section 8.5, RPs that know nothing of AIID will see tokens become inactive or suspended while an AIID or a matching scope is frozen. A scope freeze can therefore affect many agents at once (for example every workload in "spiffe://prod.example.com"), including agents that such an RP regards as unrelated. This is intended containment behavior, but operators SHOULD scope freezes narrowly, announce the behavior to dependent RPs before deployment, and consider it when choosing scope boundaries.¶
No global registry is required. Each namespace is authoritative for its own AIIDs, discovered through DNS and the well-known metadata. Cross-namespace trust is established by RP configuration in the same way RPs configure trusted OAuth issuers today.¶
Experiment: the Experimental status reflects open questions that deployment can answer, including appropriate values for max_status_ttl, the operational load of fail-closed behavior, and whether a dedicated SET event type is preferable to the CAEP mapping in Section 8.6. Feedback from implementations is solicited.¶
The considerations of [RFC8725] for JWTs and [RFC9700] for OAuth apply.¶
A compromised or faulty Monitor can place agents in safe_mode, denying service. This is a deliberate trade-off: by design a Monitor cannot grant capability, so its worst case is loss of availability, not loss of control. Mitigations: enrollment scoped to specific namespaces or AIIDs; rate limits per Monitor and per target; signed, logged requests; alerting the Owner on every Monitor action; and the ability of the Owner to disable the Monitor's enrollment at the Registry (Section 5.3), or, where the Monitor holds an AIID, to restrict that AIID, which has the same effect. Scope-freeze authority for Monitors SHOULD be granted sparingly.¶
An attacker holding owner credentials can return a restricted agent to active. Owner authentication SHOULD be phishing-resistant and MAY require approval by two administrators for set-active after a Monitor action. Because revoked is terminal, an Owner who suspects compromise of both the agent and owner credentials can revoke the AIID and issue a new one under fresh credentials. Registries SHOULD notify all registered Owner contacts of every set-active.¶
The Registry is a high-value target. Its signing keys SHOULD be held in hardware security modules. Fail-closed enforcement means that a Registry outage stops consequential actions of agents in its namespace once cached results expire, and also prevents an Owner from releasing a freeze until Resolve succeeds (Section 7.3 discusses the trade-off). Operators SHOULD run Registries with redundancy appropriate to that impact. An attacker who can block Resolve can cause denial of service but cannot cause an RP to treat a restricted agent as active, because RPs do not fall back to active. Because a child Registry answers 503, and caps the lifetime of its Status List tokens, while its ancestor data is stale (the fourth requirement of Section 6.3), an attacker who blocks an ancestor Registry also denies service, by design, for every descendant namespace that lists that ancestor in parent_namespaces; the blast radius of such an attack is therefore wider than one namespace, but the result is still fail closed. An attacker who replays an old "active" status token is stopped by its "exp" and by the version rule of Section 9.3.¶
If an agent can choose which AIID its credential is bound to, it can evade a freeze by presenting another AIID. Bindings are therefore asserted only by trusted issuers (Section 8). Scope freezes provide a backstop for credentials whose AIID binding is uncertain, but only when the RP can match the credential to a scope (by trust domain, issuer and client_id, or namespace). A credential with no matchable scope identifier, such as an opaque token from an authorization server the RP does not recognize, is outside both per-AIID and scope enforcement; such agents are handled by the "No AIID" policy of Section 9.2. An agent that obtains credentials outside any bound mechanism is outside AIID's control; the gateway profile (Section 12) addresses this for hosted agents.¶
Between a state change and its enforcement, an agent can continue acting for up to max_status_ttl at pull-only RPs, plus any time a long-running action takes to complete after its check. RPs performing long or multi-step consequential actions SHOULD re-check status before each irreversible step.¶
AIID constrains what cooperating RPs will do for an agent. It does not stop an agent from acting through RPs that ignore AIID, and it does not detect misbehavior. Its value increases with the share of consequential infrastructure that enforces it.¶
An AIID is a durable correlator across RPs, by design: it lets a restriction follow the agent. When an agent acts on behalf of a person, the AIID may indirectly reveal that person's activity. Registries SHOULD avoid local-ids that contain personal names or other personal data. Resolve MAY require RP authentication, and Registries SHOULD minimize Resolve logs, since they reveal which RPs an agent uses. Status Lists reduce this leakage because RPs fetch an entire list rather than querying one AIID; the herd-privacy considerations of [I-D.ietf-oauth-status-list] apply. Reason text for state changes is not disclosed to RPs. Receipts may contain hashes of request content; RPs SHOULD consider whether such hashes are guessable for low-entropy requests. General guidance in [RFC6973] applies.¶
IANA is requested to create the "AIID Runtime States" registry, with registration policy Specification Required [RFC8126]. Each entry contains: state name, severity rank, enforcement semantics, and reference. Initial entries:¶
| Name | Rank | Semantics | Reference |
|---|---|---|---|
| active | 0 | may act | Section 5.1 |
| safe_mode | 1 | no consequential action | Section 5.1 |
| suspended | 2 | no action | Section 5.1 |
| revoked | 3 | no action; terminal | Section 5.1 |
New states MUST define their position in the severity order and which roles may set and clear them.¶
IANA is requested to create the "AIID Freeze Scope Types" registry, with registration policy Specification Required. Each entry contains: type name, match rule, scope URI syntax, and reference. Initial entries: aiid_namespace, spiffe_trust_domain, wimse_trust_domain, and oauth_client, each with reference Section 6.1 of this document.¶
IANA is requested to register the following in the "JSON Web Token Claims" registry [RFC7519], each with Change Controller IETF:¶
| Claim Name | Description | Reference |
|---|---|---|
| aiid | AIID of the acting autonomous agent | Section 8.1 |
| aiid_state | AIID own runtime state (informational) | Section 7.2 |
| aiid_effective_state | Effective state including scope freezes | Section 7.2 |
| aiid_state_version | AIID state version | Section 7.2 |
| aiid_freeze_scopes | Applicable freeze scopes | Section 7.2 |
| aiid_query | Echo of a Resolve query | Section 7.2 |
| aiid_scope_state | Freeze scope state in a change event | Section 8.6 |
| aiid_scope_version | Freeze scope version in a change event | Section 8.6 |
| aiid_bindings | Credential identifiers bound to an AIID | Section 7.2 |
Receipt and grant claims without the "aiid_" prefix are scoped to their explicit "typ" values and are not registered (Section 10.1).¶
IANA is requested to register "aiid", "aiid_state", "aiid_effective_state", and "aiid_state_version" in the "OAuth Token Introspection Response" registry [RFC7662], each with Change Controller IETF and Reference Section 8.2 of this document.¶
IANA is requested to register the following in the "Well-Known URIs" registry [RFC8615]: URI Suffix: aiid-configuration; Change Controller: IETF; Reference: Section 7.1 of this document; Status: provisional; Related Information: none.¶
IANA is requested to create the "AIID Registry Metadata" registry, with registration policy Specification Required [RFC8126]. Each entry contains: member name, description, and reference. Initial entries, all with reference Section 7.1 of this document: issuer, namespace, parent_namespaces, resolve_endpoint, jwks_uri, state_endpoint, status_list_uri, ssf_configuration, freeze_scopes, max_status_ttl, and diagnostic_allow_list.¶
The Token Status List specification [I-D.ietf-oauth-status-list] establishes the "JWT Status Mechanisms" registry (its Section 14.2) and the "CWT Status Mechanisms" registry (its Section 14.4), both with registration policy Specification Required [RFC8126] after review on the jwt-reg-review and cwt-reg-review mailing lists respectively. IANA has created both registries, each currently containing only "status_list". IANA is requested to register the following in each of the two registries:¶
IANA is requested to register the URI scheme "aiid" in the "Uniform Resource Identifier (URI) Schemes" registry with status Provisional per [RFC7595]: Scheme name: aiid; Status: Provisional; Applications/protocols: AIID identifiers for autonomous agents; Contact: the author; Change Controller: IETF; Reference: Section 4.1 of this document. The scheme is an identifier, not a locator; it is not dereferenced directly. The registration is requested as Provisional deliberately: the identifier form may change in a later revision in response to feedback from the venue that considers this work, in which case the request will be updated or withdrawn.¶
IANA is requested to register the following in the "Media Types" registry [RFC6838]: "application/aiid-status+jwt" (Section 7.2), "application/aiid-receipt+jwt" (Section 10.1), and "application/aiid-grant+jwt" (Section 10.2). For each: Type name: application; Subtype name as given; Required parameters: none; Optional parameters: none; Encoding considerations: binary, as for the "+jwt" structured syntax suffix; Security considerations: Section 14 of this document; Interoperability considerations: none; Published specification: this document; Fragment identifier considerations: as for "+jwt"; Intended usage: COMMON; Change Controller: IETF. The "+jwt" suffix is registered in the "Structured Syntax Suffixes" registry [RFC6838] by Section 7.2 of [RFC8417].¶
Signatures and encodings are omitted; decoded JSON is shown.¶
Header: {"typ":"aiid-status+jwt","alg":"Ed25519","kid":"reg-1"}
Payload:
{
"iss": "https://agents.example.com",
"sub": "aiid://agents.example.com/finance/invoice-bot-7",
"aiid": "aiid://agents.example.com/finance/invoice-bot-7",
"iat": 1794571200,
"exp": 1794571260,
"aiid_effective_state": "safe_mode",
"aiid_state": "active",
"aiid_state_version": 41,
"aiid_freeze_scopes": [
{"uri": "spiffe://prod.example.com",
"state": "safe_mode", "scope_version": 3}
],
"aiid_bindings": [
"spiffe://prod.example.com/ns/finance/sa/invoice-bot"
]
}
¶
The AIID itself is active, but a scope freeze on the SPIFFE trust domain places it in safe_mode. RPs enforce aiid_effective_state.¶
GET /aiid/resolve?binding=spiffe%3A%2F%2Fprod.example.com%2Fns%2F
batch%2Fsa%2Fetl HTTP/1.1
Host: agents.example.com
¶
(The request line is shown on two lines for display.) The response is a status token with "sub" set to the SPIFFE ID, no "aiid" claim, "aiid_effective_state": "safe_mode", and the same scope entry as above.¶
POST /aiid/state HTTP/1.1
Host: agents.example.com
Authorization: Bearer <token with scope aiid:monitor>
Content-Type: application/json
{"aiid":"aiid://agents.example.com/finance/invoice-bot-7",
"state":"safe_mode","expected_version":40,
"reason":"INC-20261113-042"}
¶
The agent of Appendix A.3 is now in safe_mode. Because introspection reports "active": true only when the effective state is active (Section 8.2), the authorization server returns "active": false, whatever the token's scope, and includes "aiid_effective_state" to aid diagnosis.¶
{
"active": false,
"client_id": "invoice-bot",
"scope": "payments:write",
"aiid": "aiid://agents.example.com/finance/invoice-bot-7",
"aiid_effective_state": "safe_mode",
"aiid_state_version": 41
}
¶
=============== NOTE: '\' line wrapping per RFC 8792 ================
{
"iss": "https://agents.example.com",
"jti": "5f1c0a",
"iat": 1794571201,
"aud": "https://pay.example.net",
"sub_id": {
"format": "uri",
"uri": "aiid://agents.example.com/finance/invoice-bot-7"
},
"events": {
"https://schemas.openid.net/secevent/caep/event-type/\
token-claims-change": {
"event_timestamp": 1794571200,
"claims": {"aiid_state": "active",
"aiid_state_version": 41,
"aiid_effective_state": "safe_mode"}
}
}
}
¶
The event type URI is folded using the single-backslash strategy of [RFC8792], which requires the header line shown as the first line of the folded text; it is therefore marked as text rather than JSON. To recover the JSON, remove the header line and the blank line after it, and join each line ending in "\" with the following line after removing the backslash and the line break.¶
Header: {"typ":"aiid-receipt+jwt","alg":"Ed25519","kid":"pay-gw-1"}
Payload:
{
"iss": "https://pay.example.net",
"sub": "aiid://agents.example.com/finance/invoice-bot-7",
"iat": 1794571230,
"jti": "rcpt-8812",
"action": "payments.create",
"target": "acct/88-1102",
"req_hash": "Yx3Q...",
"outcome": "refused",
"aiid_state_version": 41,
"aiid_effective_state": "safe_mode",
"aiid_freeze_scopes": [
{"uri": "spiffe://prod.example.com",
"state": "safe_mode", "scope_version": 3}
]
}
¶
Registry R1 ("https://agents.example.com") holds AIID X and its namespace scope N ("aiid://agents.example.com"). Registry R2 ("https://trust.example.com") is authoritative for the SPIFFE trust domain scope P ("spiffe://prod.example.com"), which matches X's bound SPIFFE ID. The RP queries R1 by AIID and R2 by binding. "v" is aiid_state_version and "sv" is scope_version.¶
| Step | Input received by the RP | Records after the step | Effective state |
|---|---|---|---|
| t0 | R1: X active v=40; N active sv=1 R2: P active sv=2 |
X active v=40 N active sv=1 P active sv=2 |
active |
| t1 | Monitor freezes P at R2. R2 event: P safe_mode sv=3 | P safe_mode sv=3 (X unchanged, v=40) | safe_mode |
| t2 | Replayed old R2 token: P active sv=2 | Ignored (2 < 3: stale) | safe_mode |
| t3 | R1 refresh: X active v=40, aiid_effective_state active (R1 knows only N) | X active v=40 (same version, same state: not an error) | safe_mode |
| t4 | Scope Owner lifts P at R2. R2: P active sv=4 | P active sv=4 | active |
| t5 | Stale R1 event: X suspended v=39 | Ignored (39 < 40: stale) | active |
At t3 the RP keeps safe_mode because P is a recorded component at its newest version, even though R1's floor is active: R1's t3 result has the same floor key as its t0 result (same "iss" and the AIID X in "sub"), so it replaces the earlier floor, and its new "exp" extends how long that floor applies. At t4 the lift arrives as a higher scope_version, every component is now active, and no unexpired floor is more severe (R2's previous floor of safe_mode was replaced by its t4 result), so the agent returns to active.¶
At t5 the stale event reports a more restrictive state, yet the RP ignores it. The version rule applies in both directions: the statement that a pushed event can only tighten state (Section 7.3, Section 8.6) applies only to events that are not stale. A replayed restrictive event cannot be used to reimpose a state that the Owner has since changed.¶
A Registry migrating an agent named with the dotted form of [I-D.sogomonian-aiid-namespace] records the old identifier as a binding of the new AIID. An informative Registry record:¶
{
"aiid": "aiid://acme.example/robots/robot-01",
"state": "active",
"state_version": 7,
"owner": "https://acme.example/owners/ops",
"bindings": [
{"type": "legacy_dotted", "value": "aiid.acme.robot-01"},
{"type": "spiffe",
"value": "spiffe://acme.example/robots/robot-01"}
]
}
¶
Resolve by binding with the legacy value returns the status of the new AIID. The legacy form is not itself an AIID under this document and is never compared with AIIDs.¶
This appendix is informative.¶
This appendix is to be removed before publication.¶
The author thanks an anonymous reviewer for a detailed review of an earlier version of this document.¶