Internet-Draft Execution Finality for Cyber Defense November 2026
Das Expires 22 May 2027 [Page]
Workgroup:
Network Working Group
Internet-Draft:
draft-das-cyber-defense-execution-finality-00
Published:
Intended Status:
Informational
Expires:
Author:
S. K. Das
Independent

Execution Finality for AI Safety and Agentic AI Security: Containing the Consequences of Stolen Credentials and Autonomous Cyberattacks at the Final Effect Boundary

Abstract

A cyberattack does not have to defeat every security mechanism to become catastrophic. One internet-facing service, one stolen but valid credential, one hijacked administrative session, or one autonomous AI tool calling a legitimately available interface may be enough. The decisive risk is the transition from access, prediction, intention or nominal authorization into an actual consequence: a changed configuration, an executed privileged command, a released dataset, a provisioned cloud resource, a dispatched payment, an altered network route or an activated physical device.

This document analyzes two independently documented public developments of November 2026: the reported intrusion into the internal operational network of the Fugaku supercomputer through a publicly reachable status dashboard, and the reported discovery of autonomous multi-agent offensive frameworks, including an exposed framework named exploit_agent, together with cloud-credential abuse such as LLMJacking. The two events are not shown to be connected, and no public evidence shows artificial intelligence was used at Fugaku. They share a defender-risk pattern: apparently valid access becoming a real consequence.

The document specifies a consequence-bound architecture. A proposed operation (a Candidate Act) remains non-effective until the actual pending operation, its target, destination, scope, resource version, current authority and protected policy state have been independently validated at a defender-controlled, non-bypassable enforcement point (a Finality Sink, in industry terms a reference monitor or commit gate) located at, or unavoidably upstream of, the point where the effect becomes real. It defines normative requirements for coverage, independence, effect binding, freshness and revocation, cumulative exposure, replay and idempotency, failure semantics and safety-critical operation; application profiles for high-performance computing, cloud control planes, AI-agent tool execution, telecommunications, finance and cyber-physical systems; a counterfactual analysis of the Fugaku incident; a differentiation from conventional systems; ten falsifiable experiments; and an informative FAQ.

IETF relevance: the document is an architectural and requirements contribution relevant to security work on remote attestation, workload identity, delegated and fine-grained authorization, transparency of authorization evidence, and agent-to-tool interfaces. Industry relevance: the model is applicable to AI-agent platforms, cloud providers, HPC operators, telecommunications operators and financial infrastructure; the alignment sections are AI-generated, are not an endorsement, validation or infringement statement, and must be cross-checked against the original filings. Regulatory relevance: the document discusses relevance to the EU AI Act (cybersecurity and robustness of high-risk AI systems), NIS2, DORA and GDPR security of processing; it is not legal advice.

Based on the Mothership application PCT/IB2026/055615, filed 4 June 2026 and publicly disclosed 16 July 2026. The underlying invention is human-originated; AI-assisted tools were used to create this document, which may contain errors, and readers must cross-check it against the original, publicly available sources. To read the full PCT filing, search "Sangam Das" on WIPO PATENTSCOPE, search PCT/IB2026/055615 (pctib202655615), or read it at https://www.tdcommons.org/dpubs_series/12542/. No deployment, adoption, endorsement or performance claim is made about any third-party system, and no latency, efficacy or safety guarantee is claimed.

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 22 May 2027.

▲

Table of Contents

1. Introduction

1.1. Motivation

Modern defenses are layered: perimeter filtering, authentication, authorization policy, endpoint and network detection, and, increasingly, guardrails around AI models. Each layer answers a question about identity, session, request content or observed behavior. None of these questions is "may this specific, reconstructed operation, with this actual target and these actual effects, become effective at this protected boundary under the current independently protected authority?"

The question matters because identity-bound and request-bound decisions can be satisfied by an attacker. A stolen SSH key authenticates. A compromised dashboard process makes service-to-service calls that look legitimate. A manipulated AI agent emits a syntactically valid tool call. A correctly signed request may describe one thing while its actual side effects are another. When the consequence is irreversible (disclosure of plaintext, physical actuation, settlement, public certificate issuance), a detection that arrives after the effect cannot undo it.

The central proposition of this document is that "identity accepted" is not equivalent to "this specific consequential operation is independently authorized to take effect now", and that "an AI system proposed an action" is not equivalent to "the protected downstream system must carry it out".

1.2. Scope

This document addresses high-consequence systems: national scientific computing platforms, critical cloud management, AI-driven infrastructure operations, financial clearing and settlement, telecommunications control planes, electricity distribution, industrial safety systems and protected enterprise-data release. It is not about conversational question answering, per-token moderation, or validating every packet, instruction or floating-point operation.

1.3. Non-Goals

  • It does not claim to prevent initial compromise of a vulnerable service. Patching, hardening and attack-surface reduction remain necessary.
  • It does not claim to govern an attacker's model, tools or network. It governs consequences attempted against participating defender-side interfaces.
  • It does not claim that it would have prevented the Fugaku incident, that it was deployed there, or that it has been independently benchmarked anywhere.
  • It does not replace zero trust, IAM, endpoint detection, hardware security or safety engineering. It is a complementary pattern.
  • It does not specify a wire protocol. Section 9 is an informative sketch.

1.4. Evidence Labels

To keep facts separate from design and speculation, statements in this document are of four kinds.

PUBLIC FACT:
An assertion present in the named public primary source as of its date, limited to what the reporter actually said, including uncertainty.
ENGINEERING INTERPRETATION:
A security consequence inferred from general system behavior; not a claim about undisclosed incident detail.
PROPOSED DESIGN:
An architecture, integration or policy offered for future implementation. Feasibility is system-specific.
COUNTERFACTUAL:
A hypothetical statement of what a properly deployed and trusted control might have denied. It is not an observation of a real incident.

A published description of an attack is not proof of the victim's full configuration. A framework's capability is not proof that every observed intrusion used it. No attribution is inferred from language in source-code comments. No claim of product adoption, deployment, licensing, infringement, partnership or endorsement is made about any third-party system named here.

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.

Candidate Act
A proposed consequential operation generated by an agent, user, scheduler, application, orchestration system or remote client. It is not yet permission to commit a classified consequential effect. Industry approximation: deferred operation or staged transaction.
Non-Effective State
A state in which the operation is staged, pending, simulated, queued or dry-run and cannot cross its protected effectuation boundary.
Actual Pending Operation
The operation that would really run, reconstructed or measured by a trusted component: normalized arguments, destination object, privilege and identity context, delegated authority, resource version, scope, side effects, expected consumption and transitive operations known to the platform.
Protected Effect Class
A category of consequential effect that a deployment has chosen to protect, for example "grant administrative role", "release dataset class X to a destination outside domain Y", or "provision accelerator capacity".
Protected Authority
Policy, trusted human or multi-party authorization, bounded capabilities, safety constraints, attestation results, revocation state and protected system state from which a decision derives.
Independent Validator
The component that evaluates a canonical operation against current policy and trusted observations. Independence is relative to the initiator. Industry approximation: policy decision point.
Finality Sink
The defender-controlled protected effectuation boundary that can ALLOW, DENY, HOLD or route a classified operation to a safe fallback. Industry approximation: reference monitor, commit gate, execution enforcement point.
Defender Entry Enforcement Zone
The first receiving security boundary (for example a reverse proxy, WAF, API gateway or remote-access front end). It is not automatically a Finality Sink.
Commit Binding
A mechanism ensuring that the operation taking effect remains exactly within the validated scope and the current policy state.
Policy Epoch
A version or freshness value preventing stale authorization from silently continuing after a policy or revocation change.
Consequence Closure
Identification and enforcement coverage of direct and relevant indirect side effects of an operation.
Exposure Ledger
A protected record of reservations and committed consumption for a defined exposure unit (for example a cloud project, a budget, a dataset egress allowance), used to bound cumulative effect.
Hot Path / Warm Path
The hot path is the local, deterministic, time-sensitive check at the actual commit point. The warm path is policy authoring, stronger identity verification, review, attestation negotiation and reconciliation performed before commit or outside strict deadlines.

3. Public Incident Background (Informative)

3.1. The Fugaku Incident

PUBLIC FACT: In an English notice dated 17 November 2026, RIKEN reported unauthorized access to the internal operational network of the supercomputer Fugaku through a publicly available operational-status dashboard [RIKEN]. The reported timeline (RIKEN local time) is summarized below.

  • 10-13 November: investigation identified the unauthorized access route.
  • 12 November: suspicious network traffic detected.
  • 13 November 16:33: unauthorized access confirmed; 22:07: the system used for the access was isolated.
  • 14 November 04:30: Fugaku operations and external access suspended; 20:20: administrative keys replaced.
  • 15 November 16:18: affected users notified; user login public keys invalidated; users advised to revoke credentials used elsewhere.

