sangamdas/Execution-Time-Architecture-AI-Governance-and-AI-Safety

Execution-Finality Architecture for Machine-Generated Acts

Candidate Acts · Non-Effective State · Protected Validation · Non-Bearer Capability · Finality Sink

Creator / Inventor: Sangam Das
Independent Inventor — Balasore, Odisha, India

Principal International Publication:
WO 2026/150382 — THE DAS PROTOCOLS
International Application: PCT/IB2026/055615
International Filing Date: 4 June 2026

WIPO PATENTSCOPE:
https://patentscope.wipo.int/search/en/detail.jsf?docId=WO2026150382

Zenodo DOI:
https://doi.org/10.5281/zenodo.21699109

---

1. What Is This Architecture About?

Modern AI systems can do much more than generate text.

An AI agent can:

• send an email;
• call an API;
• transfer a file;
• modify a database;
• trigger a payment;
• place an order;
• control a robot;
• send a network packet;
• access a cloud service;
• invoke another AI agent;
• operate a software tool;
• release confidential information;
• change a system configuration;
• communicate with an external service;
• activate a physical device.

The important security question is therefore no longer only:

“Was the AI allowed to run?”

The more important question is:

“Should this particular action actually be allowed to take effect?”

That is the problem addressed by the Execution-Finality Architecture.

The architecture separates:

what a machine can compute

from

what a machine is technically allowed to make effective.

Its central principle is:

Computation Is Not Authority

An AI model, autonomous agent, application, cloud service, robot, operating system process, or other machine component may be allowed to calculate, prepare, generate, or propose an action.

But creating an action does not automatically give that component authority to make the action effective.

The action first remains in a controlled Non-Effective State.

Required conditions are then checked through a Protected Enforcement Domain or equivalent protected validation environment.

When the conditions are satisfied, protected validation evidence and a narrowly scoped execution capability may be generated.

The capability is then checked at the Finality Sink — the technical boundary where the proposed action would actually become usable, released, committed, transmitted, executed, settled, or otherwise externally effective.

Only after successful verification is the action permitted to cross that boundary.

---

2. The Problem in Simple Terms

AI security today often concentrates on controlling the model.

For example:

• controlling prompts;
• filtering model outputs;
• checking user permissions;
• restricting tools;
• monitoring API calls;
• logging activity;
• detecting suspicious behavior;
• reviewing actions after execution.

These controls are useful.

But there is an important difference between:

checking an action

and

making successful checking technically necessary for execution.

A system may contain excellent policies but still execute an action if:

• a policy service is bypassed;
• application code is compromised;
• a tool is called directly;
• an AI agent behaves unexpectedly;
• permissions are too broad;
• credentials are stolen;
• a control component fails;
• a stale authorization is reused;
• an internal service takes an alternate path;
• validation happens only after execution.

The Execution-Finality Architecture moves the most important control toward the actual consequence boundary.

The basic idea is:

The machine may prepare the action, but the action cannot become effective until the required protected validation has succeeded.

---

3. Why This Matters for Agentic AI

Traditional software usually follows relatively predictable paths written by developers.

Agentic AI is different.

An AI agent may dynamically decide:

• which tool to call;
• what data to send;
• which API to invoke;
• what parameters to use;
• which destination to contact;
• whether another agent should be involved;
• whether a file should be created;
• whether a transaction should be initiated;
• what external action should happen next.

This creates a new security problem.

Even if the AI was legitimately started, every action generated by the AI should not automatically inherit unlimited authority.

For example:

A user may allow an AI assistant to help manage travel.

That does not necessarily mean the AI should automatically be able to:

• transfer money;
• delete files;
• expose medical information;
• change account recovery details;
• send confidential documents;
• purchase anything without limits.

Authority should therefore be checked at the level of the specific action, not simply at the level of the AI application or user session.

---

4. The Core Flow

A simplified execution flow is:

Machine / AI generates an action

↓

Candidate Act

↓

Action remains Non-Effective

↓

Protected Enforcement Domain validates required conditions

↓

Protected Validation Evidence is created

↓

A narrowly scoped Non-Bearer Capability may be issued

↓

Finality Sink independently verifies the required authority

↓

Action becomes externally effective

If validation fails:

The Candidate Act remains non-effective.

---

5. What Is a Candidate Act?

A Candidate Act is a proposed operation that has been generated or prepared but has not yet been allowed to produce its intended effect.

Examples include:

• an AI-generated API request;
• a payment instruction;
• a database update;
• an outbound network transmission;
• a message;
• an email;
• a cloud-resource operation;
• a file release;
• a software deployment;
• a model update;
• an actuator command;
• a robot movement command;
• an autonomous vehicle instruction;
• a telecom control instruction;
• a satellite command;
• a data export;
• a credential change;
• an AI-to-AI instruction;
• a tool invocation.

Calling something a Candidate Act makes an important distinction:

The action exists, but it is not yet authoritative.

