Internet-Draft AIID Runtime Control Status November 2026
Sogomonian Expires 19 May 2027 [Page]
Workgroup:
Network Working Group
Internet-Draft:
draft-sogomonian-aiid-00
Published:
Intended Status:
Experimental
Expires:
Author:
A. Sogomonian
AIIF

Autonomous Agent Identity and Runtime Control Status (AIID)

Abstract

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.

About This Document

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.

Status of This Memo

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

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

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

This Internet-Draft will expire on 19 May 2027.

▲

Table of Contents

1. Introduction

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:

  1. A durable principal identifier for an autonomous agent that is independent of host names, network addresses, cloud accounts, and short-lived credentials (Section 4).
  2. Four runtime control states with defined enforcement semantics and a strict severity order (Section 5).
  3. An asymmetric authority model: automated Monitors MAY tighten state to safe_mode; only the Accountable Owner MAY loosen state; revoked is terminal (Section 5.3).
  4. A namespace or deployment-wide freeze that applies even to agents that have not yet been issued an AIID (Section 6).
  5. A pre-action status check (Resolve) with bounded caching and fail-closed behavior (Section 7, Section 9).
  6. Bindings to OAuth 2.0, token introspection, SPIFFE, WIMSE, the Token Status List, and the Shared Signals Framework (Section 8).
  7. Compact JWS action receipts (Section 10).
  8. Accountability and attribution: registration as a condition of access, records, incident reconstruction, and the limits of attribution (Section 11).
  9. An OPTIONAL gateway deployment profile (Section 12).

1.1. Design Goals

Bind, do not replace:
An AIID is an additional attribute of an agent that already authenticates with OAuth, SPIFFE, WIMSE, or similar mechanisms. No new transport or authentication protocol is required.
Detection may be automated; release stays human:
Automated systems can react within seconds, but they cannot undo a restriction. This bounds the damage an erroneous or compromised Monitor can cause to loss of availability.
Check before acting:
Status is consulted by the relying party immediately before a consequential action, with an explicit cache bound, rather than only at credential issuance time.
Incremental adoption:
A single platform can deploy AIID for its own agents and obtain value without a global registry or census.

1.2. Non-Goals

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.

1.3. Relationship to Existing Mechanisms and Gap Analysis

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.

1.3.1. What Existing Mechanisms Provide

OAuth 2.0 token revocation and introspection:
Revocation [RFC7009] lets a client or authorization server invalidate an access or refresh token. Introspection [RFC7662] lets a resource server ask whether a given token is currently active. Both operate on individual tokens issued by one authorization server, and the answer is a single active or inactive value.
Short-lived JWT access tokens and token exchange:
JWT access tokens [RFC9068] with short lifetimes bound the exposure of any one token, and token exchange [RFC8693] expresses delegation, including an acting party in the "act" claim. The identity of the acting party is whatever the authorization server assigns, typically a client identifier within that server.
SPIFFE and WIMSE:
SPIFFE [SPIFFE-ID] issues short-lived, automatically rotated credentials (SVIDs) naming a workload within a trust domain. The WIMSE architecture [I-D.ietf-wimse-arch] generalizes workload identity and credentials across systems, and AIMS [I-D.ietf-wimse-aims] applies WIMSE and OAuth to AI agents (see Section 8.4). These name running software within a trust domain and control which credentials it can obtain.
Shared Signals and CAEP:
The Shared Signals Framework [OpenID.SSF] and CAEP [OpenID.CAEP] deliver security events, such as session revocation, credential change, and changes in assurance or risk level, from a transmitter to receivers that have subscribed, so that receivers can attenuate access promptly.
Token Status List:
The Token Status List [I-D.ietf-oauth-status-list] publishes a compact, cacheable status (including VALID, INVALID, and SUSPENDED) for each referenced token, indexed per token by its issuer.

1.3.2. Gaps Addressed by AIID

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:

  1. Durable principal identifier. Tokens, sessions, and SVIDs are deliberately short-lived, and workload identifiers are scoped to a trust domain. AIID provides a vendor-neutral identifier for the agent itself that persists across tokens, sessions, restarts, key rotation, and clouds (Section 4).
  2. Accountable Owner binding. Existing credentials identify a client or workload but do not standardize a link to the human or organization answerable for it. Each AIID record names its Accountable Owner (Section 4.3).
  3. Graded runtime control states. Introspection reports a binary active value, and the Token Status List reports the status of individual tokens. AIID defines states for the agent with distinct enforcement meanings: active, safe_mode (no consequential actions, diagnostics permitted), suspended, and revoked (Section 5).
  4. Asymmetric authority. Existing mechanisms specify how status is conveyed, not which principals may change it in which direction. AIID specifies that Monitors may only tighten, only the Owner may loosen, and revoked is terminal (Section 5.3).
  5. One effective status across all bindings. An agent may hold several OAuth clients, SPIFFE IDs, and workload credentials across issuers. AIID gives one effective state for the agent, so that restricting one AIID restricts every credential bound to it, and adds scope freezes for groups of agents, including agents not yet registered (Section 6, Section 8).
  6. Attribution records. Audit logging is widely required but its records are not standardized across organizations. AIID defines signed receipts and Registry transition logs that tie each action and refusal to an accountable principal (Section 10, Section 11).

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.

Table 1: Existing Mechanisms and AIID Capabilities
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).

2. Conventions and Terminology

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.