PUBLIC FACT: RIKEN reported that multiple internal servers were tampered with, including installation of malicious programs on some. Information from the user authentication system and files in user home directories were taken or may have been taken, potentially including names, email addresses, identifiers, stored SSH private keys and access keys, and stored research files, with a possible impact of up to 4,597 individuals across Fugaku and RIKYU users. RIKEN stated it had no evidence of exfiltration of research data or files at that time, reported attempts to connect to other systems using some obtained credentials, and was still investigating the exploitation method and secondary damage [RIKEN].

The notice does not establish a specific vulnerability, a credential-stealing technique, an AI offensive agent or named malware as the cause of entry, does not disclose Fugaku's full administrative topology, and does not prove the absence of exfiltration beyond the state of evidence at publication.

ENGINEERING INTERPRETATION: The public dashboard is the entry exposure. The potential protected effects are deeper: changing privileged server state, accessing stored secrets, authorizing later administrative operations, connecting to remote systems with stolen credentials, and releasing sensitive information. Each has its own effect boundary. Treating the dashboard as the only possible enforcement point would be an architectural error.

3.2. The Google Threat Intelligence Group Findings

PUBLIC FACT: On 16 November 2026 Google Threat Intelligence Group and Mandiant published "GTIG AI Threat Tracker: Agentic Threat Activity Crosses a Significant Threshold" [GTIG]. As reported, threat actors used or experimented with multi-agent offensive frameworks (the report names ARTEX, CAIRN, CyberStrikeAI and PentAGI, with CAIRN and PentAGI observed in deployment). GTIG reported an exposed staging server hosting a framework it called exploit_agent, which integrated with multiple language models, compared pre-patch and post-patch software, identified likely vulnerabilities, drafted exploits and was configured to execute them automatically without a human approving each step. GTIG also described credential theft, compromised sessions, unauthorized service-account creation, cloud-resource abuse and LLMJacking, and attacks through AI-related software and coding-agent configurations [GTIG].

PUBLIC FACT: The report reproduced Russian-language comments from configuration material. This document does not treat language in comments as evidence of operator nationality or state sponsorship and does not state that any particular actor attacked Fugaku.

3.3. What the Events Do and Do Not Establish

The Fugaku case demonstrates a pathway from an externally accessible service into an internal operational environment followed by suspected credential exposure and attempted credential reuse. The GTIG report demonstrates movement toward autonomous attack chaining and that stolen cloud credentials can rapidly become consequential consumption or privilege changes. The connection between the cases is a shared defender-risk pattern, not a shared attacker: an exposed or compromised component may supply apparent authority for a more consequential action elsewhere. Joint government guidance on adopting agentic AI services addresses the related organizational risk [AGENTIC-GUIDANCE]. It would be unsound to claim one defense would have prevented both incidents entirely. Some harms occur at the moment of exploitation or an unmediated memory read, before any separately defined control point, and some attacks target the very kernel, hypervisor, firmware or storage layer relied upon to enforce finality.

4. Problem Statement: Scope Limits of Conventional Controls

The controls below are valuable and are retained by this architecture. Their limits are limits of scope and trust assumption, not defects.

Table 1: Conventional controls and where their scope ends
Control Scope limit relevant here
Firewall, WAF, ingress gateway Cannot attest that a later privileged command from an already compromised internal host is safe.
Passwords, SSH keys, MFA, signed requests Establish identity or key possession. A stolen secret looks like the principal unless hardware-bound or context-sensitive. A real user may request an effect that is unauthorized now.
IAM, RBAC, ABAC Restrict action classes. Gaps may arise from stale authorization, no reconstruction of actual effects, indirect mutation paths, or inconsistent coverage across heterogeneous systems.
Zero trust (NIST SP 800-207) Rejects implicit trust from network location. Whether exact effect reconstruction, resource-version binding, cumulative exposure, transitive effects and proof of no unmediated path are provided depends on the design [NIST800-207] [NIST800-207A].
EDR, SIEM, SOC Detection after a privileged operation cannot always undo it.
AI guardrails Do not govern every external model, and cannot guarantee integrity of each downstream tool call.
Sandboxes Still need sanctioned channels for external effects. Those channels are the consequence boundary.
Human approval A person may approve a description while the actual command differs; too slow for some machine-speed flows.
Logs, signatures, receipts Evidence is not prevention. A receipt from a compromised agent may be untrustworthy. A log cannot un-send stolen data.

A conventional defense can be excellent at asking who, deciding whether a session can start, observing what happened, or preventing known threats. The architecture in this document adds one narrow question at the final boundary: may this reconstructed operation, with this actual target and these effects, become effective here under the current independently protected authority?

5. Threat Model

The attacker MAY control any of: a public web service or dashboard; the tools of an AI agent; an ordinary user account; stolen session material or long-lived credentials; an internal process; a delegated service identity; an automated multi-agent offensive workflow located outside the defender's administrative reach. The attacker MAY act at machine speed, in parallel, across many identities, and MAY replay valid prior requests.

The architecture assumes that the Finality Sink, the Protected Authority store and the necessary trust anchors remain outside the attacker's effective control. If that assumption cannot be established for an effect class, the protection claim for that class MUST be narrowed. Compromise of a hypervisor, firmware or kernel hosting the sink, collusion among sufficiently privileged administrators, and compromise of the trust root are explicitly out of the protection claim (see Section 21).

6. Architecture

6.1. Overview

 OUTSIDE DEFENDER              DEFENDER-CONTROLLED DOMAIN
+-----------------+          +------------------------------+
| attacker, AI    | request  | ENTRY ENFORCEMENT ZONE       |
| offensive agent,+--------->| WAF / API / SSH gateway      |
| stolen-key user |          +--------------+---------------+
+-----------------+                         |
                            +---------------v---------------+
                            | COMPROMISABLE WORKFLOW        |
                            | service, session, agent, queue|
                            +---------------+---------------+
                                            |
                            +---------------v---------------+
                            | CANDIDATE ACT                 |
                            | actual pending operation      |
                            | NON-EFFECTIVE                 |
                            +---------------+---------------+
                                            |
                            +---------------v---------------+
                            | PROTECTED FINALITY SINK       |
                            | independent validation        |
                            | exact effect binding          |
                            +-------+---------------+-------+
                                    |               |
                            DENY / HOLD /      ALLOW effect
                            SAFE FALLBACK      at the resource
Figure 1: Request entry versus effect boundary

Ingress and sink can coincide for a simple API. In multi-hop critical infrastructure they usually do not.

6.2. Candidate Act and Non-Effective State

A Candidate Act is any proposal for a classified effect, for example "delete these records", "start these GPU instances", "grant this role", "alter routing configuration", "release this protected dataset" or "open this industrial valve". Until validated and committed it MUST remain in a Non-Effective State. A "pending" flag held only in an untrusted application database is insufficient if another path can commit the same operation without gating.

6.3. Actual Pending Operation

The Finality Sink, or a trusted component upstream of it that the initiator cannot influence, reconstructs the Actual Pending Operation: normalized arguments, resolved destination object, privilege and identity context, delegated authority, transaction or resource version, scope, side effects, targets, expected resource consumption, and transitive operations that the platform can enumerate. Approval MUST bind to this operation and not to an earlier natural-language request, a wildcard, or a mutable pointer such as "latest".

6.4. Protected Authority

Authority is derived from protected policy, trusted human or multi-party authorization, prior authenticated workflow, bounded capabilities, safety constraints, attestation results, revocation state and protected system state. Where used, an authorization SHOULD carry at least: subject; operation class; protected resource; scope; destination; resource generation or version; expiry or freshness; revocation (policy) epoch; and risk or dependency limits. Missing fields MUST NOT silently permit scope substitution.

6.5. Independent Validator

The validator evaluates the canonical Actual Pending Operation against current Protected Authority and trusted observations. It MUST be independent of the initiator: the same compromised agent, dashboard or credential MUST NOT be able both to propose a protected effect and to self-approve it. Physical separation is not mandatory when hardware or software isolation is demonstrably strong. Validator availability, trust roots, integrity and authenticated communication have to be engineered.

6.6. Finality Sink

The Finality Sink is the protected effectuation boundary. It MAY be implemented as an application reference monitor, storage-release mediator, trusted privileged-operation gateway, scheduler administrative commit hook, cloud control-plane commit gate, protected settlement boundary, HSM-backed authorization boundary, or hardware-mediated actuator command guard. It MUST be co-located with, or unavoidably upstream of, the real effect point. A dashboard that merely displays a policy decision is not a Finality Sink.

6.7. Commit Binding

The protected effect commits only if the operation still matches the validated operation and current policy conditions. Resource version, target identity, scope, signed capability, monotonic counter or transactional compare-and-swap MAY enforce the binding. The sink MUST recheck or abort if material state changes between evaluation and use.

6.8. Supplementary Evidence