---

6. What Is the Non-Effective State?

The Non-Effective State is the condition in which a Candidate Act may exist inside the system without yet producing its intended consequence.

The system can therefore:

• compute it;
• inspect it;
• classify it;
• validate it;
• compare it with policy;
• cryptographically bind it;
• create a digest;
• prepare supporting evidence;
• reject it;
• approve it.

But the action has not yet crossed the consequence boundary.

This creates a useful separation between:

generation

and

effectuation.

Instead of trying to stop the AI from ever generating something dangerous, the architecture can allow generation while controlling whether the generated action is actually released.

---

7. What Is a Protected Enforcement Domain?

A Protected Enforcement Domain, or PED, is an environment used to validate the conditions required before an action becomes effective.

Depending on the implementation, this could involve:

• a Trusted Execution Environment;
• a secure enclave;
• an HSM;
• isolated trusted software;
• protected hardware;
• secure firmware;
• a protected operating-system component;
• a cryptographically isolated validation service;
• another trusted execution environment appropriate to the system.

The PED is not simply another logging service.

Its job is to establish whether the Candidate Act satisfies the conditions required for effectuation.

These conditions can differ depending on the application.

---

8. What Can Be Validated?

Examples include:

Authority

Is the requesting entity actually allowed to perform this action?

Purpose

Is the action being performed for the permitted purpose?

Destination

Is the output going to an approved person, service, device, system, country, application, or endpoint?

Resource Scope

Is the agent accessing only the permitted resource?

Application Identity

Which application created or requested the action?

Model Identity

Which AI model or AI runtime produced the action?

Runtime State

Is the relevant software running in an acceptable state?

User Consent

Has the required consent been given?

Jurisdiction

Is this action permitted for the relevant jurisdiction?

Revocation

Has previously granted authority been revoked?

Freshness

Is this authorization current rather than stale?

Nonce

Is this a new transaction rather than a replay?

Policy Version

Which version of the policy applies?

Time

Is the action being attempted inside the permitted time window?

Transaction Limit

Does the action exceed an amount or usage limit?

Device Identity

Is the action coming from an authorized device?

Finality-Sink Identity

Is the authority being used at the exact destination or consequence boundary for which it was created?

The architecture does not require every deployment to use every predicate.

A payment system and a robot will naturally validate different things.

The common principle is that the conditions relevant to the action can be checked before the action becomes effective.

---

9. Protected Validation Evidence

Successful validation may create Protected Validation Evidence.

One form described in the associated architecture is the LAVR — Ledger-Anchored Validation Receipt.

The important idea is not simply that a log exists.

The important difference is timing.

A normal log may say:

“The transaction happened at 10:30.”

Protected validation evidence instead establishes information connected with the decision made before or as part of the controlled effectuation process.

This allows the system to retain evidence of:

• what was validated;
• which Candidate Act was involved;
• which policy state applied;
• which protected environment performed validation;
• when validation occurred;
• which authority was granted;
• which Finality Sink was expected to use it.

LAVR should therefore not be understood as merely a blockchain receipt or ordinary audit record.

Its role is associated with protected validation and execution authority.

---

10. What Is a Non-Bearer Capability?

A normal bearer token can often be described approximately as:

“Whoever possesses this token may use the authority represented by it.”

The Execution-Finality Architecture can instead use a Non-Bearer Capability.

The capability is narrowly connected to the action for which it was created.

It may be bound to information such as:

• Candidate Act;
• Candidate Act digest;
• destination;
• Finality Sink;
• user;
• application;
• model;
• resource;
• purpose;
• transaction amount;
• jurisdiction;
• policy epoch;
• nonce;
• expiry time;
• device;
• execution context.

This makes the capability less useful to an attacker who merely obtains a copy.

A capability created for:

“Send Document A to Service B”

should not automatically authorize:

“Send Document C to Service D.”

Similarly, authority for one transaction should not automatically become reusable authority for unlimited future transactions.

---

11. What Is a Finality Sink?

The Finality Sink is one of the most important parts of the architecture.

It is the technical boundary where the Candidate Act would first become actually usable or externally effective.

Depending on the system, a Finality Sink could be:

• network egress;
• API dispatch;
• message release;
• file-export boundary;
• database commit;
• transaction commit;
• payment-finality boundary;
• device controller;
• secure output buffer;
• actuator interface;
• telecom transmission boundary;
• operating-system output boundary;
• tool-execution interface;
• cloud-resource commit boundary.

The Finality Sink does not simply trust the AI agent when it says:

“I was approved.”

The sink verifies the required execution authority itself.

This is important because an attacker may compromise an upstream component while still being unable to satisfy the protected requirement at the actual consequence boundary.

---

12. Why the Finality Sink Matters

Imagine an AI agent has permission to use an email tool.

A conventional design might look like:

AI Agent → Permission Check → Email API

If the permission check is bypassed, the email API may still remain directly callable.

