The Authorization Threshold

Defining the Standard for Governance in AI Systems

Edward Meyman · FERZ, Inc. · 2026

The question that dominates AI governance discourse is procedural: how do we govern AI systems? The answers follow accordingly. Monitor outputs. Align models. Filter content. Log activity. Build dashboards.

Each of these functions is useful. None of them answers the question that governance must answer.

The prior question is definitional: what must be true for an action to be considered governed?

This is not a difference of emphasis. It is a difference of kind. The procedural question accepts governance as a collection of capabilities. The definitional question demands governance as a set of conditions. Capabilities can be partial, approximate, and aspirational. Conditions are either met or not met.

AI systems now initiate actions autonomously, operate across regulatory domains, and produce irreversible outcomes. In this environment, governance must attach to actions, not systems, and must be established before execution, not reconstructed after observation.

Governance is not a property of systems. It is a property of decisions.

The unit of governance

Before governance conditions can be defined, the subject of governance must be identified.

Models are too abstract. A model is a capability, not a decision. Users are too coarse. A user identity establishes who initiated an action, not whether this action, in this context, under these constraints, was permitted. Policies are too static. A policy defines what should be true. It does not verify that it was true at the moment of execution.

The correct unit of governance is a proposed action, in a specific context, under a specific authority claim. This is the smallest entity to which governance conditions can meaningfully attach.

Every governable action resolves six elements: the Actor (identity of the initiating entity), the Authority (under what right the action is performed), the Object (what is being acted upon), the Scope (boundaries of the action), the Context (environmental, temporal, and system state at evaluation time), and the Constraints (applicable rules and conditions). If any element is missing or implicit, governance becomes interpretive. Interpretation cannot produce proof.

The threshold

With the unit defined, the central question becomes: what separates a governed action from an ungoverned one?

An action is governed only if its authorization can be established prior to execution under explicit, evaluable constraints.

This draws a hard line. If authorization is inferred after execution, governance has not occurred. If authorization is reconstructed from logs, governance has not occurred. If authorization depends on trusting the system to have checked, governance has not occurred. Each of these may be evidence that something governance-adjacent took place. None of them constitutes governance.

Two clarifications prevent misapplication. Pre-execution placement is necessary but not sufficient. A control point that sits before execution but evaluates heuristically is pre-execution in position but not in capability. And the word "established" is doing critical work. Authorization is not checked. It is established: derived from defined constraints, bound to a specific action representation, and available for independent verification.

Governance begins at the point where permission must be proven before action.

Two classes of systems

Systems that participate in AI decision-making fall into two structural classes. This is not a quality ranking. It is a categorical distinction.

Interpretive and evaluative systems interpret context, apply rules heuristically or probabilistically, generate decisions or recommendations, and record outcomes. Guardrails, content filters, alignment techniques, observability platforms, and agentic security controls all belong to this class. Their structural limitation is that they cannot establish formal permissibility. They can estimate whether an output is acceptable. They cannot prove whether an action was permitted. The distinction is not quality. It is category: judgment-based systems produce assessments; derivation-based systems produce proofs. No amount of improvement to judgment closes the gap to derivation.

Authorization systems operate on formalized constraints, evaluate a defined action representation against those constraints, and produce deterministic outcomes: allow, deny, escalate, or abstain. They emit verifiable artifacts. Decisions are derived, not interpreted. The artifact exists because the evaluation occurred. The artifact cannot exist without the evaluation.

These are not competing approaches. They answer different questions.

Evidence versus proof

The distinction between these two classes rests on a deeper distinction that most governance discussions leave unexamined.

Evidence describes what happened. It depends on logs, traces, internal system state, and operator trust. Evidence is retrospective. It tells a story about a decision after the decision has been made. The story may be accurate, detailed, and useful. But it remains a narrative.

Proof demonstrates that a decision followed from defined constraints. It is independent of system operator, independent of mutable system state, reproducible, and verifiable by a third party. Proof is not retrospective. It is constitutive. It does not describe the decision. It defines the space within which the decision could occur.

Evidence can justify after the fact. Proof restricts the space of valid actions before execution.

Most AI governance systems today produce evidence. They produce it well. But evidence without proof creates a specific vulnerability: the governance artifact can exist without the governance evaluation. A log entry can record "policy checked" without any mechanism ensuring that the check actually bound the decision. When the artifact can be generated independently of the evaluation, the artifact proves nothing.

One clarification prevents overreach. Proof, as defined here, guarantees constraint-consistency: the decision was derived from the constraints that were in effect. It does not guarantee that the constraints themselves were correct. Correctness is a property of the policy content, which remains the responsibility of policy authors and GRC workflows. Deterministic governance ensures that whatever policy was defined is the policy that was enforced. No more, no less.

Evidence explains a decision. Proof constrains what decisions were possible.

The constraint representation layer

If proof requires derivation from defined constraints, the constraints must exist in a form that supports derivation. This is the transformation layer that most governance architectures omit. Its absence is not a gap in implementation. It is a gap in category.

Governance operates across three layers. The policy layer contains human-readable rules expressed in natural language. Policies are inherently ambiguous, context-dependent, and subject to interpretation. The evaluation layer is the runtime mechanism that evaluates actions against constraints and produces verdicts. Evaluation engines exist. Solvers exist. Authorization gates exist. The technology is not the bottleneck. The bottleneck is representational, not computational.

The bottleneck is the constraint representation layer. This is where human-readable policy is transformed into a canonical, unambiguous, machine-evaluable form. Without this layer, the evaluation engine has nothing formal to evaluate against. It falls back to interpretation.

