Skip to main content

🕸️ AetherMesh

Decentralized Peer-to-Peer Agent Synchronization and State CRDTs for Autonomous Multi-Agent Systems

A Formal Architecture for Epidemic Gossip Propagation and Lightweight Byzantine Fault Tolerance at Agent Scale


DOI License: MIT + CC-BY-4.0 ORCID Release Python

PyPI PyPI downloads PyPI status Tests Coverage Experiments

Zenodo Record ID OSF: 10.17605/OSF.IO/9PE5V Website Aether Family


📄 Paper · 🌐 Website · 📦 Releases · ⚙️ Installation · 📖 Citation


"The simulation results here are an invitation to such evaluation, not a substitute for it." — AetherMesh v1.0.0, Section 8.2

"We state the evidentiary status of this work at the outset, because it determines how every later claim should be read." — AetherMesh v1.0.0, Section 1.4


📑 Table of Contents


🔭 Overview

AetherMesh is a fully decentralized peer-to-peer synchronization framework for autonomous agent networks that modify shared codebases and metadata DAGs. It replaces locking and central coordination with a tripartite architecture, and is the decentralization layer (fourth layer) of the Aether family, above AetherGit (storage), AetherFlow (integration), and AetherProof (verification).

AetherMesh answers three questions together:

  1. How are concurrent changes combined without coordination? → CRDTs
  2. How are they disseminated without a central broker? → Epidemic gossip
  3. Which received changes may a node trust when some peers may be faulty or hostile? → Lightweight Byzantine admission
Release What it adds
v1.0.0 Architecture specified: 4 definitions, 3 theorems, 6 assumptions, 3 pillars, with a simulated evaluation (paper)
v2.0.0 Reference implementation (src/aethermesh/): 107 tests, 79% coverage, 3 reproducible experiments

📊 v2.0.0 at a Glance

Dimension Status
Manuscript (v1.0.0) Complete (33 pages, PDF)
Formal definitions / Theorems / Pillars 4 / 3 (proof sketches) / 3
Implementation ✅ Built — src/aethermesh/ (15 modules)
Tests ✅ 107 passed, 79% coverage
Experiments ✅ 3/3 completed (simulated data)
PyPI package ✅ Published
Real-world deployment ❌ Not evaluated
Causal claims None (formal analysis only)

AetherMesh — Tripartite Architecture

Figure 1 — The tripartite architecture of AetherMesh: CRDTs, gossip, and lightweight BFT sit above the peer-to-peer agent network. No central coordinator · no global locks · eventual consistency (under stated assumptions).

Contributions

# Contribution Kind
1 A tripartite architecture combining code- and metadata-specific CRDTs, epidemic gossip, and a local Byzantine admission layer Specification
2 A formal model of four definitions and three theorems (with proof sketches), with assumptions A1–A6 written out explicitly — including an admission determinism requirement (A6) Analysis
3 A simulated evaluation of convergence latency, conflict-resolution overhead, and fault resilience, with our own analysis showing the reported values are not consistent with a pure logarithmic law Simulation + analysis
4 A threat taxonomy of fifteen threats across six classes Analysis
5 A reference implementation (v2.0.0) with 107 tests, 79% coverage, and 3 reproducible experiments Implementation

⚙️ Installation

# From PyPI (once published)
pip install aethermesh

# From source (development)
git clone https://github.com/gitdeeper15/aethermesh.git
cd aethermesh
pip install -e ".[dev]"

# Run tests
pytest

# Run experiments
python experiments/convergence_latency/run.py
python experiments/conflict_resolution/run.py
python experiments/fault_resilience/run.py

# CLI
aethermesh info
aethermesh verify
aethermesh simulate --nodes 50 --fanout 5

Requires Python 3.9+. Runtime dependencies: numpy >= 1.24, cryptography >= 41.0.


🧪 Experiments (v2.0.0)

# Experiment Result Status
1 Convergence Latency Converged at 1–2 rounds (10–500 nodes) ✅
2 Conflict Resolution 0 deadlocks, 0 conflicts flagged ✅
3 Fault Resilience 100% block rate (10–500 malformed) ✅

❓ The Central Question

How can autonomous agents synchronize shared code and metadata without central coordination — combining concurrent changes, disseminating them, and deciding which received changes to trust — and under which explicit assumptions may the combined guarantees hold?