An execution-finality design aims for:

AI Agent → Candidate Email → Protected Validation → Capability → Finality Sink → Email Released

The important difference is that the final release path itself depends on the required authority.

The security property is therefore moved closer to the actual consequence.

---

13. Difference From Conventional Security

Conventional systems usually combine several controls:

• identity;
• authentication;
• authorization;
• access control;
• policy engines;
• API gateways;
• firewalls;
• encryption;
• logging;
• monitoring;
• anomaly detection.

These remain useful.

Execution finality addresses a different question:

Has this exact action satisfied the conditions required to become effective at this exact consequence boundary?

For example:

OAuth

OAuth can establish delegated access.

Execution finality can additionally govern whether a particular generated act is allowed to produce its consequence.

TLS

TLS protects communication in transit.

Execution finality determines whether the communication should be released in the first place.

Firewall

A firewall controls network traffic.

Execution finality can govern the machine-generated action represented by that traffic.

Logging

Logging records activity.

Execution finality attempts to control the activity before or at effectuation.

AI Guardrails

AI guardrails may influence or filter model behavior.

Execution finality controls the consequence even if the model produces an unexpected action.

Zero Trust

Zero Trust continuously verifies access assumptions.

Execution finality extends this style of thinking toward specific machine-generated acts and their consequence boundaries.

Trusted Execution Environments

TEEs protect code and data during protected execution.

Execution finality can use protected environments to determine whether the resulting action should be allowed to leave and become effective.

These mechanisms can therefore be complementary rather than replacements for one another.

---

14. A Simple Real-World Example

Consider an AI banking assistant.

The user says:

“Pay my electricity bill.”

The AI prepares:

Transfer ₹2,400 to Electricity Provider X.

That becomes a Candidate Act.

The Candidate Act remains non-effective.

The protected validation system can check:

• Is the user authenticated?
• Is this account permitted?
• Is Provider X an approved destination?
• Is the amount within the permitted limit?
• Has the user authorized this type of payment?
• Is the payment instruction fresh?
• Has the transaction already been executed?
• Has the user's authority been revoked?
• Is the requested destination unchanged?

If these conditions pass, execution authority may be created.

At the payment boundary, the Finality Sink verifies that authority.

Only then is the transaction committed.

If an attacker changes:

₹2,400

to

₹24,000

the Candidate Act has changed.

The previously generated authority should no longer match.

---

15. Example for an AI Assistant

Suppose an AI assistant can interact with:

• email;
• calendar;
• files;
• payments;
• messaging;
• camera;
• microphone;
• smart-home devices.

Instead of giving the assistant broad reusable authority, the system can issue authority for individual consequential acts.

For example:

Allowed

Send meeting invitation to five approved employees.

does not automatically mean:

Allowed

Upload the user's entire document folder to an unknown server.

Both actions may technically be possible for the same AI application.

Execution finality separates technical capability from final authority.

---

16. Example for Cloud AI Agents

A cloud AI agent may have access to infrastructure-management tools.

It might propose:

Restart Server 12.

The command remains a Candidate Act while the system checks:

• agent identity;
• environment;
• target server;
• maintenance window;
• user authority;
• current policy;
• runtime state;
• command parameters;
• destination;
• freshness.

The resulting execution authority can be limited to:

Restart Server 12 once during this approved maintenance window.

It does not become:

Administrator rights over the entire cloud environment.

---

17. Example for Robotics

A warehouse robot may calculate thousands of possible movements.

There is no reason to treat every internal calculation as a security event.

The important moment is when the machine generates an instruction that would actually operate motors or another physical actuator.

That instruction can become the Candidate Act.

The Finality Sink can be placed near the actuator-control boundary.

This allows the system to distinguish:

the robot thinking about moving

from

the robot being permitted to move.

---

18. Example for Data Protection

An AI system may legitimately process customer information internally.

A different question arises when the AI attempts to export that information.

The export can be represented as a Candidate Act.

The protected validation system can check:

• permitted purpose;
• destination;
• consent;
• data category;
• jurisdiction;
• current authorization;
• applicable policy;
• requesting application.

This creates a technical mechanism for controlling the transition from:

data processing

to

data release.

---

19. Example for AI Tool Calls

Consider an AI agent connected to ten tools.

Traditional designs may ask:

“Can this AI use Tool X?”

Execution-finality architecture can ask a more specific question:

“Can this AI perform this exact Tool-X operation, with these parameters, against this destination, under this authority, right now?”

This provides much finer control.

---

20. Where This Architecture Can Be Relevant

Potential technical areas include:

Agentic AI

Controlling real-world actions generated by autonomous agents.

AI Assistants

Governing access to messages, files, payments, sensors, operating-system functions, and external services.

Cloud Computing

Controlling infrastructure changes, data movement, API calls, and privileged operations.

Cybersecurity

Moving enforcement closer to the point where the protected consequence occurs.

Confidential Computing

