Documentation
A complete reference for AetherOrchestrate v2.0.0 — architecture, formal definitions, failure conditions, and reference implementation
A research article plus reference implementation (v2.0.0) of the orchestration architecture for the Aether family. The manuscript is published on Zenodo and Figshare. The OSF registration is published. A reference implementation is built (7 modules, 39 tests) and 3 experiments are completed on simulated data. No real-world deployment has been evaluated.
Table of Contents
Overview
AetherOrchestrate is a structured investigation of whether a decentralized orchestration gap genuinely exists in the Aether family, or whether it is already covered by the existing six dimensions: AetherGit (storage), AetherFlow (integration), AetherProof (verification), AetherMesh (distribution), AetherGovern (governance), and AetherRuntime (runtime assurance). It is the seventh functional dimension (provisional) of the Aether family. v2.0.0 adds a reference implementation; no real-world deployment is claimed.
| Field | Value |
|---|---|
| Full title | AetherOrchestrate: A Falsification-First Investigation of Decentralized Orchestration in the Aether Family |
| Subtitle | A Falsification-First Investigation of Goal Decomposition, Task Assignment, Scheduling, Dependency Tracking, and Routing in Multi-Agent Software Ecosystems |
| Version | 2.0.0 (paper v0.1.0 + reference implementation) |
| Stage | Reference Implementation (preliminary results, simulated) |
| License | MIT (code) · CC-BY-4.0 (docs, manuscript) |
| Domain | Distributed Systems / Software Engineering / Multi-Agent Coordination |
| DOI (Zenodo) | 10.5281/zenodo.24095399 |
| DOI (Figshare) | 10.6084/m9.figshare.34963687 |
| OSF | 10.17605/OSF.IO/2F7TZ |
| PyPI | Published |
| Record ID | AETHERORCHESTRATE-02 |
"AetherOrchestrate is a candidate, not a result."
Installation
2.0.0) is the reference implementation. It is not a production system. The v0.1.0 paper remains the authoritative hypothesis record.
# From PyPI (published)
pip install aetherorchestrate
# From source (development)
git clone https://github.com/gitdeeper15/aetherorchestrate.git
cd aetherorchestrate
pip install -e ".[dev]"
# Run tests
pytest
# Run experiments
python experiments/decomposition_accuracy/run.py
python experiments/assignment_fairness/run.py
python experiments/coordination_window/run.py
# CLI
aetherorchestrate info
aetherorchestrate verify
Requires Python 3.9+. Runtime dependency: cryptography >= 41.0.
Architecture — The Five Orchestrate Layers
| Layer | Question | Status |
|---|---|---|
| L1 — Decomposition | How is a goal broken into tasks? | Implemented |
| L2 — Assignment | Which agent executes each task? | Implemented |
| L3 — Scheduling | When does each task run? | Implemented |
| L4 — Dependency Tracking | What are the dependencies between tasks? | Implemented |
| L5 — Routing | How is each task routed to its executor? | Implemented |
Coordination lifecycle: goal → decompose → assign → schedule → route → execute → complete. Each arrow is an append to replicated state.
Task state machine: each state has defined entry and exit conditions; exception transitions represent recovery paths (failure, timeout, revocation).
Formal Definitions
Definition 1 — Goal Decomposition. A tuple (T, <, κ, Acc) where T is a finite set of tasks, < is a strict partial order (irreflexive and transitive), κ assigns required capabilities, and Acc is an acceptance predicate over completed tasks. A decomposition is well-formed if < is acyclic, κ is total on T, and every task names the goal.
D = (T, <, κ, Acc)
Definition 2 — Eligibility and Preferred Assignee. For agent a and task t, the eligibility predicate is Elig(a, t; S) = [κ(t) ⊆ cap_a(S)] ∧ Auth(a, t; S) ∧ ¬Revoked(a; S). The preferred assignee is the eligible agent minimizing h(t, a), where h is a hash function modelled as a random oracle.
Elig(a, t; S) = [κ(t) ⊆ cap_a(S)] ∧ Auth(a, t; S) ∧ ¬Revoked(a; S)
Assign(t; S) = arg min_{a ∈ E(t; S)} h(t, a)
Definition 3 — Dependency Graph. The dependency graph of S is G(S) = (T(S), E(S), τ), where T(S) is the set of recorded tasks, E(S) the set of recorded edges, and τ maps edges to types {FS, SS, data}. The materialized graph G*(S) is G(S) minus a deterministic cycle-breaking set ρ(G(S)).
G(S) = (T(S), E(S), τ) G*(S) = G(S) \ ρ(G(S))
Definition 4 — Coordination Window. The coordination window at node X for fault φ is Δt_window(X, φ) = t_enforced(X, φ) − t_detect(φ). It is bounded below by the time to form the corrective record, propagate it, and verify it.
Δt_window(X, φ) ≥ t_form + t_prop(X) + t_queue(X) + t_verify(X)
Failure Conditions (F1–F5)
| ID | Claim under test | Status |
|---|---|---|
| F1 | Non-redundancy | Not falsified (R2, R4, R6 partly covered) |
| F2 | Orthogonality to verification | Not falsified (narrowly) |
| F3 | Boundary with governance | Not falsified (decentralized setting) |
| F4 | Decentralizability | Not falsified (with residuals) |
| F5 | Observable benefit | Untested |
Propositions (P1–P2)
| # | Proposition | Status |
|---|---|---|
| P1 | Determinism of Local Decomposition | Proof sketch (not machine-checked) |
| P2 | Irreducible Coordination Window | Proof sketch (not machine-checked) |
Proposition 1 (restated). If (a) admission of a decomposition delta is a deterministic function of the delta and its causal closure, and in particular does not read the verifying node's local model; (b) decomposition deltas are inflationary additions to S; and (c) each node selects the canonical decomposition by a deterministic rule, then (1) admission satisfies A6, and (2) once all deltas are delivered, every honest node selects the same canonical decomposition.
Proposition 2. In any decentralized coordination protocol, the coordination window at an honest node is bounded below by the time to form the corrective record, propagate it, and verify it. The window is strictly positive.
Mathematical form (P2).
Δt_window(X, φ) ≥ t_form + t_prop(X) + t_queue(X) + t_verify(X)
Jain fairness (M4).
J = (Σ x_i)² / (m · Σ x_i²) ≈ n / (n + m − 1)
Validation
| Check | Result |
|---|---|
| Formal Definitions | 4 (all defined) |
| Propositions | 2 (stated with proof sketches) |
| Failure Conditions | 5 (F1–F5) |
| Requirements | 6 (R1–R6) |
| Orchestrate Layers | 5 (Decomposition, Assignment, Scheduling, Dependency Tracking, Routing) |
| Figures | 6 (all generated) |
| References | 36 (in paper); 15 (in Zenodo record) |
| Open Questions | 20 (Q1–Q20) |
| Evaluation Metrics | 9 (M1–M9) |
| Baselines | 5 (B1–B5) |
| Scenarios | 6 (S1–S6) |
| Threats to Validity | 7 |
| Python Modules | 7 (reference implementation) |
| Tests | 39 passed |
| Experiments | 3/3 completed (simulated) |
| PyPI Package | Published |
| Real-world deployment | Not evaluated |
| Causal Claims | None (argument only) |
Experimental Results (v2.0.0)
| # | Experiment | Metrics | Result |
|---|---|---|---|
| 1 | Decomposition Accuracy | M1 | 10 goals; mean task count = 1.00; all acyclic |
| 2 | Assignment Fairness | M4 | Jain index = 0.8803 (expected 0.9174; 4% deviation) |
| 3 | Coordination Window | M8 | 5 scenarios; all positive; min 0.008 s, max 7.5 s |
Scope & Limits
What AetherOrchestrate v2.0.0 supports:
- A falsification-first methodology with five failure conditions (F1–F5).
- A comparison of three candidate capabilities (orchestration, governance, runtime assurance).
- A hypothesized five-layer orchestrate architecture (decomposition, assignment, scheduling, dependency tracking, routing).
- Two propositions with proof sketches (determinism of local decomposition; irreducible coordination window).
- 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 (7 modules, 39 tests, 3 experiments).
- Open manuscript (CC-BY-4.0).
What AetherOrchestrate does not support:
- Real-world deployment (not evaluated).
- Causal claims (argument only).
- Machine-checked proofs (P1–P2 are proof sketches; conditional on A1–A6).
- Any security property in practice (P1–P2 concern determinism and monotonicity, not resistance to attack).
- Strong exclusivity (I3′) — requires bounded agreement, not implemented.
- Completion readiness (I5) — requires verification layer, not implemented.
- Canonical convergence under full delivery (I7) — requires full-delivery simulation, not implemented.
- A production-grade system (the reference implementation is preliminary).
Design philosophy. AetherOrchestrate is a research investigation with a reference implementation, not a production system. 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, triple, or quadruple project) 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). AetherOrchestrate: A Falsification-First Investigation of Decentralized Orchestration in the Aether Family (Version 0.1.0). Zenodo. https://doi.org/10.5281/zenodo.24095399
APA (software): Baladi, S. (2026). AetherOrchestrate v2.0.0: Reference Implementation of the Falsification-First Orchestration Architecture (Version 2.0.0). PyPI. https://pypi.org/project/aetherorchestrate/
@techreport{baladi2026aetherorchestrate,
author = {Baladi, Samir},
title = {AetherOrchestrate: A Falsification-First Investigation of
Decentralized Orchestration in the Aether Family},
institution = {Ronin Institute / Rite of Renaissance},
type = {Research Paper},
year = {2026},
month = {November},
version = {0.1.0},
doi = {10.5281/zenodo.24095399},
url = {https://doi.org/10.5281/zenodo.24095399}
}
@software{baladi2026aetherorchestrate_v2,
author = {Baladi, Samir},
title = {{AetherOrchestrate} v2.0.0: Reference Implementation of the
Falsification-First Orchestration Architecture},
year = {2026},
month = {November},
publisher = {PyPI},
version = {2.0.0},
doi = {10.5281/zenodo.24095399},
url = {https://pypi.org/project/aetherorchestrate/},
note = {Reference implementation. Available via pip install aetherorchestrate.}
}
@misc{baladi2026aetherorchestrate_figshare,
author = {Baladi, Samir},
title = {AetherOrchestrate: A Falsification-First Investigation of
Decentralized Orchestration in the Aether Family},
year = {2026},
month = nov,
publisher = {Figshare},
doi = {10.6084/m9.figshare.34963687},
url = {https://doi.org/10.6084/m9.figshare.34963687},
note = {Preprint. Archived version of the AetherOrchestrate manuscript.}
}
@misc{baladi2026aetherorchestrate_osf,
author = {Baladi, Samir},
title = {{AetherOrchestrate: A Falsification-First Investigation of
Decentralized Orchestration in the Aether Family}},
year = {2026},
month = nov,
day = {10},
publisher = {OSF},
doi = {10.17605/OSF.IO/2F7TZ},
url = {https://doi.org/10.17605/OSF.IO/2F7TZ},
note = {OSF Preregistration. Associated project: https://osf.io/8beur}
}