Internet-Draft AI Agent Effect Finality November 2026
Das Expires 21 May 2027 [Page]
Workgroup:
Independent Submission
Internet-Draft:
draft-das-ai-agent-cyberattack-effect-finality-00
Published:
Intended Status:
Informational
Expires:
Author:
S. Das
Independent

AI Safety: When AI Agents Initiate Cyberattacks -- Execution Finality for Data Exfiltration, Payment Diversion, Infrastructure Changes, and Code-Executing Agents

Abstract

Problem. An AI agent can cause an unauthorized real-world effect -- a confidential data export, a payment to a substituted beneficiary, a network or industrial configuration change, a code deployment or a secret release -- while every individual check succeeds: the model accepted a plausible task, the agent held a valid credential, the tool call was syntactically permitted, and the gateway saw an allowed method. The gap is that the check and the effect are not the same thing. Identity and access controls answer "may this principal call this interface?"; they do not, by themselves, answer "may this exact effect, with these resolved targets and values, complete now, on this route, given what has already happened?"

Solution. This document describes an execution-finality profile for AI-initiated operations. An agent's proposal is held as a non-effective Candidate Act. A protected validator compares a canonical descriptor of the operation actually about to be committed with a source-authority envelope that model-editable content cannot create or enlarge. A Finality Sink, which owns the effect-causing credential or commit right, verifies an act-bound, non-bearer Execution Handle over the same bytes it commits, consumes it atomically with the commit, and emits an authenticated destination receipt. Later phases and retries are gated on that receipt rather than on the agent's own report. Unknown outcomes become INDETERMINATE and are reconciled before any retry.

Context. The document analyses four scenarios (enterprise data exfiltration, payment diversion, critical-infrastructure configuration manipulation, and code-executing agents), specifies data objects, a Candidate Act state machine, atomic consumption and crash-recovery rules, sink trust, delegation attenuation, protocol placement for tool and agent-to-agent calls, revocation freshness, latency placement, legacy integration and a falsifiable evaluation plan. It is a prospective architecture: no measured latency, blocking rate or deployment is claimed. A reviewer FAQ is included. Critical technical review is invited.

Status of This Memo

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

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

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

This Internet-Draft will expire on 21 May 2027.

▲

Table of Contents

1. Introduction

1.1. The Problem Space

Documented agent risks include indirect prompt injection through retrieved content, tool misuse, excessive agency, and AI-orchestrated intrusion activity in which humans select targets while agents perform most operational steps [OWASP-AGENTIC] [NIST-AI-100-2] [ANTHROPIC-ESPIONAGE] [MITRE-T1698]. The consequential event in each case is not model text. It is a committed effect: bytes leaving an organization, funds moving, a rule installed in a controller, a commit merged, a secret released.

Mature deployments already constrain many of these effects with identity and access management, Zero Trust policy enforcement points [NIST-SP-800-207], attribute-based access control [NIST-SP-800-162], data-loss prevention, payment risk engines, change management and operational-technology safety systems [NIST-SP-800-82]. This document does not claim that such controls are inherently bypassable. It identifies four narrower residual gaps that appear in partial deployments:

  1. After authorization, before effect: the target, amount, scope or destination changes between an approval and the operation actually committed.
  2. After a first effect, before continuation: reported success is false, late or missing, and the agent continues or retries on its own account.
  3. Across routes: the same outcome is reachable through a direct API, a queue consumer, an administrative interface, a hosted tool or a delegated agent that does not pass the expected gate.
  4. Across transformations: a benign-looking entry operation causes material transitive effects through stored procedures, workflow rules, controller reconciliation or downstream fan-out.

1.2. Why Common Protocol Work Is Needed

Each of these gaps can be closed locally by a single vendor for a single resource. The cross-vendor problem is that an agent's operation typically crosses an orchestrator, a tool server, an identity provider, a gateway and a destination owned by different parties. Without a shared representation of "the act that was authorized", a shared rule for binding authority to that act at the commit point, and a shared form for destination evidence, each hop re-decides on partial information. The objects and rules in this document are intended as a basis for that shared representation; they reuse existing IETF mechanisms where they fit (Section 12.3).

1.3. What Is New in This Document

Relative to the companion documents listed in Appendix B, this document contributes:

  • an adversary model and four end-to-end scenarios specific to AI-initiated attacks, each with a best-practice conventional baseline for comparison;
  • an explicit rule that the sink verifies a digest computed over the final bytes it is about to commit (time-of-check to time-of-use closure, Section 7);
  • a Candidate Act state machine with permitted transitions and the component allowed to trigger each (Section 8);
  • crash-consistency rules for atomic consumption across shards and failover (Section 9);
  • delegation attenuation rules for multi-agent systems (Section 11);
  • placement for tool calls and agent-to-agent calls, and a comparison with OAuth Rich Authorization Requests, Token Exchange, DPoP and Transaction Tokens (Section 12);
  • a bounded-staleness model for revocation and offline leases (Section 13);
  • a code-executing-agent scenario and an output-channel (response egress) profile (Section 17, Section 18);
  • a falsifiable evaluation plan against a strong conventional baseline (Section 22) and a reviewer FAQ (Appendix A).

1.4. Scope and Non-Goals

In scope: consequential operations that have a narrow protected commit point -- data export or publication, payment initiation, capture and settlement phases, privileged configuration activation, credential or secret release, code merge and deployment, and command activation.

Not in scope: deciding whether a model should follow an instruction; validating every token, packet, database row or radio/actuator control cycle; replacing safety-certified interlocks; controlling external payment rails that the deploying party does not operate; and preventing harmful actions that are within a correctly specified authority. A valid policy can still authorize a bad decision.

2. Conventions and Terminology

The key words "MUST", "MUST NOT", "REQUIRED", "SHALL", "SHALL NOT", "SHOULD", "SHOULD NOT", "RECOMMENDED", "NOT RECOMMENDED", "MAY", and "OPTIONAL" in this document are to be interpreted as described in BCP 14 [RFC2119] [RFC8174] when, and only when, they appear in all capitals, as shown here. This is an Informational document; requirement keywords describe the profile, not an Internet standard.

