Published August 9, 2026 | Version v1

Computation Is Not Authority: A Technical Architecture for Locking Down What AI and Automated Systems Are Allowed to Do .

Authors/Creators

Description

Execution Finality for AI and Computational Systems: Output-Bound Protected Validation, Non-Bearer Finality Authority, and Mandatory Finality-Sink Enforcement

Technical Architecture and Workflow

Author: Sangam Das
Independent Inventor
Balasore, Odisha, India

Abstract

Modern authorization systems commonly determine whether a user, application, workload, model, agent, device, or service is permitted to initiate an operation. That determination, however, occurs before the exact computational output may exist. In artificial-intelligence and autonomous systems, the distinction is increasingly important: authorization to execute a model, process a prompt, invoke an agent, access data, or perform a computation does not necessarily establish that the particular output subsequently produced should be permitted to create an external consequence.

This publication describes an execution-finality architecture that technically separates authority to compute from authority to effectuate the resulting output.

A computation may therefore complete successfully while its resulting Candidate Output remains in a Technically Non-Final State. Completion of computation, possession of request-side authorization, or successful pre-computation validation does not by itself make the output externally effective.

After production, the actual Candidate Output is deterministically represented and an output-derived digest is generated. A Candidate Act Descriptor associates that output-specific identity with the intended effectuation context. A Protected Enforcement Domain (PED) evaluates protected predicates applicable to the produced output and intended consequence and commits Protected Validation Evidence. Only following successful validation is a Scoped Non-Bearer Finality Capability established. The capability is bound to protected information including the produced output, validation evidence, permitted effectuation scope, protected state, and a Finality Sink or protected sink-selection rule.

The Finality Sink controls at least one technically necessary effectuation-enabling resource—for example key release, signing authority, transaction commitment, network transmission, output release, API or tool invocation, persistent-storage admission, or actuator enablement. Immediately before effectuation, the Finality Sink verifies correspondence among the actual output, protected evidence, finality capability, permitted scope, current protected state, freshness, policy epoch, revocation and anti-replay conditions.

The architecture additionally addresses bypass by requiring operative alternative effectuation paths either to be disabled, technically restricted, or subjected to equivalent output-specific finality verification. Verification, protected-state consumption, and effectuation may be transactionally coupled or performed within a single protected operation.

The resulting principle is simple:

Computation is not finality. Producing an output does not itself confer authority to make that output externally effective.

The architecture is applicable to AI agents, generative AI, cloud systems, telecommunications, financial infrastructure, databases, operating systems, storage systems, cybersecurity systems, industrial control, robotics, cyber-physical systems, and other computational environments in which machine-generated outputs can create external consequences.

1. The Technical Problem

Most computational authorization begins with a question similar to:

“Is this entity permitted to perform this operation?”

A conventional system may evaluate:

  • user or service identity;

  • credentials;

  • permissions;

  • roles;

  • workload identity;

  • device state;

  • application identity;

  • cryptographic tokens;

  • trusted-execution measurements;

  • signed requests;

  • risk scores;

  • contextual information; or

  • policy-engine decisions.

Once authorization succeeds, the computation is normally allowed to proceed.

The difficulty is that the actual output may not yet exist when this authorization decision is made.

A system may know the requested operation, intended destination, execution environment and permitted scope before execution. It may not yet know the particular bytes, model-generated text, transaction parameters, tool arguments, control values, database modifications, network messages or actuator commands that will actually be produced.

This creates a fundamental distinction:

Authorization of the computation is not necessarily authorization of its eventual output.

The distinction becomes particularly significant when computation is probabilistic, adaptive, externally informed, state-dependent or autonomous.

An AI agent, for example, may be legitimately authorized to run while subsequently producing an unauthorized tool call.

A financial computation may be authorized while the resulting transfer is not.

An industrial-control algorithm may be permitted to execute while a particular actuator command should be denied.

A model may be authorized to process protected information while a particular inference generated from that information should not be released.

The architecture therefore introduces a separate technical decision after the output exists but before that output becomes externally effective.

2. Core Architectural Principle

The architecture separates two authorities:

Authority 1 — Computation Authority