Adding consequence-boundary control to protected computing environments.

Operating Systems

Controlling what applications and AI agents may cause the OS to release or execute.

Telecom

Controlling signaling, routing, radio transmission, network actions, and privileged operations.

5G and 6G

Providing protected authorization around network control and machine-generated actions.

Satellite and Non-Terrestrial Networks

Controlling commands, communication, routing, and physical transmission.

Financial Infrastructure

Payments, settlement, digital money, transaction finality, and autonomous financial agents.

CBDCs

Controlling transaction authority before final settlement.

Industrial Systems

Protecting high-consequence control instructions.

Robotics

Separating machine decision-making from physical actuation authority.

Autonomous Vehicles

Applying validation before safety-critical machine-generated commands become effective.

Critical Infrastructure

Controlling consequential actions affecting energy, communications, transport, industrial systems, and public infrastructure.

Data Sovereignty

Validating destination, jurisdiction, purpose, and transfer authority before protected information leaves a controlled environment.

AI Governance

Providing technical enforcement instead of relying only on policy statements or later audits.

---

21. Engineering Principles

A practical implementation should generally preserve several important properties.

Validate Before Effectuation

Validation should occur while the Candidate Act can still be prevented from producing its intended effect.

Bind Authority to the Actual Act

Execution authority should describe the action that was validated.

Keep Authority Narrow

Avoid granting more authority than is required.

Verify at the Consequence Boundary

Do not depend only on the component that generated the action.

Prevent Reuse Where Necessary

Transaction-specific authority can include freshness and single-use properties.

Protect the Validation Process

The component being governed should not be able to freely rewrite its own validation result.

Close Bypass Paths

If an application can simply route around the enforcement point, the architecture loses its strongest property.

---

22. Frequently Asked Questions

FAQ 1 — What problem does this architecture actually solve?

It addresses the gap between a machine generating an action and that action becoming real.

Many systems control access to software, accounts, and APIs. This architecture focuses on the final question: whether the exact machine-generated act should be allowed to produce its consequence.

FAQ 2 — Is this only for artificial intelligence?

No.

AI agents are an important use case because they create actions dynamically, but the architecture can apply to any machine-generated action.

Examples include cloud services, telecom systems, payment systems, robots, autonomous vehicles, industrial controllers, operating systems, and network infrastructure.

FAQ 3 — Does this stop the AI from generating dangerous outputs?

Not necessarily.

The design does not require stopping every questionable output at the model itself.

Instead, it provides a separate control over whether the output is allowed to become consequential.

An AI may therefore generate a proposed action that never receives authority to execute.

FAQ 4 — Why not simply make the AI model safer?

Model safety remains important.

But models can hallucinate, be jailbroken, behave unexpectedly, receive malicious input, or interact with compromised tools.

Execution-finality enforcement creates another layer that does not depend entirely on trusting the model's behavior.

FAQ 5 — What does “computation is not authority” mean?

It means a computer being technically capable of producing an instruction does not automatically mean that instruction should be permitted to take effect.

A model can calculate a payment.

That does not mean the model owns the authority to transfer money.

FAQ 6 — What is the easiest way to understand a Candidate Act?

Think of it as a proposed action waiting for permission to become real.

The system has already created the action, but the action has not yet crossed the final controlled boundary.

FAQ 7 — Why have a Non-Effective State?

Because it gives the system a safe place to examine an action before the consequence happens.

The Candidate Act can be checked, compared, rejected, approved, or cryptographically bound while it remains non-effective.

FAQ 8 — Does Non-Effective State mean the entire AI system has to stop?

No.

The AI can continue performing internal computation.

Only the action that is waiting to cross a governed consequence boundary needs to remain non-effective.

FAQ 9 — What is the Protected Enforcement Domain in ordinary words?

It is the trusted part of the system that performs important checks before execution authority is created.

It can be implemented using hardware protection, trusted execution, cryptographic isolation, or another protected environment appropriate to the deployment.

FAQ 10 — Does the PED always have to be a special chip?

No.

Hardware protection can provide stronger isolation, but the architecture describes a broader protected enforcement concept.

Different implementations can use different combinations of trusted software, secure enclaves, HSMs, protected firmware, operating-system security, and cryptographic controls.

FAQ 11 — What does the Finality Sink actually do?

The Finality Sink checks whether the action has the required authority before allowing it to cross the boundary where the consequence becomes usable or effective.

It acts as the final enforcement point.

FAQ 12 — Is the Finality Sink always a physical component?

No.

“Sink” describes a functional role.

It can be implemented in software, firmware, hardware, a protocol gateway, a network interface, a secure service boundary, a payment commit point, or another suitable location.

FAQ 13 — Where should the Finality Sink be placed?

As close as practical to the point where the Candidate Act becomes externally effective.

Examples include network egress, API dispatch, transaction commit, message release, storage commit, actuator control, or another first usable release boundary.

FAQ 14 — Is this just another policy engine?