Candidate Act:
An operation proposed by an agent, orchestrator or tool that has no external effect until released by a Finality Sink.
Source-Authority Envelope (SAE):
A protected record of what a principal actually authorized (purpose, permitted targets, recipients, amounts, scopes, phases, expiry, policy epoch). It is held outside any model-editable context. Prompt content, retrieved documents and model assertions cannot create or enlarge it.
Candidate Act Descriptor (CAD):
A canonical representation of the operation as it will actually be committed: resolved target resources, effective identity, destination, amounts, data scope, configuration delta and phase.
Execution Handle:
A short-lived, non-bearer authorization object bound to one CAD digest, one Finality Sink, one phase, the SAE, and the policy and revocation epochs. Possession alone does not authorize the effect.
Finality Sink:
The component that makes an effect real and owns the effect-causing credential or commit right (an export gateway, payment gateway, configuration admission controller, deployment controller, secret broker, response-release gate).
Protected Enforcement Domain (PED):
The execution environment in which the validator, consume state and sink signing keys reside, isolated from the agent runtime.
Destination Receipt:
An authenticated statement originated by the destination system of record (or an independent protected observer) of what was committed. A receipt is evidence; it is never usable as a handle.
Continuation Authority:
Authority for a later phase that is granted only on presentation of a valid receipt for the preceding phase.
Covered Route:
A path capable of producing a protected effect that is mediated by a Finality Sink, disabled, or restricted. Every other path is uncovered and MUST be declared as such.
INDETERMINATE:
The outcome classification used when the sink cannot establish whether an effect was committed (for example, timeout after submission).

Industry-standard equivalents, for readers who use other vocabulary:

Table 1
Term here Closest established term Difference
Finality Sink Policy Enforcement Point at the resource; commit gate; reference monitor Placed at the point where the effect becomes real, and owns the effect credential
Execution Handle Sender-constrained, fine-grained access token; capability Bound to the digest of the exact act and to one sink, consumed with the commit
SAE Authorization details; mandate; change ticket Held outside model-editable context; compared with the reconstructed act
Destination Receipt Transaction status, acknowledgement, signed log entry Originated by the destination; gates continuation and retry
INDETERMINATE Unknown commit outcome; in-doubt transaction Blocks retry until reconciled with the system of record

3. Adversary Model and Trust Assumptions

3.1. Attacker Capabilities

The attacker MAY: place instructions in retrieved documents, tickets, web pages, telemetry or tool outputs; mislead or fully control the agent's reasoning; cause the agent to invoke any tool the agent can reach with any syntactically valid arguments; substitute tool responses returned to the agent; replay or reorder requests; exploit broad credentials the agent already holds; cause timeouts and induce retries; delegate to other agents; and modify mutable business records the agent can write (for example, a beneficiary master record).

3.2. Assumptions

A1:
The Finality Sink and the validator are not both compromised. If both are, the controls in this document may fail.
A2:
The SAE is created through a channel the agent cannot write (an authenticated human approval, a mandate store, a change system).
A3:
Signature and hash primitives are not broken, and keys are held in the PED.
A4:
The consume store is linearizable for each handle.
A5:
The route inventory is complete for the routes declared as covered. Correctness of the inventory is an operational property that this document cannot prove.
A6:
Policy correctness is enforced, not verified: the architecture enforces the SAE and policy as written.

3.3. Engineering Invariants

The following are engineering targets, not proved guarantees:

I1 No agent-derived authority:
No content reaching the model can create or enlarge an SAE.
I2 Exact act:
A handle authorizes only the CAD digest it binds, at the sink it names, in the phase it names.
I3 Same bytes:
The sink verifies the digest of the bytes it commits, not a digest supplied by the caller.
I4 Single consumption:
Each handle produces at most one committed effect (or, for envelope handles, at most the declared count and aggregate ceiling).
I5 No unobserved alternate effect:
Every known act-equivalent route is covered or declared uncovered.
I6 No blind continuation:
A later consequential phase requires a valid receipt for the preceding phase.
I7 No blind retry:
An INDETERMINATE outcome is reconciled before any retry of the same intent.
I8 Attenuation:
Delegated authority is a subset of the delegator's authority.

3.4. Informal Bound

Under A1-A6, the probability that an unauthorized protected effect completes on a covered route is bounded informally by

  Pr[unauthorized effect on covered route]
      <= e_hash + e_sig + e_store + e_path + e_recon

where e_hash and e_sig are cryptographic failure probabilities, e_store is the probability of a consume-store linearizability failure, e_path the probability that a route believed covered is not, and e_recon the probability that the CAD reconstruction omits a load-bearing field. The last two terms dominate in practice and are the targets of the evaluation plan.

4. Relationship to Existing Controls and Guidance

Resource-level policy enforcement is long established. NIST SP 800-207 places a Policy Decision Point and Policy Enforcement Point in front of enterprise resources [NIST-SP-800-207]; NIST SP 800-162 describes attribute-based decisions over subject, object, action and environment [NIST-SP-800-162]. Current agent-security guidance recommends scoped access, least privilege and runtime controls [OWASP-AGENTIC] [OWASP-CHEATSHEET] [CISA-AGENTIC]. This document builds on those mechanisms. The question a PEP typically answers is "may this subject access this resource with this action?" The additional question addressed here is "may this exact, reconstructed effect complete now, on this route, in this phase, given the destination evidence for earlier phases?"

Table 2
Existing control What it already prevents Residual gap addressed here
Prompt filtering / model guardrails Many malicious instructions and disallowed outputs Accepted injection or legitimate-looking misuse still reaches an authorized tool
IAM, OAuth, RBAC/ABAC Calls without valid identity, role, scope or policy A broad valid token may not encode beneficiary, dataset, fan-out or side effect
API gateway / agent firewall Unapproved endpoints, syntax, quota, contextual policy Hosted tools, direct credentials, queues or secondary APIs bypass an app-side gate
DLP and egress control Inspected, classified data movement Encrypted or transformed payload; allowed destination with wrong purpose; unmanaged egress
Payment risk and approval Abnormal payments, limits, mandates Approval-to-capture divergence; duplicate phase replay; connector drift
SIEM / EDR / audit Anomalies, investigation Evidence after an irreversible effect; logs from compromised components
Zero Trust resource PEP Resource access with contextual policy A complete effect-aware PEP may already implement much of this; added value is phase continuity and route closure
OT interlocks / safety PLC Unsafe physical states A semantically wrong change that stays within safety limits

Where a deployment's PEP already reconstructs the effect, mediates all routes, binds phases and verifies outcomes, the incremental benefit of this profile may be marginal, and the profile serves mainly as a common representation for interoperability.

5. Architecture Overview

 +-----------+ proposal +-------------+  CAD  +-------------+
 | AI agent  |--------->| Candidate   |------>| Validator   |
 | (no       |          | Act (NON_   |       | (PED): SAE, |
 | authority)|          | EFFECTIVE)  |       | epochs      |
 +-----------+          +-------------+       +------+------+
                                                     | Execution
                                                     v Handle
 +-------------+ receipt +---------------+ commit +----------+
 | Continua-   |<--------| Finality Sink |------->| Effect   |
 | tion / next |         | (owns effect  |        | (system  |
 | phase/retry |         | credential;   |        | of       |
 +-------------+         | recomputes    |        | record)  |
                         | CAD; consumes)|        +----------+
                         +---------------+
 Other routes to the same effect: covered by a sink, disabled,
 restricted, or declared UNCOVERED.
Figure 1: Trust-and-Effect Chain