Authority to initiate or perform a computation.

Authority 2 — Finality Authority

Authority for the particular output actually produced to cross an effectuation boundary and produce an external consequence.

These authorities are intentionally distinct.

Successful completion of the first does not automatically satisfy the second.

The resulting conceptual flow is:

Operation Request

↓

Optional Pre-Computation Protected Validation

↓

Scoped Execution Authority

↓

Computation

↓

Candidate Output

↓

Technically Non-Final State

↓

Output Canonicalization

↓

Output Digest

↓

Candidate Act Descriptor

↓

Output-Specific Protected Predicate Evaluation

↓

Protected Validation Evidence

↓

Scoped Non-Bearer Finality Capability

↓

Finality Sink Verification

↓

Protected-State Consumption / Advancement

↓

Controlled External Effectuation

If a required condition fails:

DENY → WITHHOLD EFFECTUATION RESOURCE → REMAIN NON-FINAL

3. Candidate Output

A Candidate Output is a computational artifact that has been produced but has not yet been authorized to become externally effective.

It may comprise:

  • AI-generated content;

  • an agent action;

  • a tool call;

  • an API invocation;

  • a financial instruction;

  • a network message;

  • a database modification;

  • a file;

  • a control signal;

  • executable instructions;

  • a robotic command;

  • an actuator instruction;

  • a multimedia output; or

  • another computational result.

The important characteristic is not its data type.

The important characteristic is its state:

It exists computationally, but existence does not imply final authority for external use.

4. Technically Non-Final State

After computation, the Candidate Output is maintained in a Technically Non-Final State.

This is not merely a policy label such as:

“pending approval”

or:

“do not transmit.”

Instead, at least one technical mechanism required for effectuation remains unavailable.

Examples include withholding:

  • a decryption key;

  • a signing operation;

  • transaction-commit authority;

  • network-transmission authority;

  • routing authority;

  • an output-release operation;

  • storage-admission authority;

  • an API invocation;

  • a tool invocation;

  • actuator enablement; or

  • a required protected-state transition.

The execution substrate therefore cannot independently transform successful computation into successful external effectuation.

This creates technical non-completability.

5. Effectuation-Authority Isolation

A central architectural property is that the execution substrate does not independently possess everything necessary to produce the intended external consequence.

At least one required effectuation-enabling resource remains under mandatory protected control.

Consider an AI agent that generates a payment instruction.

The AI may be able to:

  • reason;

  • plan;

  • generate transaction parameters; and

  • construct a proposed instruction.

But it need not possess independent authority to perform the final signing or transaction-commit operation.

Similarly, an AI agent generating a message may construct the entire message while lacking independent access to the final network-transmission mechanism.

The architecture therefore separates:

ability to construct an act

from

ability to make the act effective.

6. Output-Specific Identification

After the Candidate Output has actually been produced, the system generates an output-specific representation.

The output may first be deterministically canonicalized.

Depending on the output type, canonicalization may include:

  • deterministic field ordering;

  • character-encoding normalization;

  • numeric normalization;

  • deterministic serialization;

  • binary framing;

  • metadata normalization;

  • fragment manifests;

  • Merkle structures; or

  • destination-sensitive/effect-sensitive fields.

An Output Digest is then computed.

The important distinction is:

the digest identifies the produced output, not merely the earlier request.

This prevents a pre-computation authorization artifact from being treated as proof that an output that did not yet exist was itself authorized.

7. Candidate Act Descriptor

The output digest forms part of a Candidate Act Descriptor.

The Candidate Act Descriptor represents the prospective externally effective act associated with the produced output.

It may include:

  • output digest;

  • invocation identifier;

  • workload identifier;

  • model or algorithm identifier;

  • destination;

  • interface;

  • effect type;

  • tenant;

  • purpose;

  • jurisdiction;

  • policy epoch;

  • protected-state reference;

  • provenance information;

  • grounding information;

  • behavioral information; and

  • other effectuation-specific attributes.

The descriptor therefore answers a more precise question than ordinary request authorization:

What exact output is now attempting to produce what external effect, under what conditions?

8. Protected Enforcement Domain