Agent:
An autonomous software system that initiates actions. An agent may consist of many running instances.
AIID:
The durable identifier of an agent, defined in Section 4. Also used for this specification as a whole.
AIID Registry (Registry):
The service authoritative for a namespace of AIIDs. It stores each AIID's state and bindings, accepts state changes, and answers Resolve.
Accountable Owner (Owner):
The human or organization accountable for an agent, acting through authenticated administrative credentials. This version assumes exactly one Accountable Owner per AIID (see Appendix C, item 5). Earlier documents of the Artificial Intelligence Internet Foundation (AIIF) call this role "HQ".
Monitor:
An automated or human-operated principal enrolled at the Registry with the monitor role, permitted only to move an AIID from active to safe_mode (Section 5.3).
Relying Party (RP):
A service that receives a request from, or on behalf of, an agent and decides whether to perform it. Resource servers, API gateways, and other agents are typical RPs.
Enforcement Point:
The component at an RP (or in front of it) that performs the pre-action check of Section 9.
Consequential Action:
An action that changes external state, moves value, discloses protected data, or acquires new capabilities or credentials. Each RP classifies its own operations; the classification SHOULD be documented.
Effective State:
The more severe of an AIID's own state and any applicable scope freeze (Section 6).

JSON [RFC8259] examples are illustrative. Times in examples use NumericDate values as in [RFC7519].

3. Architecture Overview

   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
Figure 1: AIID Roles and Flows

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.

4. The AIID Identifier

4.1. Syntax

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.

4.2. Durability and Assignment

An AIID names an agent as an accountable principal, not an instance, host, model version, or key. The following requirements apply:

  • A Registry MUST NOT reassign an AIID to a different agent, including after revocation. Revocation MUST NOT delete the AIID record, its owner reference, its bindings, or its transition log; these are retained for at least the retention period set by Registry policy and applicable law, and incident queries about a revoked AIID (Section 11.5) remain answerable during that period.
  • An AIID MUST NOT encode network locators (addresses, ports) or credentials. Locators and keys are bindings that may change while the AIID stays the same.
  • Key rotation, redeployment, scaling, and model upgrades SHOULD NOT change the AIID. A change of Accountable Owner or of the agent's declared purpose SHOULD result in a new AIID.
  • Short-lived ephemeral agents (for example, a sub-agent spawned for one task) MAY share the AIID of the agent that spawned them, or MAY be issued their own AIID; in either case state applies to every instance acting under that AIID.

4.3. AIID Record

For each AIID the Registry maintains at least:

aiid:
the identifier.
state:
one of the values in Section 5.
state_version:
a non-negative integer incremented on every state change.
owner:
a URI reference identifying the single Accountable Owner (for example an HTTPS URI of an owner record).
bindings:
zero or more credential identifiers associated with the AIID (Section 8).
jwks:
OPTIONAL public keys (JWK Set [RFC7517]) used to verify grants and receipts signed by the agent.

5. Runtime Control States

5.1. State Values

The following states are defined. They are listed in increasing order of severity.

active
The agent may act, subject to the RP's ordinary authorization.
safe_mode
A rapid, reversible restriction. RPs MUST refuse consequential actions. RPs MAY permit non-consequential actions that the Owner has listed in a published diagnostic allow-list (for example, health checks or read-only status reporting) so that the agent can be examined. safe_mode is intended for automated containment.
suspended
A deliberate administrative restriction. RPs MUST refuse all actions initiated by the agent.
revoked
Terminal. RPs MUST refuse all actions. The AIID is never returned to service and is never reassigned.

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.

5.2. Allowed Transitions

Table 2: State Transitions and Required Authority
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.

5.3. Asymmetric Authority

The central rule of this specification is that the power to restrict and the power to release are held by different principals.

  • A Monitor MAY set safe_mode on an AIID that is active, within the enrolled scope (namespaces, AIIDs, or freeze scopes) recorded for it at the Registry. A Monitor MUST NOT initiate any other transition. The Registry MUST reject any other transition requested by a principal holding only the monitor role, and any request outside the Monitor's enrolled scope.
  • Only the Accountable Owner (or a delegate holding the owner role for that AIID) MAY set active, suspended, or revoked.
  • An agent MUST NOT hold the owner role for its own AIID, and the Registry MUST reject a request to set active that is authenticated only with a credential bound to the target AIID.
  • The owner role SHOULD require authentication of a human administrator with phishing-resistant multi-factor authentication for transitions to active. Automating set-active defeats the purpose of this specification and is NOT RECOMMENDED.

Monitor enrollment and disablement: each Monitor is enrolled at the Registry as a named principal with the monitor role and an explicit enrolled scope. The Registry MUST provide an owner-role operation that disables a Monitor enrollment; once disabled, the Registry MUST reject all further requests from that Monitor until the enrollment is re-enabled by the owner role. Disabling a Monitor does not change any state the Monitor has already set. This control is defined by the Registry independently of AIID state. In addition, a Monitor that is itself an autonomous agent SHOULD hold an AIID, and a Registry MUST treat a Monitor whose own AIID is not active as disabled. The Registry MUST determine the Monitor's own AIID state at the time it authorizes each Monitor request: from its own authoritative record if the Monitor's AIID is in its namespace, or otherwise by a fresh Resolve that is not answered from cache. If that state cannot be determined, the Registry MUST reject the request.

