EGA is a reference architecture for the authorization-to-execution-authority step: it turns Runtime AI Governance output into explicit, bounded execution authority that a downstream execution boundary (such as EABC) can consume. The repository includes a minimal executable model of this step. It is not an implementation of EABC and not a production system.
Runtime AI Governance
│
│ runtime intent + governance context + evidence
▼
EGA — Execution Governance Authority
│
│ explicit execution authority
▼
EABC — Execution Authority Boundary Contract
│
│ current execution conditions
▼
Enforcement Boundary
│
▼
EFFECT
EGA is an authorization-to-execution-authority bridge.
It accepts runtime intent and relevant governance context, normalizes heterogeneous upstream outputs, evaluates the intent against applicable authorization scope, and produces explicit execution authority for downstream enforcement.
EGA is authorization-complete but execution-blind.
It does not commit effects or determine whether an authorized action may become an effect under current execution conditions.
EGA may receive runtime evidence from an upstream Observer or equivalent evidence source through a provider-neutral evidence envelope.
The evidence contract carries evidence identity, subject or target, state or value, observation time, temporal basis, provenance, uncertainty, source confidence where provided, schema version, and an integrity reference.
The Observer reports evidence. It does not assign materiality, create execution authority, or promote evidence into a commit condition.
EGA determines which evidence is materially relevant to authorization and, where required, explicitly projects selected evidence properties into execution-boundary conditions.
An evidence change does not by itself invalidate an execution condition. The condition is evaluated against the current evidence at the execution boundary.
- accepts Runtime AI Governance output or equivalent upstream authority input;
- normalizes runtime intent and governance context;
- evaluates intent against applicable authorization scope;
- derives bounded execution authority;
- preserves authorization lineage and evidence;
- hands explicit execution authority to a downstream execution boundary.
EGA does not:
- execute actions;
- commit effects;
- determine the actual state transition;
- replace Runtime AI Governance;
- replace EABC;
- determine physical or logical execution safety;
- choose software versus hardware enforcement;
- guarantee that an authorized action will execute.
EABC is implementation-neutral and does not require EGA.
Authority Source → EABC → Enforcement Boundary → EFFECT
EGA provides one concrete architecture for the upstream authorization-to-execution-authority transition:
Runtime AI Governance → EGA → EABC → Enforcement Boundary → EFFECT
The repository contains a minimal deterministic Python model of the EGA step.
python -m pip install -e ".[test]"
pytest -qThe implementation does not execute external actions. It includes a semantic PREPARE / FINAL_AUTHORITY_CHECK / COMMIT seam and emits ExecutionAttestation evidence for the resulting commit or block decision.
The second example models a provider-neutral runtime-control failure: a human restriction permits only execution path A, path A becomes unavailable, and a technically available substitute path B must not acquire execution authority merely because the system can execute it.
The reference architecture and the RAIG/Observer → EGA interoperability seams are defined. The executable model includes a minimal contract for runtime intent, external authorization scope, fail-closed evaluation, execution-authority issuance, and a prepare/final-check/commit seam.
See: