sangamdas/tool_use-Is-Not-invoke-Binding-Execution-Finality-to-MCP

Problem Space :- AI agents increasingly use tools, APIs, MCP servers, databases, payment systems, messaging platforms, cloud services, and device functions to create real-world side effects. Existing authorization often answers whether an agent, user, or service is allowed to invoke a function or access a resource, but that permission may be broader than the specific action eventually executed. An agent permitted to call refund() may still attempt refund(Customer B, $30,000) when the intended authority was only refund(Customer A, <= $300). This creates a gap between permission to invoke and authority to effectuate a concrete external consequence.

Existing Solutions:- OAuth, IAM, RBAC, ABAC, API gateways, policy engines, capability systems, MCP authorization mechanisms, human confirmation dialogs, audit logs, and trusted execution environments each address important parts of the security problem. They can authenticate principals, restrict scopes, evaluate policies, approve tool access, or record what happened. However, many controls operate before execution, authorize a class of operations rather than one concrete act, rely on bearer credentials or session-level authority, or detect violations only after the side effect has already occurred. They therefore do not always guarantee that the exact action reaching the final effectuation boundary still matches the originally approved principal, resource, parameters, destination, constraints, and current policy state.

This Solution:- Execution Finality adds a lightweight pre-effectuation and execution-boundary verification layer that works with existing IAM, OAuth, MCP, policy engines, and application authorization instead of replacing them. A proposed operation is represented as a concrete Candidate Act and bound to the specific authority under which it was approved. Before any externally effective consequence is released, a Finality Sink independently verifies that the exact act still satisfies the approved identity, resource, parameters, limits, destination, freshness, revocation state, and other required constraints. If the act has changed, been replayed, substituted, expired, revoked, or routed through an unauthorized effectuation path, the system fails closed and the consequence does not occur.

DESCRIPTION :-

Execution Finality for Agentic AI

Stopping Unauthorized Tool Calls, Memory Writes, and Real-World Consequences Before They Happen

DAS — Decoupled Authorisation System Source draft: draft-agentic-ai-tool-execution-finality-00 Author: Sangam Das, Independent Status: Technical architecture / Internet-Draft work in progress Primary focus: Agentic AI, tool execution, MCP/connectors, memory writes, cloud mutations, financial actions, external communications, telecom/network control, and cyber-physical effects

────────

1. The Core Problem

Agentic AI is moving from generating information to causing effects.

An agent can now:

• call APIs and tools; • send messages or emails; • write long-term memory; • modify databases; • change cloud infrastructure; • issue refunds or payments; • rotate credentials; • publish or disclose data; • invoke third-party connectors; • modify routing or network state; • trigger robotic, industrial, vehicle, satellite, or other physical actions.

Most authorization systems answer an upstream question:

“Is this principal permitted to invoke this operation?”

Execution finality adds a second and different question at the point where the consequence is about to become real:

“Is this exact concrete act, with these exact parameters, destination, scope, state, and constraints, still the act that was authorized?”

Those questions are not equivalent.

A principal may be permitted to invoke:

refund()

but that does not mean it has authority to effectuate:

refund(Customer B, $30,000)

when the approved authority was:

refund(Customer A, <= $300)

Likewise:

permission to call SendMessage()

is not necessarily authority to send this message, to this recipient, with this attachment, at this time, under this policy state.

The architecture in this repository is designed around that distinction.

────────

2. One-Sentence Definition

Execution Finality is a pre-effectuation control model in which a proposed action remains technically non-effective until a protected boundary independently verifies that the concrete pending action still matches the authority, evidence, state, scope, and constraints under which it was approved.

────────

3. What This Architecture Does Not Replace

Execution Finality is intended to integrate with existing authorization infrastructure, not discard it.

It can sit downstream of systems such as:

• IAM; • OAuth/OIDC; • RBAC/ABAC/ReBAC; • cloud IAM policies; • policy engines; • API gateways; • enterprise approval systems; • human-in-the-loop confirmation; • MCP authorization; • connector permissions; • application-level guardrails; • secure enclaves, HSMs, TEEs, or confidential VMs; • logging, SIEM, compliance, and audit systems.

Those systems can determine whether an operation is eligible to proceed. Execution Finality controls whether the operation is permitted to cross the last consequence-producing boundary.

A useful mental model is:

Existing authorization answers:
    MAY this actor perform this class of operation?

Execution Finality answers:
    MAY this exact pending act become real now?

────────

4. Architectural Principle

The fundamental rule is:

Computation is not authority. Permission is not effectuation. Upstream approval is not final authority.

A generated or approved operation is first represented as a Candidate Act.

The Candidate Act remains in a Non-Effective State while the system checks whether it should be allowed to become consequence-bearing.

Only at the Finality Sink does the system independently reconstruct the pending operation and determine whether it may cross the effectuation boundary.

────────

5. Core Terms

5.1 Candidate Act