The Candidate Act Descriptor is evaluated within a Protected Enforcement Domain (PED).

The PED may be implemented using hardware, firmware, software isolation, trusted execution, secure enclaves, hardware security modules, operating-system security components, cryptographic processors, isolated execution environments, or combinations thereof.

The PED evaluates protected predicates that may concern:

  • integrity;

  • authorization state;

  • provenance;

  • destination;

  • jurisdiction;

  • policy compliance;

  • grounding;

  • behavioral correspondence;

  • execution measurements;

  • freshness;

  • revocation;

  • policy epoch;

  • replay status;

  • quota;

  • prior use; or

  • other finality conditions.

If required predicates fail, finality authority is withheld.

If the predicates succeed, the system commits Protected Validation Evidence.

9. Protected Validation Evidence

Protected Validation Evidence records or commits the successful protected determination applicable to the produced output.

It may include:

  • protected commitments;

  • authenticated measurements;

  • signed protected records;

  • cryptographic attestations;

  • secure receipts;

  • ledger commitments;

  • protected-state transitions; or

  • combinations thereof.

Critically, the evidence is established before, or atomically with, release of finality authority.

It is therefore not merely a forensic log generated after an irreversible action has already occurred.

This distinguishes preventative execution governance from post-hoc audit.

10. Scoped Non-Bearer Finality Capability

Following successful output-specific validation, the system may establish a Scoped Non-Bearer Finality Capability.

“Non-bearer” means that merely possessing or copying the capability is insufficient to authorize effectuation.

Its authority depends upon correspondence with protected information.

The capability may be bound to:

  • Candidate Output;

  • output digest;

  • Candidate Act Descriptor;

  • Protected Validation Evidence;

  • Finality Sink;

  • permitted effectuation scope;

  • policy epoch;

  • runtime state;

  • freshness state;

  • anti-replay state;

  • invocation identifier;

  • nonce;

  • monotonic counter;

  • protected-state reference; and

  • capability-consumption state.

A copied capability presented for another output, destination, interface, sink, policy epoch, state or use should therefore fail verification.

11. Finality Sink

The Finality Sink is the mandatory technical enforcement role controlling the transition from non-final computation to external effectuation.

It is defined functionally rather than geographically.

The Finality Sink does not have to be:

  • a remote server;

  • a downstream gateway;

  • a separate chip;

  • the final physical component;

  • or a particular named device.

It may be implemented in:

  • the same protected component as validation;

  • a secure enclave;

  • a hardware security module;

  • an operating-system broker;

  • a transaction engine;

  • a network controller;

  • a storage controller;

  • an API gateway;

  • a model-serving runtime;

  • a tool-call broker;

  • a user-interface release controller;

  • an actuator controller; or

  • multiple cooperating protected components.

The defining property is:

without successful operation of the Finality Sink, the intended external effect cannot successfully occur.

The Finality Sink may therefore correspond to the first usable effectuation boundary—the protected point where the output changes from technically non-final into something capable of causing the intended external consequence.

12. Detailed End-to-End Workflow

Stage 1 — Operation Request

A system receives an operation request.

Examples include a prompt, API call, transaction request, control instruction, workflow instruction, tool request or agent-generated instruction.

Request authorization may occur at this stage.

However:

request authorization does not constitute output finality authorization.

Stage 2 — Optional Pre-Computation Protected Validation

In a two-stage implementation, a protected domain evaluates whether the requested computation itself may proceed.

A Candidate Operation Descriptor may identify:

  • operation request;

  • workload;

  • execution environment;

  • invocation identifier; and

  • permitted computation scope.

Pre-computation Protected Validation Evidence may be committed.

A scoped non-bearer execution capability may then permit the computation to begin.

This capability authorizes computation.

It does not authorize whatever output the computation eventually generates.

Stage 3 — Computation

The execution substrate performs the computation.

For an AI system, this could include:

  • model inference;

  • retrieval;

  • planning;

  • agent reasoning;

  • tool selection;

  • multimodal processing; or

  • generation of a proposed action.

The result becomes a Candidate Output.

Stage 4 — Non-Final Output Holding

The Candidate Output is prevented from immediately becoming externally effective.