Rationale: Monitors are often conventional security services (for example an EDR platform or a fraud engine) rather than autonomous agents, so requiring every Monitor to hold an AIID would add registration without adding control, and the disablement operation already gives the Owner strictly more control over a Monitor than AIID state would. More importantly, disabling a Monitor is a local Registry operation that does not depend on Resolve, caching, or any RP, so it takes effect immediately even when the Monitor is the cause of an incident.

5.4. State Change Requests

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:

aiid:
the target AIID, or
scope:
a freeze scope URI (Section 6);
state:
the requested state;
expected_version:
REQUIRED. The version the requester last observed. It is compared with the AIID's state_version when "aiid" is present, and with the scope's scope_version when "scope" is present; exactly one of the two members MUST be present.
reason:
OPTIONAL text for the audit log.

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.

6. Scope Freeze

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.

6.1. Freeze Scopes and Scope Identifiers

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:

aiid_namespace:
Matches every AIID whose namespace equals, or is a subdomain of, the given namespace.
spiffe_trust_domain:
Matches every credential whose SPIFFE ID [SPIFFE-ID] is in the given trust domain.
wimse_trust_domain:
Matches every credential whose workload identifier [I-D.ietf-wimse-identifier] uses the "wimse" scheme and is in the given trust domain.
oauth_client:
Matches every access token issued by the given authorization server issuer to the given client_id.

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

6.2. Scope Owner, Setting, and Lifting

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:

Table 3: Scope Freeze Transitions and Required Authority
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.

6.3. Nested Namespaces with Separate Registries

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:

  • MUST obtain the state of each listed ancestor namespace scope from the ancestor Registry, by Shared Signals or by Resolve, at least once per max_status_ttl;
  • MUST include those ancestor scopes, with their states and scope_versions, in aiid_freeze_scopes and in aiid_effective_state, and in its Status List values;
  • MUST NOT issue a status result whose "exp" is later than the expiry of the ancestor data it was computed from;
  • MUST NOT omit an ancestor scope from a result because its data is stale. While ancestor data for a listed parent namespace is expired and cannot be refreshed, the child Registry MUST answer Resolve for AIIDs and bindings within that namespace with HTTP 503, and MUST NOT publish Status List tokens covering them with a lifetime beyond the ancestor data's expiry. RPs treat these conditions as Registry unavailable and fail closed (Section 7.3).

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.

6.4. Conveyance and Discovery

Scope freezes reach RPs by the same three channels as per-AIID state:

  1. Resolve by binding (Section 7.2): the RP sends the credential identifier (a SPIFFE ID, a WIMSE workload identifier, or an OAuth issuer and client_id), and the Registry returns the effective state, the AIID if one is bound, and the list of matching freeze scopes. This is the REQUIRED mechanism; every Registry that lists deployment scopes MUST support it.
  2. Status List (Section 8.5): the Registry encodes effective state, including scope freezes, in the list entries it controls. This covers only credentials whose status index the Registry manages (Section 8.5); it is not a complete channel for deployment scopes whose credentials are issued elsewhere.
  3. Shared Signals (Section 8.6): the Registry emits an event whose subject is the scope URI.

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.

7. Registry Metadata and Resolve

7.1. Registry Metadata

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:

issuer:
REQUIRED. HTTPS URL identifying the Registry; the "iss" value of every status token it signs.
namespace:
REQUIRED. The AIID namespace.
parent_namespaces:
OPTIONAL. Ancestor namespaces whose freezes this Registry propagates (Section 6.3).
resolve_endpoint:
REQUIRED. HTTPS URL for Resolve.
jwks_uri:
REQUIRED. Registry signing keys.
state_endpoint:
OPTIONAL. State change endpoint.
status_list_uri:
OPTIONAL. Token Status List (Section 8.5).
ssf_configuration:
OPTIONAL. URL of an SSF Transmitter configuration (Section 8.6).
freeze_scopes:
OPTIONAL. Array of deployment scopes for which this Registry is authoritative; each entry has "uri" and "type" members (Section 6.1).
max_status_ttl:
REQUIRED. Maximum seconds an RP may rely on a status result.
diagnostic_allow_list:
OPTIONAL. URL of the safe_mode allow-list.

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.

7.2. 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:

aiid:
an AIID;
binding:
a credential identifier URI (a SPIFFE ID or a WIMSE workload identifier);
iss and client_id:
an OAuth issuer and client identifier.

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:

iss:
the Registry's "issuer" metadata value.
sub:
the AIID; or, for a "binding" query with no bound AIID, the queried credential identifier URI; or, for an "iss" and "client_id" query with no bound AIID, absent.
aiid_query:
REQUIRED when "sub" is absent, and OPTIONAL otherwise. A JSON object echoing the query: either {"binding": ...} or {"iss": ..., "client_id": ...}. The RP MUST check that it matches the query sent or the credential being checked.
iat, exp:
issuance and expiry; exp - iat MUST NOT exceed max_status_ttl.
aiid:
the AIID, when one is bound (absent otherwise).
aiid_effective_state:
REQUIRED. The effective state, including all scope freezes known to the Registry that match the queried identifier. This is the value RPs enforce.
aiid_state:
The AIID's own state, when an AIID is bound. Informational; RPs MUST NOT base an enforcement decision on aiid_state alone.
aiid_state_version:
The AIID's state_version, when an AIID is bound.
aiid_freeze_scopes:
REQUIRED. Array of every freeze scope known to the Registry that matches the queried identifier, including scopes that are not currently frozen (state "active"), each as an object with "uri", "state", and "scope_version" members (empty array if none). Including unfrozen scopes lets RPs observe a lift through a higher scope_version.
aiid_bindings:
OPTIONAL array of bound credential identifiers.
jwks:
OPTIONAL. The agent's public keys from the AIID record (Section 4.3), as a JWK Set. These are the agent's keys, not the Registry's: the status token itself is verified with the Registry keys published at jwks_uri.

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:

Table 4: Resolve Responses
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.

7.3. Caching, Freeze Latency, and Availability

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:

  1. Unexpired status result held (from Resolve, stapling, Status List, or a cached result updated by push): the RP MAY rely on it, even if the Registry is currently unreachable.
  2. No unexpired result and the Registry is reachable: the RP obtains a new result before acting.
  3. No unexpired result and the Registry is unreachable or returns an error other than 200: the RP MUST refuse consequential actions (fail closed). An expired result is equivalent to no result.

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.

8. Binding AIID to Existing Identity Systems

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.

8.1. OAuth 2.0 Access Tokens

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.

8.2. Token Introspection

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

8.3. SPIFFE

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.

8.4. WIMSE

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.

8.5. Token Status List

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:

Table 5: Mapping to Token Status List Values
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 credential references an AIID list through the member "aiid_status_list" of its "status" claim, registered in the "JWT Status Mechanisms" registry (Section 16.7). Its value has the same structure as "status_list" ("idx" and "uri"). The Token Status List specification defines "status" as an object containing at least one reference to a status mechanism, whose further members may be defined by other specifications (Sections 6.1 and 6.2 of [I-D.ietf-oauth-status-list]; Section 6.3 for CWTs), so "aiid_status_list" can appear alongside "status_list".
  • An RP MUST interpret 0x03 as safe_mode only if the reference was made through "aiid_status_list" and its "uri" equals the status_list_uri published in the metadata of a Registry the RP trusts for that credential.
  • In every other case, including any 0x03 value reached through a plain "status_list" reference, an RP MUST treat 0x03 as not valid (non-active).
  • For RPs that do not implement AIID, an issuer MAY additionally include a standard "status_list" reference to a separate list that uses only 0x00 to 0x02, encoding safe_mode as 0x02 (SUSPENDED). Such RPs then see a frozen agent's credential as suspended, which is conservative. The Token Status List specification does not define precedence between mechanisms, so this document does: an AIID-aware RP that has validated the "aiid_status_list" reference as above MUST use it and MUST NOT apply the plain "status_list" value, which would turn safe_mode into suspended. If the "aiid_status_list" reference cannot be validated, the list-derived state of the credential is non-active; the RP MUST NOT fall back to the plain list. This list-derived state composes with versioned results under Section 9.3: the more severe of the two applies, so the credential is refused even if the RP holds an unexpired "active" result. The only exception, a fresh Resolve result obtained after the failure, is specified in Section 9.3.
  • If the Token Status List specification, as published, does not permit more than one reference in the "status" object, the issuer includes only one reference per credential: the "aiid_status_list" reference for credentials presented to AIID-aware RPs, or the conservative "status_list" reference otherwise.

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

8.6. Shared Signals Framework

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.

9. Pre-Action Enforcement

9.1. Procedure

Before performing a consequential action requested by, or on behalf of, an agent, an Enforcement Point MUST:

  1. Authenticate the request using its existing mechanism.
  2. Determine the AIID, if any, from the credential (Section 8), and the freeze scopes that match the credential (Section 6.4).
  3. Obtain an unexpired status result covering the AIID and those scopes (Section 7.3) and apply the version rule of Section 9.3.
  4. Enforce aiid_effective_state (or the equivalent Status List value): perform the action only if it is active and ordinary authorization succeeds; in safe_mode, perform only allow-listed non-consequential actions; otherwise refuse. The aiid_state value is informational and MUST NOT override the effective state.
  5. Record the outcome; if receipts are in use, issue a receipt (Section 10).

9.2. No AIID, Unknown AIID, and Unavailable Registry

An Enforcement Point distinguishes the following cases, which have different handling:

No AIID:
The credential carries no AIID and Resolve by binding returns no bound AIID (HTTP 200 without "aiid", or 404 no_binding). Matching scope freezes still apply. Whether the RP performs consequential actions for such an agent is RP policy, subject to Section 11.1; in the gateway profile the action MUST be refused.
Unknown AIID:
The credential carries an AIID that its Registry reports as never issued (404 unknown_aiid), or whose namespace has no reachable metadata. The RP MUST treat it as non-active and refuse. A credential that names an AIID the RP cannot resolve is not equivalent to a credential with no AIID.
Registry unavailable:
Network failure, timeout, 429, 5xx, or an unverifiable response. The RP MAY rely on an unexpired result it already holds; otherwise it MUST refuse consequential actions (fail closed) and MUST NOT fall back to treating the agent as active or as having no AIID.

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.

9.3. Version Tracking

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.

9.4. Errors and Self-Checking

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.

10. Signed Action Receipts and Grants

Receipts give the Owner, auditors, and RPs verifiable evidence of which agent performed which action under which state. They are OPTIONAL to implement.

10.1. Receipt Format

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:

iss:
the signer (RP or gateway identifier).
sub:
the acting AIID (or, for a refusal of an agent with no AIID, the credential identifier).
aud:
OPTIONAL intended recipient(s).
iat:
time of execution or refusal.
jti:
unique receipt identifier.
action:
the action identifier as defined by the RP.
target:
OPTIONAL resource acted upon, as defined by the RP.
req_hash:
base64url SHA-256 of the canonical request representation, as defined by the RP.
res_hash:
OPTIONAL base64url SHA-256 of the result.
outcome:
"executed", "refused", or "failed".
aiid_state_version:
REQUIRED when the acting credential is bound to an AIID: the state_version observed at the pre-action check. Absent for refusals of agents with no AIID.
aiid_effective_state:
REQUIRED whenever aiid_state_version is present, so that the receipt records the state that was enforced; OPTIONAL otherwise (for example to record a matching scope freeze for an agent with no AIID). The effective state observed at the pre-action check.
aiid_freeze_scopes:
OPTIONAL. The matching freeze scopes observed at the pre-action check, as objects in the same format as in Section 7.2.
grant_jti:
OPTIONAL "jti" of the grant relied upon.
owner:
OPTIONAL identifier of the Accountable Owner (Section 11.2).

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.

10.2. Grants

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.

11. Accountability and Attribution

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.

11.1. Registration as a Condition of Access

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:

  • RPs that offer consequential actions to autonomous agents, including cloud providers, model API providers, financial services, and government services, SHOULD refuse consequential actions from agents that do not present a credential bound to an AIID whose effective state resolves to active.
  • Within the gateway profile (Section 12), the gateway MUST refuse consequential actions from agents without a resolvable active AIID.
  • An RP MAY distinguish agent traffic from human traffic by its existing means (client registration, workload credentials, declared user agents); this document does not define agent detection.
  • Registries SHOULD verify and record a reachable contact for the Accountable Owner at registration, so that an AIID leads to an accountable party.

11.2. Records

Three records together support attribution:

  1. The AIID record (Section 4.3), linking the AIID to its Accountable Owner and its bound credentials.
  2. The Registry transition log (Section 5.4), recording every state change, the principal that made it, and when.
  3. Receipts (Section 10). Where receipts are deployed, every consequential action and every refusal of a consequential action SHOULD produce a receipt that links the AIID, the action, the target, meaning the RP (carried in "iss") and, where the RP defines one, the resource acted upon, and the time. The Accountable Owner is linked through the AIID record; a receipt MAY also carry an "owner" claim naming it. In the gateway profile, receipts for consequential actions and refusals are REQUIRED.

11.3. Retention and Integrity

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.

11.4. Incident Reconstruction

After an incident, an investigator with access to the relevant records can establish:

  • which agent acted: the AIID in receipts at affected RPs, or the AIID bound to credentials seen in the RP's logs;
  • who is accountable: the Owner in the AIID record;
  • which credentials were used: the bindings in the AIID record and the credential identifiers in RP logs;
  • which actions were taken or attempted, and in which order: receipts, including refusals;
  • what state the agent was in at each step, and who changed it: aiid_state_version in receipts, matched against the transition log.

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.

11.5. Cross-Organization Incident Queries

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.

11.6. Limits of Attribution

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.

11.7. Mandatory Registration Through Policy and Platforms

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:

  1. Policy frameworks. Regulators and sector bodies could reference agent registration of this kind in their rules. For example, Regulation (EU) 2024/1689 [EU-AI-ACT] already contains provisions on record-keeping (Article 12), registration of certain high-risk systems (Article 49), and transparency obligations for certain AI systems (Article 50). This document makes no claim about how that Regulation or any other rule applies to autonomous agents; it observes only that a registry, state, and receipt mechanism of the kind defined here could serve as a technical means for such obligations.
  2. Platform gatekeepers. Cloud providers, model API providers, payment networks, and agent marketplaces could require a valid, active AIID before an agent may connect or transact, claiming conformance to the registration-required profile. Because a small number of such platforms carry a large share of consequential agent activity, their adoption would extend coverage faster than adoption by individual services.

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

12. OPTIONAL Gateway Deployment Profile (AIIP)

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.

13. Deployment Considerations

Adoption can proceed in stages, each useful on its own:

  1. A platform assigns AIIDs to its own agents, runs a Registry, and enforces state at its own API gateway.
  2. The platform's authorization server adds the "aiid" claim and introspection members; partner RPs begin to check state.
  3. Registries publish Status Lists and SSF streams; RPs subscribe for low-latency freeze.
  4. Operators that want stronger guarantees deploy the gateway profile.

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.

14. Security Considerations

The considerations of [RFC8725] for JWTs and [RFC9700] for OAuth apply.

14.1. Monitor Misuse and Denial of Service

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.

14.2. Compromised Owner Credentials

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.

14.3. Registry Compromise and Availability

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.

14.4. Binding and Impersonation

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.

14.5. Freeze Latency

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.

14.6. Limits of the Mechanism

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.

15. Privacy Considerations

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.

16. IANA Considerations

16.1. AIID Runtime States Registry

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:

Table 6: Initial AIID Runtime States
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.

16.2. AIID Freeze Scope Types Registry

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.

16.3. JSON Web Token Claims

IANA is requested to register the following in the "JSON Web Token Claims" registry [RFC7519], each with Change Controller IETF:

Table 7: JWT Claim Registrations
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).

16.4. OAuth Token Introspection Response

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.

