Reference · v2.0.0 · Experimental Reference Implementation

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.

Project identity
FieldValue
Full titleAetherIdentity: A Falsification-First Investigation of Decentralized Agent Identity in the Aether Family
SubtitleA Falsification-First Investigation of Identity Proof, Continuity, Reputation, Sybil Resistance, and Delegation in Multi-Agent Software Ecosystems
Version2.0.0 (Experimental Reference Implementation)
StageReference implementation + paper (v1.0.0)
LicenseMIT (code) · CC-BY-4.0 (docs, manuscript)
DomainDistributed Systems / Security / Multi-Agent Systems
DOI (Zenodo)10.5281/zenodo.24102739
DOI (Figshare)10.6084/m9.figshare.34981891
OSF Preregistration10.17605/OSF.IO/B6AEN
PyPIaetheridentity 2.0.0 Published
Record IDAETHERIDENTITY-01

"AetherIdentity is a candidate, not a result."

Installation

Requires Python 3.10+. Runtime dependency: 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

All of this is implemented in v2.0.0 (8 Python modules under src/aetheridentity/).
The five layers of AetherIdentity
LayerQuestionStatus
L1 — IdentityWho is the agent, and can it prove it?Implemented
L2 — ContinuityDoes the identity persist?Implemented
L3 — ReputationWhat is the behavioral history?Implemented
L4 — Sybil ResistanceIs one entity behind many identities?Implemented
L5 — DelegationCan 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)

Falsification status of the five failure conditions
IDClaim under testStatus
F1Non-redundancyNot falsified (identity lifecycle missing)
F2Orthogonality to verificationNot falsified (narrowly)
F3Boundary with governanceInconclusive (fragile; tested in S6)
F4DecentralizabilityNot falsified (with residuals)
F5Observable benefitUntested
"Not falsified" is a weaker status than "confirmed". F5 remains untested. No condition is confirmed.

Propositions (P1–P2)

Propositions and their proof status
#PropositionStatus
P1Determinism of Local Identity Issuance (restated)Proof sketch (not machine-checked)
P2Irreducible Trust AnchorProof sketch (regress argument, not machine-checked)
Both propositions are stated with proof sketches; neither is machine-checked. P1 bears on F4 (determinism of admission). P2 bears on F4 (irreducible anchor).

Validation

Validation checklist (v2.0.0)
CheckResult
Formal Definitions4 (all defined)
Propositions2 (stated with proof sketches)
Failure Conditions5 (F1–F5)
Requirements6 (R1–R6)
Identity Layers5 (Identity, Continuity, Reputation, Sybil Resistance, Delegation)
Figures9 (6 exported)
References29 (7 Aether + 22 external)
Open Questions20 (Q1–Q20)
Evaluation Metrics9 (M1–M9)
Baselines5 (B1–B5)
Scenarios6 (S1–S6)
Threats to Validity7
Python Modules8
Tests35 passed (93%)
Experiments2/6 executed (S1, S6)
PyPI PackagePublished (aetheridentity 2.0.0)
Real-world deploymentNot evaluated
Causal ClaimsNone (argument only)

Evaluation Design

Nine metrics (M1–M9), with partial execution in v2.0.0
#MetricDirection
M1Identity issuance accuracyHigher is better
M2Continuity preservationHigher is better
M3Reputation accuracyHigher is better
M4Sybil detection rate (with false-positive rate)Higher is better
M5Delegation scope correctnessHigher is better
M6Identity verification latencyLower is better
M7Identity storage overheadLower is better
M8Revocation propagation latencyLower is better
M9Convergence preservationMust be zero
Partial execution. In v2.0.0, only S1 and S6 are executed. S2–S5 and most metrics are deferred.

Experimental Results (v2.0.0)

Results from experiments/S*/results.json
#ExperimentResult
1S1 — Bootstrap (P2)P2 not falsified (bootstrap requires an anchor)
2S6 — Governance overlap (F3)F3 inconclusive (fragile: holds in some uses, fails in others)
Partial evaluation. S2–S5 are deferred, not passing. F1, F2, F4, and F5 are not evaluated in v2.0.0.

Scope & Limits

What AetherIdentity v2.0.0 supports:

What AetherIdentity does not support:

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

Selected threats to validity
IDThreatMitigation (planned)
T1Construct validityReport several metrics; invite independent review
T2Internal validityEqual tuning budgets; ablations; shared seeds
T3External validityNo real-world deployment; no transfer claimed
T4Baseline strengthWell-documented baselines; external configuration review
T5Scenario selectionPre-register; independent scenario proposals
T6Author biasIndependent review and replication
T7Model assumptionsSensitivity 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}
}
Status note (v2.0.0): This is an experimental reference implementation (v2.0.0) of the identity architecture for the Aether family. 8 Python modules, 35 tests (93% coverage), and 2 experiments (S1, S6) are executed. No real-world deployment has been evaluated. F1–F4 are not falsified by argument; F3 is inconclusive. F5 remains untested. S2–S5 are deferred. AetherIdentity is a candidate, not a result.