Policy formalization requires resolving ambiguities that natural language deliberately preserves. "Material" must become a threshold. "Senior" must become a role in an authority hierarchy. "Approval" must become a signed attestation with temporal validity. Each resolution is a design decision with compliance implications. The semantic definitions embedded in the constraint set must be versioned, immutable at decision time, and bound to each verdict.

Deterministic governance does not eliminate interpretation. It confines interpretation to the design-time formalization process, where it can be versioned, audited, and challenged - rather than allowing it to operate silently at evaluation time.

Everyone understands policy. Everyone understands evaluation. Almost no one has a constraint representation layer. And almost no one acknowledges what its absence means.

Without constraint formalization, all evaluation is interpretive. Even when it appears deterministic.

Systems that operate policy to interpretation to action are governance-adjacent. Systems that require policy to formal constraints to deterministic evaluation to authorization are governance-capable. The constraint representation layer is the dividing line.

When governance fails

Rather than listing features that a governed system should have, the following defines conditions under which a decision fails the governance standard. A positive list of features invites the response "we satisfy most of those." A negative test demands completeness.

A decision fails the governance standard if any of the following cannot be demonstrated:

Pre-execution evaluation. The decision was evaluated after execution, or no evaluation occurred before the action took effect. Retrospective analysis is investigation, not governance.

Constraint-bound derivation. The verdict was not derived from explicit, formal rules. It was interpreted, estimated, or heuristically determined. Interpretation is judgment. Derivation is proof.

Context completeness. The evaluation did not resolve identity, authority, object, scope, context, and constraints. A verdict against an incomplete action frame is a verdict about something other than the action that occurred.

Non-bypassability. An alternate execution path existed that could circumvent the authorization gate. A boundary with a side path is not a boundary.

Determinism. Identical governed state could produce different verdicts. Governed state includes the action representation, policy version, semantic definitions, evaluator version, and all context required for evaluation. If any element is uncontrolled or unrecorded, determinism is untestable.

Verifiability. The verdict cannot be independently checked. If verification requires trusting the system that produced the verdict, it is self-attestation, not proof.

Replayability. The verdict cannot be recomputed with an identical result by a third party using the proof artifact and referenced materials, without the cooperation of the original system.

These are not features. They are conditions of validity.

Five dimensions of completeness

Authorization establishes validity. Completeness determines whether that validity constitutes proof.

A runtime authorization gate that evaluates a subset of applicable constraints satisfies the formal conditions of governance while leaving the remaining policy domain unevaluated. The decision is governed in form but incomplete in substance. Authorization is necessary. It is not sufficient.

Five dimensions determine whether a governed decision is complete enough to constitute proof.

1. Constraint completeness. Is the constraint set complete for the policy domain? A gate that evaluates available rules without coverage verification may authorize actions that violate unevaluated policies. Governance completeness requires auditable coverage.

2. Semantic precision. Are terms defined unambiguously? If the meaning of a term can drift between decision time and audit time, the verdict is not reproducible. Semantic definitions must be versioned, bound to each decision, and immutable within the scope of that decision.

3. Policy binding. Is the policy version cryptographically bound to the verdict? A system that evaluates "the current policy" without recording which version was current cannot answer the question: which rules governed this action?

4. Temporal binding. Is the decision anchored to a specific moment? Policies have effective dates. Evidence has validity windows. Authority chains have expiration. A verdict rendered against expired policy or stale evidence is unauthorized regardless of whether the gate returned ALLOW.

5. Independent replayability. Can a third party reproduce the verdict? If the verifier is controlled by the same entity that generated the decision, the result is self-attestation, not proof. The vendor says "we can replay internally." The regulator asks: "Can I replay without you?"

A decision that satisfies the seven validity conditions but fails any of these five dimensions is governed but incomplete. Incomplete artifacts are not proof. They are narrative with a timestamp.

The standard

The standard proposed here is not aspirational. It is testable. For any decision claimed to be governed, five questions can be asked:

Was the constraint set complete for the policy domain?
Were semantic definitions versioned and bound?
Was the policy version cryptographically embedded in the proof artifact?
Does the artifact include temporal validity evidence?
Can the decision be replayed offline, by an independent verifier, without the cooperation of the original system?

A system that satisfies all five is providing governance. A system that satisfies some is providing something less.

The standard is not whether a decision can be reviewed after the fact. The standard is whether it can be proven, before execution, that the action was permitted under defined constraints. And the proof must survive independent verification: reproducible by a third party, replayable without the cooperation of the original system, binding on its own terms.

Governance begins where trust is no longer required.

Read the full paper

This article is a condensed version of the complete research paper, which includes the formal Canonical Action Frame, detailed governance validity tables, authorization artifact binding requirements, and references to supporting published research.

Download the full paper (PDF) →

Related research

A Taxonomy of AI Governance Approaches (v1.5) — Distinguishing visibility, alignment, and authorization across eight governance categories.
What Deterministic Governance Actually Means — The formal definition and its operational implications.
Deterministic Governance Is Multi-Dimensional — Why authorization alone is necessary but not sufficient.
Governance Artifacts Without Governance — When the artifact can exist without the evaluation.
Four Tests Standard (4TS) — The vendor-neutral conformance specification for verifiable AI governance.

Suggested citation: Meyman, E. (2026). The Authorization Threshold: Defining the Standard for Governance in AI Systems. FERZ, Inc.

The Authorization Threshold: Defining the Standard for AI Governance