Minimum components: (1) an SAE held outside model-editable context; (2) a CAD resolved from actual arguments, target resources, effective identities and state; (3) an independent validator checking scope, policy and revocation epochs and protected counters; (4) a PED owning the effect-causing credential or commit right; (5) Finality Sinks on all covered routes; (6) destination-originated or observer-originated receipts; (7) HOLD and reconcile handling for unresolved effects.

6. Data Objects

Objects are shown as JSON for readability. Implementations MUST use a deterministic canonical form for digests: JSON Canonicalization Scheme [RFC8785] or deterministic CBOR [RFC8949]. Digests use SHA-256 unless a profile states otherwise. Field names are illustrative; no registry is requested by this document.

6.1. Source-Authority Envelope

{
  "sae_id": "sae-7f3a",
  "principal": "user:finance-approver-12",
  "created_via": "approval-ui/authenticated",
  "purpose": "pay-invoice",
  "consequence_class": "FINANCIAL",
  "constraints": {
    "beneficiary_legal_entity": "Supplier A Ltd",
    "beneficiary_account_digest": "sha256:9c1e...",
    "invoice_ref": "INV-2026-0441",
    "currency": "EUR",
    "max_amount_minor": 1250000,
    "rails": ["SEPA-CT"],
    "phases": ["INITIATE"]
  },
  "policy_epoch": 418,
  "revocation_epoch": 77,
  "not_after": "2026-11-18T12:00:00Z",
  "sig": "<PED signature over canonical form>"
}

6.2. Candidate Act Descriptor

The CAD digest MUST cover every load-bearing field, that is, every field whose change would change the consequence. Fields that do not change the consequence (trace identifiers, formatting) SHOULD be excluded so that equivalent operations produce equal digests. Missing load-bearing information MUST be represented as UNKNOWN, never as an empty or default value, and UNKNOWN in a load-bearing field MUST cause HOLD or DENY.

{
  "cad_version": 1,
  "act_id": "act-55d1",
  "intent_id": "int-0441",
  "sae_id": "sae-7f3a",
  "act_type": "PAYMENT_INITIATE",
  "sink_id": "sink:treasury-gw-eu-1",
  "effective_identity": "svc:treasury-gw",
  "resolved": {
    "beneficiary_account_digest": "sha256:9c1e...",
    "beneficiary_name": "Supplier A Ltd",
    "amount_minor": 1250000,
    "currency": "EUR",
    "rail": "SEPA-CT",
    "fees_minor": 0
  },
  "phase": "INITIATE",
  "payload_digest": "sha256:<digest of final wire message>",
  "transitive_effects": []
}

6.3. Execution Handle

{
  "eh_id": "eh-a90c",
  "cad_digest": "sha256:<digest of canonical CAD>",
  "sink_id": "sink:treasury-gw-eu-1",
  "phase": "INITIATE",
  "sae_id": "sae-7f3a",
  "policy_epoch": 418,
  "revocation_epoch": 77,
  "reuse_policy": "SINGLE_USE",
  "parent_eh": null,
  "delegation_depth": 0,
  "nbf": "2026-11-17T18:00:00Z",
  "exp": "2026-11-17T18:02:00Z",
  "holder_key_thumbprint": "<optional proof-of-possession key>",
  "sig": "<validator signature in PED>"
}

The handle is non-bearer in the sense that the sink authorizes only the act whose recomputed digest equals cad_digest; a holder that presents the handle with a different act obtains nothing. Holder key binding (for example DPoP [RFC9449]) MAY be added as an additional layer, but key binding without act and sink binding is a token-theft mitigation, not an exact-act control.

6.4. Destination Receipt

{
  "receipt_id": "rcpt-31b8",
  "act_id": "act-55d1",
  "eh_id": "eh-a90c",
  "cad_digest": "sha256:...",
  "sink_id": "sink:treasury-gw-eu-1",
  "origin": "system-of-record:psp-eu",
  "phase": "INITIATE",
  "outcome": "ACCEPTED_FOR_PROCESSING",
  "committed_state_digest": "sha256:...",
  "sor_reference": "PSP-TX-88123",
  "counter": 90211,
  "observed_at": "2026-11-17T18:00:41Z",
  "sig": "<signature by destination or protected observer>"
}

The outcome field MUST distinguish states that are legally or technically distinct (for payments: ACCEPTED_FOR_PROCESSING, AUTHORIZED, CAPTURED, SETTLED, REJECTED; for configuration: STAGED, ACTIVATED, READBACK_MATCHED, READBACK_MISMATCH). A transport-level success or agent text is not a receipt. Receipt authenticity is necessary but not sufficient: the origin must itself be trustworthy and must observe the consequential effect.

7. Exact-Effect Binding at the Commit Point

A check performed on a request and an effect committed from different bytes leaves a time-of-check to time-of-use window. Connectors, retry workers, template expansion, beneficiary lookup and controller rendering can all change the operation after approval. The sink therefore MUST:

  1. construct the final committable message (wire payload, SQL statement and parameters, rendered configuration, deployment manifest) before verification;
  2. recompute the CAD from that final message and from current resolved state (for example, the beneficiary account the connector will actually use), never trusting a CAD or digest supplied by the caller;
  3. verify the handle signature, expiry, sink, phase and cad_digest against the recomputed CAD (VERIFY_STATIC);
  4. inside the same atomic section as consume and commit, re-read the current policy epoch, revocation epoch and protected counters (VERIFY_CURRENT);
  5. commit exactly the verified bytes, with no further transformation after verification.
function sink_commit(handle, request):
    msg  = build_final_message(request)   # bytes to be committed
    cad  = reconstruct_cad(msg, resolve_live_state(msg))
    if cad.has_unknown_load_bearing():
        return HOLD("EF-UNKNOWN-FIELD")
    if not verify_static(handle, digest(cad), SINK_ID):
        return DENY("EF-STATIC")
    begin_atomic(handle.eh_id):
        if not verify_current(handle, epochs(), counters()):
            abort_atomic(); return DENY("EF-STALE")
        if consume_state(handle.eh_id) != UNUSED:
            abort_atomic(); return DENY("EF-REPLAY")
        write_consume(handle.eh_id, PENDING, digest(cad))   # durable
        result = commit(msg)                     # the effect
        if result.known:
            write_consume(handle.eh_id, COMMITTED, result.ref)
        else:
            write_consume(handle.eh_id, INDETERMINATE, null)
    end_atomic()
    return emit_receipt(handle, cad, result)
Figure 2: Sink Procedure (Pseudocode)

When the destination is external and cannot participate in the atomic section (for example, a third-party payment API), the sink MUST record PENDING durably before submission and MUST use a destination idempotency key derived from act_id, so that a later reconciliation can establish whether the submission took effect.

8. Candidate Act State Machine

  NON_EFFECTIVE --validate ok--> AUTHORIZED --commit ok--> COMMITTED
     |     |                       ^  |   |
     |     +--needs approval--> HELD  |   +--no ack--> INDETERMINATE
     |                                |                     |
     |                   expiry --> EXPIRED            reconcile
     |                                                      |
     +--mismatch / UNKNOWN / stale --> DENIED               v
                                          RECONCILED_COMMITTED or
                                          RECONCILED_NOT_COMMITTED