A proposed effect-capable operation that has been generated, prepared, or staged but has not yet been permitted to produce its intended consequence.

Examples:

• refund(customer_id, amount); • send_email(recipient, subject, body); • kubectl delete ...; • memory insertion into a persistent vector store; • transfer(account, destination, amount); • publishing a document; • changing an ACL; • actuator movement; • credential release; • external data export.

5.2 Non-Effective State

A technical state in which a Candidate Act may be:

• generated; • buffered; • simulated; • validated; • displayed; • staged; • transformed; • queued;

but must not yet become consequence-bearing.

5.3 Effectuation

The first protected transition by which the Candidate Act becomes capable of producing its intended consequence.

Effectuation is not always the same as “the API call.” Depending on the system, it may be:

• network release; • durable database commit; • payment settlement instruction; • memory admission; • message delivery; • file publication; • actuator command release; • credential disclosure; • rendering or output release; • control-plane mutation.

5.4 Finality Sink

The component positioned at, within, or immediately before the effectuation boundary.

Its job is not merely to trust an upstream “approved” flag. It independently reconstructs the actual pending operation and verifies that it matches the protected authorization evidence and current local state.

A Finality Sink can be implemented as:

• an in-process dispatch gate; • MCP server-side execution gate; • connector gateway; • sidecar; • reverse proxy; • API gateway extension; • database commit hook; • cloud mutation controller; • payment-settlement guard; • device-side protected service; • HSM/TEE-assisted gate; • network egress guard; • actuator safety controller.

5.5 Protected Enforcement Domain (PED)

A protected or isolated enforcement environment that performs collection-time binding, execution-time validation, or related protected checks.

Isolation can be provided by different roots depending on the deployment, including separate processes, trust domains, key material, HSMs, TEEs, protected OS services, or other mechanisms appropriate to the threat model.

5.6 Collection-Time Binding

A first protected stage associates relevant context with the operation or data from which an operation may later be formed.

Potential bound attributes include:

• principal; • source; • input provenance; • purpose; • permitted resource; • maximum amount; • recipient or destination constraints; • tool identity; • schema; • jurisdiction; • policy epoch; • behavioral envelope; • permitted external effect.

Collection-time binding does not itself authorize effectuation.

5.7 Execution-Time Validation

A separate protected stage evaluates the concrete Candidate Act that is being prepared for possible effectuation.

It verifies that the Candidate Act remains within the authority and constraints originally bound to the operation.

5.8 Cross-Committed Evidence

Collection-time and execution-time evidence are mutually load-bearing.

Neither artifact alone is sufficient to authorize effectuation.

They may be linked through:

• hashes; • MACs; • signatures; • nonces; • monotonic counters; • policy epochs; • revocation epochs; • protected-state references; • chained commitments.

The purpose is to make substitution, widening, replay, or independent fabrication detectable.

5.9 Scoped Non-Bearer Execution Handle

A finality-related authority artifact may be issued after successful validation, but possession of the artifact is not enough.

The handle can be bound to:

• operation identity; • principal; • tool; • resource; • concrete parameter constraints; • destination; • purpose; • sink identity; • policy epoch; • revocation epoch; • nonce; • expiry; • usage count.

It may be:

• single-use; • sink-bound; • non-transferable; • non-delegable; • non-exportable; • consumed atomically with effectuation.

5.10 LAVR — Ledger-Anchored Validation Receipt

A protected validation receipt may be used to form a replay-resistant validation chain. The architecture does not require a public blockchain. “Ledger” can mean an append-only or protected record appropriate to the deployment.

A LAVR is evidence in the finality process; it is not a standalone bearer authorization token.

────────

6. High-Level Flow

User / Agent / Model
        |
        v
Existing IAM / OAuth / RBAC / Policy / Human Approval
        |
        |  upstream permission
        v
+-----------------------------+
|       Candidate Act         |
|      NON-EFFECTIVE          |
+-----------------------------+
        |
        v
Collection-Time Binding PED
        |
        | protected evidence A
        v
Execution-Time Validation PED
        |
        | protected evidence B
        | cross-committed with A
        v
Scoped Non-Bearer Execution Handle
        |
        v
+=======================================+
|             FINALITY SINK             |
|                                       |
| Reconstruct actual pending operation  |
| Verify principal                      |
| Verify tool/resource                  |
| Verify concrete parameters            |
| Verify destination                    |
| Verify purpose/scope                  |
| Verify policy/revocation epochs       |
| Verify nonce / replay state           |
| Verify sink binding                   |
| Verify protected evidence             |
| Advance sink-local monotonic state    |
+=======================================+
        |
        +---- mismatch / stale / replay ----> DENY
        |
        v
Atomic verify-and-effectuate
        |
        v
External Consequence

────────

7. Why Reconstruct at the Finality Sink?

Suppose an upstream policy service approves:

{
  "principal": "agent-17",
  "operation": "refund",
  "customer": "customer-A",
  "max_amount": 300,
  "currency": "USD"
}

