| Internet-Draft | AI Agent Effect Finality | November 2026 |
| Das | Expires 21 May 2027 | [Page] |
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.¶
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.¶
Copyright (c) 2026 IETF Trust and the persons identified as the document authors. All rights reserved.¶
This document is subject to BCP 78 and the IETF Trust's Legal Provisions Relating to IETF Documents (https://trustee.ietf.org/license-info) in effect on the date of publication of this document. Please review these documents carefully, as they describe your rights and restrictions with respect to this document.¶
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:¶
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).¶
Relative to the companion documents listed in Appendix B, this document contributes:¶
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.¶
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.¶
Industry-standard equivalents, for readers who use other vocabulary:¶
| 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 |
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).¶
The following are engineering targets, not proved guarantees:¶
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.¶
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?"¶
| 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.¶
+-----------+ 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.
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.¶
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.¶
{
"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>"
}
¶
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": []
}
¶
{
"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.¶
{
"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.¶
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:¶
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)
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.¶
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
| 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.¶
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:¶
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.¶
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).¶
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.¶
| 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.¶
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.¶
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.¶
| 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.¶
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.¶
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.¶
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:¶
| 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.¶
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.¶
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.¶
| 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.¶
| 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 |
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.¶
| 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.¶
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).¶
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.¶
This document has no IANA actions. Identifiers shown are illustrative.¶
The answers below reflect the author's current understanding, which may contain inaccuracies. Critical technical review and correction are invited.¶
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.¶
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).¶
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].¶
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.¶
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]).¶
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.¶
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.¶
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.¶
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).¶
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.¶
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).¶
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.¶
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.¶
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.¶
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.¶
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.¶
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.¶
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.¶
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.¶
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 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.¶
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.¶
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.¶
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.¶
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.¶
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 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.¶
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.¶
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.¶