A deployment MAY generate authenticated evidence of an executed bounded phase, a destination-side result, or a later reconciliation step. Such records are OPTIONAL supplements for multi-step or audit-intensive workflows. Neither agent-reported success nor the mere existence of a signed receipt substitutes for control of the actual protected effect.

6.9. Candidate-to-Effect State Machine

 [PROPOSED]
     |
     v
 [NORMALIZE + RECONSTRUCT]
     |
     v
 [NON-EFFECTIVE / PENDING] --> [DENY: policy conflict]
     |                     --> [HOLD: fresh evidence unavailable]
     v
 [INDEPENDENT AUTHORIZE]
     |
     v
 [BIND act + sink + target + scope + version + epoch]
     |
     v
 [ATOMIC COMMIT CHECK] --- mismatch ---> [ABORT / RE-EVALUATE]
     |
     v
 [PROTECTED EFFECT OCCURS]
     |
     +--> [OPTIONAL evidence, audit, receipts, reconciliation]
Figure 2: State machine

7. Where the Finality Sink Must Reside

The Finality Sink is on the defender's side, at the protected resource boundary that makes the consequential operation effective. The entry zone is often the first enforcement location but is not necessarily the last or a sufficient one.

7.1. Entry Zone Versus Sink

An internet-facing reverse proxy, WAF, API gateway, remote-access front end or private ingress service can perform preliminary authentication, request normalization, rate limiting, anomaly filtering and restricted routing. It cannot necessarily see the final operation after an internal service rewrites a command, a scheduler expands work, a database trigger fires, an agent calls a new tool, or an attacker moves laterally.

 [Internet]
     |
     v
 [Public dashboard] -- exploit / foothold --> [Internal host]
                                                |
                         +----------------------+
                         |                      |
                         v                      v
                  [Credential use]    [Direct unmediated path]
                         |                      |
                         v                      v
                  [Internal API]              EFFECT
                         |                 (UNSAFE COVERAGE GAP)
                         v
                  [FINALITY SINK] ---> DENY
                         |
                         v
                  [Privileged effect, only if permitted]
Figure 3: Ingress-only enforcement after lateral movement (illustrative)

The figure shows a possible architecture problem and is not the confirmed topology of Fugaku or any other system. All paths to protected effects MUST be mediated.

7.2. Resource-Specific Sink Placement

Privileged server actions
At the protected command executor or administrative management API.
HPC scheduler and configuration
At the trusted scheduler-policy commit or cluster configuration-activation hook, not in every arithmetic instruction.
Stored secrets
At a mediated key-release or secret-read boundary, before plaintext becomes accessible to a compromised process.
Sensitive research data
At storage authorization, read-release and controlled egress, limiting volume and destination.
Cloud provisioning
At actual resource creation and quota or billing exposure commit, not when an agent merely drafts a request.
Enterprise databases
At the protected transaction effectuation boundary, including reachable stored procedures, triggers and definer-rights behavior.
Network management
At configuration activation, route-policy installation, slice reconfiguration or authority delegation, not in radio PHY or HARQ timing loops.
Finance
At protected posting, clearing, capture or settlement authority, with reservation and cumulative exposure control.
Cyber-physical systems
At the protected command interface governing actuators or state transitions, subject to deterministic safety and emergency handling.

7.3. The Coverage Test

For each Protected Effect Class ask: can the same consequence become effective without passing this gate? If yes, the purported Finality Sink is incomplete for that effect. Every permitted bypass MUST be eliminated, protected by an equivalent trusted sink, or documented as an accepted residual risk. For each class an implementer SHOULD enumerate all APIs; direct file or storage access; administrative channels; job schedulers; asynchronous workers; maintenance routines; stored programs; backup and restore tools; break-glass processes; and hardware or debug paths.

8. Normative Requirements

The following requirements apply to a deployment that claims protection for a Protected Effect Class. They are stated per class: a claim for one class says nothing about others.

8.1. Coverage

  • R1. Every effectuation path of a Protected Effect Class MUST pass through an equivalent trusted Finality Sink, or MUST be explicitly excluded from the protection claim in documentation.
  • R2. A deployment MUST record the path analysis supporting R1, and MUST treat the discovery of any unmediated route as falsifying the coverage claim for that class until repaired or documented.
  • R3. Effects reachable through transitive mechanisms (triggers, stored procedures, asynchronous workers, delegated workflows) that the platform can enumerate SHOULD be within Consequence Closure. If they cannot be, the claim MUST be stated as partial.

8.2. Independence

  • R4. The initiator of a Candidate Act MUST NOT supply the decision that authorizes it, or a flag asserting that validation succeeded.
  • R5. The Independent Validator and the policy it evaluates MUST be protected from modification by the initiator, and policy updates MUST themselves be treated as Candidate Acts subject to separation of duties.
  • R6. Inputs necessary to reconstruct the Actual Pending Operation SHOULD be obtained or verified by the trusted destination rather than accepted from the initiator.

8.3. Effect Binding

  • R7. A permit MUST identify the actual target, operation, scope, resource version or generation, destination and validity interval of the operation it authorizes.
  • R8. The sink MUST abort or re-evaluate if any of these differ at commit time from what was validated.
  • R9. A permit MUST NOT bind only to a symbolic reference (for example "latest") whose resolution can change between validation and commit.
  • R10. The commit step SHOULD be atomic with respect to the check, using compare-and-swap, a transaction or an equivalent mechanism. Where atomicity is not available the deployment MUST state the residual window.

8.4. Freshness and Revocation

  • R11. A permit MUST carry an expiry and a Policy Epoch (or equivalent), and the sink MUST compare it with the current epoch at commit.
  • R12. Operations committed after the defined revocation-effective point MUST observe the new authority or be held. A cached permit MUST NOT remain effective beyond the stated revocation bound.
  • R13. Caching of policy or permits MUST be under explicit freshness, revocation, expiry and replay controls.

8.5. Cumulative Exposure

  • R14. For effects whose harm accumulates (provisioning, spend, data egress volume, successive privilege delegation), the deployment MUST apply limits to a protected exposure unit through an Exposure Ledger, not only to the individual request or token.
  • R15. Ledger reservations MUST be atomic with respect to concurrency, and policy MUST account for parallel workers, rotated service identities and fragmented projects.

8.6. Replay and Idempotency

  • R16. A permit for an irreversible effect MUST be single-use or use-count limited, using a nonce, counter or target generation, scoped so replay across cooperating services is also detected.
  • R17. After a timeout or lost acknowledgment, a caller MUST NOT blindly replay an irreversible operation. The sink MUST support reconciliation of effect state (RECONCILE) before retry or cancellation.

8.7. Failure Semantics

The sink MUST produce one of the following outcomes and MUST NOT default to ALLOW when the validator, policy store or evidence is unavailable for a protected effect that has no preauthorized safe fallback.

DENY
Prohibited or unauthenticated effect.
HOLD
Potentially valid but lacking fresh evidence, or the protected evaluator is unavailable.
ALLOW
The exact validated effect may commit within bounded scope.
SAFE FALLBACK
An explicitly preauthorized safety-preserving transition, separate from unrestricted permission.
RECONCILE
Determine whether a prior operation actually committed before retry or cancellation.
  • R18. Validator outage MUST NOT become blanket permission to execute all delayed requests when the validator returns.

8.8. Safety-Critical Operation

  • R19. For physical or life-safety systems, the response to failure MUST be a predefined safe state or locally bounded emergency authority designed with safety engineers. A general emergency bypass of the gate MUST NOT exist.
  • R20. A software gate MUST NOT impair certified safety behavior or introduce unacceptable response delay. Certified emergency trips and interlocks MUST remain deterministic and independent.
  • R21. Any emergency exception MUST have precisely bounded effects, independent integrity and periodic testing, and SHOULD leave a tamper-resistant override record where feasible.

8.9. Irreversibility

  • R22. For effects that cannot be rolled back (plaintext disclosure, physical actuation, distributed settlement, public certificate issuance) the gate MUST stand before the irreversible step. Post-event receipts MUST NOT be presented as a substitute.
  • R23. Where a transaction across resources cannot be fully atomic, implementations SHOULD use staged bounded operations, explicit uncertainty handling and compensating controls, and MUST NOT claim guaranteed reversal.

9. Protocol Sketch (Informative)

9.1. Protected-Effect Invariant

For every classified effect E committed on protected resource R, a deployment aims to satisfy:

COMMIT(E, R) implies  VALID_CURRENT_AUTHORITY(E, R)
                 and  MATCHES_APPROVED_ACT(E)
                 and  TRUSTED_SINK_ENFORCED(E, R)
                 and  CURRENT_POLICY_AND_SCOPE_VALID(E, R)

For a protected effect category C:
  ALL_EFFECTUATION_PATHS(C) pass through an equivalent trusted sink
  or are explicitly excluded from the protection claim.

This is a target property for design and verification, not an empirical theorem about deployed infrastructure.

9.2. Conceptual Permit Binding Tuple

No single encoding is prescribed. Fields MUST be canonicalized, protected against substitution, and interpreted consistently by the signer or evaluator and the sink. Deterministic JSON canonicalization [RFC8785] is one possible choice.

{
  "act_id": "opaque unique identifier",
  "initiator_context": "authenticated principal and session",
  "authenticated_delegation": "bounded delegation chain",
  "operation_type": "e.g. role.grant | data.release | vm.provision",
  "canonical_parameters": "normalized arguments",
  "target_resource": "resolved object identity",
  "effective_destination": "resolved destination",
  "authorized_scope": "limits on volume, count, duration",
  "expected_effect_class": "protected effect class",
  "resource_generation": "version or generation at validation",
  "policy_epoch": "epoch at validation",
  "expiry": "validity interval end",
  "nonce_or_use_count": "single-use or bounded-use control"
}

9.3. Decision Procedure

on consequential_operation(request, protected_resource):
    actual = trusted_reconstruct(request, protected_resource)
    if not actual.is_classified_protected_effect:
        return existing_authorized_processing(request)

    stage_as_non_effective(actual)
    context  = read_protected_policy_and_resource_state()
    decision = independent_validate(actual, context)

    if decision is DENY:
        return reject_without_effect()
    if decision is HOLD:
        return hold_without_effect_and_request_fresh_evidence()
    if not exact_act_matches(decision, actual):
        return reject_without_effect()
    if not current_epoch_and_generation_match(decision, context):
        return retry_validation_without_effect()

    return protected_atomic_commit(actual, decision)

This is a logical outline. Real implementations have to address isolation, concurrency, trust roots, deterministic safety behavior, error propagation, and whether atomic commit is possible on the target platform.

9.4. Exposure Ledger Reservation

For cumulative effects, validation includes an atomic reservation against the Exposure Ledger for the protected exposure unit. A reservation is created before commit, converted to committed consumption on success, and released on abort or expiry. Idempotency keys and protected counters limit races and blind retries. The ledger is held by the same authority as the sink, or by a service the sink can verify.

10. Application Profiles (Informative)

10.1. HPC and National Scientific Computing

Candidate effects: privileged scheduler mutations, creation of administrative identities, release of sensitive scientific datasets, high-value inter-system credential use, large quota reallocations, disabling of security controls, and job-submission privileges exceeding project scope.

Proposed placement: cluster administration API and scheduler configuration commit; hardware- or OS-mediated secret release; dataset access-control and release gateway; a designated privileged command broker. The gate SHOULD NOT interrupt compute-node numerics, parallel MPI communication, or high-throughput scheduling beyond the bounded administrative decisions selected by policy. If a gate is placed in a frequent job-submission workflow, queue overhead MUST be benchmarked and local checks optimized.

10.2. Cloud Control Planes and LLMJacking

Candidate effects: IAM privilege changes, production network or firewall activation, bulk resource provisioning, production secret release, key-management policy mutation, deployment promotion, creation of high-privilege service accounts, raising billing limits, enabling paid services.

The final-effect boundary is the protected create, scale or enable operation in the control plane, not the earlier prompt or script. The pending operation identifies account, project, region, machine type, quantity, creation rate, expected recurring expenditure, service identity and current exposure limits. Per-request success does not imply unlimited cumulative permission: the sink or its Exposure Ledger counts existing reservations and committed usage across concurrent processes and rotated service accounts. If billing or activation occurs in a third-party system without adequate enforcement hooks, an external overlay offers only a weaker proxy-level control and MUST NOT claim non-bypassability without provider-side cooperation.

10.3. Enterprise AI Agents and Tool Execution

Candidate effects: deleting records, sending payments, changing identity policy, granting repository access, deploying production code, exporting customer data, invoking privileged security tooling.

Proposed placement: the application tool dispatcher for preliminary gating plus resource-specific protected executors for authoritative commit. An agent-protocol proxy or SDK hook is useful but alone may not cover direct API and internal service routes. Agent self-reported completion is not equivalent to destination-observed finality. A model is treated as a proposer: its output does not itself carry authority.

10.4. Telecommunications

Candidate effects: management-plane configuration changes, policy activation, slice authority updates, trusted software package rollout, route propagation, sensitive subscriber-data release. Placement: management orchestration commit, domain controllers, slice-policy activation and protected administrative interfaces. Remote authorization MUST NOT be inserted into deadline-constrained radio loops (PHY, MAC or HARQ). Safe bounded rollout and rollback SHOULD be evaluated against the actual topology generation.

10.5. Banking and Financial-Market Infrastructure

Candidate effects: transaction posting, payment capture, settlement authorization, beneficiary change, treasury transfer, exposure escalation, protected signing-key use. Placement: core-banking authorization and ledger posting, the payment gateway at the actual financial-effect boundary, HSM-mediated signing under bound context, and a protected exposure ledger. The design MUST distinguish request acceptance from actual settlement and MUST NOT assume rollback of external settlement.

10.6. Electric Grid and Industrial Control

Candidate effects: circuit switching, plant setting changes, disabling protective interlocks, setpoint writes, remote actuator commands, safety parameter updates. Placement: a protected operational-technology command relay, a safety-certified controller boundary, or an equivalent secure actuation reference monitor. See R19 to R21.

10.7. Transportation, Drones and Autonomous Physical Systems

Candidate effects: release of movement or actuator authority, unsafe mission changes, protected navigation parameters, payload activation, high-consequence fleet commands. Placement: a protected vehicle or robot command guard with local bounded safety rules. Where remote latency is unacceptable, rely on locally enforceable preauthorization. A remote approval message does not verify the vehicle's actual safe state.

11. Fugaku Counterfactual Analysis (Informative)

This section is COUNTERFACTUAL. It does not describe confirmed existing Fugaku components or defenses, and it does not establish that any proposed control would have prevented the actual incident.

Initial dashboard compromise
PUBLIC FACT: the route was identified, the method was not announced [RIKEN]. An authenticated ingress gate may have reduced exposure only if the vulnerable action was within its scope. A finality layer placed solely around later privileged operations would NOT by itself prevent exploitation of a vulnerable web page. The initial weakness needs secure engineering, isolation, patching and attack-surface reduction.
Unauthorized server modification
PUBLIC FACT: multiple internal servers were tampered with, with malicious programs installed on some. POTENTIAL DEFENSE: if administrative configuration writes, package installation, persistence creation and protected-executable activation were all mediated by an integrity-preserved command and commit boundary, a request from a compromised dashboard service could be blocked as inconsistent with its limited role or approved change window. CONDITION: the attacker must not hold kernel or root write authority outside the protected mediation layer.
Stored SSH keys and credentials
PUBLIC FACT: credentials stored in affected user directories were taken or may have been taken. POTENTIAL DEFENSE: a protected secret store could refuse key export to a dashboard process, issue short-lived act-bound operations rather than exportable bearer keys, and require destination-side consequence validation after authentication. CONDITION: plain private keys already readable in an unprotected user directory cannot retroactively be made unreadable by a later gate; a non-participating remote service may accept a stolen key.
Lateral movement with stolen credentials
PUBLIC FACT: attempts to connect to other systems with obtained credentials were reported. POTENTIAL DEFENSE: on a participating destination, authentication could open a limited session without conferring final authority to change protected settings, read classified files, mint credentials or alter protected jobs. CONDITION: the destination must implement the gate.
Sensitive data read or export
PUBLIC FACT: no evidence of exfiltration at publication. POTENTIAL DEFENSE: release gates limit principal, project, destination, dataset, volume or session; egress protection can stop certain transfers. A read is not harmless merely because it is read-only: disclosure itself can be an irreversible effect. CONDITION: if plaintext is already in a compromised process's memory or readable through an unmediated local path, later egress filtering cannot guarantee confidentiality; encryption and key-release mediation must apply before disclosure.
HPC jobs and cluster operation
POTENTIAL DEFENSE: protect scheduler administration, delegation authority, quota changes, tenant privilege escalation and large-scale data staging while preserving the high-throughput computation path.

Conclusion: a correctly deployed consequence-bound system might have contained or denied certain downstream actions after an initial foothold. It cannot be claimed from public evidence that it would have prevented the actual Fugaku breach.

12. Containment of Autonomous Offensive AI (Informative)

An external attacker uses an autonomous multi-agent workflow to scan internet-facing software, generate exploit candidates, attempt access and pivot after success. The defender cannot require the attacking model to run a benign policy filter. The defender can intervene in layers:

  1. Minimize the internet-facing vulnerable surface by hardening and patching.
  2. Restrict reachability of high-consequence services and enforce service identities.
  3. Treat compromised application processes as untrusted proposers, not final authorities.
  4. Route classified effect-producing APIs through a protected sink independent from the compromised service.
  5. Bind approval to a normalized specific operation, protected target and fresh Policy Epoch.
  6. Deny or constrain abnormal scope, destination, count, volume and authority propagation.
  7. Record or authenticate evidence for incident response without placing receipt generation at the center of every real-time control loop.