This question is structural, not accusatory or normative. The three mechanisms (CRDTs, gossip, BFT-style filtering) are individually well known; the contribution is their specification as a single architecture for code and metadata DAGs, the explicit assumptions of the composition, and an evaluation that is clearly bounded in what it can show.


🧭 Assumptions A1–A6

Every theorem below is conditional on these assumptions.

ID Assumption Used by
A1 Fair-lossy channels. A message sent infinitely often between two non-faulty nodes is delivered infinitely often. T1
A2 Fair peer selection. Each non-faulty node selects every other non-faulty node as a gossip partner infinitely often; for Theorem 2, selection is uniform and independent. T1, T2
A3 Finite delta universe. The set of deltas that will ever be created is finite, so the lattice has finite height. T1
A4 Correct replicas. Non-faulty nodes implement the join and the materialization function correctly and deterministically. T1
A5 Cryptographic soundness. Signature and hash schemes are unforgeable and collision-resistant, and the key registry is correct for the origins concerned. T3
A6 Admission determinism. Admission predicates are deterministic functions of the delta and its causal closure. T1, T3

📐 Formal Definitions

Status: Defined, version 1.0.0.

Definition 1 — Convergent State Transition

R_a(t+1) = R_a(t) ⊔ ⨆_{m ∈ M_a} m                                   (1)

Each agent a keeps a local replica R_a(t); M_a is the set of incoming mutation payloads that passed admission during (t, t+1). By commutativity, associativity, and idempotence, the order and multiplicity of payloads do not matter.

Definition 2 — CRDT State Space

(S, ⊔, ⊥)  bounded join-semilattice,   s_reconciled = s_i ⊔ s_j      (2)

where ⊔ is binary, commutative, associative, and idempotent.

Property Law Operational consequence
Commutative sᵢ ⊔ sⱼ = sⱼ ⊔ sᵢ Merge order does not matter
Associative (sᵢ ⊔ sⱼ) ⊔ sₖ = sᵢ ⊔ (sⱼ ⊔ sₖ) Batching and grouping do not matter
Idempotent sᵢ ⊔ sᵢ = sᵢ Duplicate delivery is harmless
Inflationary (derived) s ⊑ s ⊔ t State never moves down the lattice; no rollback

AetherMesh — CRDT Join-Semilattice (Hasse diagram)

Figure 4 — A seven-element bounded join-semilattice as a Hasse diagram (⊥, s₁–s₃, s₁₂, s₂₃, ⊤). The join laws were verified on this example by exhaustive enumeration. An illustration of the algebra, not a model of a real codebase.

Definition 3 — Gossip Infection Probability

P_uninfected(t) ≈ e^(−β·t)                                           (3)

β is the transmission rate constant determined by fanout k and exchange frequency r.

Definition 4 — Byzantine Admission Rule

Before a peer accepts a remote CRDT delta Δᵢ, local verification daemons evaluate cryptographic provenance, structural invariants, and semantic compatibility matrices. Only deltas bearing valid signatures and satisfying the local predicates are admitted to the local join-semilattice.


📜 Theorems

# Theorem Statement Assumptions
T1 Eventual Consistency Given continuous gossip activity and channels that eventually deliver, any two non-faulty agents aᵢ, aⱼ eventually reach an identical state. Given finite height (A3), the limits are attained at a finite time. A1–A6
T2 Exponential Dampening of Gossip Latency Under the constant-hazard model, P_uninfected(t) = (1−p)^t ≈ e^(−βt) with β = −ln(1−p) ≈ p for small p. A statement about the tail of the dissemination. A2
T3 Byzantine Fault Tolerance Bound If f < n/3, local verification predicates at each honest node block all predicate-detectable invalid deltas with probability approaching 1. A5, A6

Theorem 3 — committee bound. Where a decision cannot be made locally, a delta is accepted on a majority of attestations from a random committee of size m. Under independent sampling with Byzantine probability ≤ 1/3, the Chernoff–Hoeffding bound gives P[Byzantine majority] ≤ exp(−0.0589·m):

Committee size m Upper bound on P[Byzantine majority]
25 2.29e-01
50 5.26e-02
100 2.77e-03
200 7.67e-06
400 5.88e-11

Values are the output of a formula under stated assumptions, not simulation results.

AetherMesh — Gossip Propagation