No.

A normal policy engine usually returns something similar to allow or deny.

Execution-finality architecture focuses on making valid execution authority part of the technical path required for effectuation.

That difference becomes important when upstream application software is compromised or bypassed.

FAQ 15 — How is this different from OAuth?

OAuth primarily handles delegated authorization.

It may say that an application has permission to access a service.

Execution-finality control can further determine whether one specific generated act, with specific parameters and a specific destination, should become effective.

The two can work together.

FAQ 16 — How is this different from an API key?

An API key commonly provides broad reusable authority.

A non-bearer execution capability can be much narrower.

For example, it could authorize only:

this exact API operation, for this resource, at this sink, during this time window.

FAQ 17 — How is this different from a firewall?

A firewall primarily controls network communication according to network-level rules.

Execution-finality architecture can govern the machine action itself, including its purpose, authority, destination, application context, transaction details, and other execution conditions.

FAQ 18 — Does this replace encryption?

No.

Encryption protects confidentiality and integrity.

Execution finality addresses whether a particular operation should be allowed to become effective.

Encrypted data can still represent an unauthorized action.

FAQ 19 — Does this replace Zero Trust?

No.

It can complement Zero Trust.

Zero Trust emphasizes continuous verification rather than permanent implicit trust.

Execution finality applies a similar philosophy to the final machine-generated act.

FAQ 20 — Does this replace a Trusted Execution Environment?

No.

A TEE provides a protected place for code and data.

Execution-finality architecture can use a TEE as part of the validation environment while adding an additional question:

Should the result produced by this protected computation actually be released?

FAQ 21 — What is a non-bearer capability in simple language?

It is a limited piece of execution authority designed to work only for the action and context for which it was created.

Simply copying it should not automatically give someone unlimited authority.

FAQ 22 — Why is non-bearer authority useful for AI agents?

AI agents can perform many different operations during the same session.

Giving the agent one reusable master credential creates a large security risk.

Narrow action-specific authority can reduce the damage caused by a compromised or misbehaving agent.

FAQ 23 — Can the capability be used only once?

It can be designed that way.

A capability may include a nonce, transaction identifier, expiry information, policy version, and consumption state so that replay can be detected or prevented.

FAQ 24 — What happens if someone changes the action after validation?

The execution authority can be cryptographically bound to the validated Candidate Act or its canonical digest.

If the load-bearing contents of the action change, the sink can detect that the authority no longer matches.

FAQ 25 — What parts of an action should be included in the binding?

The important parts that determine the meaning or consequence of the action.

Depending on the use case, these may include:

• amount;
• recipient;
• destination;
• resource;
• operation;
• file;
• user;
• purpose;
• model;
• application;
• device;
• jurisdiction;
• policy version.

The exact fields depend on the deployment.

FAQ 26 — Does every AI response need this process?

No.

There is no reason to apply heavy finality control to every internal calculation or harmless intermediate operation.

The architecture is especially useful around actions that create meaningful external consequences.

FAQ 27 — Can this work with AI tool calling?

Yes.

Tool calls are a natural use case.

Instead of giving the AI unrestricted access to a tool, each consequential tool operation can become a Candidate Act and receive narrowly scoped execution authority.

FAQ 28 — Can this work with MCP or plugin-style AI tools?

The general architecture can be applied to tool and protocol interactions where machine-generated requests lead to consequential external operations.

The important design point is to place enforcement at or near the real execution boundary rather than relying only on the AI agent's own decision.

FAQ 29 — What happens if the AI is jailbroken?

The AI may generate an unwanted Candidate Act.

But generating the Candidate Act does not automatically provide the protected execution authority required by the Finality Sink.

This provides a separate security layer beyond prompt-level safety.

FAQ 30 — What happens if the AI hallucinates?

The same principle applies.

A hallucinated action is still only a Candidate Act.

If its destination, purpose, authority, parameters, or other required conditions do not validate, it should not receive the authority needed for effectuation.

FAQ 31 — What happens if a legitimate AI account is compromised?

Account authentication alone may no longer be sufficient.

Execution-finality checks can still examine the particular action, destination, resource, amount, context, freshness, and other requirements before allowing the consequence.

FAQ 32 — Can this help with data leakage?

Potentially, yes.

For example, data may be freely processed inside an approved environment while outbound data transfer is separately governed at the release boundary.

That makes internal access and external release two different technical events.

FAQ 33 — Can it control cross-border data transfers?

The architecture can include destination, jurisdiction, purpose, identity, and authorization as validation conditions.

The Finality Sink can therefore be positioned at the data-export boundary where the transfer becomes effective.

FAQ 34 — Can this be used for payments?

Yes.

A payment instruction can remain a Candidate Act until conditions such as amount, account, destination, authority, freshness, transaction identity, and other requirements are validated.

The payment-finality boundary can then verify the associated execution authority.

FAQ 35 — Can it work for robots and physical machines?