Example 1 (role creation). An AI-driven exploit gains code execution in an exposed web service and calls an internal IAM API to grant itself a privileged role. With a protected IAM commit gate, the role change is an Actual Pending Operation checked against this service, this principal, the target role and delegation scope, and is denied if unauthorized however valid the API call looks. Limit: if the attacker controls the IAM enforcement root or a direct backdoor to the role store, the assumptions fail.

Example 2 (destructive script). A compromised automation agent submits a script deleting many protected research artifacts. The resource layer reconstructs the real target list, deletion type, ownership, retention rules and transitive effects. A general instruction such as "clean up old workspaces" cannot authorize deletion of all protected datasets. Limit: users may still intentionally delete approved items; the layer is not a universal truth oracle.

Example 3 (agent handoff). A monitoring agent asks a remediation agent to "restore stability" and the downstream agent interprets that as permission to change routing or firewall policy globally. The gate decides from the actual administrative update and delegated authority, not from the upstream agent's plausible language or signed message.

13. Edge-Case Scenarios (Informative)

Each scenario lists the threat, protected effect, required gate, possible result and residual risk. All are counterfactual design analyses.

A. Stolen administrator SSH key
Valid key authenticates. Effect: privileged package install or security-policy change. Gate: trusted command mediation at the real administrative operation. Result: authentication succeeds, unauthorized final effect denied. Residual: unmediated shell or root path, pre-existing data access, compromised monitor.
B. Compromised public dashboard
Status service becomes a foothold. Effect: write to administrative network configuration. Gate: destination-side policy and change-activation authority. Result: foothold persists, configuration mutation denied. Residual: initial exploit and unprotected lateral observations.
C. Malicious plugin or stored procedure
A read-looking request invokes a privileged trigger or definer-rights routine. Effect: indirect database write, external call or export. Gate: transitive operation analysis and protected commit interception. Residual: unenumerated dynamic behavior or direct low-level database bypass.
D. Race between approval and commit
Target or role mapping changes after authorization. Gate: immutable operation binding, generation check, atomic commit. Result: stale permit rejected, operation reconstructed. Residual: poorly defined version semantics or atomicity failures.
E. Revoked or expired authority
A queued action outlives its permit. Gate: current revocation epoch and freshness check. Residual: revocation propagation delay beyond the defined bound.
F. Multi-agent delegation escalation
One agent delegates a broader operation than it was authorized to perform. Gate: bounded delegation-chain validation at the sink. Residual: incomplete delegation metadata or an external tool outside protection.
G. High-speed cloud resource flood
Many small permitted requests create catastrophic cost. Gate: cumulative quotas and reservations with atomic concurrency control. Result: requests held once approved exposure is reached. Residual: eventual consistency or uncontrolled alternate accounts.
H. Replay of an authorized tool action
A valid prior request is replayed after state changed. Gate: idempotency, nonce or counter, target generation, use limits. Residual: weak identifier scoping or replay across uncoordinated services.
I. Exfiltration described as backup
An agent requests "backup" to an attacker-controlled destination. Gate: exact destination, data classification, purpose and volume checks at storage and egress boundaries. Residual: data already disclosed to compromised local memory.
J. Emergency safety override
Life-safety action needed while the validator is unavailable. Gate: preauthorized deterministic safety path with bounded local rules. Residual: a poorly designed override becomes an attack path; engineering review is mandatory.
K. Validator compromise or policy poisoning
The attacker alters approval rules. Gate: measured integrity, protected policy update, separation of duties, rollback control, audit, possibly redundant approval for exceptional changes. Residual: trust-root compromise, colluding administrators, flawed policy logic.
L. Partial commit or timeout
A caller times out after the sink has made some change and retries. Gate: idempotent act identity, effect-state reconciliation. Result: HOLD until the effect state is known; never blindly replay irreversible operations. Residual: external side effects without atomic rollback.
M. Malicious insider with a legitimate role
A real administrator seeks an out-of-policy mass change. Gate: protected scope and separation of duties even for authenticated principals. Residual: collusion at sufficient policy authority, emergency exceptions.
N. Compromised hypervisor or firmware
The attacker controls the layer hosting the monitor. Gate: stronger root of trust, isolation below or outside the compromised layer, measured boot. Result: containment only if the trust root remains intact. No claim of absolute prevention.
O. Offline critical-system operation
The remote validator is unreachable. Gate: locally verifiable preauthorized bounded capabilities and a deterministic emergency envelope. Residual: stale policy during prolonged isolation.
P. High-frequency telecom or scientific compute loop
Naive per-operation network validation would disrupt deadlines. Gate: precomputed permissions plus a lightweight local final-effect check only on infrequent configuration or authority transitions. Residual: misuse through unclassified internal parameters.

14. Differentiation from Conventional Systems

14.1. Twelve Dimensions

Table 2: Conventional stack versus consequence-bound design
Dimension Conventional (typical) Consequence-bound
Unit of decision Session, request, identity, role Reconstructed pending operation
Where enforced Perimeter, identity provider, gateway At or unavoidably upstream of the effect point
Trust in initiator Initiator or its token carries authority Initiator is an untrusted proposer
Approval binds to Identity, role or a description Canonical operation, resource generation, epoch, expiry
Timing Login or request time; detection after At commit, before irreversibility
Staleness Token lifetime; revocation lag Permit epoch compared at commit
Aggregate effects Per-request quotas Protected cumulative exposure ledger
Indirect effects Usually the direct API only Consequence closure
Bypass analysis Rarely a formal precondition Condition of the claim
Failure behavior Fail-open, fail-closed or ad hoc DENY, HOLD, ALLOW, SAFE FALLBACK, RECONCILE
Evidence Logs and alerts after the fact Gate first; receipts optional
Claim style "Protected" in general terms Conditional, per class, falsifiable

14.2. Seven Structural Differences

  1. Effect, not request. A sink judges what would actually happen after normalizing arguments, expanding wildcards and resolving mutable pointers.
  2. Submit is not commit. A compromised account, dashboard or agent may be able to submit a protected action without being able to commit it. This is the main testable benefit.
  3. The proposer never approves itself.
  4. Approval expires with the world: a change of target, scope, policy or revocation state invalidates the old permit.
  5. The sum of small things is bounded by a ledger across identities and parallel workers.
  6. Coverage is the claim. A bypassable gateway is a useful outer gate, not a Finality Sink.
  7. Irreversibility drives placement: disclosure, actuation and settlement cannot be rolled back, so the gate stands before them.

14.3. Same Attack, Two Stacks (Counterfactual)

Step 1: exploit a public status page
Conventional: foothold gained; only patching and hardening defend. With sinks: the same. A sink does not stop initial exploitation.
Step 2: read a user directory and take SSH keys
Conventional: keys are usable anywhere they are accepted. With sinks: if keys live in a protected store with bound signing, export is refused; plain keys already readable stay exposed.
Step 3: log in elsewhere with a stolen key
Conventional: authentication succeeds and the role allows many commands. With sinks: the session opens but confers no final authority for protected effects on participating destinations.
Step 4: install persistence
Conventional: succeeds if the role permits; may be detected later. With sinks: denied if outside role-of-origin or change window. Residual: root-level bypass below the monitor.
Step 5: mint a new administrative credential
Conventional: succeeds if the token carries IAM rights. With sinks: a protected commit, denied for this principal and scope.
Step 6: bulk export of research data
Conventional: egress filters may or may not match; disclosure is irreversible. With sinks: the release gate checks dataset class, destination and volume. Residual: plaintext already in compromised memory.
Step 7: provision thousands of accelerator instances
Conventional: each call looks valid and the bill arrives later. With sinks: the ledger reserves atomically, holds at budget and denies out-of-policy requests.

14.4. What Is Not Different

Reference monitors, mandatory access control, transactional databases, admission controllers, privileged-access management, capability systems, two-person rules and modern zero-trust policy enforcement points each implement part of this logic. The claim is not that each part is new. For a chosen class of effects, the combination of actual-operation reconstruction, binding to resource version and epoch, independence from the proposer, cumulative exposure, transitive-effect coverage and exhaustive bypass analysis is an integration pattern whose value is testable and SHOULD be compared fairly against the best existing baseline. If an existing policy enforcement point already does all of this for a given effect class, the architecture is simply that enforcement point, well deployed.

15. Deployment and Legacy Compatibility