Depending upon implementation, it may remain:

  • sealed;

  • encrypted;

  • buffered;

  • unsigned;

  • unrouted;

  • uncommitted;

  • unavailable to an external interface;

  • unavailable to a downstream service; or

  • unable to activate a device.

This is the architectural separation between:

computation completion

and

external consequence.

Stage 5 — Output Canonicalization

The actual produced output is transformed into a deterministic representation suitable for protected comparison.

This prevents representational differences from undermining output identity.

Stage 6 — Output Digest Generation

A digest is computed from the Candidate Output or its deterministic representation.

This digest identifies what was actually produced.

It is not merely a digest of the prompt, request or anticipated operation.

Stage 7 — Candidate Act Descriptor Formation

The output digest is associated with effectuation-specific information.

The resulting Candidate Act Descriptor represents the proposed external consequence.

Conceptually:

Candidate Act Descriptor = Produced Output Identity + Intended Effectuation Context

Stage 8 — Protected Output Validation

The PED evaluates protected predicates against the actual output and intended consequence.

For an AI agent, these predicates might determine whether:

  • the correct model/workload produced the output;

  • the output corresponds to an approved execution state;

  • the destination is permitted;

  • the requested tool is permitted;

  • the action remains within scope;

  • the policy epoch remains current;

  • required grounding is present;

  • the output remains within an authorized behavioral envelope;

  • jurisdictional conditions are satisfied;

  • the output has not already been effectuated; or

  • the proposed consequence remains authorized.

Failure prevents finality authority from being established.

Stage 9 — Protected Validation Evidence Commitment

If required predicates succeed, output-specific Protected Validation Evidence is committed.

The evidence is bound to the output or Candidate Act Descriptor and may additionally bind:

  • invocation;

  • destination;

  • policy epoch;

  • Finality Sink;

  • workload;

  • protected state;

  • effectuation scope; and

  • anti-replay information.

Stage 10 — Scoped Non-Bearer Finality Capability

Only following successful validation does the system establish finality authority.

The capability may commit to:

  • output digest;

  • evidence identifier;

  • sink identity;

  • effectuation scope;

  • nonce;

  • counter;

  • expiry;

  • policy epoch;

  • invocation identifier; and

  • protected-state reference.

Possession alone remains insufficient.

The capability must match the current protected circumstances.

13. Anti-Bypass Enforcement

Output-specific validation is insufficient if the execution substrate can simply use another path.

The architecture therefore identifies the technical dependency required for effectuation and places it under mandatory Finality Sink control.

Alternative paths may include:

  • direct APIs;

  • administrative interfaces;

  • diagnostic interfaces;

  • unmediated network connections;

  • device-driver access;

  • alternate database credentials;

  • signing services;

  • storage namespaces;

  • fallback communication routes;

  • recovery interfaces;

  • privileged software paths; or

  • replicated output channels.

Relevant paths are disabled, denied, isolated, cryptographically restricted, or brought under equivalent execution-finality enforcement.

An optional Anti-Bypass State Descriptor may bind finality authority to expected:

  • sink;

  • interface;

  • route;

  • controller;

  • device;

  • key;

  • destination;

  • topology;

  • protocol endpoint; and

  • policy epoch.

Thus, attempting to move a valid capability to a different effectuation path does not automatically preserve its authority.

14. Finality Sink Verification

Immediately before effectuation, the Finality Sink independently verifies the required finality conditions.

These may include:

  1. authenticity of the finality capability;

  2. correspondence to the Candidate Output;

  3. correspondence to Protected Validation Evidence;

  4. correspondence to the intended Finality Sink;

  5. correspondence to permitted effectuation scope;

  6. freshness;

  7. policy epoch;

  8. revocation status;

  9. consumption state;

  10. anti-replay state;

  11. integrity of the required effectuation dependency;

  12. authorized interface;

  13. authorized route;

  14. authorized controller or device; and

  15. absence of an operative bypass path lacking equivalent verification.

The Finality Sink may independently reconstruct a local descriptor from what it actually observes.

Conceptually:

Protected claim about intended effect

is compared against:

sink-local observation of actual effect