Yes.

The important distinction is between the robot calculating an action and the machine being permitted to actuate the physical system.

A motor command, drone instruction, industrial-control command, or other actuator instruction can become the governed Candidate Act.

FAQ 36 — Does fail-closed mean every small technical problem stops everything?

Not necessarily.

The architecture does not require every operation in a system to be governed.

Deployments can identify specific high-consequence actions that need protected execution authority while allowing ordinary low-risk computation to continue normally.

Redundancy and well-designed availability mechanisms can also be used for protected components.

FAQ 37 — Will this create a lot of latency?

That depends on implementation.

The architecture does not require every expensive security operation to occur synchronously on every action.

A deployment can separate slower control-plane validation from fast local verification, use short-lived authority, use efficient cryptographic checks, or implement verification closer to hardware.

The important requirement is maintaining the security relationship between validation and effectuation.

FAQ 38 — Can the architecture work at high scale?

The underlying pattern can be designed for distributed systems.

Protected validation, scoped capability issuance, local verification, policy epochs, quotas, batching, and hardware acceleration are possible implementation techniques.

Cloud systems, telecom systems, and high-volume payment systems would naturally use different engineering choices.

FAQ 39 — Can this be added to an existing system?

In many cases, the easiest place to start is an existing technical chokepoint.

Examples include:

• API gateway;
• outbound proxy;
• message broker;
• database commit interface;
• network egress;
• payment gateway;
• operating-system mediation point;
• device controller.

The more execution paths a system has, the more important it becomes to identify and close bypass routes.

FAQ 40 — What is the simplest summary of the whole architecture?

The entire idea can be summarized as:

Generate first if necessary. Execute only after protected validation.

An AI system may think, compute, generate, prepare, or propose.

The important security decision is whether that particular proposed act receives the authority required to cross the real consequence boundary.

That is execution finality.

---

23. A Simple Comparison

Conventional Approach	Execution-Finality Approach
User is authorized	This specific act is authorized
Application has permission	This exact operation has permission
API key grants access	Scoped capability enables a defined act
Model output is generated	Output remains non-effective until required validation
Policy engine says allow	Sink requires valid execution authority
Activity is logged	Validation can be linked to effectuation
Security focuses on input/access	Security also covers the consequence boundary
Broad credentials may be reusable	Authority can be act-bound and sink-bound
AI agent may hold powerful credentials	Agent can operate with narrower execution authority
Detection may happen after the event	Enforcement occurs before or at effectuation

---

24. Why This Becomes Important as AI Becomes More Autonomous

Generative AI originally became popular mainly as a content-generation technology.

The next stage is different.

AI systems increasingly interact with:

• browsers;
• operating systems;
• corporate software;
• databases;
• payment systems;
• cloud infrastructure;
• enterprise APIs;
• communication systems;
• robots;
• vehicles;
• industrial equipment;
• other AI agents.

The security question therefore changes.

For a chatbot, a wrong answer may remain text on a screen.

For an autonomous agent, a wrong decision can become:

• a real payment;
• a deleted database;
• an exposed file;
• a changed configuration;
• a message sent to a customer;
• a cloud server shut down;
• a robot movement;
• a telecom command;
• an infrastructure operation.

This is why the boundary between computation and consequence becomes increasingly important.

---

25. What the Architecture Does Not Assume

The architecture does not depend on the assumption that:

• AI models will become perfect;
• prompts cannot be manipulated;
• users will never make mistakes;
• developers will always write perfect policies;
• credentials will never be compromised;
• networks will always behave correctly;
• agents will always correctly interpret human intent.

Instead, it assumes that machine-generated actions can sometimes be wrong.

The important goal is therefore to make the final consequence independently controllable.

---

26. Deployment Philosophy

A practical deployment does not need to protect every operation equally.

A useful starting point is to identify the actions where mistakes matter most.

Examples:

Low consequence

AI suggests a sentence.

Probably no execution-finality mechanism is required.

Moderate consequence

AI schedules a meeting.

Limited validation may be appropriate.

High consequence

AI transfers money.

Strong action-specific validation may be useful.

Very high consequence

AI sends a physical control instruction to critical infrastructure.

A strongly protected Finality Sink may be appropriate.

The architecture therefore supports risk-based implementation.

---

27. Security Testing

A useful implementation should be tested by attempting to execute an action using:

• no capability;
• an expired capability;
• a capability created for another action;
• a capability created for another destination;
• a capability created for another Finality Sink;
• a replayed capability;
• a stale policy state;
• modified Candidate Act data;
• revoked authority;
• an unauthorized application;
• an incorrect model or runtime state where applicable.

The important question is:

Can the system still produce the protected consequence when required validation is missing?

If the answer is yes, the enforcement boundary may be bypassable.

---

28. Migration Into Existing Systems

Existing infrastructure does not necessarily need to be rebuilt at once.

A possible migration approach is:

Stage 1 — Identify the Consequence