Figure 8 — (a) Analytic curves of Equation (3) for β = 0.3, 0.5, 0.8 (plots of a formula). (b) Convergence latency versus network size for the five simulation-reported points; not a measurement of a deployed system.

What the proof sketches do not show
  • T1 gives no time bound; presumes M* is finite (or “eventually” is read relative to a fixed prefix); presumes A6, which a predicate author could violate; concerns non-faulty nodes only; says nothing about semantic validity of the materialized program; treats the agent set as fixed.
  • T3 does not show that invalid deltas outside the predicates are blocked — harmful but well-formed deltas from a signed, registered, Byzantine agent are admitted. It does not address colluding committees, Sybil identities, key compromise, or flooding.

🏛️ Architectural Pillars

Pillar Name Summary
1 CRDTs for Code and Metadata DAGs Replica state is the set of admitted deltas (grow-only set lifted to deltas; set union is the join). The materialized codebase is a deterministic function of the delta set (topological order with identifier tie-break). Metadata uses a product lattice (OR-sets, LWW registers, grow-only maps). Delta-state replication by default, state-based fallback for large divergence and joining nodes.
2 Epidemic Gossip Protocols Five-step anti-entropy exchange (digest → digest + difference list → delta request → delta batch → local verification and join). Digest form is a parameter: version vector, Merkle tree, or Bloom-style filter. Uniform random peer selection over a partial view. Partitions heal on the first cross-partition exchange.
3 Lightweight Byzantine Fault Tolerance Validity filtering, deliberately not a consensus protocol: (1) signature, (2) DAG integrity, (3) schema, (4) semantic compatibility matrix. Missing parents are deferred, not rejected. Predicates must satisfy the admission determinism requirement (A6).

AetherMesh — Anatomy of a Node

Figure 3 — Anatomy of an AetherMesh node. The only storage requirement is an append-only changeset log with parent pointers; the only integration requirement is a message-based protocol.

AetherMesh — Anti-Entropy Gossip Exchange

Figure 5 — One anti-entropy exchange between two peers. Received deltas pass through the admission pipeline before they are joined; deltas whose parents are not yet present are deferred rather than rejected.

AetherMesh — Partition, Divergence, and Healing

Figure 6 — Schematic of replica divergence during a partition and of healing. Conceptual; plots no measured data.

🔐 Byzantine Admission Pipeline

AetherMesh — Byzantine Admission Pipeline

Figure 7 — A remote delta passes through signature, DAG-integrity, schema, and semantic-compatibility checks before joining the local semilattice. The banner restates simulation-reported results and is not a measurement of a deployed system.

Check Evidence required Typical failure Verdict on failure
1. Signature Valid signature by a registered key over the content hash Forged or unsigned delta; unknown origin Reject
2. DAG integrity Id equals content hash; parents present; size bounds Hash mismatch; oversized; missing parents Reject (mismatch, bounds); defer (missing parents)
3. Schema Body parses against the delta schema Malformed fields Reject
4. Semantics Compatibility matrix verdict over the causal closure Incompatible concurrent operation Reject or quarantine, as configured
Illustrative semantic compatibility matrix (Table 3.1 — entries are examples, not normative)
Edit body Rename symbol Delete symbol Change signature Edit metadata
Edit body ok ok conflict ok ok
Rename symbol ok resolve (deterministic rule) conflict conflict ok
Delete symbol conflict conflict ok (idempotent) conflict ok
Change signature ok conflict conflict resolve (deterministic rule) ok
Edit metadata ok ok ok ok resolve (LWW)

🧪 Simulated Evaluation (v1.0.0 paper)

Reported results

# Metric Simulation-reported result Reading
1 State convergence latency (99% of network) 420 ms at 250 nodes (below 450 ms); 45–680 ms over 10–500 nodes Reported; scaling is not log-linear
2 Conflict-resolution overhead No blocking deadlocks; CPU < 5%; memory < 10% Deadlock-freedom follows from design; overhead baseline undefined
3 Fault resilience All injected malformed deltas blocked; 0% false positives; throughput overhead < 2% Pipeline check for predicate-detectable faults; number injected unreported
Nodes 10 50 100 250 500
Convergence time (ms), simulated 45 120 210 420 680

Our scaling analysis

The source material described scaling as “linear with log(n)”. Fitting the five reported points (computed by us; no other data used):

