<?xml version="1.0" encoding="utf-8"?>
<!DOCTYPE rfc [
  <!ENTITY nbsp "&#160;">
]>
<rfc xmlns:xi="http://www.w3.org/2001/XInclude"
     version="3"
     category="exp"
     docName="draft-sogomonian-aiid-00"
     ipr="trust200902"
     submissionType="IETF"
     xml:lang="en"
     tocInclude="true"
     sortRefs="true"
     symRefs="true">
  <front>
    <title abbrev="AIID Runtime Control Status">Autonomous Agent Identity and Runtime Control Status (AIID)</title>
    <seriesInfo name="Internet-Draft" value="draft-sogomonian-aiid-00"/>
    <author initials="A." surname="Sogomonian" fullname="Aram Sogomonian">
      <organization abbrev="AIIF">Artificial Intelligence Internet Foundation (AIIF)</organization>
      <address>
        <email>aiinternetfoundation@icloud.com</email>
      </address>
    </author>
    <date year="2026" month="November" day="15"/>
    <area>Security</area>
    <keyword>autonomous agents</keyword>
    <keyword>AI agents</keyword>
    <keyword>runtime control</keyword>
    <keyword>revocation</keyword>
    <abstract>
      <t>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.</t>
      <t>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.</t>
    </abstract>
    <note removeInRFC="true">
      <name>About This Document</name>
      <t>This document reframes earlier individual work by the author
      (<xref target="I-D.sogomonian-aiip-aiid"/>,
      <xref target="I-D.sogomonian-aiip-core"/>,
      <xref target="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 (<xref target="gateway"/>); 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.</t>
    </note>
  </front>
  <middle>
    <section anchor="intro">
      <name>Introduction</name>
      <t>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
      <xref target="BC-ARTEX"/> and against financial-sector
      organizations <xref target="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 <xref target="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 <xref target="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?</t>
      <t>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.</t>
      <t>This document specifies AIID, which provides:</t>
      <ol>
        <li>A durable principal identifier for an autonomous agent that
        is independent of host names, network addresses, cloud accounts,
        and short-lived credentials (<xref target="identifier"/>).</li>
        <li>Four runtime control states with defined enforcement
        semantics and a strict severity order
        (<xref target="states"/>).</li>
        <li>An asymmetric authority model: automated Monitors MAY
        tighten state to safe_mode; only the Accountable Owner MAY
        loosen state; revoked is terminal
        (<xref target="authority"/>).</li>
        <li>A namespace or deployment-wide freeze that applies even to
        agents that have not yet been issued an AIID
        (<xref target="freeze"/>).</li>
        <li>A pre-action status check (Resolve) with bounded caching
        and fail-closed behavior (<xref target="resolve"/>,
        <xref target="enforcement"/>).</li>
        <li>Bindings to OAuth 2.0, token introspection, SPIFFE, WIMSE,
        the Token Status List, and the Shared Signals Framework
        (<xref target="bindings"/>).</li>
        <li>Compact JWS action receipts (<xref target="receipts"/>).</li>
        <li>Accountability and attribution: registration as a condition
        of access, records, incident reconstruction, and the limits of
        attribution (<xref target="accountability"/>).</li>
        <li>An OPTIONAL gateway deployment profile
        (<xref target="gateway"/>).</li>
      </ol>
      <section anchor="goals">
        <name>Design Goals</name>
        <dl newline="true" spacing="normal">
          <dt>Bind, do not replace:</dt>
          <dd>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.</dd>
          <dt>Detection may be automated; release stays human:</dt>
          <dd>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.</dd>
          <dt>Check before acting:</dt>
          <dd>Status is consulted by the relying party immediately
          before a consequential action, with an explicit cache bound,
          rather than only at credential issuance time.</dd>
          <dt>Incremental adoption:</dt>
          <dd>A single platform can deploy AIID for its own agents and
          obtain value without a global registry or census.</dd>
        </dl>
      </section>
      <section anchor="nongoals">
        <name>Non-Goals</name>
        <t>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.</t>
      </section>
      <section anchor="gap">
        <name>Relationship to Existing Mechanisms and Gap Analysis</name>
        <t>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.</t>
        <section anchor="gap-existing">
          <name>What Existing Mechanisms Provide</name>
          <dl newline="true" spacing="normal">
            <dt>OAuth 2.0 token revocation and introspection:</dt>
            <dd>Revocation <xref target="RFC7009"/> lets a client or
            authorization server invalidate an access or refresh token.
            Introspection <xref target="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.</dd>
            <dt>Short-lived JWT access tokens and token exchange:</dt>
            <dd>JWT access tokens <xref target="RFC9068"/> with short
            lifetimes bound the exposure of any one token, and token
            exchange <xref target="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.</dd>
            <dt>SPIFFE and WIMSE:</dt>
            <dd>SPIFFE <xref target="SPIFFE-ID"/> issues short-lived,
            automatically rotated credentials (SVIDs) naming a workload
            within a trust domain.  The WIMSE architecture
            <xref target="I-D.ietf-wimse-arch"/> generalizes workload
            identity and credentials across systems, and AIMS
            <xref target="I-D.ietf-wimse-aims"/> applies WIMSE and OAuth
            to AI agents (see <xref target="bind-wimse"/>).  These name
            running software within a trust domain and control which
            credentials it can obtain.</dd>
            <dt>Shared Signals and CAEP:</dt>
            <dd>The Shared Signals Framework <xref target="OpenID.SSF"/>
            and CAEP <xref target="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.</dd>
            <dt>Token Status List:</dt>
            <dd>The Token Status List
            <xref target="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.</dd>
          </dl>
        </section>
        <section anchor="gap-gaps">
          <name>Gaps Addressed by AIID</name>
          <t>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:</t>
          <ol>
            <li>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
            (<xref target="identifier"/>).</li>
            <li>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 (<xref target="record"/>).</li>
            <li>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 (<xref target="states"/>).</li>
            <li>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
            (<xref target="authority"/>).</li>
            <li>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
            (<xref target="freeze"/>, <xref target="bindings"/>).</li>
            <li>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
            (<xref target="receipts"/>,
            <xref target="accountability"/>).</li>
          </ol>
          <t>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.</t>
          <table anchor="tbl-gap">
            <name>Existing Mechanisms and AIID Capabilities</name>
            <thead>
              <tr><th>Capability</th><th>OA</th><th>JA</th><th>SW</th><th>SS</th><th>SL</th><th>AIID</th></tr>
            </thead>
            <tbody>
              <tr><td>Authenticate agent</td><td>yes</td><td>yes</td><td>yes</td><td>-</td><td>-</td><td>reuses</td></tr>
              <tr><td>Durable agent ID across issuers</td><td>-</td><td>-</td><td>TD</td><td>-</td><td>-</td><td>yes</td></tr>
              <tr><td>Accountable Owner</td><td>-</td><td>-</td><td>-</td><td>-</td><td>-</td><td>yes</td></tr>
              <tr><td>Graded states</td><td>bin</td><td>-</td><td>-</td><td>evt</td><td>tok</td><td>yes</td></tr>
              <tr><td>Who may tighten or loosen</td><td>-</td><td>-</td><td>-</td><td>-</td><td>-</td><td>yes</td></tr>
              <tr><td>One status for all bindings</td><td>-</td><td>-</td><td>-</td><td>-</td><td>-</td><td>yes</td></tr>
              <tr><td>Push of changes</td><td>-</td><td>-</td><td>-</td><td>yes</td><td>-</td><td>reuses</td></tr>
              <tr><td>Signed action receipts</td><td>-</td><td>-</td><td>-</td><td>-</td><td>-</td><td>yes</td></tr>
            </tbody>
          </table>
          <t>  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
          (<xref target="bindings"/>).</t>
        </section>
      </section>
    </section>

    <section anchor="terms">
      <name>Conventions and Terminology</name>
      <t>The key words "<bcp14>MUST</bcp14>", "<bcp14>MUST NOT</bcp14>",
      "<bcp14>REQUIRED</bcp14>", "<bcp14>SHALL</bcp14>",
      "<bcp14>SHALL NOT</bcp14>", "<bcp14>SHOULD</bcp14>",
      "<bcp14>SHOULD NOT</bcp14>", "<bcp14>RECOMMENDED</bcp14>",
      "<bcp14>NOT RECOMMENDED</bcp14>", "<bcp14>MAY</bcp14>", and
      "<bcp14>OPTIONAL</bcp14>" in this document are to be interpreted as
      described in BCP&nbsp;14 <xref target="RFC2119"/>
      <xref target="RFC8174"/> when, and only when, they appear in all
      capitals, as shown here.</t>
      <dl newline="true" spacing="normal">
        <dt>Agent:</dt>
        <dd>An autonomous software system that initiates actions.  An
        agent may consist of many running instances.</dd>
        <dt>AIID:</dt>
        <dd>The durable identifier of an agent, defined in
        <xref target="identifier"/>.  Also used for this specification
        as a whole.</dd>
        <dt>AIID Registry (Registry):</dt>
        <dd>The service authoritative for a namespace of AIIDs.  It
        stores each AIID's state and bindings, accepts state changes,
        and answers Resolve.</dd>
        <dt>Accountable Owner (Owner):</dt>
        <dd>The human or organization accountable for an agent,
        acting through authenticated administrative credentials.  This
        version assumes exactly one Accountable Owner per AIID (see
        <xref target="questions"/>, item 5).
        Earlier documents of the Artificial Intelligence Internet
        Foundation (AIIF) call this role "HQ".</dd>
        <dt>Monitor:</dt>
        <dd>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 (<xref target="authority"/>).</dd>
        <dt>Relying Party (RP):</dt>
        <dd>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.</dd>
        <dt>Enforcement Point:</dt>
        <dd>The component at an RP (or in front of it) that performs
        the pre-action check of <xref target="enforcement"/>.</dd>
        <dt>Consequential Action:</dt>
        <dd>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.</dd>
        <dt>Effective State:</dt>
        <dd>The more severe of an AIID's own state and any applicable
        scope freeze (<xref target="freeze"/>).</dd>
      </dl>
      <t>JSON <xref target="RFC8259"/> examples are illustrative.  Times
      in examples use NumericDate values as in <xref target="RFC7519"/>.</t>
    </section>

    <section anchor="overview">
      <name>Architecture Overview</name>
      <figure anchor="fig-arch">
        <name>AIID Roles and Flows</name>
        <artwork type="ascii-art"><![CDATA[
   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
]]></artwork>
      </figure>
      <t>The agent authenticates to the RP with whatever mechanism the
      RP already supports.  The RP determines the agent's AIID from that
      credential (<xref target="bindings"/>), 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.</t>
    </section>

    <section anchor="identifier">
      <name>The AIID Identifier</name>
      <section anchor="syntax">
        <name>Syntax</name>
        <t>An AIID is a URI <xref target="RFC3986"/> with the following
        syntax, expressed in ABNF <xref target="RFC5234"/>:</t>
        <sourcecode type="abnf"><![CDATA[
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 / "-" / "_" / "~"
]]></sourcecode>
        <t>ALPHA and DIGIT are core rules of <xref target="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" <bcp14>SHOULD</bcp14> be generated in lowercase and <bcp14>MUST</bcp14> be compared case-insensitively, as for all URI schemes <xref target="RFC3986"/>.  Namespace labels <bcp14>MUST</bcp14> be
        generated in lowercase (ALPHA restricted to %x61-7A); a
        receiver <bcp14>MUST</bcp14> 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 <xref target="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 <bcp14>MUST NOT</bcp14> exceed 255 octets.
        Example:</t>
        <artwork><![CDATA[
aiid://agents.example.com/finance/invoice-bot-7
]]></artwork>
        <t>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.</t>
      </section>
      <section anchor="durability">
        <name>Durability and Assignment</name>
        <t>An AIID names an agent as an accountable principal, not an
        instance, host, model version, or key.  The following
        requirements apply:</t>
        <ul>
          <li>A Registry <bcp14>MUST NOT</bcp14> reassign an AIID to a
          different agent, including after revocation.  Revocation
          <bcp14>MUST NOT</bcp14> 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 (<xref target="acc-queries"/>) remain answerable during that
          period.</li>
          <li>An AIID <bcp14>MUST NOT</bcp14> encode network locators
          (addresses, ports) or credentials.  Locators and keys are
          bindings that may change while the AIID stays the same.</li>
          <li>Key rotation, redeployment, scaling, and model upgrades
          <bcp14>SHOULD NOT</bcp14> change the AIID.  A change of
          Accountable Owner or of the agent's declared purpose
          <bcp14>SHOULD</bcp14> result in a new AIID.</li>
          <li>Short-lived ephemeral agents (for example, a sub-agent
          spawned for one task) <bcp14>MAY</bcp14> share the AIID of
          the agent that spawned them, or <bcp14>MAY</bcp14> be issued
          their own AIID; in either case state applies to every
          instance acting under that AIID.</li>
        </ul>
      </section>
      <section anchor="record">
        <name>AIID Record</name>
        <t>For each AIID the Registry maintains at least:</t>
        <dl newline="false" spacing="compact">
          <dt>aiid:</dt><dd>the identifier.</dd>
          <dt>state:</dt><dd>one of the values in <xref target="states"/>.</dd>
          <dt>state_version:</dt><dd>a non-negative integer incremented
          on every state change.</dd>
          <dt>owner:</dt><dd>a URI reference identifying the single Accountable Owner (for example an HTTPS URI of an owner record).</dd>
          <dt>bindings:</dt><dd>zero or more credential identifiers
          associated with the AIID (<xref target="bindings"/>).</dd>
          <dt>jwks:</dt><dd>OPTIONAL public keys (JWK Set
          <xref target="RFC7517"/>) used to verify grants and receipts
          signed by the agent.</dd>
        </dl>
      </section>
    </section>

    <section anchor="states">
      <name>Runtime Control States</name>
      <section anchor="state-values">
        <name>State Values</name>
        <t>The following states are defined.  They are listed in
        increasing order of severity.</t>
        <dl newline="true" spacing="normal">
          <dt>active</dt>
          <dd>The agent may act, subject to the RP's ordinary
          authorization.</dd>
          <dt>safe_mode</dt>
          <dd>A rapid, reversible restriction.  RPs <bcp14>MUST</bcp14>
          refuse consequential actions.  RPs <bcp14>MAY</bcp14> 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.</dd>
          <dt>suspended</dt>
          <dd>A deliberate administrative restriction.  RPs
          <bcp14>MUST</bcp14> refuse all actions initiated by the
          agent.</dd>
          <dt>revoked</dt>
          <dd>Terminal.  RPs <bcp14>MUST</bcp14> refuse all actions.
          The AIID is never returned to service and is never
          reassigned.</dd>
        </dl>
        <t>An RP that receives a state value it does not recognize
        <bcp14>MUST</bcp14> 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 (<xref target="iana-states"/>)
        with a severity rank above that of suspended are, at RPs that do not
        recognize them, handled the same way as unrecognized states.</t>
      </section>
      <section anchor="transitions">
        <name>Allowed Transitions</name>
        <table anchor="tbl-transitions">
          <name>State Transitions and Required Authority</name>
          <thead>
            <tr><th>From</th><th>To</th><th>Owner</th><th>Monitor (note)</th></tr>
          </thead>
          <tbody>
            <tr><td>active</td><td>safe_mode</td><td>yes</td><td>yes (a)</td></tr>
            <tr><td>active</td><td>suspended</td><td>yes</td><td>no</td></tr>
            <tr><td>active</td><td>revoked</td><td>yes</td><td>no</td></tr>
            <tr><td>safe_mode</td><td>active</td><td>yes</td><td>no</td></tr>
            <tr><td>safe_mode</td><td>suspended</td><td>yes</td><td>no</td></tr>
            <tr><td>safe_mode</td><td>revoked</td><td>yes</td><td>no</td></tr>
            <tr><td>suspended</td><td>active</td><td>yes</td><td>no</td></tr>
            <tr><td>suspended</td><td>revoked</td><td>yes</td><td>no</td></tr>
            <tr><td>revoked</td><td>(none)</td><td>no</td><td>no</td></tr>
          </tbody>
        </table>
        <t>Note (a): only for AIIDs or scopes within the Monitor's
        enrolled scope, and only while the Monitor's enrollment is
        enabled (<xref target="authority"/>).</t>
        <t>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 <bcp14>MUST</bcp14> reject any
        transition not listed in <xref target="tbl-transitions"/>.</t>
      </section>
      <section anchor="authority">
        <name>Asymmetric Authority</name>
        <t>The central rule of this specification is that the power to
        restrict and the power to release are held by different
        principals.</t>
        <ul>
          <li>A Monitor <bcp14>MAY</bcp14> 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
          <bcp14>MUST NOT</bcp14> initiate any other transition.  The
          Registry <bcp14>MUST</bcp14> reject any other transition
          requested by a principal holding only the monitor role, and any
          request outside the Monitor's enrolled scope.</li>
          <li>Only the Accountable Owner (or a delegate holding the
          owner role for that AIID) <bcp14>MAY</bcp14> set active,
          suspended, or revoked.</li>
          <li>An agent <bcp14>MUST NOT</bcp14> hold the owner role for
          its own AIID, and the Registry <bcp14>MUST</bcp14> reject a
          request to set active that is authenticated only with a
          credential bound to the target AIID.</li>
          <li>The owner role <bcp14>SHOULD</bcp14> 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
          <bcp14>NOT RECOMMENDED</bcp14>.</li>
        </ul>
        <t>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 <bcp14>MUST</bcp14>
        provide an owner-role operation that disables a Monitor
        enrollment; once disabled, the Registry <bcp14>MUST</bcp14>
        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
        <bcp14>SHOULD</bcp14> hold an AIID, and a Registry
        <bcp14>MUST</bcp14> treat a Monitor whose own AIID is not active
        as disabled.  The Registry <bcp14>MUST</bcp14> 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 <bcp14>MUST</bcp14> reject the request.</t>
        <t>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.</t>
      </section>
      <section anchor="setstate">
        <name>State Change Requests</name>
        <t>The Registry exposes a state change endpoint (advertised in
        metadata, <xref target="metadata"/>).  Requests are HTTP POST
        with a JSON body and are authorized with an OAuth 2.0 access
        token <xref target="RFC6749"/> whose scope includes
        "aiid:owner" or "aiid:monitor".  The body contains:</t>
        <dl newline="false" spacing="compact">
          <dt>aiid:</dt><dd>the target AIID, or</dd>
          <dt>scope:</dt><dd>a freeze scope URI (<xref target="freeze"/>);</dd>
          <dt>state:</dt><dd>the requested state;</dd>
          <dt>expected_version:</dt><dd>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
          <bcp14>MUST</bcp14> be present.</dd>
          <dt>reason:</dt><dd>OPTIONAL text for the audit log.</dd>
        </dl>
        <t>The reason field <bcp14>SHOULD NOT</bcp14> contain personal
        data; requesters <bcp14>SHOULD</bcp14> use incident or ticket
        references instead.  Registries <bcp14>MUST NOT</bcp14> disclose
        reason text to RPs.</t>
        <t>The Registry <bcp14>MUST</bcp14> apply the change only if
        expected_version equals the stored version (compare and set).
        Otherwise it <bcp14>MUST</bcp14> 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.</t>
        <t>The Registry <bcp14>MUST</bcp14> log every transition,
        whether accepted or rejected, with a timestamp
        <xref target="RFC3339"/>, the requesting principal and role,
        the from-state and to-state, the target, and the reason.  Logs
        <bcp14>SHOULD</bcp14> be append-only and retained per the
        Owner's audit policy.  Monitors <bcp14>SHOULD</bcp14> be rate
        limited per target and per scope.</t>
      </section>
    </section>

    <section anchor="freeze">
      <name>Scope Freeze</name>
      <t>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.</t>
      <section anchor="freeze-scopes">
        <name>Freeze Scopes and Scope Identifiers</name>
        <t>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:</t>
        <dl newline="true" spacing="normal">
          <dt>aiid_namespace:</dt>
          <dd>Matches every AIID whose namespace equals, or is a
          subdomain of, the given namespace.</dd>
          <dt>spiffe_trust_domain:</dt>
          <dd>Matches every credential whose SPIFFE ID
          <xref target="SPIFFE-ID"/> is in the given trust domain.</dd>
          <dt>wimse_trust_domain:</dt>
          <dd>Matches every credential whose workload identifier
          <xref target="I-D.ietf-wimse-identifier"/> uses the "wimse"
          scheme and is in the given trust domain.</dd>
          <dt>oauth_client:</dt>
          <dd>Matches every access token issued by the given
          authorization server issuer to the given client_id.</dd>
        </dl>
        <t>Scope URIs have the following syntax (ABNF
        <xref target="RFC5234"/>; "namespace" is defined in
        <xref target="syntax"/>):</t>
        <sourcecode type="abnf"><![CDATA[
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
]]></sourcecode>
        <t>The rules "unreserved" and "pct-encoded" are imported from
        <xref target="RFC3986"/> (Section 2), and "authority" and
        "path-abempty" from <xref target="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
        <xref target="RFC8414"/>.  For oauth-scope, the
        client_id is percent-encoded
        <xref target="RFC3986"/>, and the issuer is the authorization
        server's issuer identifier <xref target="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".</t>
        <t>A Registry lists the deployment scopes (all types other than
        aiid_namespace) for which it is authoritative in its metadata
        (<xref target="metadata"/>), each with its type and scope URI.
        A Registry <bcp14>MUST NOT</bcp14> 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
        <bcp14>SHOULD</bcp14> be listed by exactly one Registry; where the
        Registry is also the issuer of the scope's credentials it
        <bcp14>MUST</bcp14> be the only one.  An RP <bcp14>MUST</bcp14>
        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
        <bcp14>MUST</bcp14> apply the most severe applicable freeze.
        Precedence across Registries is an open question
        (<xref target="questions"/>).</t>
      </section>
      <section anchor="freeze-semantics">
        <name>Scope Owner, Setting, and Lifting</name>
        <t>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 (<xref target="freeze-scopes"/>), or a
        delegate it designates at the Registry.</t>
        <t>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
        <xref target="setstate"/> 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
        <bcp14>MAY</bcp14> move a scope from active to safe_mode, and only
        if the scope is within its enrolled scope; only the Scope Owner
        <bcp14>MAY</bcp14> 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
        (<xref target="tbl-transitions"/>), without revoked:</t>
        <table anchor="tbl-scope-transitions">
          <name>Scope Freeze Transitions and Required Authority</name>
          <thead>
            <tr><th>From</th><th>To</th><th>Scope Owner</th><th>Monitor (note)</th></tr>
          </thead>
          <tbody>
            <tr><td>active</td><td>safe_mode</td><td>yes</td><td>yes (a)</td></tr>
            <tr><td>active</td><td>suspended</td><td>yes</td><td>no</td></tr>
            <tr><td>safe_mode</td><td>active</td><td>yes</td><td>no</td></tr>
            <tr><td>safe_mode</td><td>suspended</td><td>yes</td><td>no</td></tr>
            <tr><td>suspended</td><td>active</td><td>yes</td><td>no</td></tr>
            <tr><td>any</td><td>revoked</td><td>n/a</td><td>n/a</td></tr>
          </tbody>
        </table>
        <t>Note (a) of <xref target="tbl-transitions"/> 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 <bcp14>MUST</bcp14> reject any scope
        transition not listed in <xref target="tbl-scope-transitions"/>.</t>
        <t>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.</t>
      </section>
      <section anchor="freeze-parent">
        <name>Nested Namespaces with Separate Registries</name>
        <t>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 (<xref target="metadata"/>).  Such a child
        Registry:</t>
        <ul>
          <li><bcp14>MUST</bcp14> 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;</li>
          <li><bcp14>MUST</bcp14> 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;</li>
          <li><bcp14>MUST NOT</bcp14> issue a status result whose "exp"
          is later than the expiry of the ancestor data it was computed
          from;</li>
          <li><bcp14>MUST NOT</bcp14> 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 <bcp14>MUST</bcp14> answer Resolve for AIIDs and
          bindings within that namespace with HTTP 503, and
          <bcp14>MUST NOT</bcp14> 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
          (<xref target="caching"/>).</li>
        </ul>
        <t>An RP <bcp14>MAY</bcp14> 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.</t>
      </section>
      <section anchor="freeze-conveyance">
        <name>Conveyance and Discovery</name>
        <t>Scope freezes reach RPs by the same three channels as
        per-AIID state:</t>
        <ol>
          <li>Resolve by binding (<xref target="resolve-op"/>): 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
          <bcp14>REQUIRED</bcp14> mechanism; every Registry that lists
          deployment scopes <bcp14>MUST</bcp14> support it.</li>
          <li>Status List (<xref target="bind-tsl"/>): the Registry
          encodes effective state, including scope freezes, in the list
          entries it controls.  This covers only credentials whose status
          index the Registry manages (<xref target="bind-tsl"/>); it is
          not a complete channel for deployment scopes whose credentials
          are issued elsewhere.</li>
          <li>Shared Signals (<xref target="bind-ssf"/>): the Registry
          emits an event whose subject is the scope URI.</li>
        </ol>
        <t>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 <bcp14>MAY</bcp14> perform this matching locally
        and then use Status List or Shared Signals for the matching
        scopes, or it <bcp14>MAY</bcp14> delegate the matching to the
        Registry by using Resolve by binding.</t>
      </section>
    </section>

    <section anchor="resolve">
      <name>Registry Metadata and Resolve</name>
      <section anchor="metadata">
        <name>Registry Metadata</name>
        <t>A Registry publishes a JSON metadata document at the
        well-known URI <xref target="RFC8615"/>
        "/.well-known/aiid-configuration" on the namespace host, for
        example "https://agents.example.com/.well-known/aiid-configuration".
        Members include:</t>
        <dl newline="false" spacing="compact">
          <dt>issuer:</dt><dd>REQUIRED.  HTTPS URL identifying the Registry;
          the "iss" value of every status token it signs.</dd>
          <dt>namespace:</dt><dd>REQUIRED.  The AIID namespace.</dd>
          <dt>parent_namespaces:</dt><dd>OPTIONAL.  Ancestor namespaces
          whose freezes this Registry propagates
          (<xref target="freeze-parent"/>).</dd>
          <dt>resolve_endpoint:</dt><dd>REQUIRED.  HTTPS URL for Resolve.</dd>
          <dt>jwks_uri:</dt><dd>REQUIRED.  Registry signing keys.</dd>
          <dt>state_endpoint:</dt><dd>OPTIONAL.  State change endpoint.</dd>
          <dt>status_list_uri:</dt><dd>OPTIONAL.  Token Status List
          (<xref target="bind-tsl"/>).</dd>
          <dt>ssf_configuration:</dt><dd>OPTIONAL.  URL of an SSF
          Transmitter configuration (<xref target="bind-ssf"/>).</dd>
          <dt>freeze_scopes:</dt><dd>OPTIONAL.  Array of deployment
          scopes for which this Registry is authoritative; each entry has
          "uri" and "type" members
          (<xref target="freeze-scopes"/>).</dd>
          <dt>max_status_ttl:</dt><dd>REQUIRED.  Maximum seconds an RP
          may rely on a status result.</dd>
          <dt>diagnostic_allow_list:</dt><dd>OPTIONAL.  URL of the
          safe_mode allow-list.</dd>
        </dl>
        <t>RPs <bcp14>MUST</bcp14> ignore metadata members they do not
        understand.  Additional members are registered in the "AIID
        Registry Metadata" registry (<xref target="iana-metadata"/>).</t>
        <t>Resolve is the baseline mechanism and every Registry
        <bcp14>MUST</bcp14> 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.</t>
      </section>
      <section anchor="resolve-op">
        <name>Resolve</name>
        <t>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:</t>
        <dl newline="false" spacing="compact">
          <dt>aiid:</dt><dd>an AIID;</dd>
          <dt>binding:</dt><dd>a credential identifier URI (a SPIFFE ID
          or a WIMSE workload identifier);</dd>
          <dt>iss and client_id:</dt><dd>an OAuth issuer and client
          identifier.</dd>
        </dl>
        <t>The Registry <bcp14>MAY</bcp14> require RP authentication.
        A successful response (HTTP 200) is a JWT
        <xref target="RFC7519"/> signed by the Registry with media type
        "application/aiid-status+jwt" and JOSE header "typ" value
        "aiid-status+jwt".  Claims:</t>
        <dl newline="false" spacing="compact">
          <dt>iss:</dt><dd>the Registry's "issuer" metadata value.</dd>
          <dt>sub:</dt><dd>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.</dd>
          <dt>aiid_query:</dt><dd>REQUIRED when "sub" is absent, and
          OPTIONAL otherwise.  A JSON object echoing the query: either
          {"binding": ...} or {"iss": ..., "client_id": ...}.  The RP
          <bcp14>MUST</bcp14> check that it matches the query sent or the
          credential being checked.</dd>
          <dt>iat, exp:</dt><dd>issuance and expiry; exp - iat
          <bcp14>MUST NOT</bcp14> exceed max_status_ttl.</dd>
          <dt>aiid:</dt><dd>the AIID, when one is bound (absent
          otherwise).</dd>
          <dt>aiid_effective_state:</dt><dd>REQUIRED.  The effective
          state, including all scope freezes known to the Registry that
          match the queried identifier.  This is the value RPs
          enforce.</dd>
          <dt>aiid_state:</dt><dd>The AIID's own state, when an AIID is
          bound.  Informational; RPs <bcp14>MUST NOT</bcp14> base an
          enforcement decision on aiid_state alone.</dd>
          <dt>aiid_state_version:</dt><dd>The AIID's state_version, when
          an AIID is bound.</dd>
          <dt>aiid_freeze_scopes:</dt><dd>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.</dd>
          <dt>aiid_bindings:</dt><dd>OPTIONAL array of bound
          credential identifiers.</dd>
          <dt>jwks:</dt><dd>OPTIONAL.  The agent's public keys from the AIID
          record (<xref target="record"/>), 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.</dd>
        </dl>
        <t>The Registry signs status tokens with "alg" "Ed25519"
        <xref target="RFC9864"/>, which RPs <bcp14>MUST</bcp14> support;
        "Ed448" <bcp14>MAY</bcp14> also be used.  An RP
        <bcp14>MUST</bcp14> 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 <bcp14>MUST</bcp14>
        verify its signature, "sub", and "exp", and apply the version
        rule of <xref target="enforcement-replay"/>.</t>
        <t>Error responses use a JSON body with an "error" member:</t>
        <table anchor="tbl-resolve-errors">
          <name>Resolve Responses</name>
          <thead>
            <tr><th>HTTP</th><th>error</th><th>Meaning and RP handling</th></tr>
          </thead>
          <tbody>
            <tr><td>200</td><td>(none)</td><td>Status token; enforce aiid_effective_state.</td></tr>
            <tr><td>400</td><td>invalid_request</td><td>Malformed query; treat as unavailable.</td></tr>
            <tr><td>401, 403</td><td>unauthorized</td><td>RP not authorized to query; treat as unavailable.</td></tr>
            <tr><td>404</td><td>unknown_aiid</td><td>The namespace exists but the AIID was never issued.  Non-active: refuse.</td></tr>
            <tr><td>404</td><td>no_binding</td><td>Binding query matched no AIID and no freeze scope.  Handle as "No AIID" (<xref target="enforcement-cases"/>).  A binding that matches only a freeze scope returns 200, not 404.</td></tr>
            <tr><td>429, 5xx</td><td>(any)</td><td>Registry unavailable; see <xref target="caching"/>.</td></tr>
          </tbody>
        </table>
        <t>An AIID that is unknown to its Registry <bcp14>MUST</bcp14> be
        treated as non-active.  A Registry <bcp14>MUST NOT</bcp14> 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.</t>
      </section>
      <section anchor="caching">
        <name>Caching, Freeze Latency, and Availability</name>
        <t>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 <bcp14>SHOULD</bcp14> be no more
        than 60 seconds for agents that can take consequential
        actions.</t>
        <t>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
        <bcp14>MAY</bcp14> advertise a larger max_status_ttl for
        deployments whose consequential actions are low in impact, and
        RPs <bcp14>MAY</bcp14> apply a shorter local limit for
        high-impact actions.  Stapling and Shared Signals reduce load
        and latency respectively without changing the bound.</t>
        <t>An RP distinguishes three cases:</t>
        <ol>
          <li>Unexpired status result held (from Resolve, stapling,
          Status List, or a cached result updated by push): the RP
          <bcp14>MAY</bcp14> rely on it, even if the Registry is
          currently unreachable.</li>
          <li>No unexpired result and the Registry is reachable: the RP
          obtains a new result before acting.</li>
          <li>No unexpired result and the Registry is unreachable or
          returns an error other than 200: the RP <bcp14>MUST</bcp14>
          refuse consequential actions (fail closed).  An expired result
          is equivalent to no result.</li>
        </ol>
        <t>Push notification (<xref target="bind-ssf"/>) can reduce
        latency below the token lifetime; an RP that receives a
        restrictive change event <bcp14>MUST</bcp14> discard any cached
        result for that AIID or scope that is less restrictive.  A
        pushed event <bcp14>MUST NOT</bcp14> 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 <xref target="enforcement-replay"/>: 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.</t>
      </section>
    </section>

    <section anchor="bindings">
      <name>Binding AIID to Existing Identity Systems</name>
      <t>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 <bcp14>MUST</bcp14> be
      asserted by a party trusted by the RP (the authorization server,
      the trust domain authority, or the Registry), never solely by the
      agent.</t>
      <section anchor="bind-oauth">
        <name>OAuth 2.0 Access Tokens</name>
        <t>An authorization server that issues JWT access tokens
        <xref target="RFC9068"/> to an agent <bcp14>SHOULD</bcp14>
        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 <xref target="RFC8693"/> is used, the AIID
        <bcp14>MAY</bcp14> also appear as the "sub" of the "act" claim.
        The access token <bcp14>MUST NOT</bcp14> be treated as
        evidence of current state: tokens are long-lived relative to
        a freeze, and state is obtained separately.</t>
        <t>Issuance and refresh: an authorization server
        <bcp14>MUST</bcp14> check the effective state before issuing or
        refreshing a token for an AIID.  If the effective state is
        suspended or revoked, the request <bcp14>MUST</bcp14> fail.  If
        it is safe_mode, the request <bcp14>MUST</bcp14> fail unless the
        resulting token is limited to scopes covering only the
        diagnostic allow-list.</t>
        <t>Tokens already issued remain valid until they expire unless
        revoked.  An authorization server <bcp14>SHOULD</bcp14> revoke
        outstanding tokens and refresh tokens for an AIID that becomes
        suspended or revoked (see <xref target="RFC7009"/>), and
        deployments <bcp14>SHOULD</bcp14> use short access token
        lifetimes.  Neither measure replaces the pre-action check of
        <xref target="enforcement"/>, which is what bounds the delay to
        max_status_ttl regardless of token lifetime.</t>
      </section>
      <section anchor="bind-introspection">
        <name>Token Introspection</name>
        <t>An authorization server supporting introspection
        <xref target="RFC7662"/> <bcp14>SHOULD</bcp14> include the
        members "aiid", "aiid_effective_state", and "aiid_state_version"
        in the introspection response for tokens bound to an AIID, and
        <bcp14>MAY</bcp14> include "aiid_state" (informational).  The
        values reflect the authorization server's most recent status
        result, which <bcp14>MUST</bcp14> be unexpired.  </t>
        <t>So that RPs unaware of AIID do not fail open, the
        authorization server <bcp14>MUST</bcp14> 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
        <bcp14>MUST</bcp14> 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
        <bcp14>MUST</bcp14> return "active": false.  It
        <bcp14>MAY</bcp14> include "aiid_effective_state" in an "active":
        false response to aid diagnosis.</t>
        <t>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 (<xref target="enforcement"/>), for example with JWT
        access tokens validated locally; an RP that relies only on
        introspection treats an agent in safe_mode as inactive.</t>
        <t>An RP <bcp14>MUST</bcp14> 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
        <xref target="enforcement-cases"/> (for example by Resolve by
        binding with the token's issuer and client_id).</t>
      </section>
      <section anchor="bind-spiffe">
        <name>SPIFFE</name>
        <t>A SPIFFE ID <xref target="SPIFFE-ID"/> identifies a workload
        within a trust domain.  A Registry <bcp14>MAY</bcp14> record
        one or more SPIFFE IDs as bindings of an AIID, and Resolve
        <bcp14>MAY</bcp14> 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 <bcp14>MAY</bcp14> be listed as a freeze
        scope (<xref target="freeze"/>).  OAuth clients authenticating
        with SVIDs <xref target="I-D.ietf-oauth-spiffe-client-auth"/>
        receive tokens carrying "aiid" as in
        <xref target="bind-oauth"/>.</t>
      </section>
      <section anchor="bind-wimse">
        <name>WIMSE</name>
        <t>The WIMSE architecture <xref target="I-D.ietf-wimse-arch"/>
        defines workload identifiers
        <xref target="I-D.ietf-wimse-identifier"/> and workload
        credentials <xref target="I-D.ietf-wimse-workload-creds"/>.  An
        AIID Registry <bcp14>MAY</bcp14> bind workload identifiers to an
        AIID, a WIMSE workload credential <bcp14>MAY</bcp14> carry the
        "aiid" claim, and a WIMSE trust domain <bcp14>MAY</bcp14> be a
        freeze scope.</t>
        <t>AIMS <xref target="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.</t>
      </section>
      <section anchor="bind-tsl">
        <name>Token Status List</name>
        <t>This binding is OPTIONAL, and it and its IANA registrations
        (<xref target="iana-tsl"/>) are the only parts of this document
        that depend on <xref target="I-D.ietf-oauth-status-list"/>, which
        is not yet an RFC.</t>
        <t>For RPs that process high request volumes, a Registry
        <bcp14>MAY</bcp14> publish effective states as a Token Status
        List <xref target="I-D.ietf-oauth-status-list"/> with "bits"
        equal to 2.  Each entry encodes the effective state of the
        credential it indexes, as follows:</t>
        <table anchor="tbl-tsl">
          <name>Mapping to Token Status List Values</name>
          <thead>
            <tr><th>Effective state</th><th>Status Type value</th><th>TSL name</th></tr>
          </thead>
          <tbody>
            <tr><td>active</td><td>0x00</td><td>VALID</td></tr>
            <tr><td>revoked</td><td>0x01</td><td>INVALID</td></tr>
            <tr><td>suspended</td><td>0x02</td><td>SUSPENDED</td></tr>
            <tr><td>safe_mode</td><td>0x03</td><td>APPLICATION_SPECIFIC</td></tr>
          </tbody>
        </table>
        <t>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:</t>
        <ul>
          <li>A credential references an AIID list through the member
          "aiid_status_list" of its "status" claim, registered in the
          "JWT Status Mechanisms" registry (<xref target="iana-tsl"/>).
          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
          <xref target="I-D.ietf-oauth-status-list"/>; Section 6.3 for
          CWTs), so "aiid_status_list" can appear alongside
          "status_list".</li>
          <li>An RP <bcp14>MUST</bcp14> 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.</li>
          <li>In every other case, including any 0x03 value reached
          through a plain "status_list" reference, an RP
          <bcp14>MUST</bcp14> treat 0x03 as not valid (non-active).</li>
          <li>For RPs that do not implement AIID, an issuer
          <bcp14>MAY</bcp14> 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 <bcp14>MUST</bcp14> use it and
          <bcp14>MUST NOT</bcp14> 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
          <bcp14>MUST NOT</bcp14> fall back to the plain list.  This
          list-derived state composes with versioned results under
          <xref target="enforcement-replay"/>: 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
          <xref target="enforcement-replay"/>.</li>
          <li>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.</li>
        </ul>
        <t>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
        <xref target="I-D.ietf-oauth-status-list"/>), which would remove
        the need for the distinct reference member.</t>
        <t>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 <bcp14>MUST</bcp14> also apply matching
        deployment-scope freezes obtained through Resolve by binding or
        Shared Signals (<xref target="freeze-conveyance"/>).</t>
        <t>The status list token's time-to-live <bcp14>MUST NOT</bcp14>
        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 <bcp14>MUST</bcp14> treat the credential as
        non-active.  An RP that does not implement Status List, or a
        Registry that does not publish one, uses Resolve
        (<xref target="metadata"/>).</t>
      </section>
      <section anchor="bind-ssf">
        <name>Shared Signals Framework</name>
        <t>A Registry <bcp14>MAY</bcp14> act as a Transmitter in the
        OpenID Shared Signals Framework <xref target="OpenID.SSF"/>,
        delivering Security Event Tokens <xref target="RFC8417"/> by
        push <xref target="RFC8935"/> or poll <xref target="RFC8936"/>.
        The subject is identified with the "uri" format of
        <xref target="RFC9493"/> whose value is the AIID or the freeze
        scope URI.  State changes are conveyed with the CAEP
        <xref target="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 <bcp14>SHOULD</bcp14>
        additionally be conveyed with the CAEP "session-revoked" event
        for receivers that do not process AIID claims.  As stated in
        <xref target="caching"/>, 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 <xref target="enforcement-replay"/>, 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.</t>
      </section>
    </section>

    <section anchor="enforcement">
      <name>Pre-Action Enforcement</name>
      <section anchor="enforcement-proc">
        <name>Procedure</name>
        <t>Before performing a consequential action requested by, or on
        behalf of, an agent, an Enforcement Point <bcp14>MUST</bcp14>:</t>
        <ol>
          <li>Authenticate the request using its existing mechanism.</li>
          <li>Determine the AIID, if any, from the credential
          (<xref target="bindings"/>), and the freeze scopes that match
          the credential (<xref target="freeze-conveyance"/>).</li>
          <li>Obtain an unexpired status result covering the AIID and
          those scopes (<xref target="caching"/>) and apply the version
          rule of <xref target="enforcement-replay"/>.</li>
          <li>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 <bcp14>MUST NOT</bcp14>
          override the effective state.</li>
          <li>Record the outcome; if receipts are in use, issue a
          receipt (<xref target="receipts"/>).</li>
        </ol>
      </section>
      <section anchor="enforcement-cases">
        <name>No AIID, Unknown AIID, and Unavailable Registry</name>
        <t>An Enforcement Point distinguishes the following cases, which
        have different handling:</t>
        <dl newline="true" spacing="normal">
          <dt>No AIID:</dt>
          <dd>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 <xref target="acc-registration"/>; in the
          gateway profile the action <bcp14>MUST</bcp14> be
          refused.</dd>
          <dt>Unknown AIID:</dt>
          <dd>The credential carries an AIID that its Registry reports
          as never issued (404 unknown_aiid), or whose namespace has no
          reachable metadata.  The RP <bcp14>MUST</bcp14> 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.</dd>
          <dt>Registry unavailable:</dt>
          <dd>Network failure, timeout, 429, 5xx, or an unverifiable
          response.  The RP <bcp14>MAY</bcp14> rely on an unexpired
          result it already holds; otherwise it <bcp14>MUST</bcp14>
          refuse consequential actions (fail closed) and
          <bcp14>MUST NOT</bcp14> fall back to treating the agent as
          active or as having no AIID.</dd>
        </dl>
        <t>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 (<xref target="acc-limits"/>) at the cost of
        excluding unregistered agents; allowing them preserves
        compatibility but leaves those actions outside AIID control.  The
        SHOULD in <xref target="acc-registration"/> is the means by which
        registration becomes a condition of access as adoption grows.</t>
        <t>RPs <bcp14>MAY</bcp14> apply local policy to non-consequential
        actions in all three cases.</t>
      </section>
      <section anchor="enforcement-replay">
        <name>Version Tracking</name>
        <t>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.</t>
        <t>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 <bcp14>MUST</bcp14> be kept at least until
        max_status_ttl has elapsed after that "exp", for replay
        protection; the state <bcp14>MUST NOT</bcp14> 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 <bcp14>MUST</bcp14> 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, <bcp14>MUST NOT</bcp14> clear
        the conflict.</t>
        <t>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 <bcp14>MUST</bcp14> be
        compared element by element, with AIIDs compared as in
        <xref target="syntax"/> and other strings compared exactly; the
        key is therefore hashable and implementations need no further
        canonicalization.  A new result with the same key
        <bcp14>MUST</bcp14> 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 <bcp14>MUST NOT</bcp14> 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.  </t>
        <t>Clock skew: the RP <bcp14>MUST</bcp14> 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
        <bcp14>RECOMMENDED</bcp14>), and <bcp14>MUST</bcp14> 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.</t>
        <t>Pushed events (<xref target="bind-ssf"/>) carry a version but
        no "exp".  An event <bcp14>MAY</bcp14> 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) <bcp14>MUST NOT</bcp14> change a record; the RP
        <bcp14>SHOULD</bcp14> 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 <xref target="enforcement-proc"/> 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 (<xref target="questions"/>).  An event at
        the recorded version that reports a different state is a conflict,
        as for results.  Events do not set floors.</t>
        <t>effective() is evaluated only after the procedure of
        <xref target="enforcement-proc"/> 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 <bcp14>MUST NOT</bcp14> be treated as active:
        the RP handles it as the "No AIID" case of
        <xref target="enforcement-cases"/>, which requires refusal under
        the registration-required profile
        (<xref target="acc-mandatory"/>) and the gateway profile.</t>
        <t>The RP processes results and events and
        computes the effective state as follows; an implementation <bcp14>MUST</bcp14> produce
        the same decisions:</t>
        <sourcecode type="pseudocode"><![CDATA[
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]
]]></sourcecode>
        <t>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.</t>
        <t>Status List entries carry no version.  For Status Lists the RP
        <bcp14>MUST</bcp14> order list tokens separately for each pair of
        list URI and status mechanism ("aiid_status_list" or
        "status_list") by "iat", and <bcp14>MUST NOT</bcp14> 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 (<xref target="bind-tsl"/>).  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.</t>
        <t>Exception for an unvalidatable "aiid_status_list" reference
        (<xref target="bind-tsl"/>): such a failure concerns the list
        mechanism for that credential, not the agent.  The RP
        <bcp14>MUST</bcp14> record the time T_fail at which it detected the
        failure.  It <bcp14>MAY</bcp14> 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 <bcp14>MUST NOT</bcp14> be used for this purpose.</t>
        <t>Combined with the expiry check, these rules prevent an attacker
        from replaying an older "active" result after a freeze.  A worked
        example appears in <xref target="ex-versions"/>.</t>
      </section>
      <section anchor="enforcement-misc">
        <name>Errors and Self-Checking</name>
        <t>An RP that refuses an action because of AIID state
        <bcp14>SHOULD</bcp14> 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 <bcp14>MUST NOT</bcp14>
        reveal the reason text recorded by the Monitor or Owner.</t>
        <t>An agent framework that is aware of AIID
        <bcp14>SHOULD</bcp14> 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.</t>
      </section>
    </section>

    <section anchor="receipts">
      <name>Signed Action Receipts and Grants</name>
      <t>Receipts give the Owner, auditors, and RPs verifiable evidence
      of which agent performed which action under which state.  They
      are OPTIONAL to implement.</t>
      <section anchor="receipt-format">
        <name>Receipt Format</name>
        <t>Receipts and grants are optional features.  The requirements
        in this section apply only to implementations that produce or
        verify them.</t>
        <t>A receipt is a JWS <xref target="RFC7515"/> in Compact
        Serialization, with JOSE header "typ" value
        "aiid-receipt+jwt", signed by the Enforcement Point (or the
        gateway of <xref target="gateway"/>).  Implementations that produce or verify receipts
        <bcp14>MUST</bcp14> support the fully specified "alg" value
        "Ed25519" <xref target="RFC9864"/> and <bcp14>MAY</bcp14> support
        "Ed448" and other algorithms per <xref target="RFC8725"/>.  The
        polymorphic "EdDSA" identifier, deprecated by
        <xref target="RFC9864"/>, <bcp14>SHOULD NOT</bcp14> be used.  Keys
        are represented as OKP JWKs <xref target="RFC8037"/>.  The payload is a JWT claims set
        with:</t>
        <dl newline="false" spacing="compact">
          <dt>iss:</dt><dd>the signer (RP or gateway identifier).</dd>
          <dt>sub:</dt><dd>the acting AIID (or, for a refusal of an agent
          with no AIID, the credential identifier).</dd>
          <dt>aud:</dt><dd>OPTIONAL intended recipient(s).</dd>
          <dt>iat:</dt><dd>time of execution or refusal.</dd>
          <dt>jti:</dt><dd>unique receipt identifier.</dd>
          <dt>action:</dt><dd>the action identifier as defined by the RP.</dd>
          <dt>target:</dt><dd>OPTIONAL resource acted upon, as defined
          by the RP.</dd>
          <dt>req_hash:</dt><dd>base64url SHA-256 of the canonical
          request representation, as defined by the RP.</dd>
          <dt>res_hash:</dt><dd>OPTIONAL base64url SHA-256 of the
          result.</dd>
          <dt>outcome:</dt><dd>"executed", "refused", or "failed".</dd>
          <dt>aiid_state_version:</dt><dd>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.</dd>
          <dt>aiid_effective_state:</dt><dd>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.</dd>
          <dt>aiid_freeze_scopes:</dt><dd>OPTIONAL.  The matching freeze
          scopes observed at the pre-action check, as objects in the same
          format as in <xref target="resolve-op"/>.</dd>
          <dt>grant_jti:</dt><dd>OPTIONAL "jti" of the grant relied
          upon.</dd>
          <dt>owner:</dt><dd>OPTIONAL identifier of the Accountable
          Owner (<xref target="acc-records"/>).</dd>
        </dl>
        <t>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 <bcp14>MUST</bcp14> reject a receipt
        whose JOSE header "typ" is not exactly "aiid-receipt+jwt", and
        <bcp14>MUST NOT</bcp14> interpret these claims in any other JWT
        (explicit typing, Section 3.11 of <xref target="RFC8725"/>).
        Claims prefixed "aiid_" are registered
        (<xref target="iana-jwt"/>).</t>
        <t>Refusals caused by AIID state <bcp14>SHOULD</bcp14> 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.</t>
      </section>
      <section anchor="grants">
        <name>Grants</name>
        <t>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") <xref target="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
        <bcp14>MUST</bcp14> reject a grant whose "typ" is not exactly
        "aiid-grant+jwt".  This profile is a
        JWT-claim-aligned form of the grant format in
        <xref target="I-D.sogomonian-aiip-core"/> (informative
        background only).  An Enforcement Point
        relying on a grant <bcp14>MUST</bcp14> 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.</t>
      </section>
    </section>


    <section anchor="accountability">
      <name>Accountability and Attribution</name>
      <t>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.</t>
      <section anchor="acc-registration">
        <name>Registration as a Condition of Access</name>
        <t>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:</t>
        <ul>
          <li>RPs that offer consequential actions to autonomous agents,
          including cloud providers, model API providers, financial
          services, and government services, <bcp14>SHOULD</bcp14>
          refuse consequential actions from agents that do not present
          a credential bound to an AIID whose effective state resolves
          to active.</li>
          <li>Within the gateway profile (<xref target="gateway"/>),
          the gateway <bcp14>MUST</bcp14> refuse consequential actions
          from agents without a resolvable active AIID.</li>
          <li>An RP <bcp14>MAY</bcp14> distinguish agent traffic from
          human traffic by its existing means (client registration,
          workload credentials, declared user agents); this document
          does not define agent detection.</li>
          <li>Registries <bcp14>SHOULD</bcp14> verify and record a
          reachable contact for the Accountable Owner at
          registration, so that an AIID leads to an accountable
          party.</li>
        </ul>
      </section>
      <section anchor="acc-records">
        <name>Records</name>
        <t>Three records together support attribution:</t>
        <ol>
          <li>The AIID record (<xref target="record"/>), linking the
          AIID to its Accountable Owner and its bound credentials.</li>
          <li>The Registry transition log (<xref target="setstate"/>),
          recording every state change, the principal that made it, and
          when.</li>
          <li>Receipts (<xref target="receipts"/>).  Where receipts are
          deployed, every consequential action and every refusal of a
          consequential action <bcp14>SHOULD</bcp14> 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 <bcp14>MAY</bcp14> also carry an "owner"
          claim naming it.  In the gateway profile, receipts for
          consequential actions and refusals are
          <bcp14>REQUIRED</bcp14>.</li>
        </ol>
      </section>
      <section anchor="acc-integrity">
        <name>Retention and Integrity</name>
        <t>Receipts and transition logs are only useful after an
        incident if they still exist and have not been altered.
        Signers <bcp14>SHOULD</bcp14> store receipts in append-only
        storage with a retention period set by policy and applicable
        law.  Deployments <bcp14>MAY</bcp14> additionally register
        receipts or receipt digests with a transparency service, for
        example one following the SCITT architecture
        <xref target="RFC9943"/>, so that later
        removal or modification is detectable by third parties.
        Registries <bcp14>SHOULD</bcp14> protect transition logs in the
        same way.  Because receipts are signed, they remain verifiable
        when copied out of the signer's systems for investigation.</t>
      </section>
      <section anchor="acc-forensics">
        <name>Incident Reconstruction</name>
        <t>After an incident, an investigator with access to the
        relevant records can establish:</t>
        <ul>
          <li>which agent acted: the AIID in receipts at affected RPs, or
          the AIID bound to credentials seen in the RP's logs;</li>
          <li>who is accountable: the Owner in the AIID record;</li>
          <li>which credentials were used: the bindings in the AIID
          record and the credential identifiers in RP logs;</li>
          <li>which actions were taken or attempted, and in which
          order: receipts, including refusals;</li>
          <li>what state the agent was in at each step, and who changed
          it: aiid_state_version in receipts, matched against the
          transition log.</li>
        </ul>
        <t>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.</t>
      </section>
      <section anchor="acc-queries">
        <name>Cross-Organization Incident Queries</name>
        <t>An RP that has observed harmful activity by an agent may need
        to ask the agent's Registry about it.  A Registry
        <bcp14>MAY</bcp14> 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 <bcp14>MUST</bcp14>
        require authentication of the requester,
        <bcp14>SHOULD</bcp14> require the requester to present evidence
        of its own involvement (for example, a receipt it signed),
        <bcp14>MUST</bcp14> disclose only records about the AIIDs
        concerned, and <bcp14>MUST</bcp14> be logged.  Disclosure of
        personal data is subject to applicable law and to
        <xref target="privacy"/>.  Registries <bcp14>MAY</bcp14>
        notify the Owner of each query.  A Monitor or RP that observes
        harmful activity <bcp14>MAY</bcp14> also request safe_mode
        through its enrolled Monitor role, where it has one.</t>
      </section>
      <section anchor="acc-limits">
        <name>Limits of Attribution</name>
        <t>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.</t>
      </section>
      <section anchor="acc-mandatory">
        <name>Mandatory Registration Through Policy and Platforms</name>
        <t>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 <xref target="gateway"/>,
        <bcp14>MUST</bcp14> refuse consequential actions from agents whose
        credential is not bound to a valid AIID with effective state
        active, as determined by the procedure of
        <xref target="enforcement"/>, 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 <xref target="acc-registration"/>.</t>
        <t>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:</t>
        <ol>
          <li>Policy frameworks.  Regulators and sector bodies could
          reference agent registration of this kind in their rules.  For
          example, Regulation (EU) 2024/1689 <xref target="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.</li>
          <li>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.</li>
        </ol>
        <t>The limit stated in <xref target="acc-limits"/> 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 (<xref target="acc-records"/>).</t>
        <t>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
        (<xref target="deployment"/>).</t>
      </section>
    </section>

    <section anchor="gateway">
      <name>OPTIONAL Gateway Deployment Profile (AIIP)</name>
      <t>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
      <xref target="I-D.sogomonian-aiip-aiid"/>, but has no normative
      dependency on that document or its protocol framing.  Implementing this profile is
      <bcp14>OPTIONAL</bcp14>; nothing elsewhere in this document
      depends on it.</t>
      <t>In this profile:</t>
      <ul>
        <li>The operator runs one or more enforcement gateways.  Hosted
        agents in the profile <bcp14>MUST</bcp14> reach external RPs
        for consequential actions only through a gateway (for example
        by egress network policy), and the operator
        <bcp14>MUST</bcp14> document any bypass paths.</li>
        <li>The gateway performs the check of
        <xref target="enforcement"/> on every request, attaches the
        agent's AIID (for example as a stapled status token) to
        outbound requests, and issues receipts.</li>
        <li>The operator <bcp14>MUST</bcp14> be able to stop consequential
        actions of all agents behind its gateways.  It can always do so by
        refusing requests at its own gateways; that is local enforcement
        and needs no Registry authority.  A scope freeze at a Registry, by
        contrast, requires authority over the scope: for each scope it
        freezes, the operator <bcp14>MUST</bcp14> be the Scope Owner or a
        delegate authorized by the Scope Owner
        (<xref target="freeze-semantics"/>).  For agents in hosted
        customer namespaces, unless such delegation exists, the operator
        freezes only scopes it owns itself (for example its own namespace,
        or the SPIFFE or WIMSE trust domain or OAuth client it operates)
        and otherwise relies on refusal at its gateways.  This keeps the
        profile usable for multi-tenant hosting without giving the host
        authority over customers' agents at other RPs.</li>
        <li>Plane separation: within the profile, agent action traffic
        flows through the gateway, while HTTPS administrative
        interfaces used by humans (Owner consoles, receipt review) are a
        separate control plane.  Agents in the profile
        <bcp14>MUST NOT</bcp14> be granted credentials for the owner
        role or the control plane.</li>
        <li>How agents reach the gateway is out of scope; ordinary HTTPS
        proxying suffices.  (Informative: an operator could instead use
        an internal framing such as the AIIP Resolve/Invoke messages of
        <xref target="I-D.sogomonian-aiip-core"/>; this does not affect
        RPs outside the profile.)</li>
      </ul>
      <t>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.</t>
    </section>

    <section anchor="deployment">
      <name>Deployment Considerations</name>
      <t>Adoption can proceed in stages, each useful on its own:</t>
      <ol>
        <li>A platform assigns AIIDs to its own agents, runs a
        Registry, and enforces state at its own API gateway.</li>
        <li>The platform's authorization server adds the "aiid" claim
        and introspection members; partner RPs begin to check
        state.</li>
        <li>Registries publish Status Lists and SSF streams; RPs
        subscribe for low-latency freeze.</li>
        <li>Operators that want stronger guarantees deploy the gateway
        profile.</li>
      </ol>
      <t>Effects on RPs that do not implement AIID: when an authorization
        server applies the introspection rules of
        <xref target="bind-introspection"/>, or an issuer publishes the
        conservative Status List of <xref target="bind-tsl"/>, 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 <bcp14>SHOULD</bcp14> scope freezes narrowly,
        announce the behavior to dependent RPs before deployment, and
        consider it when choosing scope boundaries.</t>
        <t>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.</t>
      <t>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 <xref target="bind-ssf"/>.  Feedback from
      implementations is solicited.</t>
    </section>

    <section anchor="security">
      <name>Security Considerations</name>
      <t>The considerations of <xref target="RFC8725"/> for JWTs and
      <xref target="RFC9700"/> for OAuth apply.</t>
      <section anchor="sec-monitor">
        <name>Monitor Misuse and Denial of Service</name>
        <t>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
        (<xref target="authority"/>), or, where the Monitor holds an AIID,
        to restrict that AIID, which has the same effect.  Scope-freeze authority for
        Monitors <bcp14>SHOULD</bcp14> be granted sparingly.</t>
      </section>
      <section anchor="sec-owner">
        <name>Compromised Owner Credentials</name>
        <t>An attacker holding owner credentials can return a restricted
        agent to active.  Owner authentication <bcp14>SHOULD</bcp14>
        be phishing-resistant and <bcp14>MAY</bcp14> 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
        <bcp14>SHOULD</bcp14> notify all registered Owner contacts of
        every set-active.</t>
      </section>
      <section anchor="sec-registry">
        <name>Registry Compromise and Availability</name>
        <t>The Registry is a high-value target.  Its signing keys
        <bcp14>SHOULD</bcp14> 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 (<xref target="caching"/>
        discusses the trade-off).  Operators <bcp14>SHOULD</bcp14> 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
        <xref target="freeze-parent"/>), 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 <xref target="enforcement-replay"/>.</t>
      </section>
      <section anchor="sec-binding">
        <name>Binding and Impersonation</name>
        <t>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
        (<xref target="bindings"/>).  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
        <xref target="enforcement-cases"/>.  An agent that
        obtains credentials outside any bound mechanism is outside
        AIID's control; the gateway profile (<xref target="gateway"/>)
        addresses this for hosted agents.</t>
      </section>
      <section anchor="sec-latency">
        <name>Freeze Latency</name>
        <t>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
        <bcp14>SHOULD</bcp14> re-check status before each irreversible
        step.</t>
      </section>
      <section anchor="sec-limits">
        <name>Limits of the Mechanism</name>
        <t>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.</t>
      </section>
    </section>

    <section anchor="privacy">
      <name>Privacy Considerations</name>
      <t>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 <bcp14>SHOULD</bcp14> avoid local-ids that contain
      personal names or other personal data.  Resolve
      <bcp14>MAY</bcp14> require RP authentication, and Registries
      <bcp14>SHOULD</bcp14> 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
      <xref target="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 <bcp14>SHOULD</bcp14> consider
      whether such hashes are guessable for low-entropy requests.
      General guidance in <xref target="RFC6973"/> applies.</t>
    </section>

    <section anchor="iana">
      <name>IANA Considerations</name>
      <section anchor="iana-states">
        <name>AIID Runtime States Registry</name>
        <t>IANA is requested to create the "AIID Runtime States"
        registry, with registration policy Specification Required
        <xref target="RFC8126"/>.  Each entry contains: state name,
        severity rank, enforcement semantics, and reference.  Initial
        entries:</t>
        <table>
          <name>Initial AIID Runtime States</name>
          <thead>
            <tr><th>Name</th><th>Rank</th><th>Semantics</th><th>Reference</th></tr>
          </thead>
          <tbody>
            <tr><td>active</td><td>0</td><td>may act</td><td><xref target="state-values"/></td></tr>
            <tr><td>safe_mode</td><td>1</td><td>no consequential action</td><td><xref target="state-values"/></td></tr>
            <tr><td>suspended</td><td>2</td><td>no action</td><td><xref target="state-values"/></td></tr>
            <tr><td>revoked</td><td>3</td><td>no action; terminal</td><td><xref target="state-values"/></td></tr>
          </tbody>
        </table>
        <t>New states <bcp14>MUST</bcp14> define their position in the
        severity order and which roles may set and clear them.</t>
      </section>
      <section anchor="iana-scopes">
        <name>AIID Freeze Scope Types Registry</name>
        <t>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
        <xref target="freeze-scopes"/> of this document.</t>
      </section>
      <section anchor="iana-jwt">
        <name>JSON Web Token Claims</name>
        <t>IANA is requested to register the following in the "JSON Web
        Token Claims" registry <xref target="RFC7519"/>, each with
        Change Controller IETF:</t>
        <table>
          <name>JWT Claim Registrations</name>
          <thead>
            <tr><th>Claim Name</th><th>Description</th><th>Reference</th></tr>
          </thead>
          <tbody>
            <tr><td>aiid</td><td>AIID of the acting autonomous agent</td><td><xref target="bind-oauth"/></td></tr>
            <tr><td>aiid_state</td><td>AIID own runtime state (informational)</td><td><xref target="resolve-op"/></td></tr>
            <tr><td>aiid_effective_state</td><td>Effective state including scope freezes</td><td><xref target="resolve-op"/></td></tr>
            <tr><td>aiid_state_version</td><td>AIID state version</td><td><xref target="resolve-op"/></td></tr>
            <tr><td>aiid_freeze_scopes</td><td>Applicable freeze scopes</td><td><xref target="resolve-op"/></td></tr>
            <tr><td>aiid_query</td><td>Echo of a Resolve query</td><td><xref target="resolve-op"/></td></tr>
            <tr><td>aiid_scope_state</td><td>Freeze scope state in a change event</td><td><xref target="bind-ssf"/></td></tr>
            <tr><td>aiid_scope_version</td><td>Freeze scope version in a change event</td><td><xref target="bind-ssf"/></td></tr>
            <tr><td>aiid_bindings</td><td>Credential identifiers bound to an AIID</td><td><xref target="resolve-op"/></td></tr>
          </tbody>
        </table>
        <t>Receipt and grant claims without the "aiid_" prefix are scoped
        to their explicit "typ" values and are not registered
        (<xref target="receipt-format"/>).</t>
      </section>
      <section anchor="iana-introspection">
        <name>OAuth Token Introspection Response</name>
        <t>IANA is requested to register "aiid", "aiid_state",
        "aiid_effective_state", and "aiid_state_version" in the "OAuth
        Token Introspection Response" registry <xref target="RFC7662"/>,
        each with Change Controller IETF and Reference
        <xref target="bind-introspection"/> of this document.</t>
      </section>
      <section anchor="iana-wk">
        <name>Well-Known URI</name>
        <t>IANA is requested to register the following in the
        "Well-Known URIs" registry <xref target="RFC8615"/>: URI
        Suffix: aiid-configuration; Change Controller: IETF;
        Reference: <xref target="metadata"/> of this document; Status:
        provisional; Related Information: none.</t>
      </section>
      <section anchor="iana-metadata">
        <name>AIID Registry Metadata Registry</name>
        <t>IANA is requested to create the "AIID Registry Metadata"
        registry, with registration policy Specification Required
        <xref target="RFC8126"/>.  Each entry contains: member name,
        description, and reference.  Initial entries, all with reference
        <xref target="metadata"/> 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.</t>
      </section>
      <section anchor="iana-tsl">
        <name>JWT and CWT Status Mechanisms</name>
        <t>The Token Status List specification
        <xref target="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 <xref target="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:</t>
        <ul spacing="compact">
          <li>Status Mechanism Value: aiid_status_list</li>
          <li>Status Mechanism Description: A Token Status List published
          by an AIID Registry, in which Status Type 0x03 denotes
          safe_mode.</li>
          <li>Change Controller: IETF</li>
          <li>Specification Document(s): <xref target="bind-tsl"/> of
          this document</li>
        </ul>
      </section>
      <section anchor="iana-uri">
        <name>URI Scheme</name>
        <t>IANA is requested to register the URI scheme "aiid" in the
        "Uniform Resource Identifier (URI) Schemes" registry with
        status Provisional per <xref target="RFC7595"/>: Scheme name:
        aiid; Status: Provisional; Applications/protocols: AIID
        identifiers for autonomous agents; Contact: the author; Change
        Controller: IETF; Reference: <xref target="syntax"/> 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.</t>
      </section>
      <section anchor="iana-media">
        <name>Media Types</name>
        <t>IANA is requested to register the following in the "Media
        Types" registry <xref target="RFC6838"/>:
        "application/aiid-status+jwt" (<xref target="resolve-op"/>),
        "application/aiid-receipt+jwt" (<xref target="receipt-format"/>),
        and "application/aiid-grant+jwt" (<xref target="grants"/>).  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: <xref target="security"/> 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 <xref target="RFC6838"/> by Section 7.2 of
        <xref target="RFC8417"/>.</t>
      </section>
    </section>
  </middle>
  <back>
    <references>
      <name>References</name>
      <references>
        <name>Normative References</name>
        <xi:include href="https://bib.ietf.org/public/rfc/bibxml/reference.RFC.2119.xml"/>
        <reference anchor="OpenID.CAEP" target="https://openid.net/specs/openid-caep-1_0-final.html">
          <front>
            <title>OpenID Continuous Access Evaluation Profile 1.0</title>
            <author><organization>OpenID Foundation</organization></author>
            <date year="2025" month="September"/>
          </front>
        </reference>
        <reference anchor="OpenID.SSF" target="https://openid.net/specs/openid-sharedsignals-framework-1_0-final.html">
          <front>
            <title>OpenID Shared Signals Framework Specification 1.0</title>
            <author><organization>OpenID Foundation</organization></author>
            <date year="2025" month="September"/>
          </front>
        </reference>
        <xi:include href="https://bib.ietf.org/public/rfc/bibxml/reference.RFC.9864.xml"/>
        <xi:include href="https://bib.ietf.org/public/rfc/bibxml/reference.RFC.8414.xml"/>
        <xi:include href="https://bib.ietf.org/public/rfc/bibxml-ids/reference.I-D.ietf-oauth-status-list.xml"/>
        <xi:include href="https://bib.ietf.org/public/rfc/bibxml/reference.RFC.9493.xml"/>
        <xi:include href="https://bib.ietf.org/public/rfc/bibxml/reference.RFC.8417.xml"/>
        <xi:include href="https://bib.ietf.org/public/rfc/bibxml/reference.RFC.8174.xml"/>
        <xi:include href="https://bib.ietf.org/public/rfc/bibxml/reference.RFC.3339.xml"/>
        <xi:include href="https://bib.ietf.org/public/rfc/bibxml/reference.RFC.3986.xml"/>
        <xi:include href="https://bib.ietf.org/public/rfc/bibxml/reference.RFC.5234.xml"/>
        <xi:include href="https://bib.ietf.org/public/rfc/bibxml/reference.RFC.6749.xml"/>
        <xi:include href="https://bib.ietf.org/public/rfc/bibxml/reference.RFC.7009.xml"/>
        <xi:include href="https://bib.ietf.org/public/rfc/bibxml/reference.RFC.7515.xml"/>
        <xi:include href="https://bib.ietf.org/public/rfc/bibxml/reference.RFC.7517.xml"/>
        <xi:include href="https://bib.ietf.org/public/rfc/bibxml/reference.RFC.7519.xml"/>
        <xi:include href="https://bib.ietf.org/public/rfc/bibxml/reference.RFC.7662.xml"/>
        <xi:include href="https://bib.ietf.org/public/rfc/bibxml/reference.RFC.8037.xml"/>
        <xi:include href="https://bib.ietf.org/public/rfc/bibxml/reference.RFC.8259.xml"/>
        <xi:include href="https://bib.ietf.org/public/rfc/bibxml/reference.RFC.8615.xml"/>
        <xi:include href="https://bib.ietf.org/public/rfc/bibxml/reference.RFC.8725.xml"/>
        <xi:include href="https://bib.ietf.org/public/rfc/bibxml/reference.RFC.9068.xml"/>
      </references>
      <references>
        <name>Informative References</name>
        <xi:include href="https://bib.ietf.org/public/rfc/bibxml/reference.RFC.6838.xml"/>
        <xi:include href="https://bib.ietf.org/public/rfc/bibxml/reference.RFC.8792.xml"/>
        <xi:include href="https://bib.ietf.org/public/rfc/bibxml/reference.RFC.6973.xml"/>
        <xi:include href="https://bib.ietf.org/public/rfc/bibxml/reference.RFC.7595.xml"/>
        <xi:include href="https://bib.ietf.org/public/rfc/bibxml/reference.RFC.8126.xml"/>
        <xi:include href="https://bib.ietf.org/public/rfc/bibxml/reference.RFC.8693.xml"/>
        <xi:include href="https://bib.ietf.org/public/rfc/bibxml/reference.RFC.8935.xml"/>
        <xi:include href="https://bib.ietf.org/public/rfc/bibxml/reference.RFC.8936.xml"/>
        <xi:include href="https://bib.ietf.org/public/rfc/bibxml/reference.RFC.9700.xml"/>
        <xi:include href="https://bib.ietf.org/public/rfc/bibxml-ids/reference.I-D.ietf-wimse-arch.xml"/>
        <xi:include href="https://bib.ietf.org/public/rfc/bibxml-ids/reference.I-D.ietf-wimse-identifier.xml"/>
        <xi:include href="https://bib.ietf.org/public/rfc/bibxml-ids/reference.I-D.ietf-wimse-workload-creds.xml"/>
        <xi:include href="https://bib.ietf.org/public/rfc/bibxml-ids/reference.I-D.ietf-wimse-aims.xml"/>
        <xi:include href="https://bib.ietf.org/public/rfc/bibxml-ids/reference.I-D.ietf-oauth-spiffe-client-auth.xml"/>
        <xi:include href="https://bib.ietf.org/public/rfc/bibxml-ids/reference.I-D.sogomonian-aiip-aiid.xml"/>
        <xi:include href="https://bib.ietf.org/public/rfc/bibxml-ids/reference.I-D.sogomonian-aiip-core.xml"/>
        <xi:include href="https://bib.ietf.org/public/rfc/bibxml-ids/reference.I-D.sogomonian-aiid-namespace.xml"/>
        <reference anchor="EU-AI-ACT" target="https://eur-lex.europa.eu/eli/reg/2024/1689/oj">
          <front>
            <title>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)</title>
            <author><organization>European Parliament and Council of the European Union</organization></author>
            <date year="2024" month="July"/>
          </front>
          <refcontent>Official Journal of the European Union, L series</refcontent>
        </reference>
        <reference anchor="BC-ARTEX" target="https://www.bleepingcomputer.com/news/security/chinese-hackers-use-artex-ai-in-automated-attacks-against-200-orgs/">
          <front>
            <title>Chinese hackers use ARTEX AI in automated attacks against 200 orgs</title>
            <author initials="B." surname="Toulas" fullname="Bill Toulas"><organization>BleepingComputer</organization></author>
            <date year="2026" month="November" day="2"/>
          </front>
          <refcontent>Reporting research by CrowdStrike</refcontent>
        </reference>
        <reference anchor="MS-ARTEX" target="https://www.microsoft.com/en-us/security/blog/2026/11/06/artex-abuse-expands-as-cybercriminals-target-financial-sector/">
          <front>
            <title>ARTEX abuse expands as cybercriminals target financial sector</title>
            <author><organization>Microsoft Threat Intelligence</organization></author>
            <date year="2026" month="November" day="6"/>
          </front>
          <refcontent>Microsoft Security Blog</refcontent>
        </reference>
        <reference anchor="CPR-ARTEX" target="https://research.checkpoint.com/2026/hacking-on-autopilot-inside-artex-cybercrime-campaigns/">
          <front>
            <title>Hacking on Autopilot: Inside ARTEX Cybercrime Campaigns</title>
            <author><organization>Check Point Research</organization></author>
            <date year="2026" month="November" day="5"/>
          </front>
        </reference>
        <reference anchor="UNIT42-CAIRN" target="https://unit42.paloaltonetworks.com/cairn-framework-ai-autonomous-attacks/">
          <front>
            <title>Attackers Use Autonomous AI to Target Semiconductor, Defense and Civil Society Sectors</title>
            <author><organization>Palo Alto Networks Unit 42</organization></author>
            <date year="2026" month="November" day="12"/>
          </front>
        </reference>
        <xi:include href="https://bib.ietf.org/public/rfc/bibxml/reference.RFC.9943.xml"/>
        <reference anchor="SPIFFE-ID" target="https://github.com/spiffe/spiffe/blob/main/standards/SPIFFE-ID.md">
          <front>
            <title>SPIFFE Identity and Verifiable Identity Document</title>
            <author><organization>SPIFFE Project</organization></author>
          </front>
        </reference>
      </references>
    </references>

    <section anchor="examples">
      <name>Examples</name>
      <t>Signatures and encodings are omitted; decoded JSON is shown.</t>
      <section>
        <name>Resolve Status Token</name>
        <sourcecode type="json"><![CDATA[
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"
  ]
}
]]></sourcecode>
        <t>The AIID itself is active, but a scope freeze on the SPIFFE
        trust domain places it in safe_mode.  RPs enforce
        aiid_effective_state.</t>
      </section>
      <section>
        <name>Resolve by Binding Without an AIID</name>
        <sourcecode type="text"><![CDATA[
GET /aiid/resolve?binding=spiffe%3A%2F%2Fprod.example.com%2Fns%2F
    batch%2Fsa%2Fetl HTTP/1.1
Host: agents.example.com
]]></sourcecode>
        <t>(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.</t>
      </section>
      <section anchor="ex-monitor">
        <name>Monitor State Change</name>
        <sourcecode type="text"><![CDATA[
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"}
]]></sourcecode>
      </section>
      <section>
        <name>Introspection Response</name>
        <t>The agent of <xref target="ex-monitor"/> is now in safe_mode.
        Because introspection reports "active": true only when the
        effective state is active
        (<xref target="bind-introspection"/>), the authorization server
        returns "active": false, whatever the token's scope, and includes
        "aiid_effective_state" to aid diagnosis.</t>
        <sourcecode type="json"><![CDATA[
{
  "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
}
]]></sourcecode>
      </section>
      <section>
        <name>CAEP Event</name>
        <sourcecode type="text"><![CDATA[
=============== 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"}
    }
  }
}
]]></sourcecode>
        <t>The event type URI is folded using the single-backslash
        strategy of <xref target="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.</t>
      </section>
      <section>
        <name>Receipt</name>
        <sourcecode type="json"><![CDATA[
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}
  ]
}
]]></sourcecode>
      </section>
      <section anchor="ex-versions">
        <name>Version Tracking Across Two Registries</name>
        <t>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.</t>
        <table anchor="tbl-ex-versions">
          <name>Version Tracking Example</name>
          <thead>
            <tr><th>Step</th><th>Input received by the RP</th><th>Records after the step</th><th>Effective state</th></tr>
          </thead>
          <tbody>
            <tr><td>t0</td><td>R1: X active v=40; N active sv=1<br/>R2: P active sv=2</td><td>X active v=40<br/>N active sv=1<br/>P active sv=2</td><td>active</td></tr>
            <tr><td>t1</td><td>Monitor freezes P at R2.  R2 event: P safe_mode sv=3</td><td>P safe_mode sv=3 (X unchanged, v=40)</td><td>safe_mode</td></tr>
            <tr><td>t2</td><td>Replayed old R2 token: P active sv=2</td><td>Ignored (2 &lt; 3: stale)</td><td>safe_mode</td></tr>
            <tr><td>t3</td><td>R1 refresh: X active v=40, aiid_effective_state active (R1 knows only N)</td><td>X active v=40 (same version, same state: not an error)</td><td>safe_mode</td></tr>
            <tr><td>t4</td><td>Scope Owner lifts P at R2.  R2: P active sv=4</td><td>P active sv=4</td><td>active</td></tr>
            <tr><td>t5</td><td>Stale R1 event: X suspended v=39</td><td>Ignored (39 &lt; 40: stale)</td><td>active</td></tr>
          </tbody>
        </table>
        <t>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.</t>
        <t>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
        (<xref target="caching"/>, <xref target="bind-ssf"/>) 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.</t>
      </section>
      <section anchor="ex-migration">
        <name>Migration Binding for a Dotted Identifier</name>
        <t>A Registry migrating an agent named with the dotted form of
        <xref target="I-D.sogomonian-aiid-namespace"/> records the old
        identifier as a binding of the new AIID.  An informative
        Registry record:</t>
        <sourcecode type="json"><![CDATA[
{
  "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"}
  ]
}
]]></sourcecode>
        <t>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.</t>
      </section>
    </section>

    <section anchor="prior">
      <name>Relationship to Earlier AIIF Drafts</name>
      <t>This appendix is informative.</t>
      <ul>
        <li>The AIID state machine, Monitor set-only rule, compare-and-set,
        fail-closed edges, and network-wide freeze are carried forward
        from the author's earlier AIID and AIIP drafts, with "HQ"
        renamed Accountable Owner and network-wide freeze generalized to
        scope freeze.</li>
        <li>The dotted identifier form of
        <xref target="I-D.sogomonian-aiid-namespace"/> (for example
        "aiid.acme.robot-01") is replaced by a URI form with a
        DNS-based namespace, so that AIIDs can be used directly as
        subject identifiers in JWT, SET, and SPIFFE/WIMSE contexts
        without a central root.  A Registry migrating from the dotted
        form may record the old identifier as a
        binding (<xref target="ex-migration"/>).</li>
        <li>The requirement that all agent action use a dedicated access
        network is withdrawn.  It is retained as the OPTIONAL gateway
        profile of <xref target="gateway"/>.</li>
        <li>New in this document: an Accountability and Attribution
        section (<xref target="accountability"/>) covering registration
        as a condition of access, records, retention, incident
        reconstruction, and cross-organization queries.</li>
        <li>New in this document: OAuth, introspection, SPIFFE, WIMSE,
        Token Status List, and SSF/CAEP bindings; signed status tokens;
        JWS receipts aligned with JWT claims.</li>
      </ul>
    </section>

    <section anchor="questions">
      <name>Open Questions</name>
      <t>This appendix is to be removed before publication.</t>
      <ol>
        <li>Identifier forms.  This document uses the "aiid" URI scheme,
        which keeps AIIDs recognizable and distinct from locators, and
        requests only Provisional registration
        (<xref target="iana-uri"/>).  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
        (<xref target="bindings"/>) of an "aiid" identifier as in this
        version?</li>
        <li>Should state changes use a dedicated SET event type rather
        than CAEP token-claims-change?</li>
        <li>Is the definition of consequential action best left entirely
        to RPs, or should a small common vocabulary be defined?</li>
        <li>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?</li>
        <li>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.</li>
        <li>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?</li>
        <li>Held-event timeout.  A pushed restrictive event is held until a
        verifying result arrives (<xref target="enforcement-replay"/>).
        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?</li>
        <li>Multi-tenant gateway authority.  A hosting operator in the
        profile of <xref target="gateway"/> 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?</li>
        <li>Which venue is appropriate for this work (WIMSE, OAuth, or
        another group)?</li>
      </ol>
    </section>
    <section anchor="acknowledgments" numbered="false">
      <name>Acknowledgements</name>
      <t>The author thanks an anonymous reviewer for a detailed review
      of an earlier version of this document.</t>
    </section>
  </back>
</rfc>