Later, the tool-dispatch path presents:

{
  "principal": "agent-17",
  "operation": "refund",
  "customer": "customer-B",
  "amount": 30000,
  "currency": "USD"
}

If the downstream execution layer merely sees a valid session, token, or refund permission, the operation can become real.

A Finality Sink instead derives the pending operation from the actual execution request and compares it with the protected authority.

The request is rejected because:

customer-B != customer-A
30000 > 300

The important property is that the final boundary does not ask only:

Is the token valid?

It asks:

Does the exact operation I am about to effectuate still match
what was authorized, under current protected state?

────────

8. Example: Agent Tool Call

Upstream authority

{
  "principal": "support-agent-42",
  "tool": "refund",
  "resource": "customer-A",
  "constraints": {
    "amount_lte": 300,
    "currency": "USD"
  },
  "purpose": "customer-service-refund",
  "policy_epoch": 91,
  "revocation_epoch": 14
}

Candidate Act

{
  "act_id": "act-7f84",
  "principal": "support-agent-42",
  "tool": "refund",
  "arguments": {
    "customer": "customer-A",
    "amount": 175,
    "currency": "USD"
  },
  "destination": "payments-service",
  "purpose": "customer-service-refund"
}

Finality Sink checks

The sink reconstructs the actual call and checks:

principal             MATCH
operation/tool        MATCH
customer/resource     MATCH
amount                 175 <= 300
currency              MATCH
destination           MATCH
purpose               MATCH
policy epoch          CURRENT
revocation epoch      CURRENT
execution handle      UNUSED
sink binding          MATCH
operation digest      MATCH

Only then is the refund released to the payment system.

────────

9. Integration With Existing Authorization Infrastructure

A lightweight implementation can be deployed without replacing existing IAM.

Existing stack

Identity Provider
    -> IAM / OAuth
    -> Policy Engine
    -> Agent Runtime
    -> Tool

With an execution-finality layer

Identity Provider
    -> IAM / OAuth
    -> Policy Engine
    -> Agent Runtime
    -> Candidate Act
    -> Finality Sink
    -> Tool / external side effect

The policy engine can remain the system that says:

agent-42 may request refunds up to $300 for Customer A

The Finality Sink becomes the system that says:

this exact refund request is for Customer A,
is $175, is current, has not been replayed,
and therefore may now be effectuated

This is why the architecture is complementary to IAM rather than competitive with it.

────────

10. MCP / Tool-Server Deployment

MCP and similar tool ecosystems are natural places to apply execution finality.

A simple deployment pattern is:

LLM / Agent
   |
   v
MCP Client
   |
   v
Candidate Act Builder
   |
   v
Authorization / Policy
   |
   v
Finality Evidence
   |
   v
MCP Server Finality Gate
   |
   v
Actual Tool Handler

The server-side gate can independently reconstruct:

• server identity; • tool name; • tool version; • declared schema; • argument digest; • concrete sensitive fields; • external destination; • principal; • purpose; • applicable authority limits; • policy/revocation epoch; • replay state.

This can help detect or deny:

• parameter substitution; • schema widening; • tool replacement; • endpoint redirection; • replay; • stale authorization; • unauthorized delegation; • privilege expansion between planning and execution.

────────

11. Memory Writes Are Also Effects

Agent safety discussions often focus on API calls, but persistent memory changes future behavior and therefore can be consequence-bearing.

Examples include:

• long-term memory insertion; • vector-store admission; • retrieval index mutation; • user-profile updates; • enterprise knowledge-store writes; • agent-to-agent state transfer; • training or fine-tuning admission.

A memory item can remain readable or inspectable without automatically being authorized for every downstream operational purpose.

For example:

Readable for user review        YES
Eligible for retrieval          MAYBE
Eligible for cross-tenant use   NO
Eligible for training           NO
Eligible to trigger a tool      NO

Execution-finality controls can therefore be applied not only to “write” but also to later operational use of stored information.

────────

12. Threats Addressed

The architecture is designed to reduce the risk of:

Parameter substitution

An authorized call is changed before execution.

Resource substitution

The approved customer, account, host, database, file, or device is replaced with another target.

Scope widening

A narrow authority is transformed into a broader operation.

Replay

A previously valid authority is reused for a second effect.

Stale policy

An operation approved under an old policy state executes after the policy has changed.

Revocation drift

Authority is revoked after upstream approval but before effectuation.

TOCTOU

The object checked is no longer the object executed.

Tool or endpoint replacement

The tool identity, server, schema, plugin, connector, or destination changes after approval.

Alternate-path bypass

An attacker attempts to reach the effectuation endpoint around the intended authorization path.

Post-hoc-only safety

A system detects a harmful act after the money moved, the message was sent, the memory was committed, or the actuator moved.

The objective is pre-effectuation denial, not only forensic evidence afterward.

────────

13. Security Invariants

A strong implementation should preserve the following invariants.

Invariant 1 — Candidate Acts begin non-effective

Creating or approving an operation must not itself create the external consequence.

Invariant 2 — Upstream approval is insufficient

An IAM decision, OAuth token, policy result, human click, or agent decision is evidence, not final effectuation authority.

Invariant 3 — Possession is insufficient

Possession of a finality artifact or handle must not by itself authorize the action.

Invariant 4 — Final boundary reconstructs the concrete act

The sink must derive what is actually about to happen from the pending operation or trusted measurement path.

Invariant 5 — Current state matters

The sink verifies current policy, revocation, freshness, and replay state.

Invariant 6 — Denial happens before effectuation

Failure leaves the Candidate Act non-effective.

Invariant 7 — Consumption is protected

Single-use authority is consumed or invalidated as part of the effectuation transition.

Invariant 8 — Alternate effectuation paths must be closed

The strongest guarantee exists only when a protected sink gates every relevant consequence-producing path.

────────

14. Atomic Verify-and-Effectuate

One of the most important implementation details is closing the gap between:

CHECK

and:

COMMIT

A weak design could verify a correct operation and then allow a different operation to replace it immediately before execution.

High-impact implementations should therefore make verification and the first consequence-producing transition atomic or tightly bound.

Examples include:

• compare-and-commit; • transaction-bound policy verification; • write-once release latch; • HSM/TEE-mediated release; • sink-owned socket or network egress; • database transaction guard; • single-use dispatch capability consumed at commit.

────────

15. Fail-Closed Behavior

The default rule is:

missing evidence      -> deny
stale evidence        -> deny
replay detected       -> deny
mismatched operation  -> deny
unknown destination   -> deny
wrong sink            -> deny
revoked authority     -> deny
non-monotonic state   -> deny
cannot reconstruct    -> deny

For safety-critical environments, silent fail-open behavior defeats the architecture.

Deployments may define controlled emergency or break-glass paths, but those paths should themselves be explicit, protected, visible to the sink, and auditable.

────────

16. Lightweight Prototype Strategy

A first prototype does not need to implement the strongest hardware-backed form.

A practical evaluation can begin with five components:

1. Candidate Act object — canonical representation of the pending side effect.
2. Policy adapter — consumes a decision from existing IAM/OPA/Cedar/cloud IAM/custom policy.
3. Act-scoped execution handle — binds the approved scope to the Candidate Act digest and freshness state.
4. Finality middleware — positioned directly before the effect-producing handler.
5. Replay/state store — records nonce, epoch, handle consumption, and revocation state.

Pseudo-flow:

candidate = build_candidate_act(tool, args, principal, destination)

policy = existing_policy_engine.authorize(candidate)
if not policy.allowed:
    deny()

handle = bind_authority(policy, candidate)

# Immediately before the real side effect:
actual = finality_sink.reconstruct_pending_operation()

if not finality_sink.matches(actual, handle, policy):
    deny()

if not finality_sink.consume_atomically(handle):
    deny()

execute(actual)

The production design can then strengthen isolation, key management, protected state, measurement paths, and atomicity.

────────

17. Comparison With Common Approaches

Approach	Useful?	What it usually answers	Execution-Finality difference
IAM / RBAC / ABAC	Yes	May this principal perform an operation?	Re-checks the concrete pending act at the effect boundary
OAuth / access token	Yes	Does the caller possess valid delegated authority?	Possession alone is insufficient; act and sink must match
API gateway	Yes	May this request pass this gateway?	Finality must be at the last controllable consequence boundary
Policy engine	Yes	Does policy approve this request/context?	Treats the decision as input evidence, not final effectuation
Capability token	Yes	Does holder possess scoped capability?	Uses non-bearer, act/sink/state-bound authority
TEE / confidential VM	Yes	Is code/data executing in a protected environment?	Protected execution alone does not prove the exact pending effect is authorized
Guardrail / moderation	Yes	Is content or model behavior acceptable?	Controls side effects even after model generation
Human confirmation	Yes	Did a human approve something?	Human approval can be bound to one concrete act and verified at finality
Logging / SIEM	Yes	What happened?	Designed to deny before the consequence occurs
Rollback / compensation	Yes	Can an effect be reversed or repaired?	Attempts to prevent unauthorized effectuation in the first place

────────

Frequently Asked Questions

FAQ 1 — Is this simply another authorization layer?

It is an authorization-related layer, but it addresses a different boundary.

Traditional authorization is commonly evaluated before dispatch. Execution Finality controls the transition from a prepared/approved operation to an externally effective consequence.

It therefore complements existing authorization rather than requiring a new identity stack.

────────

FAQ 2 — Would this integrate with existing IAM and policy systems instead of replacing them?

Yes. That is a preferred deployment model.

Existing IAM/policy infrastructure can continue to approve the operation. The execution-finality layer consumes the resulting authority as protected evidence and independently verifies the concrete act at the final side-effect boundary.

For example:

IAM says:
agent-42 may refund Customer A up to $300.

