Computation Is Not Authority: Hardware-Enforced Execution-Finality for Agentic AI, MCP Tool Calls, and Industrial Agents
draft-das-hardware-enforced-execution-finality-02
This document is an Internet-Draft (I-D).
Anyone may submit an I-D to the IETF.
This I-D is not endorsed by the IETF and has no formal standing in the
IETF standards process.
| Document | Type | Active Internet-Draft (individual) | |
|---|---|---|---|
| Author | Sangam Das | ||
| Last updated | 2026-09-29 (Latest revision 2026-09-09) | ||
| RFC stream | (None) | ||
| Intended RFC status | (None) | ||
| Formats | |||
| Additional resources |
Before Comparing Meta Muse / Sentinel, Read the Earlier DAS Disclosures: An AI-Assisted Primary-Source Technical Guide — Zenodo
Hardware Execution Finality for AI and Autonomous Systems — GitHub: Runnable vendor-neutral reference implementation Runnable Python reference implementation with 74 tests, threat models, system variations, and latency benchmarks for preventing AI hallucinations and unauthorized actions from becoming real-world consequence The Internet Solved Communication. It Never Solved Authority. — Zenodo. Broader technical background on the execution-finality gap. |
||
| Stream | Stream state | (No stream defined) | |
| Consensus boilerplate | Unknown | ||
| RFC Editor Note | (None) | ||
| IESG | IESG state | I-D Exists | |
| Telechat date | (None) | ||
| Responsible AD | (None) | ||
| Send notices to | (None) |
draft-das-hardware-enforced-execution-finality-02
Network Working Group S. Das
Internet-Draft Independent Inventor
Intended status: Informational 9 September 2026
Expires: 13 March 2027
Computation Is Not Authority: Hardware-Enforced Execution-Finality for
Agentic AI, MCP Tool Calls, and Industrial Agents
draft-das-hardware-enforced-execution-finality-02
Abstract
Neural AI systems -- large language models, vision-language models,
and other learned decision systems -- now move directly from
computation to consequence. A model output becomes a tool call; a
tool call becomes an API transaction, memory write, payment, file
mutation, browser action, or actuator signal; an agent delegates to
another agent. Successful inference, sandbox containment, connector
allowlisting, session permission, or upstream model approval does not
by itself establish authority for that particular real-world
consequence. A model may be authorized to compute while remaining
unauthorized to act.
This document specifies a hardware-rooted execution-finality
architecture for neural and agentic systems. A proposed consequence-
bearing operation is represented as a Candidate Act and held in a
Non-Effective State until a Protected Enforcement Domain validates
act-specific predicates and an independent Finality Sink verifies
scoped, non-bearer finality authority immediately before the
operation becomes externally effective. If that authority is absent,
stale, replayed, revoked, or mismatched to the act being attempted,
the Candidate Act remains non-effective and the operation fails
closed.
The architecture is model- and vendor-neutral. It is written for the
industrial surfaces that now dominate production agent deployments:
Model Context Protocol (MCP) tool dispatch, computer use, code
execution, enterprise connectors, memory and knowledge-store writes,
GPU and confidential-computing egress, and settlement. The same
invariant applies to those surfaces: computation is not authority;
tool selection is not tool-effectuation; a connector allowlist is not
per-act finality.
Status of This Memo
This Internet-Draft is submitted in full conformance with the
provisions of BCP 78 and BCP 79.
Das Expires 13 March 2027 [Page 1]
Internet-Draft Computation Is Not Authority September 2026
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 13 March 2027.
Copyright Notice
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. Code Components
extracted from this document must include Revised BSD License text as
described in Section 4.e of the Trust Legal Provisions and are
provided without warranty as described in the Revised BSD License.
Table of Contents
1. Introduction . . . . . . . . . . . . . . . . . . . . . . . . 4
2. Scope and Non-Goals . . . . . . . . . . . . . . . . . . . . . 4
3. Why Neural Systems Need a Distinct Finality Layer . . . . . . 4
3.1. From Access Security to Consequence Security . . . . . . 5
3.2. Why This Layer Was Less Necessary a Decade Ago . . . . . 5
3.3. What Frontier and Industrial Deployments Already Show . . 5
3.4. Resulting Distinctions . . . . . . . . . . . . . . . . . 6
4. Core Execution-Finality Protocol . . . . . . . . . . . . . . 6
4.1. Architectural Invariant . . . . . . . . . . . . . . . . . 6
4.2. Terminology . . . . . . . . . . . . . . . . . . . . . . . 7
4.3. Candidate Act Descriptor . . . . . . . . . . . . . . . . 8
4.4. First Boundary: PED Validation . . . . . . . . . . . . . 10
4.5. Scoped Non-Bearer Finality Authority . . . . . . . . . . 11
4.6. Second Boundary: Independent Finality Sink
Verification . . . . . . . . . . . . . . . . . . . . . . 11
4.7. Successful Effectuation and Fail-Closed Requirement . . . 11
5. Industrial Neural-AI Embodiments . . . . . . . . . . . . . . 12
5.1. Embodiment A: MCP and Agentic Tool Dispatch . . . . . . . 12
5.2. Embodiment B: Computer Use, Browser Control, and Shell . 13
Das Expires 13 March 2027 [Page 2]
Internet-Draft Computation Is Not Authority September 2026
5.3. Embodiment C: Memory, Knowledge Stores, and Enterprise
Writes . . . . . . . . . . . . . . . . . . . . . . . . . 13
5.4. Embodiment D: GPU, Accelerator, and Confidential-Computing
Egress . . . . . . . . . . . . . . . . . . . . . . . . . 14
5.5. Embodiment E: Industrial Payments and Settlement . . . . 14
5.6. Embodiment F: Precision-Bounded Industrial Data Egress . 14
6. Protocol Operation, Verification, and Failure Handling . . . 15
6.1. Requirements Language . . . . . . . . . . . . . . . . . . 15
6.2. End-to-End Workflow . . . . . . . . . . . . . . . . . . . 15
6.3. PED Processing . . . . . . . . . . . . . . . . . . . . . 15
6.4. Finality Sink Verification . . . . . . . . . . . . . . . 16
6.5. Replay, Revocation, and Policy Epochs . . . . . . . . . . 16
6.6. Hot Path and Cold Path . . . . . . . . . . . . . . . . . 17
6.7. Failure Codes and Denial Behavior . . . . . . . . . . . . 17
6.8. Alternate-Path Closure . . . . . . . . . . . . . . . . . 18
7. Worked Example: Industrial Agent with MCP and Sensitive
Egress . . . . . . . . . . . . . . . . . . . . . . . . . 18
8. Security Considerations . . . . . . . . . . . . . . . . . . . 19
8.1. Replay and Substitution . . . . . . . . . . . . . . . . . 19
8.2. Prompt Injection and Instruction Laundering . . . . . . . 19
8.3. Tool Poisoning, MCP Substitution, and Verb Creep . . . . 20
8.4. Agentic Cascade and Delegation . . . . . . . . . . . . . 20
8.5. Permission Fatigue and Session-Scoped Allow . . . . . . . 20
8.6. Compromised Application, SDK, or Host Bridge . . . . . . 20
8.7. Protected-State Integrity and Component Failure . . . . . 20
9. Agentic-AI Threat Model . . . . . . . . . . . . . . . . . . . 21
10. Privacy Considerations . . . . . . . . . . . . . . . . . . . 21
11. Relationship to Existing Industrial Controls . . . . . . . . 21
12. IANA Considerations . . . . . . . . . . . . . . . . . . . . . 22
13. Intellectual Property Considerations . . . . . . . . . . . . 22
14. Reference Implementation . . . . . . . . . . . . . . . . . . 23
14.1. Purpose and Tested Sequence . . . . . . . . . . . . . . 23
14.2. Implementation Language and Environment . . . . . . . . 23
14.3. Baseline Test Configuration . . . . . . . . . . . . . . 23
14.4. Non-Bearer Authority Test . . . . . . . . . . . . . . . 24
14.5. Test Suite Summary . . . . . . . . . . . . . . . . . . . 24
14.6. Cryptographic, Replay-Store, and Consequence-Boundary
Variations . . . . . . . . . . . . . . . . . . . . . . 26
14.7. Benchmark Method and Measured Reference Latency . . . . 27
14.8. Limitations of the Reference Implementation . . . . . . 28
14.9. Reproducing the Reference Tests and Benchmark . . . . . 29
14.10. Interpretation . . . . . . . . . . . . . . . . . . . . . 30
15. Related Execution-Finality Drafts and Implementation . . . . 30
16. Conclusion . . . . . . . . . . . . . . . . . . . . . . . . . 31
17. Normative References . . . . . . . . . . . . . . . . . . . . 31
18. Informative References . . . . . . . . . . . . . . . . . . . 31
Author's Address . . . . . . . . . . . . . . . . . . . . . . . . 36
Das Expires 13 March 2027 [Page 3]
Internet-Draft Computation Is Not Authority September 2026
1. Introduction
This document describes a hardware-rooted execution-finality
architecture in which a proposed consequence-bearing operation
generated by a neural model or autonomous agent is represented as a
Candidate Act and maintained in a Non-Effective State until protected
validation and independent Finality Sink verification succeed.
The architecture separates computation, authentication, sandbox
membership, connector permission, application permission, model
approval, and upstream authorization from authority for the resulting
consequence. The central security principle is: COMPUTATION IS NOT
AUTHORITY.
This -01 revision narrows the document to neural, agentic, and
industrial-agent deployments. Broader motivational material on
consumer GPS, 6G sensing, and adjacent infrastructure domains that
appeared in -00 is reduced to short industrial examples so that the
load-bearing protocol and the surfaces that frontier-model and
enterprise operators actually ship remain in the foreground.
This -02 revision adds Section 14, which documents a runnable,
vendor-neutral reference implementation of the architecture -- test
methodology, system environment, policy and cryptographic parameters,
benchmark method and measured local latency, and the limitations of
the reference code -- and adds a corresponding source-code reference,
[DAS-HW-EF-IMPL]. No other normative text changes.
2. Scope and Non-Goals
This document specifies a pre-effectuation control plane for neural
and agentic systems. It is in scope to bind a generated tool call,
computer-use action, memory write, data export, payment instruction,
or accelerator egress to act-specific authority that is verified at
the consequence boundary.
This document does not specify a new model-alignment technique, a
content classifier, an age-estimation protocol, a 6G radio interface,
or a single global privacy statute. Policy engines, Responsible
Scaling evaluations, MCP authorization profiles, OAuth/GNAP grants,
and RATS attestations MAY supply predicates to the Protected
Enforcement Domain. They do not replace Finality Sink verification.
3. Why Neural Systems Need a Distinct Finality Layer
Das Expires 13 March 2027 [Page 4]
Internet-Draft Computation Is Not Authority September 2026
3.1. From Access Security to Consequence Security
Traditional controls answer: who may enter, who may read, which
application has permission, which connector is allowlisted, and
whether this process may invoke this API. Those questions remain
necessary. Execution finality answers a later question: should this
particular generated operation become an actual consequence, in this
state, for this purpose, at this destination, under this policy
epoch, at this moment?
The security problem has moved from controlling only access to
controlling the transition from COMPUTATION to CONSEQUENCE.
3.2. Why This Layer Was Less Necessary a Decade Ago
A decade ago most deployed neural systems were analytical,
classificatory, or advisory. The recommendation did not itself make
the payment. The generated text did not normally invoke tools,
operate a browser, execute a shell command, write enterprise memory,
call another agent, or modify a physical system. Authentication, OS
permissions, application-layer security, and human review remained
practical final barriers.
That boundary has disappeared. An industrial agent can now move
through a chain such as user instruction, model reasoning, tool
selection, MCP server, another agent, enterprise API, database,
payment rail, or production repository without returning to a human-
controlled decision point before each real-world consequence.
3.3. What Frontier and Industrial Deployments Already Show
Public engineering practice around production agents has converged on
a set of necessary but incomplete controls: sandboxes and VMs that
bound what an agent can reach; connector allowlists that bound which
MCP servers exist; per-tool and per-action permission policies that
choose between auto-allow and ask-the-user; credential isolation so
that raw secrets never enter the model sandbox; and proxies that
inspect tool outputs before they re-enter context.
Those controls are important. They do not close the consequence
boundary. An allowlisted MCP server can still advertise a new write
verb after review. A session-level "always_allow" policy can still
cover an act the user never saw. A human who approved 93 percent of
permission prompts is not performing act-specific authorization.
Computer-use paths that click, type, and navigate outside the sandbox
have weaker gates than file or code-execution tools. An audited
connector is not audited data: retrieved content can carry an
indirect instruction that changes the next Candidate Act.
Das Expires 13 March 2027 [Page 5]
Internet-Draft Computation Is Not Authority September 2026
Intelligence uplift alone has been observed to cause an agent to
attempt a production change that the previous model version did not
attempt, with no change to tools, permissions, or prompts.
The missing control is therefore not another model-output filter and
not another session permission dialog. It is a fail-closed boundary
that asks, immediately before effectuation: even though this
operation has been generated and upstream-approved, is this specific
act authorized to become effective now?
3.4. Resulting Distinctions
AUTHENTICATION IS NOT FINALITY. SANDBOX MEMBERSHIP IS NOT FINALITY.
CONNECTOR ALLOWLISTING IS NOT FINALITY. SESSION PERMISSION IS NOT
FINALITY. MODEL APPROVAL IS NOT FINALITY. TOOL SELECTION IS NOT
TOOL-EFFECTUATION AUTHORITY. TOOL ADVERTISEMENT IS NOT TOOL-
EXECUTION AUTHORITY. COMPUTER-USE PERMISSION IS NOT UNRESTRICTED UI
AUTHORITY. DATA ACCESS IS NOT DATA-EXPORT AUTHORITY. SUCCESSFUL
INFERENCE IS NOT ACCELERATOR-EGRESS AUTHORITY. AGENT DELEGATION IS
NOT CUMULATIVE CONSEQUENCE AUTHORITY. COMPUTATION IS NOT AUTHORITY.
4. Core Execution-Finality Protocol
4.1. Architectural Invariant
A Candidate Act MUST NOT become consequence-bearing merely because it
has been generated, computed, selected, routed, scheduled, delegated,
authenticated, sandboxed, or permitted by an upstream application or
AI system.
A Candidate Act MUST remain in a Non-Effective State until all of the
following succeed:
1. a Protected Enforcement Domain validates the applicable act-
specific predicates;
2. protected validation evidence is generated or committed;
3. scoped non-bearer finality authority is released;
4. an applicable Finality Sink independently verifies that authority
immediately before effectuation; and
5. the finality authority and associated protected state are
consumed, invalidated, advanced, or otherwise made unsuitable for
unauthorized replay.
Das Expires 13 March 2027 [Page 6]
Internet-Draft Computation Is Not Authority September 2026
This is a two-boundary architecture. The first boundary determines
whether scoped finality authority may be created. The second
determines whether the consequence may actually occur. PED approval
alone MUST NOT make the Candidate Act effective.
4.2. Terminology
Candidate Act An operation that has been generated, selected,
requested, staged, scheduled, routed, or otherwise prepared but
has not yet been permitted to become consequence-bearing. In
neural systems this includes a tool call, MCP invocation,
function-call argument set, computer-use action, shell command,
browser action, memory write, vector-store commit, payment
instruction, data-export payload, or accelerator egress.
Non-Effective State A state in which the Candidate Act may exist, be
evaluated, staged, queued, hashed, transformed, or prepared, but
the protected consequence cannot yet become externally effective.
An implementation MUST preserve the Non-Effective State whenever a
required element of the chain is absent, invalid, stale, expired,
revoked, replayed, already consumed, act-mismatched, scope-
mismatched, policy-mismatched, or Finality-Sink-mismatched.
Protected Enforcement Domain (PED) A protected validation
environment that evaluates whether a Candidate Act is eligible to
receive scoped finality authority. It MAY be implemented as a
TEE, secure enclave, HSM, protected OS service, confidential-
computing environment, secure controller, or equivalent. The
defining function is protected validation before finality
authority is released, not a particular hardware product.
Protected Validation Evidence Evidence committed by the PED
establishing the validation state associated with a Candidate Act.
It MAY take the form of a Ledger-Anchored Validation Receipt
(LAVR) or an equivalent protected commitment using hashes,
signatures, MACs, sealed state, monotonic counters, Merkle
commitments, or secure audit registers. External ledger anchoring
MAY occur later on a cold path. Protected validation evidence
MUST exist before, or atomically with, release of scoped finality
authority.
Scoped Non-Bearer Finality Authority An act-specific enablement
artifact that permits a particular Candidate Act to cross a
particular effectuation boundary only under its validated scope.
Possession alone MUST NOT be sufficient to cause effectuation.
The authority SHOULD be bound to Candidate Act identity or digest,
protected validation evidence, nonce or freshness, policy epoch,
revocation epoch, permitted scope, permitted consequence class,
Das Expires 13 March 2027 [Page 7]
Internet-Draft Computation Is Not Authority September 2026
destination, and intended Finality Sink identity. An authority
issued for one act, sink, tool, destination, precision, or policy
state MUST NOT be reusable as authority for another consequence.
Finality Sink The functional boundary at which a Candidate Act would
become externally, operationally, financially, or physically
consequential. Examples in neural deployments include an MCP
invocation interface, tool dispatcher, computer-use bridge, shell-
execution interface, browser-control interface, memory-write
controller, API gateway, payment rail, GPU or interconnect egress
controller, and data-egress controller. A gateway, firewall,
policy engine, or safety classifier is not a Finality Sink merely
because it performs checks. It must control the consequence such
that the consequence is technically non-completable without
successful finality verification.
Consequence Class The kind of external effect being proposed: for
example TOOL_INVOKE, MCP_CALL, COMPUTER_USE, SHELL_EXEC,
MEMORY_WRITE, DATA_EXPORT, PAYMENT, ACCELERATOR_EGRESS, or
ACTUATOR. Authority for one class MUST NOT automatically imply
authority for a higher-impact class.
4.3. Candidate Act Descriptor
A conforming implementation SHOULD create or derive a machine-
verifiable descriptor for the Candidate Act before effectuation. The
precise serialization is implementation-specific in this version. A
conceptual descriptor for a neural or agentic act contains:
Das Expires 13 March 2027 [Page 8]
Internet-Draft Computation Is Not Authority September 2026
CandidateAct {
version
candidate_act_id
act_type
act_digest
initiator_id
application_id
agent_id
model_id
model_or_runtime_state_ref
tool_id
mcp_server_id
function_or_verb
instruction_provenance
purpose
permitted_scope
consequence_class
arguments_digest
resource_or_data_class
destination_id
jurisdiction
data_precision
nonce
creation_time
expiration_time
policy_epoch
authority_epoch
revocation_epoch
protected_state_ref
finality_sink_id
effectuation_boundary_id
}
Not every field is required for every domain. Tool-or-function
identity, MCP server identity, argument digest, instruction
provenance, and consequence class are first-class for agentic AI.
Data precision is first-class for sensitive egress. Destination and
jurisdiction are first-class for cross-boundary export.
Implementations MUST ensure that changing a load-bearing attribute
invalidates previously issued authority.
Das Expires 13 March 2027 [Page 9]
Internet-Draft Computation Is Not Authority September 2026
A Candidate Act SHOULD have a stable digest over its load-bearing
attributes so that substitution of tool, arguments, destination,
amount, precision, or sink fails verification.
4.4. First Boundary: PED Validation
Upon receiving or resolving a Candidate Act, the PED MUST keep that
act non-effective while validation is performed. The PED SHOULD
evaluate all predicates required by the applicable consequence class.
For neural and agentic acts those predicates MAY include:
* agent, model, and runtime identity;
* instruction provenance and retrieval/memory provenance;
* tool, MCP server, verb, and argument scope;
* purpose and permitted consequence class;
* destination, jurisdiction, and data residency;
* data precision and cumulative disclosure state;
* user or enterprise authorization still current;
* policy epoch and revocation epoch;
* nonce and freshness;
* delegation depth and cumulative consequence envelope;
* Finality Sink identity.
If validation succeeds, the PED MUST establish or confirm the
applicable protected-state transition, generate or commit protected
validation evidence, bind that evidence to the Candidate Act, bind
the permitted scope and Finality Sink, and release scoped non-bearer
finality authority only after, or atomically with, the evidence
commitment. The Candidate Act remains non-effective at this stage.
If validation fails, the PED MUST NOT release usable finality
authority. The implementation SHOULD create protected denial state
sufficient to prevent unauthorized retry, replay, rollback,
substitution, or stale reuse where those risks apply. The Candidate
Act MUST remain non-effective.
Das Expires 13 March 2027 [Page 10]
Internet-Draft Computation Is Not Authority September 2026
The system MUST NOT treat a Boolean ALLOW=TRUE as sufficient
execution-finality authority. Validation state is part of the
consequence-control mechanism, not merely an audit trail.
4.5. Scoped Non-Bearer Finality Authority
Following successful protected evidence commitment, the PED MAY
release an Execution Handle, capability fragment, protected
enablement state, or equivalent scoped non-bearer finality authority.
A conforming authority SHOULD be act-bound, evidence-bound, state-
bound, scope-bound, nonce- or freshness-bound, epoch-bound, sink-
bound, and non-bearer. Copying, observing, storing, forwarding, or
possessing it MUST NOT by itself create authority for effectuation.
Where single-use effectuation is intended, the authority MUST be
consumed, invalidated, burned, or rendered unusable before or
atomically with successful effectuation.
4.6. Second Boundary: Independent Finality Sink Verification
The Finality Sink MUST NOT merely trust that the PED previously
approved the Candidate Act. It MUST independently verify the
applicable finality authority immediately before effectuation,
including authority validity, Candidate Act digest, protected
evidence and state, scope, destination, nonce, freshness, policy and
revocation epochs, consumption state, consequence class, and sink
identity.
A failed Finality Sink verification MUST prevent effectuation. It
MUST NOT merely create an alert while allowing the consequence to
proceed. For neural deployments this means: the tool call remains
non-effective; the MCP invocation is not dispatched; the computer-use
action is not injected; the memory write is not committed; the
payment does not settle; the accelerator output does not leave the
holding region.
4.7. Successful Effectuation and Fail-Closed Requirement
If Finality Sink verification succeeds, the implementation MUST
ensure that the finality authority cannot be reused outside its
permitted semantics. For single-use operations, consumption or
protected-state advancement SHOULD occur before or atomically with
effectuation. The implementation SHOULD create sink-side finality
evidence identifying the completed protected consequence.
A conforming implementation MUST fail closed for a protected
consequence when required execution-finality state cannot be
verified. Timeout, cache miss, policy miss, network failure, or
uncertainty MUST NOT be converted into permission to effectuate.
Das Expires 13 March 2027 [Page 11]
Internet-Draft Computation Is Not Authority September 2026
5. Industrial Neural-AI Embodiments
The physical or logical location of the Finality Sink changes
according to the consequence being controlled. The protocol
invariant does not.
5.1. Embodiment A: MCP and Agentic Tool Dispatch
This is the primary industrial surface. An agent may call an API,
invoke an MCP tool, write a file, update a CRM, query a warehouse,
open a ticket, or issue a refund. Generation of a syntactically
valid tool-call argument set is not authority to cause the tool's
consequence.
A consequential tool request SHOULD first be represented as an Agent
Candidate Act, for example:
Act-Type: TOOL_CALL / MCP_CALL
Agent-ID: enterprise-agent-27
Model-ID: model-build-X
MCP-Server-ID: payments-mcp-3
Tool-ID: customer-payment-api
Function: issue_refund
Requested-Amount: 500
Customer-ID: 18422
Instruction-Source: authenticated support workflow
Purpose: customer refund
Policy-Epoch: 481
Finality-Sink: mcp-dispatcher / payment-api-dispatcher
The PED MAY validate agent identity, model or runtime state,
instruction provenance, MCP server identity, tool and verb, argument
scope, user authorization, delegation authority, memory and retrieval
provenance, policy and revocation epochs, purpose, destination, and
sink identity. If the required predicates are not satisfied, no
usable finality authority is released.
The applicable Finality Sink MAY be placed at the tool dispatcher,
MCP invocation interface, function-call gateway, API gateway, or
equivalent consequence boundary. The resulting principle is: tool
selection is not tool-execution authority; an MCP server being
allowlisted is not authority for this verb, these arguments, and this
destination.
Industrial implications that existing MCP and enterprise agent
controls do not close by themselves:
Das Expires 13 March 2027 [Page 12]
Internet-Draft Computation Is Not Authority September 2026
* A connector allowlist answers which servers exist. It does not
bind this call's arguments.
* A two-gate admin-then-user authorization answers who may attach a
connector. It does not re-verify the act at dispatch.
* A permission policy of always_allow or always_ask is session- or
toolset-scoped. It is not act-digest-scoped, nonce-bound, or
sink-bound.
* A reverse proxy that injects credentials so the sandbox never
holds secrets is necessary credential hygiene. It is not
independent verification that this Candidate Act may consume those
injected credentials.
* New tools advertised by an already-approved MCP server MUST NOT
inherit prior finality authority.
5.2. Embodiment B: Computer Use, Browser Control, and Shell
Computer-use and host-side UI control are high-blast-radius neural
actions. Unlike a sandboxed code-execution tool, a computer-use path
can click, type, and navigate in the user's actual desktop, and a
link opened in an approved application can reach an application that
was never approved. Shell execution and browser control are the same
class of problem: the model produces an action descriptor; the host
injects it.
Each computer-use step that can change external state SHOULD be a
Candidate Act bound to application identity, action class (click,
type, navigate, download, submit), target surface, and permitted
consequence class. The Finality Sink is the computer-use bridge,
input-injection controller, or browser-control interface. Session
permission to "use the computer" MUST NOT be treated as unrestricted
authority for every subsequent UI action.
Where a product already requires per-application permission or per-
deletion confirmation, those signals MAY be consumed as PED
predicates. They remain insufficient unless the sink verifies act-
bound authority immediately before injection.
5.3. Embodiment C: Memory, Knowledge Stores, and Enterprise Writes
Persistent memory, vector stores, CRM records, ticket systems, and
production repositories convert a generated string into a durable
enterprise fact. A hallucinated or prompt-injected write that later
becomes retrieval context is a delayed consequence. The write itself
is already a consequence.
Das Expires 13 March 2027 [Page 13]
Internet-Draft Computation Is Not Authority September 2026
A memory-write or record-update Candidate Act SHOULD bind the
destination store, record class, write versus delete verb, provenance
of the content being written, and the agent that produced it. The
Finality Sink is the memory-write controller, database commit
boundary, or repository push interface. Industrial deployments
SHOULD treat "write to prod" and "delete" as distinct consequence
classes from "read" and "draft".
5.4. Embodiment D: GPU, Accelerator, and Confidential-Computing Egress
In large industrial inference systems the relevant consequence may
occur before an output reaches an application-layer gateway: GPU
memory release, DMA, device-to-host transfer, interconnect transfer,
or tool dispatch directly from an inference runtime. A Neural
Candidate Act MAY be staged in a protected holding region
(confidential bounce buffer, sealed memory, protected DMA target,
GPU/HBM/VRAM region, SmartNIC or DPU memory). The staged output may
already have been computed. The system withholds Completion Material
-- plaintext release, write-enable, transmit-enable, or commit-enable
-- until validation and Finality Sink verification succeed.
Where inference spans multiple GPUs, nodes, shards, or expert
partitions, the PED MAY require evidence that participating devices
belong to the approved computation. Successful inference does not
itself authorize accelerator egress.
5.5. Embodiment E: Industrial Payments and Settlement
An agent or automated workflow may generate a valid payment
instruction while the transaction has become unauthorized by the time
settlement is attempted. Relevant state may change because of
revocation, limits, sanctions, jurisdiction, duplicate detection,
stale authorization, or counterparty state. An upstream model or
application approval is not settlement authority.
The Finality Sink MAY be positioned at wallet signing, the payment
rail, banking switch, clearing interface, CBDC ledger boundary, or
settlement interface. The sink independently verifies act-bound
authority for amount, currency, counterparties, purpose, nonce, and
current epochs before settlement occurs.
5.6. Embodiment F: Precision-Bounded Industrial Data Egress
Industrial agents routinely possess high-precision data they do not
need to externalize: exact location for a field-service dispatch,
exact customer identifiers for a summary, exact schematic values for
a maintenance answer. Local access is not export authority.
Precision is itself an authorization dimension.
Das Expires 13 March 2027 [Page 14]
Internet-Draft Computation Is Not Authority September 2026
The PED MAY deny exact export while allowing a coarsened
representation (region rather than coordinate, last-four rather than
full identifier, aggregate rather than row). The Finality Sink MUST
enforce that the exact value does not escape through another field,
URL parameter, telemetry channel, or alternate path subject to the
same policy. Cumulative disclosure state MAY change the decision
even when a single record would have been permitted.
This embodiment replaces the long consumer-GPS motivation of -00.
The protocol point is identical and is not limited to location: any
high-resolution industrial data class can be scoped this way.
6. Protocol Operation, Verification, and Failure Handling
6.1. Requirements Language
The key words "MUST", "MUST NOT", "REQUIRED", "SHOULD", "SHOULD NOT",
"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. Failure to establish current finality
authority MUST NOT be converted into permission to effectuate.
6.2. End-to-End Workflow
Act Generator PED Finality Sink
| | |
|-- Candidate Act ---->| |
| NON-EFFECTIVE | |
| |-- validate predicates |
| |-- commit evidence |
| | |
| | [DENY] remain |
| | NON-EFFECTIVE |
| | |
| | [ALLOW] scoped |
| | finality authority |
|---------------------- authority --------------->|
| verify act |
| verify scope |
| verify nonce |
| verify epochs |
| verify sink |
| [FAIL] no effect
| [PASS] consume
|<---------------- permitted consequence ---------|
6.3. PED Processing
Das Expires 13 March 2027 [Page 15]
Internet-Draft Computation Is Not Authority September 2026
function PED_VALIDATE(candidate):
if candidate is malformed: return DENY(MALFORMED_ACT)
if candidate.nonce is not fresh: return DENY(REPLAY_OR_STALE)
if policy_epoch mismatch: return DENY(POLICY_EPOCH_MISMATCH)
if revocation_epoch mismatch: return DENY(REVOCATION_STATE_MISMATCH)
if sink is not authorized: return DENY(SINK_NOT_AUTHORIZED)
if purpose/scope/jurisdiction fail:
return DENY(...)
if tool/MCP/verb/arguments fail: return DENY(SCOPE_DENIAL)
if provenance or runtime checks fail:
return DENY(PROVENANCE_OR_RUNTIME)
evidence = COMMIT_PROTECTED_VALIDATION(candidate)
authority = ISSUE_SCOPED_FINALITY_AUTHORITY(
candidate, evidence, current_protected_state)
return ALLOW(authority)
The pseudocode is illustrative. An implementation MAY evaluate
additional predicates including runtime behavioral descriptors,
neural-state integrity, data residency, accelerator identity,
financial state, or cumulative disclosure state.
6.4. Finality Sink Verification
function FINALITY_SINK_VERIFY(candidate, authority):
if authority is absent or integrity fails: return DENY
if HASH(candidate) != authority.digest: return DENY(ACT_MISMATCH)
if authority.sink_id != THIS_SINK: return DENY(SINK_MISMATCH)
if expired, consumed, or nonce-stale: return DENY
if epoch or protected-state mismatch: return DENY
if scope, destination, or precision exceed authority:
return DENY
ATOMICALLY:
consume(authority)
advance_replay_state()
permit_effectuation()
return EFFECTUATED
6.5. Replay, Revocation, and Policy Epochs
Single-use authority MUST be consumed or otherwise made unusable
before or atomically with effectuation. Replay protection MAY use
nonce consumption, monotonic counters, sequence numbers, protected
consumed flags, short expiration windows, or epoch advancement.
A previously issued authority MUST NOT override a newer revocation
state. Revocation SHOULD be checked at the Finality Sink, not merely
when the authority was created. The same principle applies to policy
epochs: an authority issued before a material policy change -- tool
Das Expires 13 March 2027 [Page 16]
Internet-Draft Computation Is Not Authority September 2026
revoked, write verb removed, destination blocked, model version
withdrawn, data-residency rule changed -- SHOULD NOT silently inherit
authority under the new state.
6.6. Hot Path and Cold Path
Not every Candidate Act requires identical validation cost. A hot
path MAY use local protected state, fresh nonce state, cached policy,
short-lived authority, and a known sink for frequent, previously
bounded, low-risk acts. A hot-path operation MUST still perform
Finality Sink verification. "Hot path" does not mean "skip
finality."
A Candidate Act SHOULD be escalated to a cold or higher-assurance
path for high-value settlement, exact sensitive-data export, new or
unknown tool delegation, changed destination, runtime anomaly,
production writes, or computer-use actions outside a pre-bound
envelope. Cache miss, policy miss, revocation uncertainty, or
network failure MUST escalate or deny. They MUST NOT default to
allow.
A successful cold-path evaluation MAY establish a bounded policy
envelope for subsequent low-latency operations (approved model,
approved tool, approved purpose, maximum precision, destination,
epochs, sink, short validity). If any bound condition changes, the
system SHOULD escalate again.
Representative industrial hot-path budgets in related implementations
are on the order of 1-20 ms for local protected checks. These
figures are examples, not protocol requirements. External ledger
anchoring belongs on the cold path and MUST NOT retroactively
authorize an act that was not valid when effectuation occurred.
6.7. Failure Codes and Denial Behavior
The following identifiers are protocol-design suggestions, not IANA
assignments:
Das Expires 13 March 2027 [Page 17]
Internet-Draft Computation Is Not Authority September 2026
EF-001 MALFORMED_ACT; EF-002 NO_FINALITY_AUTHORITY; EF-003
INVALID_AUTHORITY; EF-004 STALE_AUTHORITY; EF-005
AUTHORITY_ALREADY_USED; EF-006 REPLAY_DETECTED; EF-007 NONCE_FAILURE;
EF-010 ACT_MISMATCH; EF-012 SCOPE_MISMATCH; EF-013 PURPOSE_MISMATCH;
EF-014 CONSEQUENCE_CLASS_MISMATCH; EF-020 DESTINATION_MISMATCH;
EF-021 JURISDICTION_MISMATCH; EF-023 PRECISION_MISMATCH; EF-030
POLICY_EPOCH_MISMATCH; EF-031 REVOCATION_STATE_MISMATCH; EF-032
PROTECTED_STATE_MISMATCH; EF-040 SINK_MISMATCH; EF-050
ATTESTATION_FAILURE; EF-053 INSTRUCTION_PROVENANCE_FAILURE; EF-060
VALIDATION_TIMEOUT; EF-061 AUTHORITY_UNCERTAIN; EF-070
ESCALATION_REQUIRED; EF-071 HUMAN_REVIEW_REQUIRED; EF-080
FAIL_CLOSED.
A denial MAY specify remediation: downgrade precision, redact,
quarantine, require fresh authority, or escalate to a cold path. A
timeout MUST NOT be interpreted as approval.
6.8. Alternate-Path Closure
An implementation MUST consider alternate paths capable of producing
the same protected consequence. For an agentic act those paths
include the normal tool dispatcher, a direct API call, shell
execution, browser control, IPC, memory write, an alternate plugin,
or a computer-use detour around a blocked MCP verb. Moving the act
to a different path MUST NOT remove the execution-finality
requirement if that path can produce the same protected consequence.
7. Worked Example: Industrial Agent with MCP and Sensitive Egress
User: "Find field technicians near the outage and open a dispatch
ticket."
The agent obtains precise device or asset coordinates locally and
proposes two acts.
Act 1 is an MCP search call. The PED determines that the external
discovery service requires only coarse locality. Exact coordinates
are denied; a regional representation is allowed. Authority is bound
to purpose=dispatch-discovery, precision=REGION, destination=search-
provider-X, sink=egress-controller. If the outgoing payload still
contains exact coordinates, the sink fails closed with EF-023
PRECISION_MISMATCH.
Das Expires 13 March 2027 [Page 18]
Internet-Draft Computation Is Not Authority September 2026
Act 2 is an MCP write: open_ticket(severity=P1, assignee=crew-14,
location=...). The PED validates verb, destination system, argument
scope, and current authorization. The MCP dispatcher is the Finality
Sink. A prompt-injected escalation that changes severity to a
production-shutdown command, or redirects the write to an unapproved
tracker, fails digest or destination verification and remains non-
effective.
The agent can reason over precise information internally. It does
not acquire unrestricted authority to externalize that precision or
to invoke an unvalidated write.
8. Security Considerations
The principal security objective is that a protected consequence MUST
remain technically non-effective unless current, act-specific, scoped
authority is verified at the applicable Finality Sink.
8.1. Replay and Substitution
An attacker may reuse a previously valid authority or substitute a
different operation under a valid authority (coarse location becomes
exact; refund of 50 becomes 5,000; Tool A becomes Tool B; approved
MCP server becomes a look-alike server). The Finality Sink MUST
verify that the actual consequence corresponds to the digest bound to
the authority. Authority issued for one sink MUST NOT be usable at
another sink, including a shell or computer-use path used to launder
a blocked tool call.
8.2. Prompt Injection and Instruction Laundering
The proposed Candidate Act may have been influenced by content that
was never intended to function as an instruction: retrieved
documents, webpages, email, screen-visible text, tool responses, MCP
resource bodies, database content, persistent memory, vector-store
records, multimodal inputs, malicious plugins, or another agent. An
audited connector is not audited data. A PED MAY therefore evaluate
instruction provenance, retrieval provenance, memory provenance,
runtime behavior, or equivalent trust signals before releasing
finality authority. The protocol does not require the model itself
to detect every injection. It requires that a consequential
operation influenced by such a condition still cannot become
effective unless the required finality predicates succeed.
Das Expires 13 March 2027 [Page 19]
Internet-Draft Computation Is Not Authority September 2026
8.3. Tool Poisoning, MCP Substitution, and Verb Creep
An MCP server, plugin, or tool description may change after the
session or enterprise review that allowlisted it. New verbs, widened
argument schemas, or a substituted server endpoint MUST NOT inherit
prior finality authority. Tool metadata and marketplace discovery
MUST NOT themselves be treated as authority for consequence-bearing
invocation.
8.4. Agentic Cascade and Delegation
A trusted agent may delegate to another agent, which delegates again,
creating a chain whose cumulative consequence exceeds the original
task. Discovery of an external agent or advertised capability MUST
NOT by itself establish trust to receive credentials, data, payment
authority, file access, or execution privileges. An implementation
MAY maintain cumulative delegation depth, resource use, tool-call
count, execution velocity, or consequence state, and withhold further
finality authority when the permitted envelope is exceeded.
8.5. Permission Fatigue and Session-Scoped Allow
Human approval of a session, a toolset, or a high fraction of
permission prompts is not act-specific authorization.
Implementations that offer always_allow for trusted toolsets SHOULD
still bind each high-consequence act to sink-side verification.
Auto-approval of "safer" classes MUST be represented as a bounded
policy envelope, not as the absence of a Finality Sink.
8.6. Compromised Application, SDK, or Host Bridge
Ordinary application-layer software, an SDK, a local MCP server, or a
computer-use bridge MAY be compromised. Security MUST NOT depend
solely on the application, SDK, browser, or model saying ALLOW. A
malicious component with valid session access SHOULD NOT be able to
bypass a protected Finality Sink for the same consequence.
8.7. Protected-State Integrity and Component Failure
High-assurance implementations SHOULD use protected monotonic state,
sealed storage, secure counters, or authenticated state transitions
where rollback of consumed nonces, policy epochs, or revocation
epochs could produce a consequence. If PED integrity cannot be
established, the implementation SHOULD NOT release finality authority
for protected consequence classes. An upstream PED cannot compensate
for a sink that permits consequence without checking authority. The
elements of the chain are mutually load-bearing.
Das Expires 13 March 2027 [Page 20]
Internet-Draft Computation Is Not Authority September 2026
9. Agentic-AI Threat Model
A representative industrial neural-agent deployment SHOULD consider
at least:
T1 Direct prompt injection; T2 Indirect prompt injection through
retrieved or on-screen content; T3 Poisoned retrieval; T4 Poisoned
persistent memory; T5 Malicious tool response; T6 Tool substitution;
T7 MCP or server substitution; T8 Unauthorized delegation; T9
Recursive agent escalation; T10 Stale user or enterprise authority;
T11 Destination substitution; T12 Cross-jurisdiction export; T13
Over-disclosure of high-precision industrial data; T14 Replay of
previous authority; T15 Cross-sink authority reuse including
computer-use laundering; T16 Runtime or model-state deviation,
including capability uplift that attempts new acts under unchanged
permissions; T17 Alternate-path effectuation; T18 Verb creep on an
allowlisted connector; T19 Credential injection misuse (proxy-held
secrets applied to an unauthorized act); T20 Production write or
delete presented as a draft or search.
10. Privacy Considerations
Execution-finality metadata itself may contain sensitive information:
agent identity, purpose, destination, data class, financial
consequence, or behavioral information. Implementations SHOULD
minimize information exposed outside protected validation boundaries
and MAY use hashes, commitments, attestations, or confidential-
computing evidence rather than raw descriptors. Validation of neural
and runtime state SHOULD be possible without exposing model weights,
private prompts, confidential user data, internal activations, or
sensitive inference traces.
11. Relationship to Existing Industrial Controls
The architecture is intended to coexist with systems already present
in frontier-model and enterprise agent stacks. It MAY consume
decisions or evidence from identity providers, OAuth and GNAP grants,
RBAC, MCP authorization profiles, connector allowlists, policy
engines, safety classifiers, attestation systems, DLP/DSPM, human
approval, and risk engines. Those systems provide inputs to finality
validation. They do not replace Finality Sink verification.
Das Expires 13 March 2027 [Page 21]
Internet-Draft Computation Is Not Authority September 2026
GNAP [RFC9635] already separates grant negotiation from grant use and
supports fine-grained, per-request access. The scoped non-bearer
authority described here is compatible with a GNAP access token
scoped to a single operation, with the addition that the grant
decision is made against externally verified binding records rather
than client-supplied claims, and that the consequence boundary
independently verifies the grant.
RATS [RFC9334] establishes that a piece of code is running in an
expected state. That answers a different question than whether that
code is authorized for a specific consequence. Attestation MAY be a
PED predicate. It is not finality.
OAuth 2.0 [RFC6749], JSON Web Tokens [RFC7519], and OAuth 2.0
Resource Indicators [RFC8707] address related but narrower audience-
and scope-restriction problems. This document's Execution Handle
generalizes those restrictions to a per-Candidate-Act, non-bearer
grant consumed at a named sink.
MCP authorization and enterprise-managed connector control answer
which servers and verbs an agent may see. This document answers
whether a particular generated invocation may become effective.
12. IANA Considerations
This version of the document requests no IANA actions. The EF-xxx
failure identifiers are illustrative protocol-design identifiers and
are not IANA assignments. If later versions standardize wire-format
fields, error codes, consequence classes, or capability types, an
IANA registry MAY be proposed at that time.
13. Intellectual Property Considerations
Certain technical concepts described in this document are associated
with pending patent applications in the DAS Protocols family,
including PCT/IB2026/054453, PCT/IB2026/055615, PCT/IB2026/055760,
PCT/IB2026/055870, PCT/IB2026/056058, and PCT/IB2026/053385. These
filings disclose related elements including non-bearer execution
handles, protected enforcement domains, neural candidate acts, AI-
output finality, device-side enforcement, agentic tool-use
enforcement, and Algorithmic Logic Fingerprints. Any IETF
intellectual-property disclosure required in connection with
standardization of this work should be handled separately in
accordance with applicable IETF IPR procedures [BCP79]. This section
is informational and does not define licensing terms.
Das Expires 13 March 2027 [Page 22]
Internet-Draft Computation Is Not Authority September 2026
14. Reference Implementation
This section documents a runnable, vendor-neutral reference
implementation of the Candidate Act / Non-Effective State / Protected
Enforcement Domain (PED) / scoped non-bearer finality authority /
independent Finality Sink sequence specified in this document. The
implementation is published at [DAS-HW-EF-IMPL]. It is provided to
support interoperability review, adversarial testing, and
reproducible evaluation. It is informational and does not itself
constitute a normative requirement of this specification.
14.1. Purpose and Tested Sequence
The reference implementation exercises the following sequence:
Candidate Act, Non-Effective State, Protected Enforcement Domain,
act-specific predicate validation, protected validation evidence,
scoped non-bearer finality authority, holder proof-of-possession,
independent Finality Sink verification, atomic single-use
consumption, and external effect. The property under test is that
successful computation, model output, tool selection, application
permission, connector authorization, or PED approval is not by itself
sufficient to cause the external consequence; the effectuation
callback is reached only after independent Finality Sink verification
succeeds.
14.2. Implementation Language and Environment
The reference implementation is written in Python 3.11+ and declares
a runtime dependency on cryptography >= 41 and a test-only dependency
on pytest >= 8. It was created and validated using Python 3.13.5 on
x86_64 Linux, kernel 6.18.35, glibc 2.41, on an Intel(R) Xeon(R)
Platinum 8370C CPU @ 2.80 GHz, with cryptography 46.0.4, pytest
9.0.2, and SQLite 3.46.1. Python was chosen so that each security
state transition is easy to inspect, reproduce, modify, and
independently test. Python is not asserted to be a required or
recommended production language; equivalent implementations could be
built in Rust, C, C++, Go, Java, protected OS services, TEE/enclave
code, HSM-integrated services, DPU/SmartNIC services, accelerator
runtimes, firmware, or protected device controllers.
14.3. Baseline Test Configuration
The principal automated tests use a reproducible Candidate Act
representing an agent-generated MCP payment/refund operation: act
type MCP_CALL; tool customer-payment-api; function issue_refund;
purpose customer-refund; destination payments-prod; jurisdiction US;
data precision EXACT; default amount 50 USD against a maximum
permitted amount of 500 and a cold-path threshold of 250; policy
Das Expires 13 March 2027 [Page 23]
Internet-Draft Computation Is Not Authority September 2026
epoch 481, authority epoch 9, revocation epoch 12; Finality Sink mcp-
dispatcher at effectuation boundary dispatch-boundary-1; and a
Candidate Act lifetime of 10 seconds. Candidate IDs and nonces are
generated uniquely per execution, and the runtime validation context
begins approximately 1 ms after Candidate Act creation unless a test
intentionally varies time or state. The baseline PED policy permits
only the above tool, destination, consequence class, purpose, and
maximum precision, caps the amount at 500 with a cold-path threshold
at 250, caps delegation depth at 3, and requires both attestation and
instruction provenance.
Baseline authentication for the deterministic test configuration uses
HMAC-SHA-256 with separate keys for PED/evidence/authority
authentication and for holder proof-of-possession; these are test
keys and are not production credentials.
14.4. Non-Bearer Authority Test
The implementation does not treat possession of the finality
authority as sufficient for effectuation. The authority is bound to
the Candidate Act and other validated state, and the Finality Sink
additionally requires a separate holder proof-of-possession, such
that a copied authority combined with no valid holder key is denied.
The suite tests the correct holder, an incorrect holder key, an
incorrect holder identity, proof binding, and sink challenge binding.
In a production implementation the holder key should ideally be non-
exportable and bound to a protected workload, process, device,
enclave, HSM, hardware root, or equivalent protected execution
identity.
14.5. Test Suite Summary
The validation suite contains 58 collected tests, 58 passed, 0
failures, distributed across four groups: core execution-finality and
sink tests (25); PED/policy/fail-closed tests (20); implementation
and deployment variations (12); and a failure-code catalog test (1).
Parameterized tests are counted individually, which is why the number
of executed tests exceeds the number of Python test functions.
The core group verifies the full successful path from Candidate Act
through PED validation, evidence generation, authority issuance,
holder proof, independent Finality Sink verification, consumption,
and single-execution external effect at the baseline amount of 50.
It also verifies: replay protection (a second submission of an
already-consumed authority is denied as AUTHORITY_ALREADY_USED);
denial on a wrong holder key or wrong holder identity;
STALE_AUTHORITY after the authority's expiration;
POLICY_EPOCH_MISMATCH and REVOCATION_STATE_MISMATCH when the
Das Expires 13 March 2027 [Page 24]
Internet-Draft Computation Is Not Authority September 2026
respective epoch advances after issuance; PROTECTED_STATE_MISMATCH on
a protected-state rollback or change; and denial on an authority-
epoch change before effectuation.
Candidate Act mutation testing issues authority for an original act
and then alters a load-bearing parameter -- destination, purpose,
data precision, nonce, tool ID, function or verb, MCP server ID,
model ID, agent ID, Finality Sink ID, jurisdiction, protected-state
reference, or arguments -- after issuance; the Finality Sink must
reject the previously issued authority against the modified act,
since the modification invalidates the Candidate Act digest/binding.
Signature tampering tests separately alter a valid finality-authority
signature and a valid protected-validation-evidence signature, each
producing denial. Finality Sink substitution tests present authority
issued for one sink (mcp-dispatcher) to a different sink (shell-
bridge), which must be rejected as SINK_MISMATCH, since finality
authority is not a general-purpose capability transferable among
consequence boundaries.
The PED/policy group verifies SCOPE_MISMATCH on an unauthorized tool,
DESTINATION_MISMATCH on an unauthorized destination, PURPOSE_MISMATCH
on a mismatched purpose, PRECISION_MISMATCH on a precision value
above the permitted maximum, CONSEQUENCE_CLASS_MISMATCH when the
requested consequence class lacks policy authorization, denial above
the maximum permitted amount, denial above the maximum delegation
depth, ATTESTATION_FAILURE and INSTRUCTION_PROVENANCE_FAILURE when
the corresponding runtime predicates fail, denial when policy or
revocation state is unavailable (unknown state does not imply
permission; inability to verify does not imply allow),
VALIDATION_TIMEOUT on an injected timeout, and STALE_AUTHORITY for a
Candidate Act presented past its expiration or carrying a stale
policy epoch, revocation epoch, or protected state.
Hot-path/cold-path boundary tests confirm classification on both
sides of, and exactly at, the configured cold-path threshold (amounts
of 1 and 249.99 classify hot; 250 and 500 classify cold), while
confirming that a hot-path operation must still pass Finality Sink
verification -- hot path does not mean skipped finality; cold path
means an implementation can require additional assurance such as
fresh attestation, human approval, sanctions/counterparty refresh,
remote policy decision, additional provenance analysis, new-tool
review, or higher-assurance audit commitment, none of which are
simulated as production services in the reference implementation.
Das Expires 13 March 2027 [Page 25]
Internet-Draft Computation Is Not Authority September 2026
14.6. Cryptographic, Replay-Store, and Consequence-Boundary Variations
Two PED authentication approaches are tested: HMAC-SHA-256 as the
primary deterministic reference mode (simple, reproducible, and
useful for test vectors, but requiring a shared secret between issuer
and verifier and therefore not necessarily appropriate for internet-
scale trust distribution); and an end-to-end Ed25519 variant in which
the PED holds the signing capability and the Finality Sink holds the
corresponding public verification capability, demonstrating
asymmetric separation. A production deployment could protect an
Ed25519 signing key in a TEE, HSM, secure enclave, or equivalent
hardware-backed environment.
Two replay-state implementations are tested: an in-memory store
(process-local, lock-protected, fast, non-persistent across process
loss) used for the default benchmark; and a SQLite store in WAL mode
with authority-ID uniqueness that survives reopening the same local
database, demonstrating atomic single-use behavior. Neither
substitutes for hardware monotonic counters, protected state, cross-
region consensus, or distributed transactional replay protection.
Replay protection is also tested under concurrency: 100 concurrent
attempts across 16 thread workers against the in-memory store, and 32
concurrent attempts across 8 thread workers against the SQLite store,
each required to yield exactly one successful consumption.
Eight consequence-boundary variations are instantiated with
representative tool, destination, and Finality Sink triples: MCP
call, data export, payment, accelerator egress, memory write,
computer use, shell execution, and actuator (PLC). Each follows the
same invariant -- generate, keep non-effective, validate, issue
scoped authority, prove holder possession, verify at the consequence
boundary, consume, and effectuate -- showing that the physical
location of the Finality Sink can vary without changing the core
protocol invariant.
The reference implementation defines 25 EF failure identifiers
spanning malformed acts, missing or invalid authority, stale
authority, replay, nonce failure, Candidate Act mismatch,
scope/purpose/consequence-class/destination/ jurisdiction/precision
mismatch, policy-epoch and revocation-state mismatch, protected-state
mismatch, sink mismatch, attestation and provenance failure, timeout,
uncertain authority, escalation, human review, and fail-closed state.
The suite verifies the catalog's expected count and uniqueness.
These are implementation/reference identifiers and are not IANA-
assigned protocol codes.
Das Expires 13 March 2027 [Page 26]
Internet-Draft Computation Is Not Authority September 2026
14.7. Benchmark Method and Measured Reference Latency
A reproducible local microbenchmark measures the complete local
software finality sequence in three stages -- PED validation,
evidence creation, and authority issuance; holder proof-of-possession
generation; and Finality Sink verification plus atomic replay
consumption -- and reports total hot-path latency. Default
configuration uses 500 warm-up and 5,000 measured iterations, the
HMAC-SHA-256 reference authenticator, an in-memory atomic-lock replay
store, and time.perf_counter_ns() as the clock source, with garbage
collection performed before measurement, disabled during measured
iterations, and re-enabled afterward. p50, p95, p99, mean, minimum,
and maximum are reported. A fresh Candidate Act and runtime context
are created for each iteration; network operations and external
consequence I/O are excluded.
On the environment described above, measured stage latencies were:
PED issuance (policy evaluation, evidence generation, and authority
issuance) p50 0.1943 ms, p95 0.2339 ms, p99 0.3086 ms, mean 0.2067
ms, min 0.1880 ms, max 2.9351 ms. Holder proof-of-possession: p50
0.0189 ms, p95 0.0214 ms, p99 0.0414 ms, mean 0.0207 ms, min 0.0178
ms, max 2.2148 ms. Finality Sink verification and consumption: p50
0.1701 ms, p95 0.2098 ms, p99 0.2825 ms, mean 0.1812 ms, min 0.1647
ms, max 3.1286 ms. The complete local hot-path total was p50 0.3937
ms, p95 0.4580 ms, p99 0.6236 ms, mean 0.4085 ms, min 0.3738 ms, max
3.3413 ms, showing sub-millisecond median latency for the reference
state machine in this particular local software test environment.
These results do not establish equivalent latency for a production
hardware-rooted deployment.
The repository defines a software regression target of total local
hot-path p95 <= 5 ms; the measured p95 of 0.4580 ms passes that
target. This 5 ms figure is a repository engineering/regression
target used to catch future implementation changes that introduce
large local overhead -- it is not a protocol requirement or an IETF
conformance requirement.
For deployment purposes, latency is better divided into a hot path --
for which an illustrative engineering comparison band of
approximately 1-20 ms for protected local checks is suggested,
without the hot path ever meaning that Finality Sink verification is
skipped -- and cold-path operations such as fresh remote attestation,
human approval, sanctions or counterparty refresh, remote enterprise
policy decision, or higher-assurance audit commitment, for which no
universal latency target is claimed because cost depends on
deployment architecture. External ledger anchoring, where used, is
likewise treated as cold-path or post-decision evidence anchoring
rather than a mandatory remote round trip for every local
Das Expires 13 March 2027 [Page 27]
Internet-Draft Computation Is Not Authority September 2026
effectuation, since the execution decision must already be valid at
the moment of consequence and a later ledger record cannot
retroactively authorize an unauthorized act.
14.8. Limitations of the Reference Implementation
The reference code is not itself a hardware security boundary: the
PED, holder, and Finality Sink are Python objects executing in an
ordinary software environment, so the repository demonstrates
protocol mechanics, state transitions, cryptographic binding, and
failure and replay behavior, but not physical hardware isolation. A
production implementation would need to protect the relevant state
using a TEE, HSM, secure enclave, protected OS service, secure
controller, DPU, SmartNIC, accelerator security domain, hardware
monotonic state, or an equivalent protected execution mechanism.
HMAC-SHA-256 requires a shared secret between issuer and verifier and
should not be read as the preferred production architecture; the
Ed25519 variant demonstrates asymmetric separation, but production
systems still require key provisioning, rotation, revocation,
hardware protection, certificate or identity binding, and lifecycle
management. The reference holder key exists in normal process
memory, so the implementation demonstrates the non-bearer protocol
property without establishing a hardware-enforced non-exportable key;
production holder keys should be bound to hardware, an enclave, a
process, workload or device identity, a session, mTLS identity, a
DPoP-like proof, or a protected runtime.
The attestation_ok field is a validation input, not a complete RATS
verifier, EAT parser/verifier, TPM evidence verifier, GPU attestation
verifier, confidential-VM verifier, or vendor-specific attestation
service; the attestation result is modeled, not fully implemented.
The reference implementation consumes replay state before executing
the consequence callback; in a real external system a crash between
consuming the authority and committing the external consequence could
create ambiguous state, so a production design should use
transactional commit, idempotency keys, write-ahead state, a two-
phase or equivalent commit protocol, protected device state, hardware
atomicity, or payment-specific transaction semantics as appropriate.
A software library cannot prove that every path to a real-world
consequence has been protected; if the same protected consequence is
reachable through a direct API, shell, browser automation, IPC, an
alternate plugin or MCP server, direct database access, a memory
write, DMA, or a device interface, those paths must also be routed
through an enforcing Finality Sink or made technically unable to
bypass it -- primarily a deployment-architecture property. The
current repository does not implement cluster-wide replay consensus,
Das Expires 13 March 2027 [Page 28]
Internet-Draft Computation Is Not Authority September 2026
multi-region monotonic state, cross-region revocation
synchronization, Byzantine consensus, HSM quorum, global clock
synchronization, or distributed transactional effectuation; the
SQLite variation demonstrates local persistence only.
The reference policy engine intentionally covers a limited predicate
set (tool, destination, purpose, consequence class, precision,
amount, delegation depth, attestation result, provenance result,
policy epoch, revocation epoch, protected state, availability, and
freshness) and is not a complete enterprise policy language; real
deployments may integrate OAuth, GNAP, workload identity, enterprise
PDPs, ABAC/RBAC, RATS evidence, DLP, DSPM, risk engines, sanctions
systems, data-residency policy, model/runtime assurance, or human
approval as predicate sources, none of which by themselves replace
Finality Sink verification. The code has been executed and tested
but has not been mechanically proven with TLA+, Coq, Isabelle, Lean,
model checking, or formal cryptographic proof; 58 of 58 passing tests
demonstrate the implemented scenarios and invariants and do not
constitute a mathematical proof of security.
The measured benchmark is specifically an in-process Python software-
reference microbenchmark and must not be described as TEE, HSM, GPU,
DPU, SmartNIC, confidential-computing, network, MCP-production, or
payment-network latency. Passing the reference tests does not
establish regulatory compliance, legal authorization, AI safety
certification, cybersecurity certification, payment certification,
IETF conformance, or hardware security certification; the repository
is an engineering reference implementation intended for protocol
discussion, interoperability experiments, standards-oriented review,
adversarial testing, implementation comparison, and research.
14.9. Reproducing the Reference Tests and Benchmark
The published repository documents reproduction steps (create and
activate a Python virtual environment, install the package with its
test extra, and run pytest, expected to report 58 passed) together
with a demonstration script and the latency benchmark script, whose
iteration counts, warm-up count, and reference p95 target are
configurable via environment variables (defaults: 5,000 measured
iterations, 500 warm-up iterations, 5 ms reference p95 target). A
recommended production benchmark matrix additionally records CPU/
device, OS/kernel, firmware, runtime/compiler or native binary
version, TEE/HSM/device security mode, cryptographic algorithm, key
location, attestation profile, replay-state backend, policy backend,
clock source, network topology, Finality Sink type, iteration and
warm-up counts, concurrency level, p50/p95/p99/maximum, and failure
rate, repeated across local HMAC and asymmetric signing, HSM-backed
signing, enclave/TEE PED, remote attestation, persistent replay
Das Expires 13 March 2027 [Page 29]
Internet-Draft Computation Is Not Authority September 2026
storage, concurrent requests, MCP dispatch, database commit, payment
authorization, GPU/DPU egress, and failure/timeout paths.
14.10. Interpretation
The most important result of the reference implementation is not the
sub-millisecond benchmark but the mechanically testable separation it
demonstrates between computation and authority to cause a
consequence: a Candidate Act may be fully generated and evaluated
while remaining non-effective, and changing a load-bearing parameter,
using stale authority, changing epochs, replaying an authority, using
the wrong sink, failing proof-of-possession, losing policy certainty,
failing attestation, or exceeding scope prevents the consequence from
becoming effective. This reflects the invariant stated throughout
this document: Candidate Act is not authority; PED approval is not
effectuation; possession of authority is not effectuation; and
successful computation is not external consequence. Only successful
independent verification at the applicable Finality Sink permits the
protected transition from computation to consequence.
15. Related Execution-Finality Drafts and Implementation
This document is part of a series applying the same Candidate Act /
Non-Effective State / Protected Enforcement Domain / scoped non-
bearer authority / independent Finality Sink architecture to
different domains. [DAS-PURPOSE-EXECUTION-FINALITY] develops cross-
domain data-purpose enforcement; [DAS-EU-AI-ACT] applies the
architecture to EU AI Act high-risk system enforcement;
[DAS-GLOBAL-PRIVACY] applies it to general-purpose privacy-execution
enforcement; and [DAS-PRECISION-EGRESS] applies it to precision-
bounded data egress. A vendor-neutral cross-domain framing also
appears in [DAS-EXEC-FINALITY]. Policy discussion of the same
architecture appears in [FUTURIUM-PURPOSE-LAUNDERING] and
[FUTURIUM-PAPER-COMPLIANCE].
Foundational and cross-domain treatments appear in
[DAS-CANDIDATE-ACT-FINALITY] and [DAS-PROTOCOL-LAYER].
Telecommunications and non-terrestrial applications appear in
[DAS-AI-NATIVE-6G], [DAS-6G-CVID], [DAS-MAP-DISCOVERY], and
[DAS-NTN-RF]. Neural, agentic, and model-governance applications
appear in [DAS-RATS-EXTRACT], [DAS-RATS-OPENAI-ANTHROPIC],
[DAS-RATS-ATTESTATION-BND], [DAS-CHILD-SAFE-RENDERING],
[DAS-AI-INTEROP], [DAS-ENTERPRISE-AI-OUTPUT],
[DAS-PROTOCOLS-ENTERPRISE-AI], [DAS-AGENTIC-TOOL-BINDING],
[DAS-AGENTIC-EXECUTION-FINALITY], and [DAS-AGENTIC-AI-TOOL-EXEC].
Sovereignty, settlement, and operational-technology applications
appear in [DAS-DIGITAL-SOVEREIGNTY], [DAS-PAYMENT-FINALITY], and
[DAS-OT-ACTUATION].
Das Expires 13 March 2027 [Page 30]
Internet-Draft Computation Is Not Authority September 2026
A runnable, vendor-neutral reference implementation of the
architecture specified in this document, summarized in Section 14, is
published at [DAS-HW-EF-IMPL]. Runnable reference implementations
accompanying the wider series include [DAS-PRIVACY-FINALITY-IMPL],
[DAS-HALLUCINATION-IMPL], [DAS-LOCATION-EGRESS-IMPL], [DAS-NTN-IMPL],
[DAS-GPU-IMPL], and [DAS-6G-ORAN-IMPL].
16. Conclusion
Neural systems increasingly move from computation into external
action through tool calls, MCP servers, computer use, memory writes,
payments, and accelerator egress. Sandboxes, connector allowlists,
session permissions, and model-level safety reduce blast radius.
They do not make an unauthorized consequence technically non-
completable at the moment of effectuation.
The architecture in this document introduces a distinct boundary:
Candidate Act, Non-Effective State, protected validation, protected
evidence, scoped non-bearer authority, independent Finality Sink
verification, then consequence. Its central principle remains:
computation is not authority. For agentic systems: tool selection is
not tool-effectuation authority. For industrial MCP deployments: a
connector allowlist is not per-act finality. For computer use:
session permission is not unrestricted UI authority. For inference
hardware: successful generation is not egress authority.
17. Normative References
[RFC2119] Bradner, S., "Key words for use in RFCs to Indicate
Requirement Levels", BCP 14, RFC 2119,
DOI 10.17487/RFC2119, March 1997,
<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,
May 2017, <https://www.rfc-editor.org/info/rfc8174>.
18. Informative References
[RFC9334] Birkholz, H., Thaler, D., Richardson, M., Smith, N., and
W. Pan, "Remote ATtestation procedureS (RATS)
Architecture", RFC 9334, DOI 10.17487/RFC9334, January
2023, <https://www.rfc-editor.org/info/rfc9334>.
[RFC9635] Richer, J. and F. Imbault, "Grant Negotiation and
Authorization Protocol (GNAP)", RFC 9635,
DOI 10.17487/RFC9635, October 2024,
<https://www.rfc-editor.org/info/rfc9635>.
Das Expires 13 March 2027 [Page 31]
Internet-Draft Computation Is Not Authority September 2026
[RFC6749] Hardt, D., Ed., "The OAuth 2.0 Authorization Framework",
RFC 6749, DOI 10.17487/RFC6749, October 2012,
<https://www.rfc-editor.org/info/rfc6749>.
[RFC7519] Jones, M., Bradley, J., and N. Sakimura, "JSON Web Token
(JWT)", RFC 7519, DOI 10.17487/RFC7519, May 2015,
<https://www.rfc-editor.org/info/rfc7519>.
[RFC8707] Campbell, B. and A. Bansal, "Resource Indicators for OAuth
2.0", RFC 8707, DOI 10.17487/RFC8707, February 2020,
<https://www.rfc-editor.org/info/rfc8707>.
[BCP79] IETF, "Intellectual Property Rights in IETF Technology",
BCP 79, <https://www.rfc-editor.org/info/bcp79>.
[DAS-PURPOSE-EXECUTION-FINALITY]
Das, S., "Data-Purpose Laundering Prevention: Execution-
Finality for Preventing Cross-Domain Data Reuse", Work in
Progress, <https://datatracker.ietf.org/doc/draft-das-
purpose-execution-finality/>.
[DAS-EXEC-FINALITY]
Das, S., "The Internet Solved Communication. It Never
Solved Authority.", Zenodo, DOI 10.5281/zenodo.22082995.
Also available at https://zenodo.org/records/22082995,
providing additional technical background, diagrams, use
cases, and explanatory material on the execution-finality
architecture., August 2026,
<https://doi.org/10.5281/zenodo.22082995>.
[DAS-EU-AI-ACT]
Das, S., "Technical Execution Enforcement for the EU AI
Act", Work in Progress, <https://datatracker.ietf.org/doc/
draft-das-eu-ai-act-execution-enforcement/>.
[DAS-GLOBAL-PRIVACY]
Das, S., "Global Privacy Execution Enforcement", Work in
Progress, <https://datatracker.ietf.org/doc/draft-das-
global-privacy-execution-enforcement/>.
[DAS-PRECISION-EGRESS]
Das, S., "Precision-Bounded Egress", Work in Progress,
<https://datatracker.ietf.org/doc/draft-das-precision-
bounded-egress/>.
Das Expires 13 March 2027 [Page 32]
Internet-Draft Computation Is Not Authority September 2026
[DAS-CANDIDATE-ACT-FINALITY]
Das, S., "The DAS Protocols: Candidate Act Finality", Work
in Progress, <https://datatracker.ietf.org/doc/draft-das-
protocols-candidate-act-finality/>.
[DAS-NTN-RF]
Das, S., "Execution-Finality for Non-Terrestrial Network
RF Operations", Work in Progress,
<https://datatracker.ietf.org/doc/draft-das-ntn-rf-
execution-finality/>.
[DAS-PAYMENT-FINALITY]
Das, S., "A Signed Instruction Is Not Settlement: Finality
for Agentic and API Payments", Work in Progress,
<https://datatracker.ietf.org/doc/draft-das-payment-
execution-finality/>.
[DAS-AI-NATIVE-6G]
Das, S., "Execution-Finality for AI-Native 5G/6G and
O-RAN", Work in Progress,
<https://datatracker.ietf.org/doc/draft-das-ai-native-6g-
execution-finality/>.
[DAS-6G-CVID]
Das, S., "6G Query-Scoped Communication Handles", Work in
Progress, <https://datatracker.ietf.org/doc/draft-das-6g-
query-scoped-communication-handles/>.
[DAS-MAP-DISCOVERY]
Das, S., "Execution-Finality for MAP Discovery and
Communication", Work in Progress,
<https://datatracker.ietf.org/doc/draft-das-map-discovery-
communication-finality/>.
[DAS-RATS-ATTESTATION-BND]
Das, S., "RATS Attestation-Bound Execution-Finality", Work
in Progress, <https://datatracker.ietf.org/doc/draft-das-
rats-attestation-bnd-execution-finality/>.
[DAS-CHILD-SAFE-RENDERING]
Das, S., "Execution-Finality for Preventing Unauthorized
Rendering of Age-Restricted Content", Work in Progress,
<https://datatracker.ietf.org/doc/draft-das-child-safe-
rendering-finality/>.
Das Expires 13 March 2027 [Page 33]
Internet-Draft Computation Is Not Authority September 2026
[DAS-RATS-OPENAI-ANTHROPIC]
Das, S., "Execution-Finality for Frontier Model
Information Extraction Control: OpenAI and Anthropic",
Work in Progress, <https://datatracker.ietf.org/doc/draft-
das-rats-openai-anthropic-extraction/>.
[DAS-PROTOCOLS-ENTERPRISE-AI]
Das, S., "The DAS Protocols: Enterprise AI Governance",
Work in Progress, <https://datatracker.ietf.org/doc/draft-
das-protocols-enterprise-ai/>.
[DAS-RATS-EXTRACT]
Das, S., "Execution-Finality for Frontier Model
Information Extraction Control", Work in Progress,
<https://datatracker.ietf.org/doc/draft-das-rats-frontier-
model-extraction/>.
[DAS-ENTERPRISE-AI-OUTPUT]
Das, S., "Execution-Finality for Enterprise AI Output",
Work in Progress, <https://datatracker.ietf.org/doc/draft-
das-enterprise-ai-output-finality/>.
[DAS-AI-INTEROP]
Das, S., "Execution-Finality for Third-Party AI
Interoperability Under EU DMA Article 6(7)", Work in
Progress, <https://datatracker.ietf.org/doc/draft-das-
execution-finality-ai-interoperability/>.
[DAS-AGENTIC-TOOL-BINDING]
Das, S., "tool_use Is Not invoke(): Binding Execution-
Finality to Agentic Tool Calls", Work in Progress,
<https://datatracker.ietf.org/doc/draft-das-agentic-tool-
binding/>.
[DAS-PROTOCOL-LAYER]
Das, S., "The Missing Execution-Finality Protocol Layer of
the Internet", Work in Progress,
<https://datatracker.ietf.org/doc/draft-das-execution-
finality-protocol-layer/>.
[DAS-DIGITAL-SOVEREIGNTY]
Das, S., "Execution-Finality for Digital Sovereignty",
Work in Progress, <https://datatracker.ietf.org/doc/draft-
das-digital-sovereignty-finality/>.
Das Expires 13 March 2027 [Page 34]
Internet-Draft Computation Is Not Authority September 2026
[DAS-AGENTIC-EXECUTION-FINALITY]
Das, S., "Execution-Finality for Agentic AI Systems", Work
in Progress, <https://datatracker.ietf.org/doc/draft-das-
agentic-execution-finality/>.
[DAS-OT-ACTUATION]
Das, S., "Execution-Finality for Operational Technology
Actuation", Work in Progress,
<https://datatracker.ietf.org/doc/draft-das-ot-actuation-
finality/>.
[DAS-AGENTIC-AI-TOOL-EXEC]
Das, S., "Agentic AI Tool Execution-Finality", Work in
Progress, <https://datatracker.ietf.org/doc/draft-agentic-
ai-tool-execution-finality/>.
[FUTURIUM-PURPOSE-LAUNDERING]
Das, S., "Preventing Data-Purpose Laundering by Agentic
AI: A Hardware-Rooted Pre-Effectuation Layer for GDPR
Purpose Limitation and High-Risk AI Governance", EU AI
Alliance Futurium, <https://futurium.ec.europa.eu/en/
apply-ai-alliance/community-content/preventing-data-
purpose-laundering-agentic-ai-hardware-rooted-pre-
effectuation-layer-gdpr-purpose>.
[FUTURIUM-PAPER-COMPLIANCE]
Das, S., "From Paper Compliance to Technical Enforcement:
Making GDPR and the EU AI Act Executable in the AI Era",
EU AI Alliance Futurium,
<https://futurium.ec.europa.eu/en/apply-ai-alliance/posts/
paper-compliance-technical-enforcement-making-gdpr-and-eu-
ai-act-executable-ai-era>.
[DAS-PRIVACY-FINALITY-IMPL]
Das, S., "Privacy Finality Reference Implementation",
GitHub repository,
<https://github.com/sangmdas/privacy-finality-reference>.
[DAS-HALLUCINATION-IMPL]
Das, S., "Method for Preventing Artificial-Intelligence-
Generated Hallucinations / Unsupported Outputs --
Reference Implementation", GitHub repository,
<https://github.com/sangmdas/Method-for-Preventing-
Artificial-Intelligence-Generated-Hallucinations-
Unsupported-Outputs>.
Das Expires 13 March 2027 [Page 35]
Internet-Draft Computation Is Not Authority September 2026
[DAS-LOCATION-EGRESS-IMPL]
Das, S., "Access Is Not Egress: Precision-Bounded Location
Release -- Reference Implementation", GitHub repository,
<https://github.com/sangmdas/Access-Is-Not-Egress-
Precision-Bounded-Location-Release-Reference-
Implementation>.
[DAS-NTN-IMPL]
Das, S., "NTN and Inter-Satellite Control -- Runnable
Reference Implementation", GitHub repository,
<https://github.com/sangmdas/NTN-and-Inter-Satellite-
Control-Runnable-Reference-Implementation>.
[DAS-GPU-IMPL]
Das, S., "Execution-Finality for GPU AI Accelerators and
Confidential Workloads", GitHub repository,
<https://github.com/sangmdas/Execution-Finality-for-GPU-
AI-Accelerators-and-Confidential-Workloads>.
[DAS-6G-ORAN-IMPL]
Das, S., "Execution-Finality for AI-Native 5G/6G and O-RAN
-- Runnable Reference Implementation", GitHub repository,
<https://github.com/sangmdas/Execution-Finality-for-AI-
Native-5G-6G-and-O-RAN---Runnable-Reference-
Implementation>.
[DAS-HW-EF-IMPL]
Das, S., "Hardware Execution-Finality for AI and
Autonomous Systems -- Reference Implementation", GitHub
repository, <https://github.com/sangmdas/Hardware-
Execution-Finality-for-AI-and-Autonomous-Systems>.
Author's Address
Sangam Das
Independent Inventor
Balasore 756001
Odisha
India
Email: info@sangamdas.com
Das Expires 13 March 2027 [Page 36]