Execution-Time Authorization

A FERZ-defined primitive in the runtime authorization framework, introduced in Execution-Time Authorization (Meyman, 2026) and grounded in On the Impossibility of Observability-Based Authorization (Meyman, 2026).

Where it sits

Most AI governance approaches operate at one of two boundaries. The first is design-time, where systems are built with intended behaviors and constraints. The second is post-execution, where logs and observability tools record what occurred. Neither boundary catches an AI action between intent and effect.

Execution-time authorization sits at the action boundary. When an AI system attempts an action that would have real consequences, the authorization layer evaluates the action against encoded policy and returns a verdict. ALLOW permits the action to proceed. DENY blocks it. ABSTAIN blocks it pending authorized human override, the fail-closed posture under uncertainty. The action does not execute until a verdict is returned.

How it differs from adjacent categories

This is distinct from identity and access management, which authorizes principals (users, services, agents) to access resources but not specific AI actions to execute. It is distinct from policy engines, which evaluate rules but do not own the action boundary. It is distinct from AI observability, which records what AI systems did but does not decide whether they may do it. It is distinct from runtime application security, which prevents exploits but does not adjudicate authorized actions.

Three architectural properties

The authorization gate is structurally independent of the AI system it governs. The governed system cannot bypass the gate, ignore its verdict, or modify the policy state used by the gate.

Decisions are deterministic. Given the same action, the same policy, and the same context, the verdict is the same.

Every verdict emits a Proof-Carrying Decision, a cryptographically verifiable artifact that records the decision, the policy applied, and the conditions evaluated. The artifact can be verified independently of the executing system.

Why "execution-time"

Execution-time authorization is the operational answer to the third problem in the Three Problems taxonomy. Visibility (what the AI is doing) is addressed by monitoring. Alignment (whether the AI pursues the right objectives) is addressed by training and design. Authorization (whether the AI may perform a specific action) is addressed here, at the moment of execution, because that is the only boundary at which the question can be answered without prior assumptions about what the AI will do.

Related concepts

• Runtime authorization boundarythe spatial counterpart to execution-time
• Proof-Carrying Decisionsthe verifiable artifact emitted with each verdict
• ABSTAIN verdictthe fail-closed verdict under uncertainty
• Non-bypassable AI governancethe structural property of the gate
• Three Problems taxonomythe framing under which execution-time authorization sits
• Observability is not authorizationthe doctrinal position

References

1. Meyman, E. (2026). Execution-Time Authorization. FERZ, Inc. https://doi.org/10.5281/zenodo.18764562
2. Meyman, E. (2026). On the Impossibility of Observability-Based Authorization, v1.3.2. FERZ, Inc. https://doi.org/10.5281/zenodo.19647542

The full FERZ corpus is available at /research/papers, on Zenodo, and on SSRN.

Frequently Asked Questions

@misc{ferz2026exectimeauth,
  author    = {{FERZ, Inc.}},
  title     = {Execution-Time Authorization: Definition and Architecture},
  year      = {2026},
  month     = {May},
  publisher = {FERZ, Inc.},
  url       = {https://ferz.ai/governance/concepts/execution-time-authorization}
}