Finality Sink observes:
refund(Customer B, $30,000).

Result:
DENY before the payment operation is released.

────────

FAQ 3 — Why isn’t permission to call a tool enough?

Because tool permission usually describes an operation class, while external consequences are created by a specific invocation.

refund() is a class of operation. The real consequence depends on fields such as customer, amount, currency, destination, transaction, and current policy state.

The same applies to:

• send_message(); • delete_resource(); • write_memory(); • transfer_funds(); • deploy(); • change_acl().

Execution Finality binds authority to the specific act rather than assuming that permission for the function implies permission for every possible parameterization.

────────

FAQ 4 — Why not just use OAuth scopes?

OAuth is valuable and can remain part of the design.

However, scopes commonly authorize categories such as:

payments.write
messages.send
calendar.write

A valid scope alone does not necessarily prove that the exact pending operation matches a previously approved customer, amount, recipient, purpose, schema, destination, or policy epoch.

The finality layer can require both:

valid OAuth/IAM authority
AND
exact execution-boundary match

────────

FAQ 5 — Is the Execution Handle just another bearer token?

No, not in the intended model.

A bearer token is useful because possession conveys authority. A scoped non-bearer Execution Handle is designed so that possession alone is insufficient.

The Finality Sink must also verify that:

• the sink is the intended sink; • the act digest matches; • the concrete parameters match; • current policy/revocation state matches; • the nonce or use counter is valid; • the handle has not already been consumed.

────────

FAQ 6 — Does Finality Sink reconstruction mean re-running the AI model?

No.

The Finality Sink reconstructs the pending operation descriptor, not the entire reasoning process that produced it.

For a tool call, this may be limited to:

• principal; • tool name; • server identity; • schema/version; • arguments or canonical argument digest; • sensitive parameter values; • resource; • destination; • purpose; • effect class.

This makes the sink suitable for a relatively lightweight enforcement path.

────────

FAQ 7 — Does reconstruction add unacceptable latency?

It depends on the effect class, but it need not be a remote round trip.

The sink can be:

• in-process; • co-located with the tool server; • implemented as a sidecar; • located inside the connector gateway; • placed at the database/egress/commit boundary.

Hashes and canonical descriptors may be computed earlier and compared locally. Hardware acceleration or protected execution can be added where useful.

High-impact operations such as payments, production mutations, credential release, and physical actuation already justify stronger verification than low-risk read-only calls.

────────

FAQ 8 — Will this make agents too slow when they call many tools?

Not necessarily.

Deployments can use graduated finality profiles while maintaining the invariant that effect-capable operations pass through a controlled final boundary.

Examples:

• read-only local lookup: lightweight local verification; • external message: recipient + content/destination binding; • memory write: scope + tenant + purpose + persistence binding; • payment: full parameter, epoch, replay, destination, and atomic commit verification; • physical actuation: strongest protected profile.

The architecture does not require identical overhead for every effect class.

────────

FAQ 9 — Isn’t an API gateway already the Finality Sink?

It can be, if it is actually the last controllable boundary before effectuation and if alternate paths cannot bypass it.

A gateway that merely checks a token and forwards the call is not automatically an execution-finality implementation.

To act as a Finality Sink it should reconstruct the concrete pending act and verify it against act-scoped protected authority and current state.

────────

FAQ 10 — Where should the Finality Sink live in MCP?

A strong placement is on or immediately before the server-side tool handler that produces the external effect.

For example:

MCP request
  -> parse
  -> reconstruct Candidate Act
  -> verify finality evidence
  -> consume authority
  -> call actual tool implementation

If the MCP server merely forwards the call to another system that creates the real consequence, a second or downstream Finality Sink may be required.

────────

FAQ 11 — How does this help with prompt injection?

Execution Finality does not claim to solve prompt injection itself.

Instead, it limits what a successful prompt injection can turn into.

An injected instruction may persuade an agent to propose:

transfer $50,000

but the proposed transfer still remains a Candidate Act. If the protected authority only permits $500, the Finality Sink denies the widened act before settlement.

Therefore prompt-level defenses and execution-finality controls are complementary.

────────

FAQ 12 — What about a compromised agent runtime?

The architecture assumes the agent runtime may be untrusted or less trusted than the finality path.

A compromised runtime can generate malicious Candidate Acts, but it should not be able to independently create valid mutually load-bearing protected evidence, alter sink-local state, or bypass the Finality Sink.

The strength of this guarantee depends on the isolation of protected domains and closure of alternate effectuation paths.

────────

FAQ 13 — Does this require a TEE, Secure Enclave, or confidential VM?

No.

Those technologies can strengthen enforcement, protected state, and key isolation, but they are not the definition of execution finality.

The architecture is defined by properties such as:

• separation of validation stages; • act binding; • cross-committed evidence; • non-bearer authority; • sink reconstruction; • replay-resistant state; • pre-effectuation denial.