Model Fit Quality
Linear in ln n T ≈ 156·ln n − 409 R² = 0.85 (predicts −50 ms at n = 10)
Linear in n T ≈ 1.28·n + 62 R² = 0.99
Power law T ≈ 8.4·n^0.70 R² = 0.997 (log-log) — best of the three
Nodes n Reported (sim.), ms Eq. (4), ms Refined push estimate, ms Reported / Eq. (4)
10 45 46 175 1.0×
50 120 78 297 1.5×
100 210 92 349 2.3×
250 420 110 419 3.8×
500 680 124 471 5.5×

Eq. (4): T ≈ (ln n)/(k·r) with illustrative k = 5, r = 10 Hz. Computed by us from the formulas; not simulation output.

AetherMesh — Scaling Analysis

Figure 9 — The five simulation-reported convergence times with three fitted laws and the analytic scaling of Equation (4). Fits and the analytic curve are computed by us; only the five points are simulation-reported.

Simulation limitations

  • Simulated data — no real-world deployment evaluated.
  • Scale — 10–500 nodes; behavior at thousands of nodes is unknown.
  • Simplified network model — no real latency, packet loss, churn, NAT, or adversarial network conditions.
  • Byzantine model — limited to malformed deltas; colluding, equivocating, withholding, flooding, and Sybil adversaries not evaluated.
  • Missing statistics — number of runs, variance, confidence intervals, fanout, period, and baseline definition are not reported.
  • No ablation — contribution of each pillar not isolated; no gossip-only or consensus-based comparison.

⚠️ Threats and Limitations

Fifteen threats (T1–T15) across six classes; residual-risk entries are the author's qualitative judgements, not measurements.

ID Class Threat Residual risk
T1 Soundness Admission nondeterminism causes divergent admitted sets Medium
T2 Soundness Semantic-merge gap: valid deltas combine into an invalid program High
T3 Soundness Proof sketches contain errors Medium
T4 Completeness Well-formed but harmful deltas admitted High
T5 Completeness False rejection from strict schema or version skew Medium
T6 Trust Key registry bootstrap or compromise High
T7 Trust Collusion or Sybil identities exceed n/3 High (open membership)
T8 Trust Eclipse or peer-sampling bias Medium to high
T9 Process Flooding, oversized digests, deferral exhaustion Medium
T10 Process Unbounded history growth; unsafe compaction Medium
T11 Process Costly healing after long partitions Unknown (not simulated)
T12 Toolchain Simulator infidelity to real networks High until evaluated
T13 Toolchain Crypto-library, serialization, or schema skew faults Medium
T14 Human Operator misconfiguration Medium
T15 Human Reliance on simulated results as deployed evidence Medium

When not to use AetherMesh: small co-located teams; strong-consistency requirements (global order, unique-name allocation, exactly-once external effects); settings where validity must hold before visibility; adversarial settings beyond the stated threat model; storage-constrained nodes (the delta set grows without compaction).

Architectural limitations: eventual (not strong) consistency; no global order; filters only predicate-detectable invalid deltas; assumes a trustworthy key registry; grows without compaction.


🔗 Relation to AetherGit, AetherFlow, and AetherProof

AetherMesh is the fourth layer of the Aether family:

flowchart BT
    G["🗄️ AetherGit<br/><sub>Storage layer</sub>"] --> F["🔀 AetherFlow<br/><sub>Integration layer</sub>"] --> P["📚 AetherProof<br/><sub>Verification layer</sub>"] --> M["🕸️ AetherMesh<br/><sub>Decentralization layer</sub>"]
Layer System Question it answers DOI What AetherMesh requires from it
Storage AetherGit How are changes stored and transferred? 10.5281/zenodo.23966896 An append-only changeset log with parent pointers
Integration AetherFlow How are changes admitted, verified, and remediated? 10.5281/zenodo.23979129 A message-based protocol for submitting changes and receiving notifications
Verification AetherProof What conditions make behavior correct, and how are they proven? 10.5281/zenodo.24013124 Nothing mandatory; proof evidence may be carried as delta metadata
Decentralization AetherMesh (this work) How do agents synchronize state without central coordination? 10.5281/zenodo.24038038 —

AetherMesh — The Aether Family, Four Layers

Figure 2 — The Aether family, bottom to top: storage, integration, verification, decentralization. Each layer is shown with its DOI and the question it addresses.

The four layers are methodologically independent: AetherMesh imposes only the two minimal interface requirements above. Cross-layer compositions have not been built or evaluated; the independence is a design claim, not a verified one.