This reduces reliance on an upstream component merely asserting what is about to occur.

15. Atomic Consume-and-Effectuate

After successful verification, the Finality Sink may transactionally couple:

VERIFY → RESERVE/CONSUME → EFFECTUATE → FINALIZE STATE

This prevents a capability from being repeatedly reused after successful effectuation.

The protected operation may include:

  1. final Candidate Output validation;

  2. capability verification;

  3. evidence verification;

  4. anti-bypass verification;

  5. capability reservation;

  6. activation of the required effectuation resource;

  7. external effectuation;

  8. final protected-state consumption; and

  9. generation of a finality receipt.

The architecture may therefore prevent:

  • effectuation before verification;

  • duplicate concurrent use;

  • replay after consumption;

  • consumption without corresponding effectuation; and

  • effectuation without corresponding protected-state transition.

16. Failure Behaviour — Fail Closed

If a required condition cannot be verified, the architecture does not simply record the anomaly and allow the action to continue.

It may:

  • deny effectuation;

  • withhold the required resource;

  • invalidate or revoke the capability;

  • consume the capability as denied;

  • maintain the output in its technically non-final state;

  • quarantine the Candidate Output;

  • block the alternate path;

  • require revalidation;

  • isolate the execution substrate; or

  • generate a protected denial record.

The default principle is:

Unverifiable finality does not become external effectuation.

17. Example: AI Agent

Consider an AI agent asked:

“Pay the approved supplier invoice.”

A conventional authorization architecture may determine that:

  • the user is authenticated;

  • the agent has permission to access the payment system;

  • the application has a valid API credential; and

  • the model is authorized to execute.

The AI subsequently generates:

Transfer ₹500,000 to Account B.

The critical question is no longer merely whether the AI was authorized to run.

The question is:

Is this exact generated transaction authorized to become financially effective?

Under the execution-finality architecture:

1. The agent is authorized to perform the computation.

2. The agent generates the proposed transfer.

3. The transfer remains a Candidate Output.

4. The agent cannot independently commit the transaction.

5. A digest is generated from the actual transaction fields.

6. The Candidate Act Descriptor binds the amount, recipient, destination, purpose and relevant effectuation context.

7. Protected predicates validate the generated transaction.

8. Protected Validation Evidence is committed.

9. A scoped non-bearer finality capability is established for that specific transaction.

10. The payment Finality Sink reconstructs or verifies the transaction parameters.

11. The sink checks output correspondence, scope, destination, freshness, policy epoch, replay state and protected evidence.

12. Only after successful verification does the sink release transaction-commit authority.

If malware changes:

₹500,000 → ₹5,000,000

or:

Account B → Account C

the actual transaction no longer corresponds to the validated output-specific state.

Finality verification fails.

The payment remains non-final.

18. Why This Differs From Conventional Authorization

Conventional security frequently concentrates on:

Who may request an operation?

Execution finality introduces an additional question:

May this exact produced output now become externally effective?

The difference can be summarized as follows:

Conventional Control Execution-Finality Control
Authorizes request Separately authorizes produced output
Often validates before execution Validates actual output after production
Request/context identity Output-specific identity
Token possession may convey authority Non-bearer authority requires protected correspondence
Application may retain release capability Required effectuation resource can remain outside execution-substrate control
Logging may occur after action Protected evidence precedes or is atomic with finality authority
Gateway may be bypassable Operative alternate paths require closure/equivalent enforcement
Successful execution often leads to release Successful execution may still remain technically non-final
Authorization and consequence may be coupled Computation and consequence authority are separated

The architecture does not replace authentication, access control, encryption, trusted execution, provenance, policy engines or audit systems.

It addresses a different control point:

the transition from computational possibility to externally effective consequence.

19. Location-Neutral Enforcement

A Finality Sink is a role, not necessarily a device.

The relevant boundary depends upon the consequence.

For a payment, the sink may control transaction commitment.

For telecommunications, it may control transmission.

For a database, it may control commit authority.

For an AI response, it may control release to the user interface.

For an AI tool call, it may control the tool invocation.

For robotics, it may control actuator enablement.

For storage, it may control persistent admission.