A software-only prototype can therefore evaluate the protocol semantics before stronger hardware protection is introduced.

────────

FAQ 14 — What new cryptography is required?

No exotic cryptographic primitive is inherently required.

A deployment can use standard:

• cryptographic hashes; • MACs; • digital signatures; • nonces; • monotonic counters; • secure key storage; • existing enterprise KMS/HSM infrastructure.

The architectural distinction is primarily where and how authority is verified, not invention of a new cipher.

────────

FAQ 15 — How are replay attacks prevented?

A handle can be bound to a nonce or monotonic state and marked consumed at effectuation.

The Finality Sink can maintain:

• spent-handle state; • nonce state; • policy epoch; • revocation epoch; • monotonic counters; • act identifiers.

A previously accepted handle presented again must be rejected.

On denial, an implementation may also burn, poison, quarantine, or invalidate pending authority to reduce probing and replay attempts.

────────

FAQ 16 — What happens if policy changes after authorization?

The sink checks the authority against current protected policy and revocation epochs.

Example:

12:00:00  refund authority issued under policy epoch 91
12:00:03  policy changes to epoch 92
12:00:05  old refund reaches Finality Sink

If current policy requires epoch 92, the epoch-91 authority is stale and the Candidate Act remains non-effective.

This closes an important time-of-check/time-of-use window.

────────

FAQ 17 — What if a user clicked “Approve”?

A human confirmation is useful, but a free-floating approval should not necessarily authorize every later variation of the operation.

Human approval can be treated as a protected predicate bound to:

• a specific Candidate Act; • relevant parameter values; • predicted consequence; • approver identity; • timestamp/freshness; • applicable epochs.

The sink then verifies that the act being effectuated is still the act the human approved.

────────

FAQ 18 — Isn’t logging enough?

No. Logging answers what happened after or during the event.

Execution Finality is specifically about preventing an unauthorized consequence before it becomes effective.

A perfect audit trail of an unauthorized $30,000 refund is still an audit trail of money that already moved.

Audit remains valuable and can consume sink-rooted finality evidence.

────────

FAQ 19 — What about rollback or compensating transactions?

Rollback is valuable when available, but some effects are difficult or impossible to reverse completely.

Examples:

• data disclosure; • external communication; • credential leakage; • physical actuation; • safety-critical commands; • market orders; • publication; • downstream automated reactions.

The architecture therefore favors deny before effectuation rather than assuming every error can be compensated afterward.

────────

FAQ 20 — How does this apply to memory and RAG systems?

A memory object can have different authorities for different uses.

For example, a record might be permitted for:

human inspection

but not automatically for:

persistent indexing
cross-user retrieval
model training
external export
tool-trigger decisions

A Candidate Act can be created for the operational use of memory, and the relevant memory-use boundary can act as the Finality Sink.

────────

FAQ 21 — Can streaming output work with this model?

Yes.

Not every partial token or stream segment is necessarily a high-impact effect.

A deployment can use:

• segment-level finality; • cumulative disclosure budgets; • separate finality for tool-triggering segments; • separate finality for external publication or transmission.

The important requirement is that a stream must not be used to bypass a protected consequence boundary by splitting a prohibited effect into many small releases.

────────

FAQ 22 — Can there be multiple Finality Sinks?

Yes.

One workflow may contain several distinct consequence boundaries:

Agent
  -> Tool-dispatch Finality Sink
  -> Database-write Finality Sink
  -> External-egress Finality Sink

Each governs its own effect.

Downstream operations can require evidence that upstream finality completed successfully.

────────

FAQ 23 — How does this work in multi-region systems?

Each region or path capable of producing the relevant consequence needs appropriate sink coverage.

A handle can be:

• sink-specific; • region-specific; • sink-class-specific;

and local sinks can maintain their own replay and monotonic state while receiving securely distributed policy/revocation epochs.

The important property is that a region must not blindly effectuate using stale or foreign authority that was not scoped for that sink.

────────

FAQ 24 — What happens when the Finality Sink is unavailable?

The default behavior is fail-closed.

If required finality verification cannot complete, the Candidate Act remains non-effective.

A deployment may define a narrowly scoped emergency path, but silent automatic fail-open would undermine the security property.

────────

FAQ 25 — Doesn’t fail-closed create brittleness?

It can if engineered poorly.

Practical mitigations include:

• risk-tiered profiles; • co-located sinks; • highly available sink state; • bounded local caches; • reliable epoch distribution; • health checks; • staged deployment; • explicit protected break-glass procedures.

Operational reliability should be improved without silently removing final verification for high-impact actions.

────────

FAQ 26 — What about legacy systems that cannot implement this protocol?

A legacy application does not always need to be rewritten.

The sink can often be deployed as:

• a proxy; • gateway; • sidecar; • service mesh policy point; • transaction wrapper; • database hook; • network egress controller.

The strongest guarantee requires that the legacy system cannot still be reached through an unprotected alternate path.

────────