15.1. Integration Tiers

 TIER 4  CROSS-DOMAIN CONTINUITY
         multiple participating sinks validate authority
         across resources and organizations
 TIER 3  ISOLATED / HARDWARE-ROOTED SINK
         reference monitor or key-release path, measured
         integrity, alternate-path control
 TIER 2  AUTHORITATIVE APPLICATION SINK
         privileged resource service enforces at commit
 TIER 1  OUTER GATE
         API gateway or proxy rejects some dangerous requests;
         not necessarily non-bypassable
 TIER 0  OBSERVE
         shadow mode; map and reconstruct effects;
         no prevention claim
Figure 4: Integration tiers

15.2. Legacy Infrastructure

  • No platform replacement is required. A site may add a gate in front of a selected control-plane API, integrate with an existing authorization service, place a mediator around privileged commands or instrument a storage-release interface.
  • Legacy SSH and operating systems: a jump host provides an initial gate but cannot stop direct internal SSH or local root unless those paths are blocked or equivalently protected. Use controlled service accounts, signed commands, OS policy modules, constrained administrative APIs or hardware-backed key operations. A generic SSH plug-in alone does not make a legacy estate non-bypassable.
  • Legacy databases: application-layer authorization is insufficient if stored procedures, triggers, jobs, administrative sessions, replication or direct storage access can perform the same effect. If the database cannot expose a protected commit boundary, the overlay MUST be described as partial.
  • Existing firewalls, SIEM, EDR, IAM and zero trust are retained.

15.3. Phased Deployment

  1. Select one critical consequence class and define the damage and safety objectives.
  2. Map existing controls and all effectuation paths; do not double-count features existing policy enforcement already provides.
  3. Define an authoritative protected sink; do not stop at a bypassable proxy.
  4. Define canonical effect parameters: target, destination, privilege, operation, resource generation, scope, exposure, side-effect closure, policy authority, delegation, expiry and revocation.
  5. Shadow-validate side by side with the current system, without claiming prevention, to find mismatches and overblocking.
  6. Enforce one restricted class; measure performance; test bypasses, stale permissions, concurrency and validator outages.
  7. Add safety and availability assurance: deterministic fallback, recovery, rollback where possible, handling of irreversible outcomes.
  8. Where justified, connect multiple trusted sinks with bounded delegation and optional authenticated evidence; expand only after proving coverage on each destination.
  9. Conduct third-party red-team measurement and publish methods, exclusions, latency distributions and unresolved bypass paths before making strong critical-infrastructure assurance claims.

16. Performance, Availability and Safety Engineering

It is neither necessary nor desirable to validate every token, instruction, floating-point operation, packet or sensor sample. Deployments SHOULD classify the few operation categories that cross meaningful consequence boundaries and leave the high-frequency path unchanged.

 HIGH-FREQUENCY WORKLOAD PATH (unchanged)
 AI inference | HPC compute | radio processing | sensor sampling
 ==============================================================>
   no per-token, per-flop, per-packet or PHY-loop validation

 LOW-FREQUENCY CONSEQUENCE PATH (gated)
 privileged config, data release, role change, payment, quota,
 scheduler mutation, actuator command
        |
        v
 canonical pending act
        |
        v
 LOCAL protected gate (hot path) ---> commit / deny
        ^
        |  protected cached policy + version / epoch checks
        |
 warm path: policy preparation, review, attestation
Figure 5: Control path and data path separation

Hot path: a local, deterministic validation or permit-consumption check at the protected commit point, using precomputed, signed or protected cached inputs with bounded work. Warm path: policy authoring, stronger identity, human review, attestation negotiation, multi-party approval, evidence reconciliation and semantic analysis, before commit or outside strict deadlines. The final critical action MUST NOT proceed merely because validation has not finished.

T_total = T_existing + T_normalization + T_validation
          + T_commit_binding + T_coordination + T_optional_audit

Only components on the synchronous protected path contribute to measured latency. No numeric overhead is asserted without benchmark evidence. A millisecond-level goal may be reasonable in some software control planes but is not a universal measured property, especially with remote consensus, humans, HSM operations or cross-datacenter calls.

Table 3: Critical timing classes
Class Description Gate behavior
I Hard real-time physical safety Deterministic bounded local checks; preserve certified interlocks
II Soft real-time infrastructure control Preapproved configuration corridors; local hot-path gates
III Administrative configuration Stronger validation, audit, possible human authorization
IV Financial and data release Sufficient verification before irreversible commit
V Ordinary compute and inference No per-token or per-flop check absent an external effect

Optimization techniques include: native APIs and existing protected commit hooks; precomputed policy invalidated on version change; separation of the trusted evaluator from untrusted model and tool logic; small authenticated capabilities bound to precise operation fields; batching only when atomic batch semantics and cumulative policy are preserved; avoiding network round trips for local time-critical decisions; caching only under explicit freshness, revocation, expiry and replay controls; applying cumulative quotas at one consistent resource authority; admission control for high-risk actions; and testing queue growth, timeout behavior and worst-case latency, not only the mean.

Safety versus security: critical infrastructure cannot always fail closed in the everyday IT sense, since stopping a life-saving actuator or safety relay could itself be harmful. See R19 to R21. During a validator partition, options include denying unsafe administrative changes, holding nonessential operations, continuing previously authorized bounded work, entering a deterministic degraded mode, and allowing tightly defined safety-preserving local actions.

17. Evaluation Plan

All experiments occur in isolated, consented laboratory environments. They do not reproduce the undisclosed Fugaku technique or attack live infrastructure.

E1. Stolen-key administrative mutation
Fixture: a laboratory management service and a test account with exposed credentials. Expected: connection allowed, out-of-scope configuration commit denied. Falsifier: any alternate path changes the protected configuration without the sink. Metrics: block and allow accuracy, alternate-path count, added commit latency, recovery.
E2. Compromised dashboard to internal administrative API
Fixture: a simulated status service issuing unauthorized administrative requests. Expected: the untrusted process cannot independently cause protected effects. Falsifier: a hidden internal API or background task bypasses the sink. Metrics: effect coverage, failed-action recovery, audit causality.
E3. In-house agent mis-scoped tool call
Fixture: a benign agent requests destructive cleanup beyond intended scope. Expected: the reconstructed target list differs from allowed scope and the commit is denied. Falsifier: authorizing the high-level text suffices for out-of-scope change. Metrics: false positive and negative rates, task impact, p50, p95 and p99 gate latency.
E4. Cloud quota and identity fan-out
Fixture: a mock cloud with simultaneous resource-creation requests from different test identities. Expected: cumulative exposure cannot be exceeded through concurrency. Falsifier: a race or account rotation yields unauthorized aggregate provisioning. Metrics: maximum overshoot, ledger consistency, throughput, retry safety.
E5. Data read and egress release
Fixture: synthetic restricted datasets with alternate read and export paths. Expected: protected data cannot reach an unauthorized destination through any declared route. Falsifier: an in-memory, backup, replication or direct-storage path bypasses control. Metrics: path coverage, throughput overhead, policy precision.
E6. Stale approval and resource rebind
Fixture: approve operation A at target version V, then modify the target to V+1 before commit. Expected: the stale approval is rejected or revalidated. Falsifier: approved parameters can be swapped at commit. Metrics: TOCTOU escape rate, conflict handling, extra delay.
E7. Validator outage in safety simulation
Fixture: a simulated controller under network partition with local safety constraints. Expected: unauthorized new administrative effects remain blocked and predetermined safe operations remain available. Falsifier: partition grants broad bypass or removes mandatory safety behavior. Metrics: worst-case deadline, fail-safe correctness, availability.
E8. HPC non-interference
Fixture: representative synthetic workloads, job submission and parallel compute. Expected: protected administrative commits incur bounded overhead while unrelated compute loops remain materially unchanged. Falsifier: the added critical path makes workload, scheduler or resource management violate service objectives. Metrics: compute throughput, job startup time, p50, p95 and p99 gate latency, variance.
E9. Coverage against transitive effects
Fixture: a synthetic database with triggers, stored procedures, background jobs and definer-rights operations. Expected: indirect classified mutations remain protected. Falsifier: a permitted outer action causes an unmediated prohibited side effect. Metrics: reachable effect-graph completeness, wrong allow or deny count, transactional consistency.
E10. Simultaneous revocation
Fixture: queued protected actions and concurrent policy revocation. Expected: operations committed after the revocation-effective point observe new authority or are held. Falsifier: a stale cached permit remains effective beyond the bound. Metrics: revocation propagation bound, false holds, policy consistency.

Reporting rule: results SHOULD report hardware, topology, software versions, classification rules, trust assumptions, baseline controls, exact enforcement coverage, methodology, traffic, median and tail latencies, failure outcomes and confidence intervals. Blanket claims such as zero latency, 100 percent prevention or unhackable MUST NOT be made. A laboratory demonstration MUST be distinguished from deployment in HPC or national critical infrastructure.

18. Industry Relevance (Informative, AI-Generated)