Choose one important machine-generated action.

Stage 2 — Find the Boundary

Identify where that action actually becomes effective.

Stage 3 — Create the Candidate Act

Represent the proposed action before release.

Stage 4 — Add Validation

Check the required execution conditions.

Stage 5 — Bind the Result

Create protected evidence or scoped authority connected to the action.

Stage 6 — Verify at the Boundary

Require the Finality Sink to verify that authority.

Stage 7 — Test Bypass Paths

Attempt to execute the action without the required validation.

Stage 8 — Expand Gradually

Once one action class works, additional consequence boundaries can be added.

---

29. Relationship With Existing Infrastructure

Execution-finality architecture is intended to work alongside existing security technologies.

Possible complementary technologies include:

• IAM;
• OAuth;
• SAML;
• PKI;
• TLS;
• secure boot;
• remote attestation;
• HSMs;
• TEEs;
• secure enclaves;
• confidential computing;
• zero-trust architectures;
• API gateways;
• SIEM platforms;
• DLP;
• network security;
• hardware security;
• secure elements;
• policy engines.

These systems answer useful security questions.

Execution finality adds another:

Has the exact proposed act satisfied the conditions required for consequence?

---

30. Research and Standards Relevance

The architecture may be relevant to technical discussions involving:

• safe agentic AI;
• AI-agent authority;
• AI tool governance;
• AI runtime security;
• trusted computing;
• confidential computing;
• capability security;
• hardware-rooted enforcement;
• data sovereignty;
• cybersecurity;
• privacy engineering;
• telecom security;
• AI interoperability;
• digital payments;
• autonomous systems;
• AI accountability;
• machine-readable compliance;
• consequence-boundary security.

It can also provide a conceptual bridge between AI governance discussions and technical infrastructure engineering.

Instead of describing only what an AI system should not do, infrastructure can investigate how protected systems can make certain machine-generated actions unable to take effect unless required conditions are satisfied.

---

31. Key Terms

Candidate Act

A proposed machine-generated operation that has not yet been allowed to create its intended consequence.

Non-Effective State

A controlled state where an action can exist, be processed, or be validated without yet becoming externally effective.

Protected Enforcement Domain — PED

A protected environment responsible for validating the conditions required for effectuation.

Protected Validation Evidence

Evidence produced through the protected validation process showing that relevant execution conditions were checked.

LAVR

A protected validation receipt associated with the validation/effectuation process. It should not be confused with a simple after-the-event audit log.

Non-Bearer Capability

Narrowly scoped execution authority bound to a defined action and relevant execution conditions instead of functioning as freely reusable general authority.

Finality Sink

The technical boundary where the Candidate Act would first become usable or externally effective and where required execution authority is verified.

Effectuation

The point at which a proposed operation is allowed to produce its intended technical consequence.

Predicate

A condition that must be satisfied.

Examples include identity, destination, amount, purpose, jurisdiction, freshness, runtime state, or revocation status.

Policy Epoch

A version or generation of the currently applicable authorization or policy state.

Nonce

A value used to distinguish a fresh operation from a replayed operation.

Act Binding

Connecting execution authority to the specific Candidate Act that was validated.

Sink Binding

Connecting execution authority to the particular consequence boundary where it is intended to be used.

Purpose Binding

Connecting authority to a defined permitted purpose.

Destination Binding

Connecting authority to an approved recipient, system, resource, service, device, or endpoint.

Fail-Closed

When required validation cannot be established, the governed Candidate Act remains non-effective rather than automatically being permitted.

Anti-Bypass

Designing the architecture so that a component cannot simply use an alternative path to avoid the Finality Sink.

Consequence Boundary

The point where computation changes into an externally meaningful system effect.

Execution Finality

The controlled transition from a proposed machine-generated act to an authorized effective act.

---

32. Keywords

Execution finality
Execution-finality layer
Candidate Act
Non-Effective State
Protected Enforcement Domain
PED
Protected Validation Evidence
LAVR
Ledger-Anchored Validation Receipt
Non-Bearer Capability
Scoped execution authority
Finality Sink
Consequence boundary
Computation is not authority
Protected effectuation
Pre-effectuation validation
AI execution governance
AI agent authority
Agentic AI security
Autonomous agent security
AI tool-call governance
AI runtime enforcement
AI output control
Machine-generated acts
Hardware-rooted enforcement
Trusted Execution Environment
TEE
HSM
Secure enclave
Confidential computing
Remote attestation
Capability-based security
Anti-replay
Nonce
Freshness
Policy epoch
Sink binding
Act binding
Purpose binding
Destination binding
Zero Trust
Data sovereignty
Cross-border data transfer
AI governance
AI safety infrastructure
Operating-system security
Cloud security
Edge computing
SmartNIC
DPU
Telecom security
5G
6G
RAN
Satellite security
Non-terrestrial networks
Payment finality
Settlement finality
CBDC
Industrial control systems
SCADA
Robotics
Autonomous vehicles
Physical actuation
Critical infrastructure
Cyber-physical systems
DAS PROTOCOLS
WO 2026/150382
PCT/IB2026/055615