For cryptographic operations, it may control key use or signing.

This permits the architecture to operate across hardware, operating-system, cloud, network, application, transactional and cyber-physical environments.

20. Single-Point and Distributed Implementations

The architecture does not require a large chain of physically separate security components.

A single protected component may perform:

output validation → evidence commitment → final verification → state consumption → effectuation

provided the Candidate Output cannot become externally effective before the required finality conditions have been satisfied.

Alternatively, validation and finality enforcement may exist in separate trust domains.

Multiple Finality Sinks may also operate:

  • sequentially;

  • hierarchically;

  • conjunctively;

  • per destination;

  • per jurisdiction;

  • per output fragment; or

  • per effect type.

Thus, the architecture is compatible with both compact device-side implementations and distributed infrastructure.

21. Streaming and Fragmented Outputs

Execution finality need not require waiting for an entire large output.

Streaming outputs may be divided into:

  • fragments;

  • chunks;

  • segments; or

  • bounded groups.

Each fragment or group may receive its own output-specific commitment and finality determination before release.

This allows execution-finality principles to be applied to low-latency AI and communication systems without treating every output as a single monolithic object.

22. Representative Application Areas

The architecture may be applied to:

Artificial Intelligence

  • autonomous agents;

  • generative AI;

  • tool-using models;

  • model-serving infrastructure;

  • AI-to-AI actions;

  • retrieval systems;

  • AI-generated code;

  • AI-generated transactions;

  • AI-controlled workflows.

Telecommunications

  • message transmission;

  • routing;

  • signaling;

  • network configuration;

  • protected communication release.

Financial Systems

  • payments;

  • settlement;

  • transaction commitment;

  • trading instructions;

  • machine-generated financial actions.

Cloud and Distributed Computing

  • API execution;

  • service invocation;

  • workload outputs;

  • cross-domain actions;

  • cloud configuration changes.

Databases and Storage

  • transaction commit;

  • persistent writes;

  • protected data release;

  • storage admission.

Operating Systems and Devices

  • application output release;

  • IPC-mediated actions;

  • network access;

  • secure key use;

  • device-side AI actions.

Robotics and Cyber-Physical Systems

  • robotic movement;

  • industrial commands;

  • actuator activation;

  • autonomous-machine control;

  • safety-critical physical actions.

23. Technical Significance

The architecture moves the security boundary from merely asking:

“Was the computation authorized?”

to additionally enforcing:

“Is the exact consequence now attempting to become real the consequence that was protected, validated, scoped and authorized?”

This is particularly relevant to increasingly autonomous systems because an AI agent can be completely authorized as software while still producing an individual action that should never become effective.

Execution finality therefore treats machine-generated consequence as a separately controlled technical state transition.

The central invariant is:

A Candidate Output may be completely computed while remaining technically incapable of producing its intended external consequence until output-specific protected validation and Finality Sink verification succeed.

24. Compact Technical Workflow

RECEIVE OPERATION REQUEST
        |
        v
OPTIONAL PRE-COMPUTATION VALIDATION
        |
        v
ISSUE SCOPED EXECUTION AUTHORITY
        |
        v
EXECUTE COMPUTATION
        |
        v
PRODUCE CANDIDATE OUTPUT
        |
        v
HOLD OUTPUT IN TECHNICALLY NON-FINAL STATE
        |
        v
CANONICALIZE ACTUAL OUTPUT
        |
        v
COMPUTE OUTPUT-DERIVED DIGEST
        |
        v
FORM CANDIDATE ACT DESCRIPTOR
        |
        v
EVALUATE OUTPUT-SPECIFIC PROTECTED PREDICATES
        |
     +--+--+
     |     |
   FAIL   PASS
     |     |
     v     v
   DENY   COMMIT PROTECTED VALIDATION EVIDENCE
             |
             v
        ESTABLISH SCOPED
        NON-BEARER FINALITY CAPABILITY
             |
             v
        FINALITY SINK
        RECONSTRUCTS / VERIFIES
        ACTUAL EFFECTUATION STATE
             |
             v
        VERIFY ANTI-BYPASS
        + FRESHNESS
        + SCOPE
        + POLICY EPOCH
        + REVOCATION
        + ANTI-REPLAY
             |
          +--+--+
          |     |
        FAIL   PASS
          |     |
          v     v
        DENY   CONSUME / ADVANCE
               PROTECTED STATE
                  |
                  v
          RELEASE EFFECTUATION-
          ENABLING RESOURCE
                  |
                  v
          EXTERNAL EFFECTUATION

