---
title: "Decision-Admissibility Is Not Action-Authority | KYE Protocol™ blog"
description: "Compiling a clause into code proves the rule is satisfiable — not that anyone may act on it. Where policy-as-code stops and Authority Finality™ begins."
url: https://kyeprotocol.com/blog/decision-admissibility-is-not-action-authority/
lang: en
source: "KYE Protocol"
---

> Compiling a clause into code proves the rule is satisfiable — not that anyone may act on it. Where policy-as-code stops and Authority Finality™ begins.

22 July 2026 · KYE Protocol™ · Doctrine · ― Is Not Authority

# Decision-Admissibility Is Not Action-Authority.

Compiling a regulatory clause into runnable code is powerful. It proves a rule can be checked — not that anyone may act on the result.

[See action admissibility](https://kyeprotocol.com/action-admissibility/) [More doctrine](https://kyeprotocol.com/blog/)

Clause-to-code proves the rule is satisfiable. It does not confer the authority to act on it.

## What decision-admissibility gives you

Policy-as-code turns a written rule into a testable decision.

- A clause from a framework compiled into an evaluable check.
- A deterministic verdict on whether a decision satisfies the rule.
- Traceability from the code back to the source obligation.

This is real rigour, and regulated teams need it. But admissibility asks whether a decision is well-formed against a rule — a narrower thing than whether an actor may act.

## Where it stops

Admissibility judges the decision against the clause; authority judges the actor against the delegation.

A decision can be perfectly admissible under a compiled rule and still be taken by an agent with no delegated authority to take it — for the wrong principal, outside its purpose, past its expiry. Clause-to-code answers "does this satisfy the rule?" It is silent on "may this actor turn this decision into an action, here and now?" Satisfiable-in-principle is not authorised-in-fact, and the two are decided by different machinery.

- It validates the decision; it never entitles the actor.
- It maps a clause to logic — not a principal to a grant.
- An admissible action taken without authority is still a breach.

## The line

Authority binds an admissible decision to a specific principal's live delegation, at the boundary.

KYE Protocol™ takes the admissibility verdict as one input and adds the one it cannot supply: does this actor hold delegated authority to carry the decision out, within purpose and scope, right now? It returns admit or deny and seals the result into a replay-verifiable [Evidence Pack™](https://kyeprotocol.com/evidence-pack/). That is Authority Finality™ — clause-to-code proves the rule is met; Authority Finality™ proves the actor was entitled to act on it.

## Honest scope

KYE Protocol™ proves authority, not the correctness of your policy logic.

Whether a clause was compiled faithfully is the work of your policy engine, and it stays essential. KYE Protocol™ consumes that verdict and closes the last gap — the actor's entitlement to act — bound to the principal and provable to an auditor from public keys alone. Keep the admissibility engine. Add the authority.

> Clause-to-code proves the rule is satisfiable. It does not confer the authority to act on it.