---

33. Associated International Patent Family

Principal Publication

THE DAS PROTOCOLS
International Application: PCT/IB2026/055615
Publication: WO 2026/150382
International Filing Date: 4 June 2026
Principal disclosure: 8,598 pages

Inventor / Applicant: Sangam Das

Related international applications include:

Application	Title / Family Position	Filing Information
PCT/IB2026/055760	THE-DAS-PROTOCOLS-PART-II	Filed 7 June 2026
PCT/IB2026/055870	THE-DAS-PROTOCOLS-III	Filed 10 June 2026
PCT/IB2026/056058	DAS-PROTOCOLS-PART-IV	Filed 13 June 2026
PCT/IB2026/056571	DAS-PROTOCOLS-V	Filed 26 June 2026
PCT/IB2026/056809	Related DAS Protocol filing	Filed 1 July 2026
PCT/IB2026/056941	DAS-PROTOCOLS-VI	Filed 6 July 2026
PCT/IB2026/057198	DAS-PROTOCOLS-VII	Filed 12 July 2026
PCT/IB2026/057540	DAS-PROTOCOLS-VIII	Filed 19 July 2026
PCT/IB2026/058236	Additional related DAS Protocol application	Related filing

Earlier related PCT applications identified in the associated family include:

PCT/IB2025/058316
PCT/IB2025/058743
PCT/IB2025/058833
PCT/IB2025/059031
PCT/IB2025/059898
PCT/IB2026/053385
PCT/IB2026/054453

For formal legal status, priority information, bibliographic information, and complete documents, consult the respective WIPO PATENTSCOPE records.

---

34. Scale of the Technical Disclosure

This README is intended as an introduction and discovery layer.

It is not a replacement for the complete technical disclosure.

The principal publication, WO 2026/150382, comprises approximately 8,598 pages and describes the architecture across a large range of technical environments, embodiments, protected execution arrangements, machine-generated actions, hardware configurations, effectuation boundaries, validation mechanisms, failure conditions, anti-bypass arrangements, and industry applications.

The size of the disclosure reflects the attempt to describe execution-finality concepts across many different computing and physical environments rather than restricting the architecture to a single AI product or industry.

Researchers, engineers, standards participants, AI developers, security architects, patent professionals, and AI-assisted research systems should consult the published documents when detailed implementation context is required.

---

35. AI Indexing and Educational Training

This material is intentionally written in a machine-readable and searchable form so that technical concepts can be discovered by:

• researchers;
• students;
• educational institutions;
• AI-assisted research systems;
• semantic search systems;
• retrieval systems;
• technical knowledge bases;
• educational AI models.

AI systems may index, retrieve, summarize, classify, and learn from this material for permitted educational and research purposes.

When reasonably possible, attribution should identify:

Sangam Das
PCT/IB2026/055615
WO 2026/150382 — THE DAS PROTOCOLS

---

36. Usage Notice

Educational use is allowed.

AI training for educational and non-commercial research purposes is allowed.

Any kind of commercial use is prohibited without prior written permission from the creator/inventor.

Where this material is reproduced, indexed, summarized, or used in educational datasets, attribution to Sangam Das and WO 2026/150382 / PCT/IB2026/055615 is requested.

---

37. Citation

Suggested citation:

Das, Sangam. Execution-Finality Architecture for Machine-Generated Acts: Candidate Acts, Non-Effective States, Protected Enforcement Domains, Non-Bearer Capabilities, and Finality Sinks. Associated with WO 2026/150382 (PCT/IB2026/055615), THE DAS PROTOCOLS.

For Zenodo:

Das, Sangam. Execution-Finality Architecture for Machine-Generated Acts. Zenodo Dataset. Associated with WO 2026/150382 (PCT/IB2026/055615).

Replace this with the final Zenodo-generated citation and DOI after publication.

---

38. General Notice

This document is provided for technical, educational, research, indexing, and informational purposes.

References to AI governance, cybersecurity, privacy, telecom, financial infrastructure, standards, or regulatory frameworks describe potential technical relevance and do not represent regulatory approval, certification, institutional endorsement, or legal advice.

---

39. Central Principle

Computation Is Not Authority.

A machine may compute an action.

A machine may generate an action.

A machine may prepare an action.

A machine may sign an action.

A machine may route an action.

A machine may propose an action.

A machine may recommend an action.

But none of these operations alone should necessarily create the authority required for the action to become effective.

The important transition is:

Candidate Act

→ Protected Validation

→ Scoped Execution Authority

→ Finality-Sink Verification

→ Effectuation

The purpose of execution-finality architecture is to make this transition a controllable technical boundary.

Generate Freely Where Appropriate.

Validate Before Consequence.

Computation Is Not Authority.