| Internet-Draft | Agentic Cyberattack Execution Finality | November 2026 |
| Das | Expires 22 May 2027 | [Page] |
Autonomous AI agents can now carry out parts of a cyber operation that previously needed repeated human effort: reconnaissance, tool selection, execution attempts, observation of results, and adaptation when a route fails. An attacker-controlled agent does not have to malfunction to be dangerous; it can follow malicious instructions efficiently, using stolen credentials and well-formed requests that existing controls accept as valid.¶
This document describes a defender-side architecture, called execution finality, that adds one bounded layer to existing security controls. An incoming request, credential, permitted API call, or agent-composed workflow does not by itself create authority for a sensitive consequence. The defender reconstructs the operation that would actually take effect, holds it in a non-effective state, evaluates authorization independently of the requester, and enforces the result at an enforcement point located at or immediately before the protected consequence. The document specifies placement rules, requirements, state handling, failure behavior, latency strategy, and test methods. It uses publicly reported AI-assisted activity against Taiwanese government agencies in 2026 as an illustrative threat scenario and does not claim that the architecture would have prevented that activity.¶
This note is to be removed before publishing as an RFC.¶
This is an individual, independent-submission Internet-Draft. It is a technical proposal and has not been adopted by any IETF working group. It reports no measured performance, formal proof, or deployment results.¶
Basis of disclosure: this document is based on the international patent application PCT/IB2026/055615, filed 4 June 2026 and publicly disclosed (published as WO 2026/150382 A2) on 16 July 2026. The full filing can be read by searching "Sangam Das" on WIPO PATENTSCOPE, by searching PCT/IB2026/055615 (pctib202655615), or at https://www.tdcommons.org/dpubs_series/12542/ . The filing text, not this draft, is authoritative for the patent disclosure.¶
Any mention of third-party products, standards, or organizations is for technical context only. It is not an endorsement, validation, or statement of infringement, and no third-party adoption is implied.¶
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 22 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.¶
Much AI safety work addresses accidental failure: hallucination, misalignment, or unintended tool use. A separate problem is deliberate use. An attacker supplies the objective, and AI agents perform substantial parts of the work: finding targets, choosing tools, trying routes, reading results, and trying another route when one is blocked.¶
On 13 August 2026, Taiwan's Ministry of Digital Affairs publicly confirmed that government agencies had been targeted during July 2026 by an overseas campaign using both conventional techniques and AI agents, and stated that its defenses detected the abnormal activity and that the affected agencies handled the incident [TAIWAN-MODA]. The background rate is also high: Taiwan's National Security Bureau reported an average of roughly 2.63 million intrusion attempts per day against its infrastructure in 2025 [TAIWAN-NSB]. Public reporting does not establish the intrusion path, the protected resources involved, or what would have happened under any alternative defense. This document therefore treats the incident only as an illustrative scenario (Section 17).¶
The lesson drawn here is narrow. An AI agent need not "go rogue." It can follow hostile instructions competently. When it does, the target system often sees a valid credential, a well-formed request, and a permitted API call. Authentication and coarse authorization answer whether a caller may use a function or resource. They do not always answer whether this specific operation, with this final payload and destination, may take effect now.¶
This document describes a complementary layer that asks that second question at the point of consequence. It does not replace identity and access management, zero trust architectures, endpoint detection, network security, or transactional controls. It identifies where those controls may leave a gap and specifies what an additional enforcement layer needs in order to close it.¶
This document covers defender-controlled systems that can commit, release, transmit, or actuate a protected effect, for example a data export, a configuration change, a secret release, a financial posting, or an actuator command. It does not attempt to control, detect, or attribute the attacker's AI. It does not address model training, alignment, or content moderation.¶
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.¶
The names below describe architectural roles in this proposal. They are not established protocol or standard terms.¶
A traditional operation often needs a human to inspect each result and decide the next step. An AI-assisted operation can compress that loop:¶
Human objective
-> one or more AI agents
-> reconnaissance
-> target and vulnerability analysis
-> tool selection
-> attempt
-> observe response
-> re-plan / try another path
-> attempted external consequence
¶
The defender's problem is not that the agent has an unusual intent. It is that adaptation is cheap, retries are fast, and each attempt can look like ordinary authenticated traffic.¶
The attacker MAY:¶
The model assumes the attacker does not simultaneously compromise the Finality Sink, the Protected Validator, the authority store, and all audit and reconciliation channels. See Section 23.¶
The defender cannot require the attacker's AI to use any guardrail, logging, identity scheme, or policy. Controls placed inside the attacker's agent are therefore out of scope. The enforcement opportunity begins when a request reaches a defender-controlled system.¶
For a Protected Consequence, the existence of a machine-generated request, a valid credential, a technically permitted API call, or a statement of authorization MUST NOT by itself cause the effect. The effect occurs only when bounded authority bound to the exact Candidate Act is verified at the Finality Sink.¶
Corollary: an agent that discovers a new route, tool, or vulnerability MUST NOT thereby gain authority over any additional Protected Consequence. Adaptation changes how an attempt arrives. It does not change what is authorized.¶
ATTACKER DOMAIN | DEFENDER TRUST BOUNDARY
|
Hostile AI / |
stolen credential |
| |
| ordinary |
| request |
+--------------->| Protected service / API
| |
| v
| Reconstruct Candidate Act
| |
| v
| Non-Effective State (staged)
| |
| v
| Protected Validator
| (act, destination, purpose,
| quantity, time, policy epoch,
| revocation, cumulative exposure)
| |
| +----+---------------+
| | |
| deny / hold / issue Bounded
| reconcile Authority
| | |
| v v
| NO EFFECT Finality Sink
| (fail closed) verifies act-bound,
| current authority
| |
| v
| PROTECTED EFFECT + Receipt
The Candidate Act is created on the defender side. No cooperation from the attacker or the attacker's AI is assumed. The Protected Validator and Finality Sink SHOULD be separated from the requesting workload so that compromise of the workload does not directly yield authority.¶
The architecture reduces to four principles.¶
A summary of the invariant: machine decision is not machine authority. The AI may reason, adapt, discover, and request. Authority to turn computation into consequence stays independently bounded, verifiable, and enforceable at the protected consequence boundary.¶
A common misunderstanding is that this architecture needs the attacking AI to run inside, or take part in, the protected system. It does not.¶
Consider a hostile AI running entirely on infrastructure outside the target organization. It learns that an employee account can reach a sensitive government database, obtains valid credentials, and sends an apparently ordinary request such as "retrieve records matching these identifiers." The request arrives over an encrypted, authenticated channel through a legitimate API, and the application holds database permission. Traditional authentication did its job. None of those facts establishes that the resulting consequence is authorized.¶
The attacker does not need to send anything called a Candidate Act and may know nothing about the architecture. The protected system interprets the requested consequential operation as a Candidate Act before allowing the effect:¶
External request
-> application receives request
-> application proposes "release protected records"
-> protected architecture treats the proposal as a Candidate Act
-> Candidate Act remains NON-EFFECTIVE
-> protected validation
-> finality decision
¶
The security property resides with the defender. The attacker cannot avoid the gate by declining to participate, provided the protected consequence cannot be reached through another unmediated path. This is analogous to a building's access-control system: a visitor does not need to implement it, because the building does.¶
Traditional compromise often creates a chain: compromise an account, inherit its permissions, use application privileges, reach data, reach the network, create a consequence. Agentic AI makes this worse because the attacker can automate the search for ways to exploit inherited privileges. The architecture attempts to interrupt that propagation:¶
Invariant: compromise of an upstream authority SHOULD NOT automatically propagate into unrestricted authority over downstream consequences.¶
The Finality Sink SHOULD be located in the lowest practical trusted component that exclusively controls the Protected Consequence, and all equivalent paths MUST converge on it. A check placed higher in the stack is supplementary, not final, if an alternate API, batch job, privileged account, internal service, or direct driver can reach the same effect without passing through it.¶
An API gateway or agent dispatcher that approves a request but leaves downstream workers, direct database connections, alternate cloud APIs, scheduled tasks, or maintenance routes able to produce the same result is not a complete boundary. In distributed systems there MAY be several cooperating sinks, each governing its own consequential transition.¶
| Protected effect | Sink location |
|---|---|
| Sensitive database export | Protected query-result release or export service, before records leave the trusted data domain; paired with egress controls |
| Database mutation or deletion | Database transaction commit, privileged write service, or enforced stored-program effect boundary |
| File or object disclosure | Object-store retrieval or release gateway, or protected key release, before plaintext is externally usable |
| Network exfiltration | Exclusive egress gateway or protected transmission release boundary, coordinated with data-origin controls |
| Cloud administration | Privileged cloud-control API execution proxy or enforcement service, before the resource or configuration change |
| Credentials and secrets | HSM- or KMS-backed secret release, issuance, signing, or privileged credential activation |
| MCP and agent tool workflows | Destination tool-effect gateway or protected service; an MCP proxy alone is insufficient if direct access remains |
| Financial transfer | Capture, payment authorization, ledger posting, or settlement execution boundary appropriate to the effect |
| Industrial and robotics | Trusted actuator command gate, safety controller, or protected physical output interface |
| Telecom and 6G networks | Configuration commit, privileged control-plane transition, or transmission authorization; PHY and HARQ timing loops are avoided |
This section describes the information each object needs. It does not define a wire format. A future revision, or a profile for a specific protocol, could define serialization, canonicalization, and signature suites.¶
Implementers can build much of this from existing primitives, such as signed tokens, hash binding, and fine-grained authorization details [RFC9396], token exchange [RFC8693], sender-constrained tokens [RFC9449], and remote attestation [RFC9334]. This document does not claim novelty for any of them individually. The point of the architecture is the integrated invariants in Section 7.¶
An implementation SHOULD track each Candidate Act through the following states.¶
Consumption of Bounded Authority and the effect SHOULD be atomic where the substrate allows. Where it cannot be, the sink MUST persist consumption durably before the effect and MUST resolve INDETERMINATE acts by reconciliation, not by re-issuing authority.¶
Existing controls remain necessary. The comparison below is a shorthand for where an additional layer may add value, not a claim that existing controls cannot do these things. A well-engineered policy enforcement point under attribute-based access control or zero trust [NIST-SP-800-207] can already evaluate action-specific attributes and may implement much of what is described here.¶
| Control | What it provides | Remaining question |
|---|---|---|
| Authentication | Establishes who or what is calling | Is this specific consequence authorized, even for a valid caller? |
| IAM, RBAC, ABAC | Resource- and attribute-level permission | Is the enforcement point at the actual effect, and does it bind the final payload? |
| OAuth tokens and authorization details | Scoped and sender-constrained delegation | Does the sink verify the final effective payload, target, and version, and the commit outcome? |
| Sandboxing | Contains a process | What if the legitimate environment already exposes a harmful capability? |
| Firewall, IDS/IPS, EDR, zero trust | Detect and constrain | If an action is technically possible and reaches the protected system, does it hold bounded authority? |
| Model guardrails | Reduce unsafe model output | Cannot be the final boundary against an attacker who controls the model or prompt |
| Logging and audit | Evidence after the effect | Can authorization evidence exist before the effect? |
For tool-using agents, an agent-to-tool dispatch policy, for example at an MCP client or proxy, is useful but advisory. The enforcement point that matters is the tool server's effect executor or the downstream target API or credential broker. Tool output MUST NOT be treated as proof that an effect was committed. For agent-to-agent handoff, parent identity and task metadata do not by themselves grant new power; a child action needs authority issued by a trusted delegator that attenuates the parent's restrictions.¶
If execution authority were an ordinary transferable token, a compromised application could steal and replay it, recreating the original problem one layer down: steal a credential to gain access becomes steal a finality token to gain effectuation authority. Authority SHOULD therefore not behave as a bearer credential whose possession alone suffices. It can instead be tied to protected state for the intended consequence, which may include protected workload identity, Candidate Act attributes, purpose, resource, destination, security epoch, freshness state, protected execution environment, and sink-local consumption state. Copying an authorization artifact SHOULD NOT reproduce the authority needed to effectuate the consequence. Stealing evidence of authority is not the same as stealing the authority.¶
Destination control is especially important against AI-assisted attacks. A legitimate government application may normally export reports to an authorized repository. A compromised process may instead try to send sensitive records to an external endpoint. At the coarse level of "the application has network access" both look alike, but the consequences differ completely. Destination SHOULD be part of the authorization decision: authorized resource, purpose, and destination pass; an authorized resource with an unauthorized destination fails. Broad network permission is not consequence-specific authority.¶
An employee or AI assistant may legitimately access personnel data for payroll administration. That does not imply authority to use the same data for external profiling, unrelated analytics, disclosure, model training, or export. Conventional access control sees an authorized user and an authorized database. A finality check can additionally evaluate authorized purpose and authorized consequence. This matters in agentic settings because AI can combine individually legitimate capabilities in ways nobody anticipated when the permissions were granted.¶
Suppose an agent holds three individually authorized capabilities: read internal documents, summarize information, send email. The agent reads a confidential document, extracts sensitive information, summarizes it, and sends the summary to an unauthorized external recipient. Every tool operated correctly. The harm arises from the composition, which exposes a limit of tool-by-tool permission models. The question cannot always stop at whether the AI was permitted to call the send tool. It may need to be whether the consequence produced by this sequence was authorized.¶
The final external disclosure SHOULD be treated as the protected Candidate Act. The chain of tool calls ends in a candidate disclosure that stays NON-EFFECTIVE until validation confirms destination, purpose, and scope. For multi-step workflows, consequential steps SHOULD be authorized by their own effects, and later authority SHOULD be bound to verified earlier outcomes where necessary. A workflow-level permission MUST NOT become blanket permission for every later tool and destination.¶
An attacker can split one large export into thousands of small acts that each pass a per-act limit. Implementations SHOULD enforce aggregate budgets across time windows, destinations, identities, and related operations, using protected accounting that cannot be reset by changing tools or sessions. They MUST account for parallel requests and races so that simultaneous small transfers cannot together exceed the authorized exposure budget.¶
Tool invocation authority is not the same as consequence finality authority. An AI MAY be permitted to prepare an operation without being permitted to finalize it:¶
The intelligence layer decides what to do. The protected finality layer decides whether this particular consequence may occur. Finality controls are targeted at the transition where a proposed action becomes consequential, not at every internal computation.¶
Not every computation needs finality enforcement. The architecture matters most near the point where an action becomes externally usable, externally visible, financially settled, physically actuated, transmitted, committed, disclosed, or otherwise hard to reverse. Drafting an email is not sending it. Calculating a payment is not settling it. Generating an industrial command is not moving the actuator. Preparing a database update is not committing it. Reading sensitive data internally is not necessarily releasing it externally. Staging itself MUST NOT leak the effect indirectly, because temporary files, logs, telemetry, caches, and previews can become release channels.¶
Human approval of every action does not scale when autonomous systems produce hundreds, thousands, or millions of machine-speed decisions. Granting broad standing authority to avoid constant approvals creates excessive risk. A third option is machine-verifiable bounded authorization: humans or organizational policy define the authorized envelope; machines generate Candidate Acts; protected mechanisms check each act against the envelope at effectuation time; humans intervene where policy requires escalation. This does not remove human oversight. It moves human judgment to defining authority and handling escalations.¶
A permissive system that executes when authorization is missing, stale, ambiguous, unverifiable, revoked, inconsistent, or unavailable, and investigates afterwards, is dangerous for high-consequence autonomous systems. A human operator may make one questionable decision. An autonomous system may repeat a mistaken assumption across thousands of operations before anyone notices. Fail-closed enforcement limits the ability of uncertainty to propagate into real-world consequences. The safety-critical qualification in Section 7 R8 still applies.¶
A perfect log of an unauthorized action does not prevent it. After money has moved, data has escaped, an actuator has moved, or a command has been transmitted, excellent audit evidence is valuable but insufficient. Traditional audit runs effect then evidence. Execution finality runs authorization evidence then effect. This does not remove audit; it changes the time relationship between evidence and consequence. For high-consequence machine actions, the strongest evidence is evidence that had to exist before the system permitted the consequence.¶
The finality layer MUST be evaluated against strong configurations of existing controls, not against a straw-man perimeter firewall. Modern security already includes transaction-level authorization, data-loss prevention, egress controls, database activity monitoring, and hardware isolation. The defensible claim is narrower than "conventional systems fail": existing controls can be correctly implemented and still leave a gap between permission to invoke an interface and authorization for its specific downstream consequence.¶
Authentication verifies an identity claim or credential possession. MFA, device posture, and phishing-resistant authenticators materially reduce many credential attacks, but do not alone prove that an authenticated request is within an authorized purpose, recipient, volume, or workflow. IAM, RBAC, and ABAC can express richer constraints, but deployments may be coarse or inconsistent. OAuth and scoped API access may already support fine-grained resource indicators, audiences, and consent, and a finality design MUST NOT claim these are inherently incapable of consequence control. Its distinctive target is enforcement at the actual side-effecting sink, with a reconstructed effective operation, freshness, non-transferable authorization, and denial if the sink cannot verify it.¶
| Control | Baseline issue | Proposed test or property |
|---|---|---|
| Authentication | Valid credential | Act-specific authorization |
| IAM / RBAC / ABAC | Scope may be coarse | Destination and purpose binding |
| OAuth | API invocation scope | Effect and revocation check |
Test: valid stolen identity with a prohibited destination, comparing strong ABAC policies with and without the sink, including direct-service and queued paths.¶
Firewalls, segmentation, IDS/IPS, EDR, DLP, database controls, and zero trust are complementary. They can block many unauthorized operations before any finality gate is reached. Detection-oriented systems can also miss novel or blended behavior, and prevention-oriented controls may already provide equivalent effect-specific denial. The finality layer SHOULD reuse their telemetry and not duplicate it. Sandboxing is valuable when it restricts reachable resources and system calls, but a compromised process can still abuse a legitimately exposed API. The relevant question is whether every protected effect path is mediated, including service identities, background jobs, replication, bulk exports, and maintenance interfaces. An asserted universal gate without an exhaustive path inventory is not a complete claim.¶
| Control | Baseline issue | Proposed test or property |
|---|---|---|
| EDR / IDS | Detects suspicious behavior | Deny the protected effect at the sink |
| DLP / egress | May already prevent release | Test incremental benefit |
| Sandbox | Constrains reachable tools | Mediate legitimate effect paths |
External AI / compromised credential
|
v
Defender application: candidate export held
|
v
Independent validation of scope, recipient, freshness
|
v
FINALITY SINK: protected release / egress / key gate
|
v
Authorized destination or DENY
The statement that an action must fall inside an authorized envelope does not say who defines the envelope, who may expand it, who may revoke it, or what protects those operations. Policy creation is part of the trust model. If policy is too static, legitimate new workflows are blocked and pressure builds to add broad exceptions or disable the control. If policy can be widened silently, authority can expand until the finality layer is meaningless. Mature deployments therefore need controlled policy evolution: changes to the scope of authority are themselves protected acts, authenticated, change-controlled, and auditable. Different environments MAY choose static, periodically reviewed, or context-narrowed envelopes. A policy update MUST NOT retroactively authorize a pending operation unless re-evaluation under the new policy is explicit and the applicable epoch is recorded. During an incident, relevant envelopes SHOULD be frozen or revoked and queued operations prevented from draining under stale approvals.¶
Delegating work is not delegating finality authority. It MUST NOT be the case that Agent B inherits every authority Agent A possessed. Delegated authority SHOULD be attenuated, bounded, and verifiable at the consequence boundary that Agent B's action reaches.¶
The simplest model assumes one defender controls the agent, the policy, the protected resource, and the consequence boundary. Real workflows often cross organizations. Open questions include whose policy governs the action, which organization issues authority, which verifies finality, whether one organization can trust another's authorization evidence, how authority is revoked across domains, and what happens when jurisdictional rules conflict. Each organization controls its own consequence boundaries. An authorization valid in one domain MUST NOT be presumed valid in another, and the receiving sink MUST independently enforce its own policy. Bounded authority that crosses an organizational boundary MUST NOT turn into a transferable bearer permission that can be replayed or broadened downstream. Cross-domain finality needs explicit protocol and trust-model design (trust anchors, delegated scope, policy composition, authenticated evidence, revocation semantics) and MUST NOT be assumed to work automatically.¶
When two organizations' policies conflict, a deterministic composition rule is needed. The system MUST NOT simply choose whichever rule allows execution. Acceptable rules include explicit contractual priority, jurisdiction-specific policy, or a fail-closed conflict rule. This is an interoperability matter, not only an implementation detail.¶
Taiwan's Ministry of Digital Affairs reported on 13 August 2026 that government agencies were targeted in July 2026 by an overseas campaign using conventional techniques and AI agents, and that its cybersecurity infrastructure detected the activity and the agencies handled it [TAIWAN-MODA]. This document does not attribute the activity and takes no position on its origin.¶
The following is a hypothetical walk-through, not a description of the reported incident. A hostile agent sends a valid, authenticated request to export government records. The application can read the data, but the export remains staged. The protected release service reconstructs the true record set, recipient, and quantity. The Protected Validator evaluates destination, purpose, policy, and revocation. The Finality Sink checks act-bound authority and permits only the exact bounded release. A mismatched external destination is denied even though the stolen credential authenticates.¶
This outcome holds only if the attacker cannot use an unmediated alternative route and cannot compromise the enforcement layer (Section 23).¶
The incident illustrates that AI can lower the cost of adaptation and parallelism in an operation. It does not show that this architecture would have prevented it, and it is not evidence of deployment or effectiveness in any Taiwanese system. It supports a general point: defenses that depend only on detecting or limiting the attacker's methods face a faster adversary, so it is worth also controlling which consequences can occur at all.¶
Agentic AI complicates accountability. After an autonomous system executes an important command, investigators ask who gave the objective, which AI generated the action, which account and credential were used, and which application invoked the tool. A further question becomes important: which protected authority actually permitted this specific act to cross into consequence?¶
Traditional logs establish what happened. Finality evidence could additionally establish what authorization state existed before the protected consequence was permitted. That distinction may help incident investigation, organizational accountability, regulatory supervision, contractual responsibility, human oversight, and technical assurance. Such evidence does not itself determine legal liability, but it can give a technically stronger authorization chain. Investigators could then ask both "which AI produced the command?" and "which protected authority permitted this command to cross the finality boundary?"¶
This section is a technical observation, not a legal analysis. Nothing here claims that any current law mandates this architecture.¶
The European Union's AI Act establishes a risk-based framework that includes requirements concerning areas such as risk management, human oversight, robustness, and cybersecurity for relevant systems. The Cyber Resilience Act sets cybersecurity requirements for products with digital elements across their lifecycle. As implementation moves toward harmonised standards and technical specifications, an additional technical question arises for agentic systems that interact with critical infrastructure, financial systems, telecommunications, public administration, industrial systems, healthcare infrastructure, or transportation: how can authorization be demonstrated at the moment an autonomous machine-generated act becomes an externally effective consequence?¶
A system can have excellent documentation, strong model evaluation, high-quality training data, and detailed audit logs, and still lack a technical mechanism that independently determines whether a specific machine-generated consequence was authorized immediately before effectuation. Execution finality addresses that narrower gap. It is proposed as a technical direction for future standards, critical-infrastructure deployments, and high-consequence agentic systems.¶
Rather than mandating one architecture, standards bodies could consider a technology-neutral property: can the system demonstrate that a defined class of high-consequence machine-generated acts cannot become externally effective unless required authorization conditions have been independently satisfied at the relevant consequence boundary? That formulation does not mandate any one token format, hardware architecture, cryptographic scheme, AI model, operating system, or implementation. It defines a security property: no protected consequence without valid authority. The objective is to standardize, where justified, that invariant rather than any one inventor's terminology.¶
Implementations SHOULD NOT insert human review or heavyweight remote cryptography into every routine operation. Practical approaches include precomputed bounded policy corridors, local deterministic sink checks, cached authenticated state where safe, and stronger checks reserved for consequential transitions. Deployments SHOULD measure p50, p95, and p99 latency, throughput, failover behavior, queue saturation, and denial-of-service behavior. No measured performance is asserted in this document.¶
Deployments can start with the highest-consequence effects (bulk export, privileged administration, secret release), run the Protected Validator in observe-only mode to compare its decisions with actual outcomes, and then move individual consequence classes to enforcing mode with a rollback path.¶
Where a legacy system cannot host a Finality Sink, a mediating component MAY be placed in front of it only if all routes to the legacy system's effect are forced through that component. Otherwise the residual risk in Section 7 R5 applies.¶
This section turns the scenarios above into a repeatable defender-side simulation plan. All expected outcomes are test hypotheses. No simulation result is reported in this document.¶
| ID | Simulated attack | Mitigation under test | Pass criterion (Arm C) |
|---|---|---|---|
| S1 | Stolen valid credential requests a bulk export to an external destination | Reconstruct the real record set, recipient, and quantity; destination and purpose binding at the release sink | Authentication succeeds; no records reach the unauthorized destination |
| S2 | Prompt-injected agent widens the dataset and redirects an upload | Authority from protected policy, never from model text or tool output | Agent's claim of approval is ignored; widened export denied |
| S3 | Tool composition: read confidential file, summarize, email externally | Treat the final send as the Candidate Act; check recipient, purpose, and scope | Message is not sent to the unauthorized recipient |
| S4 | Export split into thousands of small acts, run in parallel | Protected aggregate budget per identity, destination, and window | Cumulative release never exceeds the budget, including under races |
| S5 | Alternate route: direct database connection, scheduled job, replica, backup, queue | Consequence-path inventory; every route converges on a sink or is separately restricted | No route produces the effect without passing a sink; any gap is recorded as residual risk |
| S6 | Token or receipt theft and replay against another act or destination | Non-bearer, act-bound authority with sink-local consumption state | Replay, wrong destination, and second use are all rejected |
| S7 | Race: destination or payload changed after validation, before commit | Bind decision to payload digest and version; recheck atomically at the sink | Changed operation fails; no effect from the earlier authorization |
| S8 | Delegated sub-agent tries to exceed or widen the parent's authority | Attenuated delegation; sink checks the parent chain and actual operation | Child action outside the parent's bounds is denied |
| S9 | Validator outage or flood of validation requests | Fail closed for protected effects; admission control; local sink checks; safe-state path for safety functions | No unauthorized effect during the outage; safety functions stay available; recovery within target |
| S10 | Stale revocation or policy drift: use of authority after it should be revoked | Short validity, revocation epoch, incident freeze of envelopes | Revoked or expired authority is not accepted beyond the stated window |
| S11 | Timeout or crash between consumption of authority and confirmation | Durable consumption record; HOLD and RECONCILE; idempotent retry | No duplicate effect; outcome resolved by authoritative state |
| S12 | Compromise of the validator, sink, signing key, or host | Isolation, key protection, attestation, monitoring, rapid revocation and recovery (the finality layer is expected to fail here) | Compromise is detected and contained within target time; the report states this is outside the layer's protection |
Setup: a synthetic government-records service, a test employee identity with read access, and a controlled external endpoint standing in for the attacker. The simulated agent has the stolen credential and the goal of moving the records to that endpoint.¶
| Stage | Simulated attacker action | Arm B (conventional controls) | Arm C (adds finality layer) |
|---|---|---|---|
| 1 | Authenticate with the stolen credential | Succeeds unless anomaly or device checks fire | Succeeds; authentication is not the gate |
| 2 | Query the record set | Succeeds within the identity's read scope; may be flagged by monitoring | Same; the read path is separately protected where plaintext exposure matters |
| 3 | Request export to the external endpoint | May be blocked by DLP or egress rules; may pass if the data is transformed or routed through an allowed channel | Candidate Act created and held in the non-effective state |
| 4 | Retry by another route (batch job, alternate API, smaller pieces) | Depends on how well each route is covered | Each route reaches a sink or is a recorded gap; aggregate budget applies |
| 5 | Replay a captured authorization | Not applicable | Rejected: wrong act, destination, or already consumed |
| 6 | Outcome measured | Record whether any records reached the endpoint | Expected: none; any leak means a path was unmediated |
Mitigations SHOULD be applied in this order, because each later layer assumes the earlier ones:¶
For each simulation and arm, report: whether the unauthorized effect occurred; bypass success rate across all attempted paths; false denials on a legitimate-workload mix; p50, p95, and p99 latency added; throughput under load; behavior during validator outage; and time to recover and reconcile. Publish the threat model, the path inventory, and the list of unmediated routes together with any result, so readers can see what was not covered.¶
A practical evaluation SHOULD be performed in a defender-owned synthetic environment and SHOULD attempt: credential theft, direct-service bypass, privileged internal calls, tool chaining, asynchronous queue execution, policy replay, stale revocation, altered destinations, partial commit, validator outage, and enforcement-component compromise. Evidence SHOULD record whether an unauthorized effect actually occurred, not only whether a policy engine returned DENY. The security benefit SHOULD be measured against a strong conventional control set, not against an unprotected deployment.¶
The finality boundary can itself be attacked. An attacker who compromises a kernel, hypervisor, trusted component, validator, sink, or underlying device can bypass or forge decisions. An unmediated route to the effect defeats the protection for that effect. The architecture therefore does not remove the need for patching, vulnerability management, segmentation, credential hygiene, monitoring, and incident response. Its contribution is narrower: where the protected consequence path remains under trusted enforcement control, an authenticated and technically valid request is not sufficient to cause the effect.¶
This entire document concerns security. Additional points:¶
Candidate Act descriptors and Receipts can contain data classifications, recipient identities, and quantities. Operators SHOULD minimize retained detail, protect these records against unauthorized access, and apply retention limits consistent with applicable law.¶
This document has no IANA actions.¶
The answers describe proposed design patterns and conditions for enforceability. They are not deployed or empirically validated results.¶
This document is based on the international application PCT/IB2026/055615, filed 4 June 2026 and published as WO 2026/150382 A2 on 16 July 2026. The full filing is available by searching "Sangam Das" on WIPO PATENTSCOPE, by searching PCT/IB2026/055615 (pctib202655615), or at https://www.tdcommons.org/dpubs_series/12542/ . The underlying invention is human-originated. Preparation of this draft, summaries, and any mapping to third-party systems or regulations used AI assistance and may contain errors or omissions; readers MUST verify against the original filings and primary sources. Nothing here implies endorsement, collaboration, licensing, or an allegation of infringement by any third party. The author is open to acquihire or strategic collaboration.¶
The author thanks the security community for public reporting and discussion of AI-assisted cyber operations.¶