25. Relationship to the DAS Protocols Architecture

This publication describes a focused implementation within the broader DAS Protocols execution-finality architecture.

The underlying architecture separates computation from authority to produce an externally effective consequence through protected authorization state, protected validation evidence, scoped finality authority, protected-state transitions and verification at a Finality Sink.

The present implementation particularly develops:

  • separation of pre-computation and post-computation authority;

  • actual-output-derived identification;

  • output-specific Protected Validation Evidence;

  • technically non-final output states;

  • scoped non-bearer finality authority;

  • mandatory effectuation-resource control;

  • location-neutral Finality Sinks;

  • sink-local verification;

  • anti-bypass closure; and

  • transactionally coupled verification, consumption and effectuation.

26. Associated Patent Disclosure

This technical publication is based on and summarizes subject matter disclosed in the author's DAS Protocols patent architecture, including the disclosure titled:

“Execution Finality Architecture Using Output-Bound Protected Validation Evidence, Candidate Act Descriptors, Scoped Non-Bearer Capabilities, and Finality Sink Verification for Controlling External Effectuation of Computational Outputs.”

The associated disclosure further identifies PCT/IB2026/055615, filed 4 June 2026, as the DAS Protocols Mothership Application and describes the present architecture as developing focused implementations within that broader execution-finality framework.

27. Patent and Copyright Notice

Author: Sangam Das

This publication is provided for technical, academic, research, standards-discussion and public-information purposes.

Copyright licensing of this publication does not constitute a grant, waiver, abandonment, dedication, covenant not to sue, or other authorization under any patent application, patent claim, invention, or patent right associated with the disclosed technology.

Any copyright licence associated with a Zenodo record applies only to copyright permissions in the deposited publication to the extent stated by that licence.

Patent rights, patent applications, priority rights, continuation rights, national-phase rights and other industrial-property rights, where applicable, remain separately reserved.

The publication of this explanatory material should not be interpreted as expanding, replacing, amending or limiting the disclosure or claims of any associated patent application. In the event of any difference, the relevant officially filed patent documents govern their own disclosure.

 Keywords

Execution Finality; Artificial Intelligence; Agentic AI; AI Agents; AI Security; AI Governance; Machine Authority; Protected Enforcement Domain; Finality Sink; Candidate Act; Candidate Output; Non-Bearer Capability; Protected Validation Evidence; Trusted Computing; Cybersecurity; Autonomous Systems; AI Infrastructure; Hardware Security; Secure Execution; Anti-Bypass Enforcement; Tool-Using AI; Machine-Generated Actions; Computational Governance; DAS Protocols

 

Abstract

Summary 

This technical publication presents an execution-finality architecture for controlling when computational and AI-generated outputs are permitted to become externally effective. The architecture separates authorization to perform computation from authorization of the actual output produced by that computation. It introduces technically non-final Candidate Outputs, output-derived Candidate Act Descriptors, Protected Enforcement Domains, output-specific Protected Validation Evidence, scoped non-bearer finality capabilities, mandatory effectuation-resource isolation, anti-bypass enforcement, protected-state consumption, and location-neutral Finality Sink verification. Applications include AI agents, generative AI, cloud systems, telecommunications, payments, databases, operating systems, storage infrastructure, robotics, industrial systems, and cyber-physical systems.

Central principle: Computation is not authority to effectuate.

Files

Execution Finality Architecture for AI and Computational Systems .pdf

Files (402.0 kB)

Name Size
md5:c70cc1d63e1dd8a4a92e2ce6bc95a532
299.5 kB Preview Download
md5:0e9f670109f9ae8e0b806e385e37959c
80.5 kB Preview Download
md5:8fbf540880aca400654fc8bf8cb177c9
22.0 kB Preview Download