This section is AI-generated. Readers MUST cross-check it against the original PCT filing (PCT/IB2026/055615) and each company's current documentation before drawing any conclusion. The alignment below is not an endorsement, validation or infringement statement, and implies no adoption, licence or partnership, nor that any company uses the described approach. Product descriptions reflect general public information and may be outdated or wrong.

For each company the text states where a Finality Sink would sit, what it would check, what it would reject and why that matters.

Anthropic (Claude: agentic tool use, coding agents, agent-protocol servers)
Where: in the tool executor or protocol server that holds the credential for a consequential API (repository write, production deploy, payment, identity and access, data export), not in the model or prompt; agent-host permission prompts and hooks act as an outer Tier 1 gate. Checked: canonicalized tool arguments resolved to the real target set (for example the list of object identifiers a delete query would affect), delegated scope, resource version, Policy Epoch and cumulative budget. Rejected: a call whose resolved targets exceed approved scope, a replay of an earlier approved call, a call after revocation, a call whose destination differs from the approved one, a bulk export labelled "backup" to an unapproved endpoint. Why: a prompt-injected or manipulated model can emit a valid-looking call; with the sink the model is a proposer, so a harmful call fails at the resource even if the agent host or approval prompt was fooled.
OpenAI (function calling, agent SDKs, API platform)
Where: at the backend service behind each function or tool (the code that mutates state) and at the API-credential and spend-limit control plane; input and output guardrails in the agent loop are an outer layer. Checked: exact function arguments after normalization, principal and delegation chain, target resource generation, and for account effects key creation, limit changes and cumulative spend against a protected ledger. Rejected: arguments that widen scope after approval, stolen-key usage that raises limits or creates new keys, fan-out across many keys that together exceed the exposure budget. Why: LLMJacking-style abuse turns a stolen key into large consumption; a cumulative ledger at the commit point bounds loss even when every request authenticates.
Google (Gemini and Google Cloud control plane, agent gateways)
Where: at cloud control-plane commit operations (service-account creation, IAM policy attachment, quota and billing changes, accelerator provisioning, secret release). A published agent gateway or IAM policy layer is a natural Tier 1 or Tier 2 integration point; whether any custom authorization hook fails open or closed needs independent verification. Checked: account, project, region, machine type, quantity, creation rate, expected recurring cost, service identity, delegation chain and existing reservations. Rejected: role grants outside policy, provisioning above the reservation, service accounts created by an automation identity, requests rotated across accounts to evade per-token limits. Why: GTIG documents unauthorized service accounts, GPU provisioning and heavy AI consumption; a sink at resource creation turns accepted credentials into bounded exposure.
Microsoft (Azure and Entra control plane, Microsoft 365 data, agent governance)
Where: at role-assignment and resource-deployment commit in the resource manager, key and secret release in the vault, and bulk mail or file export at the data-release boundary. Published action-bound human-approval work for agents is a closely related public pattern at the application layer. Checked: the exact action digest and parameters, approving principal, policy version, resource generation, single-use consumption and aggregate export volume. Rejected: an approved description whose real command differs, a stale approval after policy change, a second use of a one-time approval, a bulk export above volume to a new destination. Why: agents running with delegated rights act at machine speed; the sink keeps an agent's valid token from being enough to grant roles or export tenant data.

What the alignment shows: all four expose tools or control planes through which an authenticated, legitimate-looking call can cause a real consequence. For model vendors the natural insertion point is the tool-execution and API-credential layer outside the model; for cloud vendors it is the control-plane commit; for productivity suites it is role assignment and data release. Each vendor already ships identity, policy, quota, logging and approval features. Whether any of them already satisfies the coverage, binding and cumulative-exposure conditions for a given effect class is an empirical question this document does not answer.

19. European Regulatory Context (Informative, AI-Generated)

This section is AI-generated, is not legal advice, and does not claim that following this document achieves compliance with any law. References to instruments SHOULD be verified against the official texts.

20. Relationship to Existing IETF Work (Informative)

21. Security Considerations

This entire document is about security properties. The following considerations apply specifically to deployments of the architecture.

Trust root and monitor integrity
The protection claim is conditional on the sink, policy store and trust anchors being outside the attacker's control. Compromise of the kernel, hypervisor, firmware or hardware root hosting the sink defeats the claim. Isolation below or outside the compromised layer, measured boot and hardware memory protection are mitigations. Attestation cannot by itself prove business-policy correctness or rule out supply-chain compromise.
Incomplete mediation and misclassification
An unmediated alternate path defeats complete-coverage claims. Effects outside the protected classes are not intercepted. Path analysis (R1 to R3) is the principal mitigation and has to be maintained as systems change (deployment drift).
Policy poisoning and insider risk
A privileged authorizer can maliciously change policy. Use separation of duties, provenance, independently secured logs, measured versions and recovery. Signing the wrong policy does not make it right. Colluding administrators with sufficient policy authority are out of scope.
Canonicalization and parsing differentials
If the signer or evaluator and the sink interpret an operation differently, an attacker can obtain a permit for one meaning and execute another. Fields MUST be canonicalized and interpreted identically.
Time-of-check to time-of-use and races
See R7 to R10. Symbolic references and mutable pointers are a primary source of escape.
Availability and denial of service
The sink can become a single point of failure or a target for flooding. Use redundancy where justified, capacity testing, protected local fallback and explicit partition behavior. Backlog storms after outage recovery, hot-key contention and failover split-brain need specific tests. Overly strict gates can impair restoration, incident response or safety operation.
Revocation, clock skew and caching
Revocation propagation has distributed-consistency limits. Cached permits and policy MUST stay within the stated bound (R12, R13). Clock skew and cache poisoning can extend permit validity if not controlled.
Low-and-slow and cumulative effects
Many individually small effects can accumulate. The Exposure Ledger addresses this only where it is authoritative for the exposure unit; eventual consistency across gateways weakens it.
Human approval
Authorized humans can approve dangerous actions and approval fatigue is real. Consequence checks help only to the extent policy can recognize the danger.
Non-participating destinations
External services may accept stolen credentials without any such check; the architecture cannot impose policy there. Local key export limits, bound signing, attested release, rotation and revocation remain essential.
Confidentiality already lost
A post-access gate cannot undo disclosure. Mediation must precede plaintext release, and keys SHOULD be protected before plaintext exists in a process that may be compromised.
Timing side channels and information leakage
Decision latency or denial reasons can leak policy or state. Deployments MAY return minimal denial reasons to untrusted callers.
Multi-resource atomicity
A sequence across services can partially commit. Claims of all-or-nothing finality require implementation evidence.
No universally safe fallback
Safety-critical failure handling needs domain hazard analysis and certification.

22. Privacy Considerations

Authorization records, Exposure Ledgers, audit logs and optional receipts can contain personal data (identities, dataset names, destinations, volumes). Deployments SHOULD minimize what is recorded, restrict access to these records, apply retention limits, and consider the obligations that apply to personal data processing, including breach-notification obligations when a release gate or ledger is itself compromised. Release gates are a privacy-protecting control when they limit what a stolen identity can disclose, but the classification rules that drive them can themselves reveal sensitive structure and MUST be protected.

23. IANA Considerations

This document has no IANA actions.

24. Intellectual Property and Provenance

The underlying invention, architectural concepts and identified patent disclosures are human-originated by the author. This document is based on the Mothership international application PCT/IB2026/055615 [PCT-55615], filed 4 June 2026 and publicly disclosed 16 July 2026. The publication reference supplied by the author is WO 2026/150382 A2. Additional applications supplied by the author for cross-platform execution-finality architecture and independent-evaluator design are Indian application 202631127058 (25 October 2026) and Indian application 202631131650 (3 November 2026); these identifiers are provided for traceability and MUST be cross-checked against authoritative patent-office records. Detailed IETF IPR disclosures will be filed separately, and a reference implementation will be published on GitHub later.