📋 Research Status Statement

Item Status
Document type Research article + reference implementation
Version / record 2.0.0, November 2026 · AETHERMESH-02 · DOI 10.5281/zenodo.24038038
Implementation ✅ Built (src/aethermesh/, 15 modules)
Tests ✅ 107 passed, 79% coverage
Experiments ✅ 3/3 completed (simulated data)
PyPI package ✅ Published
Real-world deployment None; no deployed system has been benchmarked
Theorems 1–3 Stated with proof sketches; not machine-checked; conditional on A1–A6
Byzantine evaluation Limited to malformed deltas
Third-party claims As reported by cited sources; not independently verified
Review status Not peer reviewed
Reconciliation notes (v1.0.0 departures from the supplied draft material)
  1. Theorem status — labeled as sketches, not “Proven”.
  2. Delay assumption — “bounded message delay” replaced by fair-lossy channels (A1).
  3. Admission determinism — A6 and Section 3.3.4 added.
  4. Theorem 3 — scope clarified to predicate-detectable invalid deltas; n/3 bound placed in the quorum-based part with a Chernoff–Hoeffding bound.
  5. Latency bound — the 110 ms estimate does not match the experimental result across sizes; text says so.
  6. Scaling claim — “linear with log(n)” not supported by the five reported points.
  7. Deadlock elimination / 100% blocking — largely from design and from the class of faults injected; denominators not supplied.
  8. Figures — the five supplied figures were redrawn; Figures 6–9 are supplementary.
  9. Conclusion wording — softened to match the evidence.
  10. References — assembled from knowledge; verification before submission recommended.

Catalogues: 50 open questions (Q1–Q50) across formal analysis, state and storage, gossip and performance, Byzantine tolerance and trust, integration with other layers, and evaluation method; 52 design decisions (D1–D52). See Appendices B and C of the paper.


🌍 Platforms & Mirrors

Platform URL Role Status
GitHub gitdeeper15/aethermesh Source code, issues, PRs ✅ Active
GitLab gitlab.com/gitdeeper15/aethermesh Mirror repository ✅ Active
Codeberg codeberg.org/gitdeeper15/aethermesh Mirror repository ✅ Active
Bitbucket bitbucket.org/gitdeeper15/aethermesh Mirror repository ✅ Active
PyPI pypi.org/project/aethermesh Python package (2.0.0) ✅ Published
Zenodo 10.5281/zenodo.24038038 Citable DOI, paper archive ✅ Published
OSF 10.17605/OSF.IO/9PE5V Registration ✅ Published
Website aethermesh-web.netlify.app Live documentation ✅ Active
ORCID 0009-0003-8903-0029 Author identity ✅ Active

🗂️ Project Structure

Click to expand the repository tree
AetherMesh/
├── src/
│   └── aethermesh/                 # Reference implementation (v2.0.0)
│       ├── __init__.py
│       ├── __version__.py
│       ├── models.py               # Delta, Replica, Signature, Verdict, DeltaKind
│       ├── cli.py
│       ├── py.typed
│       ├── crdt/
│       │   ├── semilattice.py
│       │   └── delta_state.py
│       ├── gossip/
│       │   ├── protocol.py
│       │   └── peer_sampling.py
│       ├── bft/
│       │   ├── provenance.py
│       │   ├── invariants.py
│       │   └── semantic_matrix.py
│       ├── admission/
│       │   └── pipeline.py
│       └── simulation/
│           ├── network.py
│           ├── node.py
│           └── testbed.py
├── tests/                          # 107 tests, 79% coverage
│   ├── test_models.py
│   ├── test_crdt.py
│   ├── test_gossip.py
│   ├── test_bft.py
│   ├── test_admission.py
│   └── test_simulation.py
├── experiments/                    # 3 experiments
│   ├── convergence_latency/
│   ├── conflict_resolution/
│   └── fault_resilience/
├── docs/
│   ├── figures/
│   │   ├── Fig1_Tripartite_Architecture.png
│   │   ├── Fig2_CRDT_Join_Semilattice.png
│   │   ├── Fig3_Gossip_Propagation.png
│   │   ├── Fig4_BFT_Validation.png
│   │   ├── Fig5_Aether_Family.png
│   │   ├── Fig6_Scaling_Analysis.png
│   │   ├── Fig7_Gossip_Exchange.png
│   │   ├── Fig8_Node_Anatomy.png
│   │   └── Fig9_Partition_Healing.png
│   └── v1.0.0/                     # 8 markdown files from the paper
├── PUBLICATION/
│   └── AetherMesh_Research_Paper.pdf
├── REPORTS/
│   └── v2.0.0/
│       └── report.md
├── DATA/
├── ANALYSIS/
├── EXTERNAL_REVIEW/
├── VALIDATION/
├── AUTHORS.md
├── CHANGELOG.md
├── CITATION.cff
├── CONTRIBUTING.md
├── INVENTORY.md
├── LICENSE
├── PROJECT_SUMMARY.txt
├── README.md
├── VERSION
├── manifest.json
├── netlify.toml
├── pyproject.toml
├── requirements.txt
├── scientific_state.json
└── upload_aethermesh.py

