Reference · v2.0.0 · Reference Implementation

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.

Project identity
FieldValue
Full titleAetherOrchestrate: A Falsification-First Investigation of Decentralized Orchestration in the Aether Family
SubtitleA Falsification-First Investigation of Goal Decomposition, Task Assignment, Scheduling, Dependency Tracking, and Routing in Multi-Agent Software Ecosystems
Version2.0.0 (paper v0.1.0 + reference implementation)
StageReference Implementation (preliminary results, simulated)
LicenseMIT (code) · CC-BY-4.0 (docs, manuscript)
DomainDistributed Systems / Software Engineering / Multi-Agent Coordination
DOI (Zenodo)10.5281/zenodo.24095399
DOI (Figshare)10.6084/m9.figshare.34963687
OSF10.17605/OSF.IO/2F7TZ
PyPIPublished
Record IDAETHERORCHESTRATE-02

"AetherOrchestrate is a candidate, not a result."

Installation

The PyPI package (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

All of this is hypothesis: a specification-level description of what an orchestration dimension might contain.
The five layers of AetherOrchestrate
LayerQuestionStatus
L1 — DecompositionHow is a goal broken into tasks?Implemented
L2 — AssignmentWhich agent executes each task?Implemented
L3 — SchedulingWhen does each task run?Implemented
L4 — Dependency TrackingWhat are the dependencies between tasks?Implemented
L5 — RoutingHow 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)

Falsification status of the five failure conditions
IDClaim under testStatus
F1Non-redundancyNot falsified (R2, R4, R6 partly covered)
F2Orthogonality to verificationNot falsified (narrowly)
F3Boundary with governanceNot falsified (decentralized setting)
F4DecentralizabilityNot falsified (with residuals)
F5Observable benefitUntested
"Not falsified" is a weaker status than "confirmed". F5 (observable benefit) remains untested. Neither the implementation nor the simulated experiments promote "not falsified" to "confirmed".

Propositions (P1–P2)

Propositions and their proof status
#PropositionStatus
P1Determinism of Local DecompositionProof sketch (not machine-checked)
P2Irreducible Coordination WindowProof sketch (not machine-checked)
Both propositions are stated with proof sketches; neither is machine-checked. They are conditional on assumptions A1–A6 (inherited from AetherMesh) and bear directly on F4 (decentralizability).

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

Validation checklist (v2.0.0)
CheckResult
Formal Definitions4 (all defined)
Propositions2 (stated with proof sketches)
Failure Conditions5 (F1–F5)
Requirements6 (R1–R6)
Orchestrate Layers5 (Decomposition, Assignment, Scheduling, Dependency Tracking, Routing)
Figures6 (all generated)
References36 (in paper); 15 (in Zenodo record)
Open Questions20 (Q1–Q20)
Evaluation Metrics9 (M1–M9)
Baselines5 (B1–B5)
Scenarios6 (S1–S6)
Threats to Validity7
Python Modules7 (reference implementation)
Tests39 passed
Experiments3/3 completed (simulated)
PyPI PackagePublished
Real-world deploymentNot evaluated
Causal ClaimsNone (argument only)

Experimental Results (v2.0.0)

Results from experiments/*/results.json (simulated data)
#ExperimentMetricsResult
1Decomposition AccuracyM110 goals; mean task count = 1.00; all acyclic
2Assignment FairnessM4Jain index = 0.8803 (expected 0.9174; 4% deviation)
3Coordination WindowM85 scenarios; all positive; min 0.008 s, max 7.5 s
Simulation only. No generalization beyond simulation is claimed. Baselines B1–B5 and scenarios S1–S6 are not evaluated in v2.0.0.

Scope & Limits

What AetherOrchestrate v2.0.0 supports:

What AetherOrchestrate does not support:

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

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). 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}
}
Status note (v2.0.0): This is a research article plus reference implementation (v2.0.0) of the orchestration architecture for the Aether family. A reference implementation is built (7 modules, 39 tests) and 3 experiments are completed on simulated data. No real-world deployment has been evaluated. F1–F4 are not falsified by the implementation or the experiments, but they are also not confirmed. F5 (observable benefit) remains untested. Propositions P1–P2 remain proof sketches (not machine-checked) and are conditional on assumptions A1–A6. The paper is not peer reviewed. AetherOrchestrate is a candidate, not a result.