Figure 3: States and Transitions
Table 3
Transition Triggered only by Condition
NON_EFFECTIVE to AUTHORIZED Validator Reconstructed CAD within SAE; epochs current; handle issued
NON_EFFECTIVE to HELD Validator Policy requires approval, or scope exceeds SAE but is approvable
HELD to AUTHORIZED Validator, after authenticated approval Approval bound to the same CAD digest (what is displayed is what is executed)
any to DENIED Validator or sink Mismatch, UNKNOWN load-bearing field, revoked or stale authority
AUTHORIZED to COMMITTED Sink Atomic consume and commit with known outcome
AUTHORIZED to INDETERMINATE Sink Commit attempted; outcome unknown
INDETERMINATE to RECONCILED_* Reconciler using system of record Authoritative status obtained
AUTHORIZED to EXPIRED Sink or validator Handle past exp without consumption

The agent triggers no transition. A new attempt for the same intent_id while any act for that intent is AUTHORIZED, HELD or INDETERMINATE MUST be refused (one live authority per intent). Compensation for a committed effect is a new Candidate Act with a new handle; it is never an undo of a consumed handle. The state machine is small enough to be checked with model-checking tools such as TLA+; doing so is part of the evaluation plan.

9. Atomic Consumption, Idempotency and Crash Recovery

10. Trust in the Sink and the Validator

11. Delegation and Attenuation in Multi-Agent Systems

When agent A delegates a sub-task to agent B, B does not receive A's credentials. B receives, at most, the ability to request handles under a derived SAE. The following rules apply:

  1. A derived SAE MUST be a subset of its parent in every constraint dimension (targets, recipients, amounts, data scope, phases, expiry). The validator, not the delegating agent, computes and signs the derived SAE.
  2. Aggregate ceilings are shared: the sum of effects under all derived SAEs MUST NOT exceed the parent ceiling. The validator tracks this in protected counters.
  3. Handles record parent_eh and delegation_depth; a maximum depth is set per consequence class.
  4. Revoking a parent SAE revokes all derived SAEs.
  5. A delegated agent's statement that a sub-task succeeded is not a receipt; continuation depends on destination receipts.

This is the attenuation property of capability systems applied to agent delegation; it prevents a sub-agent from accumulating authority that no human principal granted.

12. Placement in Tool-Call and Agent-to-Agent Protocols

12.1. Tool Calls

For a tool protocol such as the Model Context Protocol [MCP], the tool server that holds the effect credential is the natural Finality Sink. A "tools/call" request is a Candidate Act. The tool server reconstructs the CAD from the arguments it will actually use and from live state, and commits only on a valid handle. Tools that only read non-sensitive data need not participate. Hosted or provider-side tools that the deploying party cannot instrument are uncovered routes unless the destination enforces.

An illustrative HTTP carriage, not a registered scheme:

POST /v1/payments HTTP/1.1
Host: treasury-gw.example
Authorization: EFHandle eh=<base64url(handle)>
Idempotency-Key: act-55d1
Content-Type: application/json

Failures SHOULD be returned as problem details [RFC9457] with an explicit reason (UNKNOWN field, stale epoch, replay, mismatch).

12.2. Agent-to-Agent Calls

A request from one agent to another is not itself an effect. The receiving agent's eventual effects pass through their own sinks under a derived SAE (Section 11). Agent-to-agent messages SHOULD carry the parent SAE identifier and intent_id so that one live authority per intent can be enforced across agents.

12.3. Relationship to OAuth Mechanisms

Table 4
Mechanism What it provides What this profile adds
OAuth 2.0 [RFC6749] Delegated access tokens with scopes Scopes do not bind a resolved act; the handle binds a CAD digest and a sink
Rich Authorization Requests [RFC9396] Structured authorization_details describing an intended act RAR can describe the act; it does not by itself require the resource to recompute the act from final bytes, consume authority with the commit, or gate continuation on a destination receipt. RAR authorization_details are a suitable carrier for SAE constraints.
Token Exchange [RFC8693] Exchange of one token for another, including delegation and impersonation semantics Attenuation rules and shared aggregate ceilings across derived authorities
DPoP [RFC9449] Sender-constrained tokens Binding to the act and sink, not only to a key
Transaction Tokens [TXN-TOKENS] Propagation of immutable context through a call chain inside a trust domain Commit-time verification, consumption and receipt-gated continuation at the effect point

A practical deployment can therefore carry SAE constraints in RAR, derive sub-agent authority with Token Exchange, constrain the holder with DPoP, propagate context with Transaction Tokens, and add the act-bound handle, sink recomputation, consumption and receipts described here.

13. Revocation and Freshness

The validator maintains a monotonic policy epoch and revocation epoch per consequence class. Sinks hold a protected local copy. The maximum time during which a revoked authority could still be honoured on a covered route is bounded by

  W_stale <= min( handle_lifetime , D_prop + d_sink ) + T_hot

  D_prop : maximum time for an epoch change to reach the sink
  d_sink : maximum sink cache age before mandatory refresh
  T_hot  : sink verify-to-commit time

Each consequence class SHOULD declare a target W_stale. If the sink cannot confirm its epoch copy is within d_sink, it MUST HOLD.

Offline leases. Where connectivity to the validator is intermittent (edge, OT, satellite), a protected edge controller MAY hold a signed, time-bounded lease for a pre-approved operation set. The lease declares T_off_max (maximum offline exposure), a monotonic counter that cannot be rolled back, and the safe state on expiry. Revocation lag during offline operation is bounded by T_off_max and MUST be accepted explicitly in the safety case.

14. Scenario A: AI-Driven Enterprise Data Exfiltration

Legitimate work: an agent summarizes supplier contracts and sends approved reports to a known partner. Attack: indirect prompt injection in a supplier PDF directs the agent to query an expanded confidential dataset and upload it to an attacker-controlled bucket.

Table 5
Stage What may happen Consequence to prevent
Ingest Agent treats document text as instruction Untrusted content as instruction source
Plan Broad query and export endpoint chosen Privilege used outside purpose
Query Authorized read identity retrieves large set Collection beyond business scope
Export Upload to unapproved domain or bucket Irreversible disclosure
Continue Agent reports success, starts more exports Cascading exfiltration

Profile: the SAE records the purpose, permitted classifications, recipients, columns or row predicates, volume ceiling and expiry. The export service or egress proxy is the sink and owns the upload credential; the agent never holds it. The sink reconstructs the CAD from the effective query plan or result-set classification, row count, tenant, encryption target, resolved destination account and endpoint, and the content hash of the final object or manifest. Mismatched recipient, classification or scope yields HOLD or DENY. The destination or export gateway emits the receipt; further exports require it, and the volume ceiling is enforced cumulatively across acts (closing fragmented exfiltration).