FAQ 27 — What is two-instance binding actually protecting against?

It reduces the risk that one compromised stage can both fabricate the evidence and authorize the effect.

A first stage binds collection/input/context. A second independent stage validates the concrete execution-time act.

If the stages are meaningfully isolated, compromising one does not automatically let an attacker mint every artifact required for finality.

────────

FAQ 28 — Why make evidence mutually load-bearing?

If one receipt alone can authorize the final effect, that receipt becomes the single artifact an attacker needs to steal, forge, replay, or substitute.

Mutually load-bearing evidence requires agreement between independently generated protected artifacts and the sink’s reconstruction of the actual act.

This reduces single-artifact authorization failure.

────────

FAQ 29 — What exactly is “non-bearer” in this context?

It means holding the authority artifact is not enough to exercise it.

The artifact is useful only when additional protected facts match, such as:

• exact Candidate Act; • intended Finality Sink; • sink-local state; • current epoch; • nonce; • operation digest; • relevant scope constraints.

Copying the artifact to another caller, another sink, or another operation should not automatically transfer authority.

────────

FAQ 30 — Is a Finality Sink a specific hardware box?

No.

“Finality Sink” is a role at the effectuation boundary, not necessarily a particular physical component.

It may be implemented in software, protected hardware, a gateway, a server, a device service, an HSM-assisted operation, or another architecture that can enforce the required boundary properties.

────────

FAQ 31 — Is the architecture limited to AI agents?

No.

Agentic AI is an important use case because agents dynamically compose tools and side effects, but the same architectural issue occurs in:

• cloud control planes; • CI/CD; • financial systems; • telecom/network control; • privacy enforcement; • distributed applications; • industrial control; • robotics; • vehicles; • satellites; • data-governance systems.

────────

FAQ 32 — Does this prevent all malicious actions?

No.

It is designed to close a specific architectural gap between computation/authorization and effectuation.

Strong guarantees do not apply if, for example:

• every protected domain is compromised simultaneously; • an attacker has a completely unmediated alternate effectuation path; • the physical or external system ignores the protected boundary; • social or procedural processes deliberately bypass the technical controls.

The design reduces the technical escalation path; it does not claim to solve every security problem.

────────

FAQ 33 — How is this different from a transaction-signing system?

Transaction signing can be an important building block, especially when signatures bind the exact transaction.

Execution Finality is broader. It includes:

• upstream and execution-time binding; • protected state and epochs; • replay control; • sink identity; • final reconstruction of the pending act; • atomic or tightly coupled effectuation; • non-financial side effects such as memory writes, cloud mutation, tool invocation, external communications, and physical actions.

A transaction signature can therefore be one input to a finality decision rather than the whole architecture.

────────

FAQ 34 — How is this different from policy-as-code?

Policy-as-code describes and evaluates rules.

Execution Finality defines where the last authoritative check is enforced and what exact object is checked before consequence.

OPA, Cedar, cloud IAM, or custom policy engines can therefore be used as policy inputs to the finality architecture.

────────

FAQ 35 — Can the Finality Sink trust a canonical digest instead of the full payload?

Yes, where the sink can reliably derive or verify the same canonical representation from the actual pending operation.

Canonicalization is security-sensitive. Implementations must avoid ambiguous encodings, duplicate fields, schema confusion, normalization differences, and parser discrepancies that could cause two components to hash semantically different operations as if they were the same.

For high-impact fields, sinks may compare both canonical digest and selected explicit values.

────────

FAQ 36 — What about schema changes or tool upgrades?

Tool identity should include enough version or schema information to prevent an old authority from silently applying to a materially different operation contract.

Possible bindings include:

• tool name; • server identity; • schema digest; • semantic version; • policy version; • argument schema commitment.

If the tool’s meaning changes materially, the sink should require authority compatible with the new contract.

────────

FAQ 37 — Can a batch of actions share one authorization?

Possibly, but the authority must explicitly describe the permitted batch semantics.

A batch may be bound to:

• exact member set; • maximum count; • cumulative amount; • destination set; • time window; • ordering rules; • aggregate risk limit.

A generic “batch approved” flag should not silently authorize unlimited additional members.

────────

FAQ 38 — How should delegation between agents work?

Delegation should not automatically convert a narrow authority into a transferable bearer capability.

A delegated Candidate Act can carry evidence of:

• original principal; • delegating agent; • receiving agent; • permitted sub-scope; • destination; • purpose; • expiry; • policy/revocation epochs.

The Finality Sink still verifies the concrete final act.

────────

FAQ 39 — Can this support dry-run or simulation?

Yes.

Simulation is naturally compatible with the Non-Effective State.

A Candidate Act may be:

generated -> simulated -> reviewed -> validated

without gaining authority to become real.

Simulation output can contribute evidence, but it does not replace finality verification of the actual pending operation.

────────

FAQ 40 — Why publish this as an Internet-Draft?

Agentic execution increasingly crosses organizational boundaries:

• model provider to tool provider; • MCP client to MCP server; • enterprise agent to SaaS connector; • multi-cloud orchestration; • multi-agent delegation; • telecom and network APIs; • external payment and settlement systems.

Interoperable definitions of Candidate Acts, execution-bound authority, replay state, sink semantics, and finality evidence may therefore be useful across vendors.

The draft is intended to enable technical review and discussion; it should not be read as claiming that the architecture is already an IETF standard.

────────

Implementation Questions for Reviewers

A useful technical review of an execution-finality prototype should ask:

1. Where exactly is the effectuation boundary?
2. Can the operation become effective through another route?
3. What fields are reconstructed independently at the sink?
4. How is the Candidate Act canonicalized?
5. What prevents parameter substitution after authorization?
6. What prevents replay?
7. What prevents use at a different sink?
8. How are policy and revocation epochs represented?
9. How is authority consumed?
10. Is verification atomic with the first consequence-producing transition?
11. Can one compromised service mint all required evidence?
12. What is the latency at P50/P95/P99?
13. What does degraded operation look like?
14. What happens when sink state is unavailable?
15. How are schema upgrades handled?
16. What evidence is emitted after allow or deny?
17. What is protected by hardware and what is only process-isolated?
18. Which threats remain explicitly out of scope?

────────

Suggested Prototype Evaluation

A minimal useful benchmark could compare three paths.

Path A — Conventional upstream authorization

Agent -> IAM/Policy -> Tool

Test whether a valid tool permission can be abused through parameter substitution or replay.

Path B — Authorization + execution-finality middleware

Agent -> IAM/Policy -> Candidate Act -> Finality Middleware -> Tool

Measure:

• successful legitimate calls; • rejected widened calls; • rejected substituted resources; • rejected replay; • revoked/stale authorization; • sink-bypass attempts; • P50/P95/P99 latency overhead.

Path C — Stronger protected deployment

Add:

• isolated validation domain; • hardware-protected keys/state; • sink-local monotonic counter; • atomic consumption; • attested measurement path.

Compare assurance and overhead with Path B.

────────

Example Test Matrix

Test	Approved	Presented at Sink	Expected Result
Exact refund	Customer A, <= $300	Customer A, $175	ALLOW
Amount widening	Customer A, <= $300	Customer A, $30,000	DENY
Resource substitution	Customer A, <= $300	Customer B, $175	DENY
Replay	one use	same exact call, second use	DENY
Stale policy	epoch 91	sink requires epoch 92	DENY
Wrong sink	Payments-A	Payments-B	DENY
Schema substitution	tool schema v3	materially changed v4	DENY / REAUTHORIZE
Valid low-risk call	permitted lookup	exact lookup	ALLOW
Missing evidence	required binding absent	otherwise valid call	DENY
Revoked principal	previously allowed	revocation epoch advanced	DENY

────────

Deployment Philosophy

Execution Finality should be deployed closest to the point where an unauthorized action becomes expensive, irreversible, externally visible, safety-relevant, or difficult to compensate.

Not every action needs the same assurance level.

A useful deployment strategy is:

LOW RISK
  lightweight local finality

MEDIUM RISK
  act binding + freshness + replay control

HIGH RISK
  independent protected validation
  + sink-local protected state
  + strong non-bearer binding
  + atomic verify-and-effectuate
  + attested measurement where appropriate

What should remain constant is the architectural separation between:

permission to attempt

and:

authority to make the exact consequence real

────────

Security and Scope Notes

This architecture assumes that the Finality Sink and required protected enforcement components remain trustworthy under the chosen threat model.

The strongest guarantees require:

• fail-closed handling; • rejection of stale/revoked/spent authority; • reliable reconstruction of the actual pending operation; • closure of alternate effectuation paths; • protected replay/epoch state; • appropriate isolation of mutually load-bearing validation evidence.

A completely unmediated endpoint that can independently create the same external consequence cannot be protected merely by placing a Finality Sink somewhere else in the workflow.

────────

Status and Feedback

This README summarizes and explains the architecture described in draft-agentic-ai-tool-execution-finality-00 in a developer-oriented form.

The work is intended for technical review, prototyping, interoperability discussion, security analysis, and implementation feedback.

Particularly useful feedback includes:

• whether the effectuation boundary is precisely defined; • whether the architecture can be integrated cleanly with existing IAM/policy systems; • whether Candidate Act schemas can be made interoperable across agent frameworks; • how MCP/tool servers should expose a finality boundary; • canonicalization and signing concerns; • replay/state synchronization; • multi-region operation; • latency and failure-mode measurements; • legacy integration; • bypass-path analysis; • distinctions from existing capability and transaction-authorization systems.

────────

Short Summary

An agent may be allowed to CALL a tool.
That does not mean every concrete invocation is authorized.

DAS Execution Finality keeps the proposed action non-effective,
then verifies the actual pending operation at the final side-effect
boundary before allowing the consequence to occur.