16.5. Well-Known URI

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.

16.6. AIID Registry Metadata Registry

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.

16.7. JWT and CWT Status Mechanisms

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:

  • Status Mechanism Value: aiid_status_list
  • Status Mechanism Description: A Token Status List published by an AIID Registry, in which Status Type 0x03 denotes safe_mode.
  • Change Controller: IETF
  • Specification Document(s): Section 8.5 of this document

16.8. URI Scheme

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.

16.9. Media Types

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

17. References

17.1. Normative References

[I-D.ietf-oauth-status-list]
Looker, T., Bastian, P., and C. Bormann, "Token Status List (TSL)", Work in Progress, Internet-Draft, draft-ietf-oauth-status-list-21, , <https://datatracker.ietf.org/doc/html/draft-ietf-oauth-status-list-21>.
[OpenID.CAEP]
OpenID Foundation, "OpenID Continuous Access Evaluation Profile 1.0", , <https://openid.net/specs/openid-caep-1_0-final.html>.
[OpenID.SSF]
OpenID Foundation, "OpenID Shared Signals Framework Specification 1.0", , <https://openid.net/specs/openid-sharedsignals-framework-1_0-final.html>.
[RFC2119]
Bradner, S., "Key words for use in RFCs to Indicate Requirement Levels", BCP 14, RFC 2119, DOI 10.17487/RFC2119, , <https://www.rfc-editor.org/info/rfc2119>.
[RFC3339]
Klyne, G. and C. Newman, "Date and Time on the Internet: Timestamps", RFC 3339, DOI 10.17487/RFC3339, , <https://www.rfc-editor.org/info/rfc3339>.
[RFC3986]
Berners-Lee, T., Fielding, R., and L. Masinter, "Uniform Resource Identifier (URI): Generic Syntax", STD 66, RFC 3986, DOI 10.17487/RFC3986, , <https://www.rfc-editor.org/info/rfc3986>.
[RFC5234]
Crocker, D., Ed. and P. Overell, "Augmented BNF for Syntax Specifications: ABNF", STD 68, RFC 5234, DOI 10.17487/RFC5234, , <https://www.rfc-editor.org/info/rfc5234>.
[RFC6749]
Hardt, D., Ed., "The OAuth 2.0 Authorization Framework", RFC 6749, DOI 10.17487/RFC6749, , <https://www.rfc-editor.org/info/rfc6749>.
[RFC7009]
Lodderstedt, T., Ed., Dronia, S., and M. Scurtescu, "OAuth 2.0 Token Revocation", RFC 7009, DOI 10.17487/RFC7009, , <https://www.rfc-editor.org/info/rfc7009>.
[RFC7515]
Jones, M., Bradley, J., and N. Sakimura, "JSON Web Signature (JWS)", RFC 7515, DOI 10.17487/RFC7515, , <https://www.rfc-editor.org/info/rfc7515>.
[RFC7517]
Jones, M., "JSON Web Key (JWK)", RFC 7517, DOI 10.17487/RFC7517, , <https://www.rfc-editor.org/info/rfc7517>.
[RFC7519]
Jones, M., Bradley, J., and N. Sakimura, "JSON Web Token (JWT)", RFC 7519, DOI 10.17487/RFC7519, , <https://www.rfc-editor.org/info/rfc7519>.
[RFC7662]
Richer, J., Ed., "OAuth 2.0 Token Introspection", RFC 7662, DOI 10.17487/RFC7662, , <https://www.rfc-editor.org/info/rfc7662>.
[RFC8037]
Liusvaara, I., "CFRG Elliptic Curve Diffie-Hellman (ECDH) and Signatures in JSON Object Signing and Encryption (JOSE)", RFC 8037, DOI 10.17487/RFC8037, , <https://www.rfc-editor.org/info/rfc8037>.
[RFC8174]
Leiba, B., "Ambiguity of Uppercase vs Lowercase in RFC 2119 Key Words", BCP 14, RFC 8174, DOI 10.17487/RFC8174, , <https://www.rfc-editor.org/info/rfc8174>.
[RFC8259]
Bray, T., Ed., "The JavaScript Object Notation (JSON) Data Interchange Format", STD 90, RFC 8259, DOI 10.17487/RFC8259, , <https://www.rfc-editor.org/info/rfc8259>.
[RFC8414]
Jones, M., Sakimura, N., and J. Bradley, "OAuth 2.0 Authorization Server Metadata", RFC 8414, DOI 10.17487/RFC8414, , <https://www.rfc-editor.org/info/rfc8414>.
[RFC8417]
Hunt, P., Ed., Jones, M., Denniss, W., and M. Ansari, "Security Event Token (SET)", RFC 8417, DOI 10.17487/RFC8417, , <https://www.rfc-editor.org/info/rfc8417>.
[RFC8615]
Nottingham, M., "Well-Known Uniform Resource Identifiers (URIs)", RFC 8615, DOI 10.17487/RFC8615, , <https://www.rfc-editor.org/info/rfc8615>.
[RFC8725]
Sheffer, Y., Hardt, D., and M. Jones, "JSON Web Token Best Current Practices", BCP 225, RFC 8725, DOI 10.17487/RFC8725, , <https://www.rfc-editor.org/info/rfc8725>.
[RFC9068]
Bertocci, V., "JSON Web Token (JWT) Profile for OAuth 2.0 Access Tokens", RFC 9068, DOI 10.17487/RFC9068, , <https://www.rfc-editor.org/info/rfc9068>.
[RFC9493]
Backman, A., Ed., Scurtescu, M., and P. Jain, "Subject Identifiers for Security Event Tokens", RFC 9493, DOI 10.17487/RFC9493, , <https://www.rfc-editor.org/info/rfc9493>.
[RFC9864]
Jones, M.B. and O. Steele, "Fully-Specified Algorithms for JSON Object Signing and Encryption (JOSE) and CBOR Object Signing and Encryption (COSE)", RFC 9864, DOI 10.17487/RFC9864, , <https://www.rfc-editor.org/info/rfc9864>.