To read the full PCT filing: search "Sangam Das" on WIPO PATENTSCOPE (https://patentscope.wipo.int/); search PCT/IB2026/055615 (pctib202655615); or read the PCT file directly at https://www.tdcommons.org/dpubs_series/12542/. This document is explanatory and is not a substitute for the claims, specification or prosecution file; the authoritative scope and priority of any invention reside in the original filed patent documents.

AI-assisted tools were used to create this document, including to summarize the filing and public incident reports and to draft the threat scenarios, comparisons, industry-relevance and regulatory-context material. It may contain errors, omissions, outdated details or unverified assumptions. Readers MUST cross-check all incident, product, regulatory and technical claims against the original, publicly available sources. Third-party names appear solely for public-source context; no deployment, adoption, collaboration, endorsement, licensing relationship or infringement is asserted or implied, and no efficacy, latency, performance, certification or safety guarantee is claimed without a reproducible implementation and independent testing.

25. References

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

25.2. Informative References

[AGENTIC-GUIDANCE]
ASD/ACSC, CISA, NSA, Canadian Centre for Cyber Security, NCSC-NZ and NCSC-UK, "Careful Adoption of Agentic AI Services", , <https://www.ncsc.govt.nz/protect-your-organisation/careful-adoption-of-agentic-ai-services/>.
[GTIG]
Google Threat Intelligence Group and Mandiant, "GTIG AI Threat Tracker: Agentic Threat Activity Crosses a Significant Threshold", , <https://cloud.google.com/blog/topics/threat-intelligence/agentic-threat-activity-crosses-a-significant-threshold/>.
[NIST800-207]
Rose, S., "Zero Trust Architecture", NIST Special Publication 800-207, , <https://csrc.nist.gov/pubs/sp/800/207/final>.
[NIST800-207A]
Chandramouli, R., "A Zero Trust Architecture Model for Access Control in Cloud-Native Applications in Multi-Cloud Environments", NIST Special Publication 800-207A, , <https://csrc.nist.gov/pubs/sp/800/207/a/final>.
[PCT-55615]
Das, S. K., "Mothership international application PCT/IB2026/055615 (publication reference supplied by the author: WO 2026/150382 A2)", , <https://www.tdcommons.org/dpubs_series/12542/>.
[RFC8785]
Rundgren, A., "JSON Canonicalization Scheme (JCS)", RFC 8785, DOI 10.17487/RFC8785, , <https://www.rfc-editor.org/info/rfc8785>.
[RFC9334]
Birkholz, H., "Remote ATtestation procedureS (RATS) Architecture", RFC 9334, DOI 10.17487/RFC9334, , <https://www.rfc-editor.org/info/rfc9334>.
[RFC9396]
Lodderstedt, T., "OAuth 2.0 Rich Authorization Requests", RFC 9396, DOI 10.17487/RFC9396, , <https://www.rfc-editor.org/info/rfc9396>.
[RFC9449]
Fett, D., "OAuth 2.0 Demonstrating Proof of Possession (DPoP)", RFC 9449, DOI 10.17487/RFC9449, , <https://www.rfc-editor.org/info/rfc9449>.
[RFC9635]
Richer, J., "Grant Negotiation and Authorization Protocol (GNAP)", RFC 9635, DOI 10.17487/RFC9635, , <https://www.rfc-editor.org/info/rfc9635>.
[RIKEN]
RIKEN, "Notice regarding a possible personal information leak affecting Fugaku and RIKYU users following unauthorized access to the supercomputer Fugaku", , <https://www.riken.jp/en/news_pubs/news/2026/20261116_2/index.html>.

Appendix A. Terminology and Industry Mapping

Candidate Act
Deferred operation or staged transaction.
Non-Effective State
Pending, non-committed state in which the protected effect has not occurred.
Actual Pending Operation
Reconstructed effective operation, including meaningful parameters and transitive effects.
Finality Sink
Protected effectuation boundary; execution enforcement point; commit gate; reference monitor.
Defender Entry Enforcement Zone
First receiving boundary such as an ingress gateway, WAF or remote-access point.
Independent Validator
Policy decision point independent of the proposer.
Source-Authority Envelope
Origin authorization package including context and bounded delegation.
Commit Binding
Mechanism ensuring the committed operation remains within validated scope and current policy.
Policy Epoch
Version or freshness mechanism preventing stale authorization from continuing silently.
Consequence Closure
Coverage of direct and relevant indirect side effects.
Interim Effectuation Validation
Optional validation of bounded real effects across phases.
Evidence-Carrying Receipt
Optional authenticated evidence of an observed destination-side effect; not a substitute for the sink.

Appendix B. Frequently Asked Questions (Informative)

Q1. Is the Finality Sink on the defender side?
Yes. The consequential enforcement authority belongs in the protected, defender-controlled environment, at the effectuation boundary or an unavoidably traversed trusted mediator.
Q2. Is the entry zone itself the sink?
Sometimes, if the entry API is also the authoritative, non-bypassable place where the entire protected effect commits. Often not.
Q3. Why not put the gate on the public dashboard?
That may reduce one ingress risk but cannot govern internal service calls, lateral movement, valid stolen credentials, background jobs or alternative APIs. The decision must follow the effect.
Q4. Would this have prevented the Fugaku intrusion?
It cannot be asserted. The exploit and internal topology are not public, and the initial dashboard exploit might still have occurred.
Q5. Was the Fugaku incident carried out by AI?
No public evidence in RIKEN's notice establishes that.
Q6. Did Google prove state-sponsored operation of exploit_agent?
No. Language in configuration comments does not prove operator nationality or sponsorship.
Q7. Would this stop an external AI model generating malware?
No. It is not content censorship or remote-model control. It can potentially stop certain protected consequences on a participating defender's system.
Q8. Is a data read a final effect?
It can be. Disclosure of plaintext, release of credentials or transmission of research data can be an irreversible confidentiality effect.
Q9. Does every request call a remote validator?
No. Many controls are local, using protected precomputed policy with bounded validity.
Q10. Does it add latency?
Any added processing has a cost. Protecting infrequent consequential transitions rather than all computation limits it in some designs. It must be measured; no universal figure is promised.
Q11. What happens if the validator is offline?
Nonessential high-risk operations hold or deny; approved bounded operation may continue under explicit policy; emergency safety functions use deterministic local behavior. Allowing everything is not acceptable for a strong claim.
Q12. Does this create a new single point of failure?
It can, if poorly implemented. Use redundancy, capacity testing and explicit partition behavior.
Q13. What if the agent lies about what it executed?
Do not rely on the agent's statement. The destination reconstructs or observes the operation and commits only the independently authorized effect.
Q14. What if an operation changes after approval?
It is rejected or revalidated if parameters, destination, scope, epoch or resource generation differ.
Q15. Can many small allowed actions exceed a critical limit?
Yes, unless protected cumulative counters or reservations track aggregate consequences.
Q16. Isn't this just a zero-trust policy enforcement point?
A policy enforcement point can be the implementation vehicle. What matters is where it stands and what it binds to: the reconstructed operation, version and epoch at the authoritative effect point, with a path analysis showing nothing bypasses it.
Q17. How is it different from an API gateway?
A gateway is an outer gate that sees traffic passing through it. Internal calls, scheduled jobs, direct database access and lateral movement may never touch it. A sink sits where the effect becomes real.
Q18. How is it different from database transactions?
Transactions give atomicity and consistency of a change, not authorization of whether it is allowed. A sink uses atomic commit as a mechanism and adds independent validation, scope and epoch binding and cumulative exposure.
Q19. How is it different from capability-based security?
Capabilities are closely related and can serve as permits. The difference is emphasis: binding to a specific reconstructed operation, version and epoch at the commit point, with fail semantics and bypass analysis in the claim.
Q20. How is it different from admission controllers or policy engines?
Admission control is a good example of a commit-time gate for one platform. The architecture generalizes the pattern across heterogeneous systems and requires coverage evidence.
Q21. Isn't this a reference monitor?
Largely yes in spirit: complete mediation, tamper-resistance and verifiability. The contribution is applying them to classified consequence points in AI-agent, cloud and critical-infrastructure settings with operation reconstruction, epoch binding and falsifiable evaluation.
Q22. How is it different from privileged access management?
Privileged access management supervises a principal's elevated session. A sink also checks each protected effect during that session.
Q23. Is it the two-person rule?
No. Two-person control is one possible policy input for exceptional effects. The sink binds even a two-person approval to the actual operation.
Q24. How does it differ from EDR or SOAR?
EDR and SOAR respond to behavior and are essential. A sink is a pre-commit condition for a classified effect and works even when no detection fires.
Q25. How does it differ from data-loss prevention?
DLP inspects content and channels. A release gate decides on principal, dataset class, destination, volume and purpose at the storage or key-release point. They complement each other.
Q26. How does it differ from sandboxing an agent?
A sandbox limits what code can touch. Agents still need sanctioned tools with real-world effects, and the sink governs those tools' final effects.
Q27. How does it differ from permission prompts in agent frameworks?
Prompts and allow-lists sit at the agent host and typically approve a described action. A sink sits at the resource that commits the effect and binds approval to the canonical arguments and target set, so it still works if the host is compromised or injected.
Q28. Does "finality" mean blockchain finality?
No. Here it means an effect becomes real only after independent authorization at the boundary.
Q29. Does it need AI to work?
No. It is AI-agnostic; AI agents make the problem urgent because they act at machine speed through legitimate interfaces.
Q30. How could a skeptic falsify the main claim?
Find any route by which a classified effect commits without the sink, a stale permit surviving the revocation bound, aggregate exposure exceeding the ledger through concurrency, or a gate that breaks agreed service levels. Experiments E1 to E10 target exactly these.
Q31. Why does the document stress limits and overlap?
The credible claim is conditional. Overclaiming would be false and would discredit a useful pattern.

Author's Address

Sangam Kumar Das
Independent
Balasore
Odisha
India