Documentation
A complete reference for AetherIdentity v2.0.0 — architecture, formal definitions, failure conditions, propositions, and reference implementation
An experimental reference implementation (v2.0.0) of the identity architecture for the Aether family. The manuscript is published on Zenodo and Figshare. The OSF preregistration is published. 8 Python modules, 35 tests (93% coverage), and 2 experiments (S1, S6) are executed. No real-world deployment has been evaluated.
Table of Contents
Overview
AetherIdentity is a structured investigation of whether a decentralized identity gap genuinely exists in the Aether family, or whether it is already covered by the existing seven dimensions: AetherGit (storage), AetherFlow (integration), AetherProof (verification), AetherMesh (distribution), AetherGovern (governance), AetherRuntime (runtime assurance), and AetherOrchestrate (orchestration). It is the eighth functional dimension (candidate, provisional) of the Aether family. v2.0.0 is an experimental reference implementation; no real-world deployment is claimed.
| Field | Value |
|---|---|
| Full title | AetherIdentity: A Falsification-First Investigation of Decentralized Agent Identity in the Aether Family |
| Subtitle | A Falsification-First Investigation of Identity Proof, Continuity, Reputation, Sybil Resistance, and Delegation in Multi-Agent Software Ecosystems |
| Version | 2.0.0 (Experimental Reference Implementation) |
| Stage | Reference implementation + paper (v1.0.0) |
| License | MIT (code) · CC-BY-4.0 (docs, manuscript) |
| Domain | Distributed Systems / Security / Multi-Agent Systems |
| DOI (Zenodo) | 10.5281/zenodo.24102739 |
| DOI (Figshare) | 10.6084/m9.figshare.34981891 |
| OSF Preregistration | 10.17605/OSF.IO/B6AEN |
| PyPI | aetheridentity 2.0.0 Published |
| Record ID | AETHERIDENTITY-01 |
"AetherIdentity is a candidate, not a result."
Installation
cryptography >= 41.0.# From PyPI (published)
pip install aetheridentity
# From source (development)
git clone https://github.com/gitdeeper15/aetheridentity.git
cd aetheridentity
pip install -e ".[dev]"
# Run tests
pytest
# Run experiments
python experiments/S1_bootstrap/run.py
python experiments/S6_governance_overlap/run.py
Architecture — The Five Identity Layers
src/aetheridentity/).| Layer | Question | Status |
|---|---|---|
| L1 — Identity | Who is the agent, and can it prove it? | Implemented |
| L2 — Continuity | Does the identity persist? | Implemented |
| L3 — Reputation | What is the behavioral history? | Implemented |
| L4 — Sybil Resistance | Is one entity behind many identities? | Implemented |
| L5 — Delegation | Can authority move with bounded scope? | Implemented |
Identity lifecycle: issue → verify → use → delegate → revoke → ended. Revocation ends an identity; it does not return it to issue. Each arrow is an append to replicated state. Rotation (L2) creates a new key epoch under the same identifier.
Monotone vs. non-monotone functions: most identity functions are monotone or deterministic functions of monotone state and need no agreement. Four need something outside the replicated state: choosing the genuine branch of a fork, changing the anchor, recovering after total loss, and enforcing a single live instance.
Formal Definitions
Definition 1 — Identity. Fix a signature scheme (Sign, Verify) over a key space, a collision-resistant hash H, and a set Λ of labels (bounded strings). An inception record is t = (alg, pk, λ, t_c), signed with the secret key matching pk, where alg names the scheme, λ ∈ Λ is a semantic label, and t_c is a creation timestamp. The identifier is id(t) = H(tag ‖ alg ‖ pk ‖ λ), with tag a fixed domain-separation string. An identity is an identifier together with its continuity chain.
id(t) = H(tag ‖ alg ‖ pk ‖ λ)
Definition 2 — Continuity Chain. A continuity chain for identifier id is a sequence C = (r₀, …, rₙ), where r₀ = t and each r_k = (id, k, pk_k, c_k, h_{k−1}, o_k). Here c_k = H(pk_{k+1}) is a pre-commitment to the next key, h_{k−1} = H(r_{k−1}) links to the previous record, and o_k is a signature by sk_k over the rest of r_k. C is valid if r₀ is correctly self-signed, and for each k ≥ 1, H(pk_k) = c_{k−1}, h_{k−1} is correct, and o_k verifies under pk_k. The current key is pk_n. Two valid records with the same predecessor and different content are a fork; an identity with a fork in S has status contested.
C = (r₀, …, rₙ)
c_k = H(pk_{k+1})
h_{k−1} = H(r_{k−1})
Definition 3 — Reputation Record and Score. A reputation record is ρ = (o, s, e, v, t), signed by the observer identity o, about subject identity s, where e is a content-addressed reference to evidence, v ∈ {−1, 0, +1} is the outcome, and t a timestamp. Records are only added to S. Let n_os = max(Σ v over records from o about s, 0) and C_os = n_os / Σ_j n_oj (with a fixed convention when the denominator is zero). Let p be the uniform distribution over the anchor set Γ₀. The reputation vector is the fixed point of t = (1 − a) · Cᵀ t + a · p for a fixed a ∈ (0, 1).
t = (1 − a) · Cᵀ t + a · p
Definition 4 — Delegation Scope and Chain. Let (Scopes, ⊆) be a family of scopes closed under intersection (a meet-semilattice). A delegation is d = (i, j, S_d, e_d, p_d), signed by identity i, granting identity j the scope S_d ∈ Scopes until expiry e_d, where p_d references the parent delegation (or a root authority record from AetherGovern) under which i itself holds authority. A delegation is valid if S_d ⊆ S_p, e_d ≤ e_p, and the parent is valid. The effective scope of a chain is the intersection of its scopes and its expiry is the minimum of its expiries. A revocation of any link invalidates that link and all links downstream of it.
d = (i, j, S_d, e_d, p_d) valid iff S_d ⊆ S_p, e_d ≤ e_p, parent valid
Failure Conditions (F1–F5)
| ID | Claim under test | Status |
|---|---|---|
| F1 | Non-redundancy | Not falsified (identity lifecycle missing) |
| F2 | Orthogonality to verification | Not falsified (narrowly) |
| F3 | Boundary with governance | Inconclusive (fragile; tested in S6) |
| F4 | Decentralizability | Not falsified (with residuals) |
| F5 | Observable benefit | Untested |
Propositions (P1–P2)
| # | Proposition | Status |
|---|---|---|
| P1 | Determinism of Local Identity Issuance (restated) | Proof sketch (not machine-checked) |
| P2 | Irreducible Trust Anchor | Proof sketch (regress argument, not machine-checked) |
Validation
| Check | Result |
|---|---|
| Formal Definitions | 4 (all defined) |
| Propositions | 2 (stated with proof sketches) |
| Failure Conditions | 5 (F1–F5) |
| Requirements | 6 (R1–R6) |
| Identity Layers | 5 (Identity, Continuity, Reputation, Sybil Resistance, Delegation) |
| Figures | 9 (6 exported) |
| References | 29 (7 Aether + 22 external) |
| Open Questions | 20 (Q1–Q20) |
| Evaluation Metrics | 9 (M1–M9) |
| Baselines | 5 (B1–B5) |
| Scenarios | 6 (S1–S6) |
| Threats to Validity | 7 |
| Python Modules | 8 |
| Tests | 35 passed (93%) |
| Experiments | 2/6 executed (S1, S6) |
| PyPI Package | Published (aetheridentity 2.0.0) |
| Real-world deployment | Not evaluated |
| Causal Claims | None (argument only) |
Evaluation Design
| # | Metric | Direction |
|---|---|---|
| M1 | Identity issuance accuracy | Higher is better |
| M2 | Continuity preservation | Higher is better |
| M3 | Reputation accuracy | Higher is better |
| M4 | Sybil detection rate (with false-positive rate) | Higher is better |
| M5 | Delegation scope correctness | Higher is better |
| M6 | Identity verification latency | Lower is better |
| M7 | Identity storage overhead | Lower is better |
| M8 | Revocation propagation latency | Lower is better |
| M9 | Convergence preservation | Must be zero |
Experimental Results (v2.0.0)
| # | Experiment | Result |
|---|---|---|
| 1 | S1 — Bootstrap (P2) | P2 not falsified (bootstrap requires an anchor) |
| 2 | S6 — Governance overlap (F3) | F3 inconclusive (fragile: holds in some uses, fails in others) |
Scope & Limits
What AetherIdentity v2.0.0 supports:
- A falsification-first methodology with five failure conditions (F1–F5).
- A five-layer identity architecture (identity, continuity, reputation, Sybil resistance, delegation).
- Two propositions with proof sketches (determinism of local identity issuance; irreducible trust anchor).
- An evaluation design that specifies in advance what outcomes would count as failure (M1–M9, B1–B5, S1–S6).
- Twenty open questions (Q1–Q20).
- A reference implementation (8 modules, 35 tests, 2 experiments).
- Open manuscript (CC-BY-4.0).
What AetherIdentity does not support:
- Real-world deployment (not evaluated).
- Causal claims (argument only).
- Machine-checked proofs (P1–P2 are proof sketches).
- Guaranteed Sybil detection (detection is heuristic).
- Elimination of the trust anchor (it is irreducible; P2).
- Perfect recovery after total key loss (impossible without an anchor or a pre-declared recovery set).
- Single-instance enforcement without bounded agreement.
- Network transport, consensus, or AetherMesh integration.
Design philosophy. AetherIdentity is a research investigation with a reference implementation. 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 is explicitly left undetermined.
Threats and Limitations
| ID | Threat | Mitigation (planned) |
|---|---|---|
| T1 | Construct validity | Report several metrics; invite independent review |
| T2 | Internal validity | Equal tuning budgets; ablations; shared seeds |
| T3 | External validity | No real-world deployment; no transfer claimed |
| T4 | Baseline strength | Well-documented baselines; external configuration review |
| T5 | Scenario selection | Pre-register; independent scenario proposals |
| T6 | Author bias | Independent review and replication |
| T7 | Model assumptions | Sensitivity runs; state assumptions with every result |
Citation
APA (paper): Baladi, S. (2026). AetherIdentity: A Falsification-First Investigation of Decentralized Agent Identity in the Aether Family (Version 1.0.0). Zenodo. https://doi.org/10.5281/zenodo.24102739
APA (software): Baladi, S. (2026). AetherIdentity v2.0.0: Reference Implementation of the Falsification-First Identity Architecture (Version 2.0.0). PyPI. https://pypi.org/project/aetheridentity/
APA (OSF): Baladi, S. (2026). AetherIdentity: A Falsification-First Investigation of Decentralized Agent Identity in the Aether Family. OSF. https://doi.org/10.17605/OSF.IO/B6AEN
@techreport{baladi2026aetheridentity,
author = {Baladi, Samir},
title = {AetherIdentity: A Falsification-First Investigation of
Decentralized Agent Identity in the Aether Family},
institution = {Ronin Institute / Rite of Renaissance},
type = {Research Paper},
year = {2026},
month = {November},
version = {1.0.0},
doi = {10.5281/zenodo.24102739},
url = {https://doi.org/10.5281/zenodo.24102739}
}
@software{baladi2026aetheridentity_v2,
author = {Baladi, Samir},
title = {{AetherIdentity} v2.0.0: Reference Implementation of the
Falsification-First Identity Architecture},
year = {2026},
month = {November},
version = {2.0.0},
doi = {10.5281/zenodo.24102739},
url = {https://pypi.org/project/aetheridentity/},
note = {Reference implementation. Paper: v1.0.0.}
}
@misc{baladi2026aetheridentity_osf,
author = {Baladi, Samir},
title = {{AetherIdentity: A Falsification-First Investigation of
Decentralized Agent Identity in the Aether Family}},
year = {2026},
month = nov,
day = {11},
publisher = {OSF},
doi = {10.17605/OSF.IO/B6AEN},
url = {https://doi.org/10.17605/OSF.IO/B6AEN},
note = {OSF Preregistration for the v2.0.0 evaluation plan.
Associated project: https://osf.io/5y783}
}