17.2. Informative References

[BC-ARTEX]
Toulas, B., "Chinese hackers use ARTEX AI in automated attacks against 200 orgs", Reporting research by CrowdStrike, , <https://www.bleepingcomputer.com/news/security/chinese-hackers-use-artex-ai-in-automated-attacks-against-200-orgs/>.
[CPR-ARTEX]
Check Point Research, "Hacking on Autopilot: Inside ARTEX Cybercrime Campaigns", , <https://research.checkpoint.com/2026/hacking-on-autopilot-inside-artex-cybercrime-campaigns/>.
[EU-AI-ACT]
European Parliament and Council of the European Union, "Regulation (EU) 2024/1689 of the European Parliament and of the Council of 13 June 2024 laying down harmonised rules on artificial intelligence (Artificial Intelligence Act)", Official Journal of the European Union, L series, , <https://eur-lex.europa.eu/eli/reg/2024/1689/oj>.
[I-D.ietf-oauth-spiffe-client-auth]
Schwenkschuster, A., Kasselman, P., Rose, S., Thorgersen, S., and N. Cam-Winget, "OAuth SPIFFE Client Authentication", Work in Progress, Internet-Draft, draft-ietf-oauth-spiffe-client-auth-03, , <https://datatracker.ietf.org/doc/html/draft-ietf-oauth-spiffe-client-auth-03>.
[I-D.ietf-wimse-aims]
Kasselman, P., Lombardo, J., Rosomakho, Y., Campbell, B., Steele, N., and A. Parecki, "AI Identity Management System", Work in Progress, Internet-Draft, draft-ietf-wimse-aims-01, , <https://datatracker.ietf.org/doc/html/draft-ietf-wimse-aims-01>.
[I-D.ietf-wimse-arch]
Salowey, J. A., Rosomakho, Y., and H. Tschofenig, "Workload Identity in a Multi System Environment (WIMSE) Architecture", Work in Progress, Internet-Draft, draft-ietf-wimse-arch-08, , <https://datatracker.ietf.org/doc/html/draft-ietf-wimse-arch-08>.
[I-D.ietf-wimse-identifier]
Rosomakho, Y. and J. A. Salowey, "Workload Identifier", Work in Progress, Internet-Draft, draft-ietf-wimse-identifier-04, , <https://datatracker.ietf.org/doc/html/draft-ietf-wimse-identifier-04>.
[I-D.ietf-wimse-workload-creds]
Campbell, B., Salowey, J. A., Schwenkschuster, A., Sheffer, Y., and Y. Rosomakho, "WIMSE Workload Credentials", Work in Progress, Internet-Draft, draft-ietf-wimse-workload-creds-03, , <https://datatracker.ietf.org/doc/html/draft-ietf-wimse-workload-creds-03>.
[I-D.sogomonian-aiid-namespace]
Sogomonian, A., "AIID: An Identifier Namespace for Autonomous Systems", Work in Progress, Internet-Draft, draft-sogomonian-aiid-namespace-00, , <https://datatracker.ietf.org/doc/html/draft-sogomonian-aiid-namespace-00>.
[I-D.sogomonian-aiip-aiid]
Sogomonian, A., "AIIP/AIID: No-Surprise Autonomous Action, Identity, Access Plane, Receipt, and Revocation", Work in Progress, Internet-Draft, draft-sogomonian-aiip-aiid-00, , <https://datatracker.ietf.org/doc/html/draft-sogomonian-aiip-aiid-00>.
[I-D.sogomonian-aiip-core]
Sogomonian, A., "AIIP Core: Agent Access Plane, AIID, Resolve, Invoke, and Receipt", Work in Progress, Internet-Draft, draft-sogomonian-aiip-core-00, , <https://datatracker.ietf.org/doc/html/draft-sogomonian-aiip-core-00>.
[MS-ARTEX]
Microsoft Threat Intelligence, "ARTEX abuse expands as cybercriminals target financial sector", Microsoft Security Blog, , <https://www.microsoft.com/en-us/security/blog/2026/11/06/artex-abuse-expands-as-cybercriminals-target-financial-sector/>.
[RFC6838]
Freed, N., Klensin, J., and T. Hansen, "Media Type Specifications and Registration Procedures", BCP 13, RFC 6838, DOI 10.17487/RFC6838, , <https://www.rfc-editor.org/info/rfc6838>.
[RFC6973]
Cooper, A., Tschofenig, H., Aboba, B., Peterson, J., Morris, J., Hansen, M., and R. Smith, "Privacy Considerations for Internet Protocols", RFC 6973, DOI 10.17487/RFC6973, , <https://www.rfc-editor.org/info/rfc6973>.
[RFC7595]
Thaler, D., Ed., Hansen, T., and T. Hardie, "Guidelines and Registration Procedures for URI Schemes", BCP 35, RFC 7595, DOI 10.17487/RFC7595, , <https://www.rfc-editor.org/info/rfc7595>.
[RFC8126]
Cotton, M., Leiba, B., and T. Narten, "Guidelines for Writing an IANA Considerations Section in RFCs", BCP 26, RFC 8126, DOI 10.17487/RFC8126, , <https://www.rfc-editor.org/info/rfc8126>.
[RFC8693]
Jones, M., Nadalin, A., Campbell, B., Ed., Bradley, J., and C. Mortimore, "OAuth 2.0 Token Exchange", RFC 8693, DOI 10.17487/RFC8693, , <https://www.rfc-editor.org/info/rfc8693>.
[RFC8792]
Watsen, K., Auerswald, E., Farrel, A., and Q. Wu, "Handling Long Lines in Content of Internet-Drafts and RFCs", RFC 8792, DOI 10.17487/RFC8792, , <https://www.rfc-editor.org/info/rfc8792>.
[RFC8935]
Backman, A., Ed., Jones, M., Ed., Scurtescu, M., Ansari, M., and A. Nadalin, "Push-Based Security Event Token (SET) Delivery Using HTTP", RFC 8935, DOI 10.17487/RFC8935, , <https://www.rfc-editor.org/info/rfc8935>.
[RFC8936]
Backman, A., Ed., Jones, M., Ed., Scurtescu, M., Ansari, M., and A. Nadalin, "Poll-Based Security Event Token (SET) Delivery Using HTTP", RFC 8936, DOI 10.17487/RFC8936, , <https://www.rfc-editor.org/info/rfc8936>.
[RFC9700]
Lodderstedt, T., Bradley, J., Labunets, A., and D. Fett, "Best Current Practice for OAuth 2.0 Security", BCP 240, RFC 9700, DOI 10.17487/RFC9700, , <https://www.rfc-editor.org/info/rfc9700>.
[RFC9943]
Birkholz, H., Delignat-Lavaud, A., Fournet, C., Deshpande, Y., and S. Lasker, "An Architecture for Trustworthy and Transparent Digital Supply Chains", RFC 9943, DOI 10.17487/RFC9943, , <https://www.rfc-editor.org/info/rfc9943>.
[SPIFFE-ID]
SPIFFE Project, "SPIFFE Identity and Verifiable Identity Document", <https://github.com/spiffe/spiffe/blob/main/standards/SPIFFE-ID.md>.
[UNIT42-CAIRN]
Palo Alto Networks Unit 42, "Attackers Use Autonomous AI to Target Semiconductor, Defense and Civil Society Sectors", , <https://unit42.paloaltonetworks.com/cairn-framework-ai-autonomous-attacks/>.

Appendix A. Examples

Signatures and encodings are omitted; decoded JSON is shown.

A.1. Resolve Status Token

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.

A.2. Resolve by Binding Without an AIID

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.

A.3. Monitor State Change

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"}

A.4. Introspection Response

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
}

A.5. CAEP Event

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

A.6. Receipt

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}
  ]
}

A.7. Version Tracking Across Two Registries

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.

Table 8: Version Tracking Example
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.8. Migration Binding for a Dotted Identifier

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.

Appendix B. Relationship to Earlier AIIF Drafts

This appendix is informative.

Appendix C. Open Questions

This appendix is to be removed before publication.

  1. Identifier forms. This document uses the "aiid" URI scheme, which keeps AIIDs recognizable and distinct from locators, and requests only Provisional registration (Section 16.8). Should deployments additionally be able to use HTTPS URIs under the namespace host, or WIMSE workload identifiers with an AIID path convention, as equivalent forms, or should those remain bindings (Section 8) of an "aiid" identifier as in this version?
  2. Should state changes use a dedicated SET event type rather than CAEP token-claims-change?
  3. Is the definition of consequential action best left entirely to RPs, or should a small common vocabulary be defined?
  4. Cross-namespace deployment scopes. This version requires each deployment scope to be listed by exactly one Registry and applies the most severe freeze if an RP is configured otherwise. Should multiple Registries be allowed to freeze the same scope, and if so with what precedence, or should deployment scopes be restricted to a single namespace permanently?
  5. Shared agents. Should an AIID have exactly one Accountable Owner, or may several Owners share it (for example a vendor and a customer)? If several, must all of them, or any one, agree to set active? The asymmetry principle of this document suggests that release should require all of them; this version assumes a single Owner.
  6. Receipt retention after revocation. How long should receipts and transition logs for a revoked AIID be retained, and should the Registry continue to answer incident queries for it indefinitely?
  7. Held-event timeout. A pushed restrictive event is held until a verifying result arrives (Section 9.3). Should a hold expire if no such result arrives within some multiple of max_status_ttl, with the RP then failing closed on the next action until it obtains a result?
  8. Multi-tenant gateway authority. A hosting operator in the profile of Section 12 can always refuse at its own gateways, but can freeze a customer's namespace only as a delegate of its Scope Owner. Should this document define how such delegation is granted and recorded, or leave it to the Registry and the customer?
  9. Which venue is appropriate for this work (WIMSE, OAuth, or another group)?

Acknowledgements

The author thanks an anonymous reviewer for a detailed review of an earlier version of this document.

Author's Address

Aram Sogomonian
Artificial Intelligence Internet Foundation (AIIF)