🕓 Version History

Version Release Focus Status
v2.0.0 2026-11-08 (release) Reference implementation: 15 modules, 107 tests (79%), 3 experiments, PyPI 2.0.0 ✅ Released
v1.0.0 2026-11 (release) Formalization: 4 definitions, 3 theorems, 6 assumptions, 3 pillars, 9 figures ✅ Released
(planned) 2027+ Real-world evaluation, mechanized proofs, extended Byzantine models ⏳ Not executed

v2.0.0: reference implementation of the v1.0.0 architecture. 15 modules, 107 tests, 79% coverage, 3 reproducible experiments. No real-world deployment evaluated.


📖 Citation

Primary Manuscript — AetherMesh v1.0.0

@techreport{baladi2026aethermesh,
  author       = {Baladi, Samir},
  title        = {AetherMesh: Decentralized Peer-to-Peer Agent Synchronization and State CRDTs for Autonomous Multi-Agent Systems},
  institution  = {Ronin Institute / Rite of Renaissance},
  type         = {Research Paper},
  year         = {2026},
  month        = {November},
  version      = {1.0.0},
  doi          = {10.5281/zenodo.24038038},
  url          = {https://doi.org/10.5281/zenodo.24038038},
  note         = {Formal Architecture Proposal with Simulated Evaluation --- No Real-World Deployment Benchmarked.}
}

Software — AetherMesh v2.0.0

@software{baladi2026aethermesh_v2,
  author       = {Baladi, Samir},
  title        = {{AetherMesh} v2.0.0: Reference Implementation of Decentralized Peer-to-Peer Agent Synchronization and State CRDTs},
  year         = {2026},
  month        = {November},
  publisher    = {PyPI},
  version      = {2.0.0},
  doi          = {10.5281/zenodo.24038038},
  url          = {https://pypi.org/project/aethermesh/},
  note         = {Reference implementation. Available via pip install aethermesh==2.0.0.}
}
Related work — AetherGit (Storage Layer)
@software{baladi2026aethergit,
  author       = {Baladi, Samir},
  title        = {{AetherGit}: Scalable Source Control for Autonomous AI Agents},
  year         = {2026},
  month        = {November},
  version      = {1.0.0},
  doi          = {10.5281/zenodo.23966896},
  url          = {https://doi.org/10.5281/zenodo.23966896}
}
Related work — AetherFlow (Integration Layer)
@techreport{baladi2026aetherflow,
  author       = {Baladi, Samir},
  title        = {AetherFlow: Automated Post-Merge Verification and Dynamic Conflict Resolution in Multi-Agent Programming Environments},
  institution  = {Ronin Institute / Rite of Renaissance},
  type         = {Research Paper},
  year         = {2026},
  month        = {November},
  version      = {1.0.0},
  doi          = {10.5281/zenodo.23979129},
  url          = {https://doi.org/10.5281/zenodo.23979129}
}
Related work — AetherProof (Verification Layer)
@techreport{baladi2026aetherproof,
  author       = {Baladi, Samir},
  title        = {AetherProof: Autonomous Formal Verification and Invariant Synthesis for Multi-Agent Software Ecosystems},
  institution  = {Ronin Institute / Rite of Renaissance},
  type         = {Research Paper},
  year         = {2026},
  month        = {November},
  version      = {1.0.0},
  doi          = {10.5281/zenodo.24013124},
  url          = {https://doi.org/10.5281/zenodo.24013124}
}

👤 Author

Samir Baladi Interdisciplinary AI Researcher — Ronin Institute / Rite of Renaissance

Research Area Distributed Systems / Software Engineering / Formal Methods
Research Domain CRDTs, Epidemic Gossip, Byzantine Fault Tolerance, Decentralized Synchronization, Eventual Consistency, Agentic Software Engineering
Research Type Formal Architecture Proposal + Reference Implementation
📧 Email gitdeeper@gmail.com
🔗 ORCID 0009-0003-8903-0029
🐙 GitHub gitdeeper15/aethermesh
🦊 GitLab gitlab.com/gitdeeper15/aethermesh
🟦 Codeberg codeberg.org/gitdeeper15/aethermesh
🪣 Bitbucket bitbucket.org/gitdeeper15/aethermesh
🐝 PyPI pypi.org/project/aethermesh
🌐 Official Site aethermesh-web.netlify.app

⚖️ License

Scope License
Code MIT License — Copyright © 2026 Samir Baladi
Documentation, manuscript, and figures CC-BY-4.0
MIT License — full text
MIT License

Copyright (c) 2026 Samir Baladi

Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:

The above copyright notice and this permission notice shall be included in all
copies or substantial portions of the Software.

AetherMesh — Program Manuscript v2.0.0 (Reference Implementation)

© 2026 Samir Baladi — Ronin Institute / Rite of Renaissance — MIT (code) + CC-BY-4.0 (docs)

Zenodo · Website · PyPI (publishing) · OSF: 10.17605/OSF.IO/9PE5V

Metadata

Release files for aethermesh 2.0.0

For a detailed explanation of source distributions (sdists) and built distributions (wheels), please see the package formats documentation.

Source distribution (sdist)

Source distribution for aethermesh 2.0.0
File Size Uploaded Provenance Actions
aethermesh-2.0.0.tar.gz 76.6 kB Without provenance Details for aethermesh-2.0.0.tar.gz

Built distribution (wheel)

Table of built distributions (wheels) for aethermesh 2.0.0
File Interpreter ABI Platform Actions
aethermesh-2.0.0-py3-none-any.whl Python 3 none any Details for aethermesh-2.0.0-py3-none-any.whl

Total release size: 130.5 kB

Release files / aethermesh-2.0.0.tar.gz

Download URL aethermesh-2.0.0.tar.gz
Size 76.6 kB
Tags Source
SHA-256 checksum
How to use checksums
777cbb5157c751f1fa0a141061970eb4457b92b3cbe34f44df20e419e22c5349
BLAKE2b-256 checksum
How to use checksums
f2a280a0eca271814fd0d47d3249d906a7c1578b753eb571b5d96f05c568a7be
Upload date
Uploaded using Trusted Publishing?
What is trusted publishing?
No
Uploaded via aethermesh-uploader/2.0.0

Release files / aethermesh-2.0.0-py3-none-any.whl

Download URL aethermesh-2.0.0-py3-none-any.whl
Size 53.9 kB
Tags Python 3
SHA-256 checksum
How to use checksums
d5e32cdc5608e1470fdeaf304ccfe6e522deaa83086086d924ef0388d162a8be
BLAKE2b-256 checksum
How to use checksums
6bfa5ff116de26b9610bf03f788b6f02ff116d09193ae787490516bf7112493b
Upload date
Uploaded using Trusted Publishing?
What is trusted publishing?
No
Uploaded via aethermesh-uploader/2.0.0

Security for aethermesh 2.0.0

Provenance

Provenance describes where a file came from. On PyPI, provenance is shared via attestations, which provide a verifiable record of the build or publishing details. View details, limitations and caveats.

No provenance found

None of the files in this release were uploaded with provenance metadata.

A note on package security

PyPI is a repository for distributing packages, not a service for auditing them. While third-party security researchers and our staff do their best to detect and remove malicious packages, PyPI cannot guarantee the quality, security or suitability of any given package.

To learn more about protecting yourself from malicious actors, visit our package security documentation.

Release history Release notifications | RSS feed

This release

2.0.0 This release

2 release files No provenance

Anthropic, PBC Visionary sponsor Bloomberg Visionary sponsor Hudson River Trading Visionary sponsor Meta Visionary sponsor NVIDIA Visionary sponsor Microsoft Sustainability sponsor Depot Continuous Integration AWS Cloud computing and Security Sponsor Datadog Monitoring Fastly CDN Google Download Analytics Sentry Error logging StatusPage Status page