Placement in existing estates: storage gateway or bucket policy requiring a scoped export authorization; a controlled export procedure for SQL, with trigger and definer-rights effects included in the CAD; the tool server's broad service credential replaced with a non-effectuating request interface; DLP and TLS inspection retained.

Residual: an approved destination later compromised; inaccurate classification; scheduled jobs outside the gateway; leakage in the model's own response (Section 18); onward forwarding by an allowed recipient; side channels.

15. Scenario B: AI-Initiated Payment Diversion

A treasury agent is asked to pay a valid invoice for Supplier A. An attacker manipulates a vendor instruction, purchase-order field, stored beneficiary record or connector response so the submitted transaction pays another account. The request is well formed and sent under a legitimate credential.

Profile: the SAE binds payer, legal beneficiary and account digest, invoice reference, currency, amount, FX conditions, rail, phase and expiry. The payment gateway is the sink and holds the transaction credential. It reconstructs the CAD from the beneficiary and routing data the connector will actually submit (not the agent's displayed confirmation), including fees, FX and split payments. Exposure is reserved atomically per invoice and act_id; split captures that together exceed the approved total are refused by the cumulative counter. Each phase (initiate, authorize, capture, settle) is a separate act with its own handle; continuation requires a receipt identifying the actual accepted or posted state from the PSP or bank. A timeout becomes INDETERMINATE and is reconciled using the idempotency key before any retry. Payment rails and participant rules remain authoritative; the profile does not control external settlement.

Residual: beneficiary master data that is wrong at approval time; partner APIs that do not expose transaction identity or idempotency; settled payments that are costly to reverse. The profile aims to prevent unauthorized phases, not to promise rollback.

16. Scenario C: Critical-Infrastructure Configuration Manipulation

An operations agent may propose changes to a network slice, an industrial gateway or an OT management system. Injected telemetry or ticket text induces a change outside the approved envelope: a policy rule, route redirection, slice resource change, security-control disablement or unsafe maintenance command.

Profile: the SAE binds the change ticket, target nodes or slices, configuration delta, maintenance window, topology assumptions and permitted failure mode. Changes are staged as non-effective. The sink is the controller admission point, configuration activation or hardware-rule installation step. The CAD is reconstructed from the actual target set, dependent resources, transitive controller effects and generated hardware or network rules, compared with live desired and observed state. The receipt is an acknowledged installed-state version or independent readback; fleet-scale continuation requires bounded verified outcomes from an initial subset where the effect is divisible.

Placement: slice or service-management configuration activation and security-policy commit; non-real-time control policy and approved application deployment in O-RAN management; remote engineering commands and recipe or setpoint changes in OT; Kubernetes admission and firewall or route installation in cloud and edge. Per-frame, per-packet, scheduler and near-real-time control loops are not suitable boundaries without measured proof.

Safety: this profile complements safety-certified interlocks and MUST NOT replace them or delay a protective action [NIST-SP-800-82]. "Fail closed" is not universally safe. When validation is unavailable, the system enters the safe state selected by its operational safety case. Vendor maintenance ports, local panels and alternate automation paths that retain unrestricted authority are uncovered routes.

17. Scenario D: Code-Executing and Computer-Use Agents

Coding and computer-use agents run shell commands, edit repositories, push commits, trigger CI/CD pipelines, and request secrets. Injected content in an issue, dependency README or web page can direct the agent to add a malicious dependency, exfiltrate environment variables, push to a protected branch, or deploy to production.

Consequential boundaries in this setting are few and identifiable:

Table 6
Boundary Sink CAD fields
Secret release Secret broker Secret identifier, requesting workload, destination process or environment, purpose, lifetime
Push / merge to protected branch Repository server pre-receive or merge gate Repository, branch, commit digest set, changed paths, dependency manifest delta
Pipeline or deployment Deployment controller Artifact digest, target environment, manifest digest, rollout scope
Network egress from the sandbox Egress proxy Resolved destination, payload digest, volume
Package publication Registry publish gate Package name, version, artifact digest

Commands confined to an isolated workspace without credentials or egress are not consequential and need no handle; this keeps the interactive loop fast. The agent's sandbox SHOULD hold no long-lived credentials; the secret broker releases only act-bound, short-lived secrets into a destination it can identify. A CI job's report of success is not a receipt; the deployment controller's readback of the running artifact digest is.

18. Output-Channel (Response Egress) Profile

Data can leave through the agent's own response to a user or to another system, without any export tool. Where the response is delivered across a trust boundary (to an external user, a partner system, or a lower-classification tenant), the response-release point can be treated as a Finality Sink: the CAD records the recipient, the classifications of sources that contributed to the response (via retrieval provenance), and a digest of the response; the SAE states which classifications may be released to that recipient. Missing provenance is UNKNOWN, not "no sensitive sources". This profile limits disclosure scope; it does not detect paraphrase of protected content from sources whose provenance was never recorded, and it is not a content classifier.

19. Latency, Throughput and Availability

Design principle: move heavy validation away from high-rate inference, packet and actuator paths into rare consequential commit boundaries.

  T_finality = T_intercept + T_reconstruct + T_policy
             + T_protected_state + T_crypto + T_sink_commit
             + T_optional_remote

The quantity of interest is incremental p50/p95/p99/p99.9 delay relative to a comparable best-practice baseline, not an isolated signature-verification benchmark. Overhead-limiting strategies: precompile policy and target descriptors (cold path) so the sink performs deterministic verification (hot path); co-locate the validator with the sink; gate only consequence classes; bind a canonical manifest for batches instead of signing each row or packet, and refuse hidden additions after manifest approval; verify a signed lease once and then apply a lightweight local match until expiry; deliver receipts asynchronously except where they gate the next phase.

Tail hazards include remote policy stores, HSM contention, cold starts, partitions, counter lock contention and shared receipt services. Under overload, the sink MUST NOT silently fall back to allow; bounded queues, partitioned counters, circuit-breaker HOLD and pre-authorized emergency paths are preferred. Monitor false-denial rate, non-effective dwell time, receipt age, reconciliation time and cache staleness. No specific millisecond figure is asserted by this document.

20. Legacy Integration

Table 7
Available point Approach Coverage claim
Native transaction hook Plug in reconstruction and protected commit authorization Strong if all equivalent routes use the hook
Mature resource PEP Extend with act and phase binding; reuse policy May already satisfy much of the model
API gateway or tool dispatcher Hold the effect credential; inspect material arguments Covered routes only
Queue or workflow engine Consumers verify handle before commit; outbox and idempotency Requires all consumers to enforce
Closed appliance Management boundary, credential isolation, compensating controls No native sink claim without proof

Migration in five stages: inventory every act-equivalent path (credentials, admin channels, scheduled jobs, delegated workers, queue consumers, maintenance interfaces); observe with shadow policy and CAD logging; constrain by removing broad credentials from agents and inserting one sink at one high-value boundary; enforce with consumption and HOLD/reconcile semantics; expand only after alternate-path closure is demonstrated.

What cannot be promised: a shim in front of a service does not protect a direct admin API that bypasses it; a token in an agent runtime does not make an external rail secure; a signed receipt from a compromised destination does not prove the truthful effect; a non-bypassability statement is limited to the resources, versions and routes for which coverage has been demonstrated.

21. Bypass, Replay and Failure-Mode Analysis

Table 8
Case Rule Residual
Injection changes agent intent Retrieved content never amends the SAE In-scope harmful acts remain possible
Direct credential bypass Remove unmanaged credentials; sink rejects acts without handles Unmanaged credential = uncovered route
Destination changed after approval Recompute CAD at commit from final bytes Endpoint and beneficiary resolution must be controlled
Stale policy or revocation VERIFY_CURRENT inside atomic section Offline lease window
Replay or parallel race Per-handle CAS; one live authority per intent Failover consistency
Lost acknowledgement INDETERMINATE; reconcile before retry Delayed finality at system of record
Fragmentation Cumulative ceilings across acts and delegates Cross-principal decomposition
Receipt presented as handle Distinct object types; sink rejects None expected
Approval fatigue Approval bound to CAD digest and shown in full Human error
Hardware offload mismatch Readback of installed rules before continuation Hardware API availability
Validator unavailable HOLD or predeclared lease; never silent bypass Availability and safety trade-off
Malicious validator or sink Attestation, separation of roles, multi-party checks Joint compromise outside guarantee

22. Falsifiable Evaluation Plan

Test arms: A, a basic agent with ordinary tool access (measures the unprotected failure mode only); B, a strong conventional baseline with guardrails, scoped IAM, DLP and egress, a resource PEP, approvals, logging, idempotency and native safeguards; C, the B baseline plus this profile.

Attack variants include: prompt injection; tool-output substitution; benign-looking wrong endpoint; scope escalation; multi-step delegation; stale authority after revocation; reordering; duplicate webhook; lost acknowledgement; expired handle; direct credential route; alternate API route; stored-procedure transitive effect; fragmented exfiltration; split payment capture; changed beneficiary master record; replayed configuration; controller reconciliation to stale state; validator outage; failover race; compromised receipt source; poisoned dependency in a coding task; secret request to an unidentified destination.

Table 9
Measure Acceptance condition
Unauthorized commits at covered sinks Target zero over the test corpus; publish coverage limits
Alternate-path completions Target zero on routes declared covered
Legitimate task completion No unacceptable false-denial regression
Incremental tail latency Within the declared SLO per consequence class
Outcome classification No silent retry after unresolved effect
Revocation Observed staleness within declared W_stale
Safety No missed safety-case requirement

Formal checks: model the state machine of Section 8 and the consume rules of Section 9 in a model checker and check I4 (single consumption) and I7 (no blind retry) under crash, failover and message reordering. An advantage exists only if arm C blocks cases arm B does not, at acceptable latency, cost and availability. A negligible difference against a complete effect-aware baseline is a valid result and should be reported.

23. Relevance to IETF Work

24. Limitations and Open Problems

25. Security Considerations

This document is about security. The principal risks of deploying it are: (1) false confidence from declaring routes covered that are not; (2) incomplete CAD reconstruction that authorizes an act differing in an unmodelled field; (3) denial of service through deliberate HOLD-inducing requests or validator overload; (4) unsafe fail-closed behaviour in physical systems; (5) treating receipts from compromised origins as truth; (6) canonicalization disagreements between validator and sink implementations in different languages. Mitigations: publish declared coverage with each deployment; fail closed on UNKNOWN load-bearing fields and canonicalization failure; rate-limit Candidate Acts per principal and intent; define safe states per safety case; diversify receipt origins; maintain cross-implementation canonicalization test vectors including negative vectors (duplicate keys, Unicode normalization, numeric forms).

26. Privacy Considerations

SAEs, CADs and receipts can contain personal data (beneficiary names, data subjects, recipients). Implementations SHOULD place digests rather than values in objects that leave the PED, retain receipts only for the period required by the consequence class, and avoid using receipt logs as a general activity record of users.

27. IANA Considerations

This document has no IANA actions. Identifiers shown are illustrative.

28. References

28.1. Normative References

[RFC2119]
Bradner, S., "Key words for use in RFCs to Indicate Requirement Levels", BCP 14, RFC 2119, DOI 10.17487/RFC2119, , <https://www.rfc-editor.org/info/rfc2119>.
[RFC8174]
Leiba, B., "Ambiguity of Uppercase vs Lowercase in RFC 2119 Key Words", BCP 14, RFC 8174, DOI 10.17487/RFC8174, , <https://www.rfc-editor.org/info/rfc8174>.

28.2. Informative References

[ANTHROPIC-ESPIONAGE]
Anthropic, "Disrupting the first reported AI-orchestrated cyber espionage campaign", , <https://www.anthropic.com/news/disrupting-AI-espionage>.
[CISA-AGENTIC]
CISA and international partners, "Careful Adoption of Agentic AI Services", , <https://content.govdelivery.com/accounts/USDHSCISA/bulletins/41544ff>.
[DAS-BOUNDARY]
Das, S., "When AI Agents Hold the Keys: Threat Model and Execution-Finality Requirements for Autonomous High-Consequence Systems", Work in Progress, Internet-Draft, draft-das-agentic-effectuation-boundary, , <https://datatracker.ietf.org/doc/draft-das-agentic-effectuation-boundary/>.
[DAS-CBEA]
Das, S., "Consequence-Bound Execution Authority for Autonomous Systems", Work in Progress, Internet-Draft, draft-das-consequence-bound-execution-authority-00, , <https://datatracker.ietf.org/doc/html/draft-das-consequence-bound-execution-authority-00>.
[DAS-COMPOSITE]
Das, S., "Partial Commit Is Not Finality: Composite Execution Finality", Work in Progress, Internet-Draft, draft-das-composite-execution-finality, , <https://datatracker.ietf.org/doc/draft-das-composite-execution-finality/>.
[DAS-HANDLE]
Das, S., "Possession Is Not Authority: Execution Handles, Sink Verification, Atomic Consume and Finality Receipts", Work in Progress, Internet-Draft, draft-das-execution-handle, , <https://datatracker.ietf.org/doc/draft-das-execution-handle/>.
[DAS-IEV]
Das, S., "Receipt-Gated IEV", Work in Progress, Internet-Draft, draft-das-receipt-gated-iev, , <https://datatracker.ietf.org/doc/draft-das-receipt-gated-iev/>.
[DAS-PATH]
Das, S., "When the Gate Can Be Bypassed: Consequence-Path Completeness for Execution Finality", Work in Progress, Internet-Draft, draft-das-consequence-path-completeness, , <https://datatracker.ietf.org/doc/draft-das-consequence-path-completeness/>.
[DAS-REFIMPL]
Das, S., "Execution-Finality Reference Implementation: Runnable implementation for AI agents, GPUs, confidential computing, and zero-trust automation", , <https://github.com/sangmdas/Execution-Finality-for-AI-Agents-GPUs-Confidential-Computing-and-Zero-Trust-Automation>.
[DAS-REVOCATION]
Das, S., "Revoked but Still Executable: Closing the Authorization-to-Effect Gap with Finality-Bound Revocation", Work in Progress, Internet-Draft, draft-das-finality-bound-revocation, , <https://datatracker.ietf.org/doc/draft-das-finality-bound-revocation/>.
[DAS-TOOL]
Das, S., "tool_use Is Not invoke(): Binding Execution-Finality to Agent Tool Calls", Work in Progress, Internet-Draft, draft-das-agentic-tool-binding, , <https://datatracker.ietf.org/doc/draft-das-agentic-tool-binding/>.
[DAS-ZENODO]
Das, S., "The Internet Solved Communication. It Never Solved Authority", DOI 10.5281/zenodo.22082995, , <https://zenodo.org/records/22082995>.
[MCP]
Model Context Protocol project, "Model Context Protocol Specification", , <https://modelcontextprotocol.io/specification>.
[MITRE-T1698]
MITRE ATT&CK, "Indirect Prompt Injection (Technique T1698)", , <https://attack.mitre.org/techniques/T1698/>.
[NIST-AI-100-2]
NIST, "Adversarial Machine Learning: A Taxonomy and Terminology of Attacks and Mitigations", NIST AI 100-2e2025, , <https://csrc.nist.gov/pubs/ai/100/2/e2025/final>.
[NIST-SP-800-82]
NIST, "Guide to Operational Technology (OT) Security", NIST SP 800-82r3, , <https://csrc.nist.gov/pubs/sp/800/82/r3/final>.
[NIST-SP-800-162]
NIST, "Guide to Attribute Based Access Control (ABAC) Definition and Considerations", NIST SP 800-162, , <https://csrc.nist.gov/pubs/sp/800/162/upd2/final>.
[NIST-SP-800-207]
NIST, "Zero Trust Architecture", NIST SP 800-207, , <https://csrc.nist.gov/pubs/sp/800/207/final>.
[OWASP-AGENTIC]
OWASP GenAI Security Project, "Top 10 Risks and Mitigations for Agentic AI Security", , <https://genai.owasp.org/2025/12/09/owasp-genai-security-project-releases-top-10-risks-and-mitigations-for-agentic-ai-security/>.
[OWASP-CHEATSHEET]
OWASP, "AI Agent Security Cheat Sheet", , <https://cheatsheetseries.owasp.org/cheatsheets/AI_Agent_Security_Cheat_Sheet.html>.
[RFC6749]
Hardt, D., Ed., "The OAuth 2.0 Authorization Framework", RFC 6749, DOI 10.17487/RFC6749, , <https://www.rfc-editor.org/info/rfc6749>.
[RFC8693]
Jones, M., Nadalin, A., Campbell, B., Ed., Bradley, J., and C. Mortimore, "OAuth 2.0 Token Exchange", RFC 8693, DOI 10.17487/RFC8693, , <https://www.rfc-editor.org/info/rfc8693>.
[RFC8785]
Rundgren, A., Jordan, B., and S. Erdtman, "JSON Canonicalization Scheme (JCS)", RFC 8785, DOI 10.17487/RFC8785, , <https://www.rfc-editor.org/info/rfc8785>.
[RFC8949]
Bormann, C. and P. Hoffman, "Concise Binary Object Representation (CBOR)", STD 94, RFC 8949, DOI 10.17487/RFC8949, , <https://www.rfc-editor.org/info/rfc8949>.
[RFC9334]
Birkholz, H., Thaler, D., Richardson, M., Smith, N., and W. Pan, "Remote ATtestation procedureS (RATS) Architecture", RFC 9334, DOI 10.17487/RFC9334, , <https://www.rfc-editor.org/info/rfc9334>.
[RFC9396]
Lodderstedt, T., Richer, J., and B. Campbell, "OAuth 2.0 Rich Authorization Requests", RFC 9396, DOI 10.17487/RFC9396, , <https://www.rfc-editor.org/info/rfc9396>.
[RFC9449]
Fett, D., Campbell, B., Bradley, J., Lodderstedt, T., Jones, M., and D. Waite, "OAuth 2.0 Demonstrating Proof of Possession (DPoP)", RFC 9449, DOI 10.17487/RFC9449, , <https://www.rfc-editor.org/info/rfc9449>.
[RFC9457]
Nottingham, M., Wilde, E., and S. Dalal, "Problem Details for HTTP APIs", RFC 9457, DOI 10.17487/RFC9457, , <https://www.rfc-editor.org/info/rfc9457>.
[TXN-TOKENS]
Tulshibagwale, A., Fletcher, G., and P. Kasselman, "Transaction Tokens", Work in Progress, Internet-Draft, draft-ietf-oauth-transaction-tokens, <https://datatracker.ietf.org/doc/draft-ietf-oauth-transaction-tokens/>.

Appendix A. Reviewer FAQ

The answers below reflect the author's current understanding, which may contain inaccuracies. Critical technical review and correction are invited.

A.1. Is this not simply a Zero Trust Policy Enforcement Point?

It is a PEP placed at a particular point and given particular inputs. A PEP in [NIST-SP-800-207] enforces access decisions for a subject and resource. The profile here additionally requires the enforcement point to own the effect credential, recompute the act from the final bytes, consume single-use authority with the commit, and gate later phases on destination receipts. Where an existing PEP already does all of this, the profile adds interoperability, not new protection.

A.2. OAuth RAR already describes the act. What is missing?

RAR [RFC9396] carries a structured description of the intended act to the authorization server and into the token. It does not by itself require the resource server to recompute the act from what it will actually commit, to consume authority atomically with the commit, or to refuse continuation without a destination receipt. RAR is a good carrier for SAE constraints (Section 12.3).

A.3. Is this two-phase commit or a saga under another name?

Two-phase commit coordinates atomicity among participants that agree to commit; it does not decide whether a participant is authorized to commit a specific act. A saga coordinates compensations after effects. This profile decides authorization at the commit point and treats compensation as a new authorized act. Multi-sink atomicity is addressed in [DAS-COMPOSITE].

A.4. Does this stop prompt injection?

No. It assumes injection may succeed in changing the agent's intent. It limits what a successfully injected agent can make real to effects inside the SAE on covered routes. Harmful acts within the SAE remain possible.

A.5. What if the agent holds another credential?

Then the route using that credential is uncovered. The profile requires removing effect credentials from agent runtimes and declaring any remaining route as uncovered. This is the largest practical dependency ([DAS-PATH]).

A.6. How can the sink reconstruct the act for complex resources?

Only the sink that first makes the effect real needs to reconstruct, and it already has to construct the effect to perform it. Reconstruction is hardest where effects are transitive (triggers, controller reconciliation). Where a field cannot be resolved, it is UNKNOWN and the act is held. Completeness of reconstruction is an open problem (Section 24) and is measured, not assumed.

A.7. What if the sink or validator is compromised?

If both are compromised, the controls may fail (A1). Attestation, separate administration and multi-party validation reduce the likelihood of joint compromise (Section 10); they do not eliminate it.

A.8. How much latency does this add?

No figure is claimed. Validation is placed at rare consequential commits, with policy precompiled so the hot path is deterministic verification and a per-handle compare-and-swap. Tail latency must be measured against a comparable baseline (Section 19). Hard real-time loops are excluded.

A.9. Is fail-closed always correct?

No. In physical systems, blocking can itself be unsafe. The safe state on validator or store unavailability is defined by the operational safety case, and the profile does not override interlocks (Section 16).

A.10. Why trust a destination receipt more than the agent's report?

The agent, its proxy or its tool may be compromised; the destination system of record is a different trust domain that observed the effect. A receipt is only as trustworthy as its origin, which is why receipt origin is recorded and diversification is recommended.

A.11. What happens on timeout after submission?

The act becomes INDETERMINATE, and no retry of the same intent is permitted until reconciliation with the system of record using the idempotency key establishes whether the effect occurred (Section 9).

A.12. Can an attacker split one large act into many small ones?

Cumulative ceilings in protected counters apply across acts and across delegated agents under the same SAE. Decomposition across different principals with different SAEs remains an open problem.

A.13. How does this work with multiple cooperating agents?

Delegated agents receive derived SAEs that are strict subsets with a shared ceiling, computed by the validator (Section 11). No agent passes its credentials to another.

A.14. Where does it sit in MCP or similar tool protocols?

At the tool server that owns the effect credential, for tools whose effect is consequential (Section 12). Read-only, non-sensitive tools need not participate. Provider-hosted tools that cannot be instrumented are uncovered unless the destination enforces.

A.15. Does it require a TEE or HSM?

No. Keys and consume state must be isolated from the agent runtime; HSM or TEE isolation is recommended for higher consequence classes. A software-only PED provides weaker assurance and should be declared as such.

A.16. Does it address data leaking through the model's own answer?

Only partially, through the output-channel profile (Section 18), which limits release by source classification and recipient. It does not detect paraphrase of protected content whose provenance was not recorded.

A.17. Why bring this to the IETF?

Because the act crosses components from different parties, a shared representation of the authorized act, of commit-time binding, and of destination evidence is a protocol interoperability question. The mapping to existing working groups is in Section 23.

A.18. How would one show this profile does not help?

Run the evaluation of Section 22. If a strong conventional baseline (arm B) blocks the same attack corpus with equal coverage and comparable latency, the profile offers no security gain for that deployment, and that result should be published.

A.19. Why not simply bind the token to a key, as DPoP does?

Key binding stops a stolen token from being used by a different holder. It does not stop the legitimate holder, including a compromised agent, from using the token for a different act than the one approved. The handle binds the digest of the exact act and the sink, so an authorized key holder obtains nothing for a different act. Key binding MAY be layered on top as a token-theft mitigation.

A.20. If the handle is stolen, can it be used?

Only for the single act whose recomputed digest it binds, at the sink it names, in its phase, before expiry, and once. A thief presenting it with a different act is refused. A thief who can cause the same act to be submitted gains nothing beyond what was already authorized. Lifetime is kept short (minutes), and holder key binding can further restrict presentation.

A.21. What if the validator and the sink canonicalize differently?

A disagreement means the digests differ and the handle fails verification, which is a fail-closed outcome. The risk is the opposite case: two different operations that canonicalize to the same bytes. This is addressed by using one canonical form (JCS or deterministic CBOR), rejecting duplicate keys and ambiguous encodings, treating UNKNOWN differently from empty or default, and maintaining shared cross-language test vectors, including negative vectors. Canonicalization failure is DENY, never allow.

A.22. Who decides which fields are load-bearing?

The consequence-class profile for each sink type, reviewed by the owner of the resource. A field is load-bearing if changing it changes the consequence (beneficiary account, destination, data scope, target set, artifact digest). Ordinary trace identifiers are excluded so equivalent operations produce equal digests. An omitted load-bearing field is the main source of reconstruction error, so profiles should be tested by mutating every field, and the evaluation plan counts any undetected mutation as a failure.

A.23. What does the human approver see, and is it what executes?

Approval is bound to the CAD digest. The approval interface renders the reconstructed act (resolved beneficiary, destination, data scope, configuration delta), not the agent's description of it. If the act changes after approval, the digest changes and the approval no longer applies. This addresses displayed-versus-executed divergence but not approver fatigue or an approver who approves a harmful act.

A.24. Does this replace human oversight or risk management?

No. It is a technical enforcement mechanism that can implement a decision to require approval or to limit scope. It does not decide policy, does not evaluate whether an authorized action is wise, and does not substitute for organizational risk management or safety cases.

A.25. How does this relate to the EU AI Act?

The profile does not make a system compliant and this document makes no legal conclusion. For high-risk AI systems, the Act sets requirements on risk management, logging and record-keeping, human oversight, and accuracy, robustness and cybersecurity. Technical measures of the kind described here (enforced scope limits at the effect point, authenticated records of what was actually committed, approvals bound to the exact act, and defined failure behaviour) may be among the measures a provider selects. Whether they are sufficient is a determination for the provider against the legal text, harmonised standards and guidance, not for this document.

A.26. Do receipts and logs create privacy or data-protection concerns?

They can, because they record beneficiaries, recipients and data scopes. Objects that leave the protected domain should carry digests rather than values, retention should follow the consequence class, and receipt logs should not become a general activity record about individuals. Data-protection review of retention and access is a deployment task.

A.27. What if the agent regenerates slightly different arguments on retry?

A different argument set is a different act with a different CAD digest, so the earlier handle does not apply. To prevent resubmit-until-accepted behaviour, the profile allows only one live authority per intent_id. A new attempt for an intent with an AUTHORIZED, HELD or INDETERMINATE act is refused until that act is resolved.

A.28. What is the smallest useful first deployment?

One high-value boundary with a narrow commit point, such as an export service or a payment gateway in a sandbox. Remove the effect credential from the agent runtime, reconstruct the act at that boundary in shadow mode first, then enforce. Measure attempted versus completed unauthorized effects, tail latency and false denials against a strong conventional baseline before expanding.

Appendix B. Companion Documents and Resources

Preparation Note

The architecture is the author's. Parts of the analysis, scenario descriptions and editorial preparation were AI-assisted. Industry references describe published material only and imply no affiliation, endorsement, adoption or implementation by any organization.

Author's Address

Sangam Das
Independent
Balasore
Odisha
India