Documentation
A complete reference for AetherGovern v2.0.0 — architecture, formal definitions, failure conditions, and propositions
A reference implementation (v2.0.0) of the falsification-first governance architecture specified in v0.1.0. 15 modules, 60 tests, 3 experiments. The manuscript is published on Zenodo. The OSF registration is published. No real-world deployment has been evaluated.
Table of Contents
Overview
AetherGovern is a structured investigation of whether a governance gap genuinely exists in the Aether family, or whether it is already covered by the existing four dimensions: AetherGit (storage), AetherFlow (integration), AetherProof (specification), and AetherMesh (decentralization). It is the fifth functional dimension (provisional) of the Aether family. v2.0.0 adds a reference implementation alongside the v0.1.0 hypothesis.
| Field | Value |
|---|---|
| Full title | AetherGovern: A Falsification-First Investigation of Governance in the Aether Family |
| Subtitle | A Falsification-First Investigation of Authority, Policy, and Accountability in Multi-Agent Software Ecosystems |
| Version | 2.0.0 (Reference Implementation) + 0.1.0 (Formal Architecture) |
| Stage | Reference Implementation with Reproducible Experiments |
| License | MIT (code) · CC-BY-4.0 (docs, manuscript) |
| Domain | Distributed Systems / Software Engineering / Institutional Analysis |
| DOI (Zenodo) | 10.5281/zenodo.24054524 |
| Concept DOI | 10.5281/zenodo.24054523 |
| OSF | 10.17605/OSF.IO/TAHC8 |
| PyPI | pypi.org/project/aethergovern (publishing) |
| Record ID | AETHERGOVERN-02 |
"AetherGovern is a candidate, not a result."
Formal Definitions
Definition 1 — Delegation Certificate. A record in which the issuer authorizes the subject for the stated scope. A chain is a sequence of certificates in which each certificate's issuer is the previous certificate's subject, and the first certificate's issuer is a root of authority.
c = (issuer, subject, scope, constraints, expiry, parent, signature)
Definition 2 — Chain Validity at Frontier F. A chain is valid at revocation frontier F if:
(a) every signature verifies
(b) scope attenuates: scope(c_{i+1}) ⊆ scope(c_i)
(c) no certificate has expired at the action's logical time
(d) no certificate in the chain appears in the revocation set recorded in F
(e) the first certificate's issuer is a recognised root
Definition 3 — Causal-Authority Admission. Every action record includes a reference to a revocation frontier F (a set of revocation records identified by hash) that the actor had seen when it acted, and to the policy version it relied on. A node evaluates chain validity at the frontier F named by the action, not at its own current revocation set.
Definition 4 — Revocation Set. The set of revocation records known at a node. Adding a revocation to the set can only invalidate certificates, never validate them.
Failure Conditions (F1–F5)
| ID | Claim under test | Status |
|---|---|---|
| F1 | Non-redundancy | 🟡 Not falsified (R1, R3, R5) |
| F2 | Orthogonality to verification | 🟡 Not falsified (narrowly) |
| F3 | Boundary with orchestration | 🟡 Not falsified (decentralized setting) |
| F4 | Decentralizability | 🟡 Not falsified (with residuals) |
| F5 | Observable benefit | 🔴 Untested |
Propositions (P1–P2)
| # | Proposition | Status |
|---|---|---|
| P1 | Determinism of Causal-Authority Admission | Proof sketch · implemented in code |
| P2 | Monotonicity of Revocation | Proof sketch · implemented in code |
Validation
| Check | Result |
|---|---|
| Formal Definitions | 4 (all defined) |
| Propositions | 2 (stated with proof sketches; implemented in code) |
| Failure Conditions | 5 (F1–F5) |
| Requirements | 6 (R1–R6) |
| Governance Layers | 5 (Authorization, Policy, Accountability, Revocation, Dispute Resolution) — all implemented |
| Figures | 5 (all generated) |
| References | 25 (in paper); 15 (in Zenodo record) |
| Open Questions | 20 (Q1–Q20) |
| Design Principles | 8 (P1–P8) |
| Threats to Validity | 7 |
| Python Modules | 15 (in src/aethergovern/) |
| Tests | 60 (all passing) |
| Experiments | 3 (M1–M5, simulated data) |
| PyPI Package | aethergovern 2.0.0 (publishing) |
| Real-world deployment | Not evaluated |
| Causal Claims | None (argument only) |
Scope & Limits
What AetherGovern supports (as a hypothesis + reference implementation):
- A falsification-first methodology with five failure conditions (F1–F5).
- A comparison of three candidate capabilities (orchestration, governance, runtime assurance).
- A hypothesized five-layer governance architecture (authorization, policy, accountability, revocation, dispute resolution).
- Two propositions with proof sketches (determinism of causal-authority admission; monotonicity of revocation).
- An evaluation design that specifies in advance what outcomes would count as failure (M1–M9, B1–B5).
- Twenty open questions (Q1–Q20).
- A reference implementation (v2.0.0): 15 modules, 60 tests, 3 reproducible experiments.
- Open manuscript (CC-BY-4.0) and open code (MIT).
What AetherGovern does not support:
- Real-world deployment (not evaluated).
- Causal claims (argument only).
- Machine-checked proofs (P1–P2 are proof sketches, though they are implemented in code).
- Any security property in practice (P1–P2 concern determinism and monotonicity, not resistance to attack).
- A small exposure window (H1 is a hypothesis resting on unverified results from another preprint).
- Implementability at acceptable cost (no real measurement exists; the simulation covers M1–M5 only).
- A resolution of accountability in a legal or organizational sense (it provides records, not responsibility).
Design philosophy. AetherGovern is a research investigation, not a committed project. Its purpose is to specify an architecture precise enough to be tested against the failure conditions — and to make the limits of that specification explicit. The final project structure (single, dual, or triple project) is explicitly left undetermined.
Citation
APA: Baladi, S. (2026). AetherGovern: A Falsification-First Investigation of Governance in the Aether Family (Version 2.0.0). Zenodo. https://doi.org/10.5281/zenodo.24054524
@techreport{baladi2026aethergovern,
author = {Baladi, Samir},
title = {AetherGovern: A Falsification-First Investigation of
Governance in the Aether Family},
institution = {Ronin Institute / Rite of Renaissance},
type = {Research Paper},
year = {2026},
month = {November},
version = {2.0.0},
doi = {10.5281/zenodo.24054524},
url = {https://doi.org/10.5281/zenodo.24054524}
}
Software (v2.0.0):
@software{baladi2026aethergovern_v2,
author = {Baladi, Samir},
title = {{AetherGovern} v2.0.0: Reference Implementation of the
Falsification-First Governance Architecture},
year = {2026},
month = {November},
publisher = {PyPI},
version = {2.0.0},
doi = {10.5281/zenodo.24054524},
url = {https://pypi.org/project/aethergovern/},
note = {Reference implementation. Available via pip install aethergovern.}
}
OSF Registration:
@misc{baladi2026aethergovern_osf,
author = {Baladi, Samir},
title = {{AetherGovern: A Falsification-First Investigation of
Governance in the Aether Family}},
year = {2026},
month = nov,
day = {9},
publisher = {OSF},
doi = {10.17605/OSF.IO/TAHC8},
url = {https://doi.org/10.17605/OSF.IO/TAHC8},
note = {OSF Preregistration. Associated project: https://osf.io/we2tm}
}