Documentation

Table of Contents

• Overview
• Installation
• Architecture (Five Layers)
• Formal Definitions
• Failure Conditions (F1–F5)
• Propositions (P1–P2)
• Validation
• Experimental Results (v2.0.0)
• Scope & Limits
• Threats and Limitations
• Citation

Overview

AetherRuntime is a structured investigation of whether a runtime-assurance gap genuinely exists in the Aether family, or whether it is already covered by the existing five dimensions: AetherGit (storage), AetherFlow (integration), AetherProof (verification), AetherMesh (decentralization), and AetherGovern (governance). It is the sixth functional dimension (provisional) of the Aether family. v2.0.0 adds a reference implementation; no real-world deployment is claimed.

"AetherRuntime is a candidate, not a result."

Installation

# From PyPI (published)
pip install aetherruntime-arch

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

# Run tests
pytest

# Run experiments
python experiments/detection_accuracy/run.py
python experiments/halt_window/run.py
python experiments/recovery_correctness/run.py

# CLI
aetherruntime info
aetherruntime verify

Requires Python 3.9+. Runtime dependency: cryptography >= 41.0.

Architecture — The Five Runtime Layers

Runtime lifecycle: observe → detect → classify → contain → halt → recover. Schematic, not a protocol specification.

Runtime state machine: each state has defined entry and exit conditions; exception transitions represent recovery paths.

Formal Definitions

Definition 1 — Telemetry Stream. A time-stamped sequence of observations from a running agent. Categories: CPU usage, memory usage, network I/O, syscall stream, and semantic action log.

telemetry = [(t, category, value), ...]

Definition 2 — Anomaly Predicate. A deterministic function of the telemetry stream and a baseline model that returns a boolean verdict (anomalous / not anomalous) together with a confidence score.

anomaly(telemetry, baseline) → (bool, confidence)

Definition 3 — Containment Policy. A record (target, level, restrictions, expiry) that specifies the containment level (L1–L4) applied to an anomalous agent, together with the restrictions (resource limits, access scope) and the expiry of the containment.

containment = (target, level, restrictions, expiry)

Definition 4 — Halt Order. A signed record (agent_id, reason, timestamp, proposer, approvals) that, when approved by a quorum of authorized nodes, requires every honest node to refuse further actions from the halted agent.

halt = (agent_id, reason, timestamp, proposer, approvals)

Failure Conditions (F1–F5)

Propositions (P1–P2)

Proposition 1 (mathematical form).

S_i(t+1) = S_i(t) ⊔ ⊔_{m ∈ M_i} m

∀ i, j, A_i(S_i) ∧ A_j(S_j) ⇒ (S_i ⊔ S_j) = (S_j ⊔ S_i)

Proposition 2 (mathematical form).

Δt_window = t_halt_enforced − t_detect
          = D_gossip(N, f) + t_queue + t_verify

Resource monitoring metric.

Ω_i(t) = ∫_0^t ( CPU_i(τ) + Memory_i(τ) + NetworkIO_i(τ) ) dτ > Θ_max

Validation

Experimental Results (v2.0.0)

Scope & Limits

What AetherRuntime 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 runtime architecture (monitoring, detection, containment, halt, recovery).
• Two propositions with proof sketches (determinism of local anomaly detection; irreducible halt 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 (16 modules, 60 tests, 3 experiments).
• Open manuscript (CC-BY-4.0).

What AetherRuntime 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).
• A small halt window (P2 establishes that the window is irreducible; its size is a property of the simulation).
• Implementability at acceptable cost (no production measurement exists).
• A resolution of accountability in a legal or organizational sense (it provides records, not responsibility).
• A production-grade system (the reference implementation is preliminary).

Design philosophy. AetherRuntime 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

Citation

APA (paper): Baladi, S. (2026). AetherRuntime: A Falsification-First Investigation of Runtime Assurance in the Aether Family (Version 0.1.0). Zenodo. https://doi.org/10.5281/zenodo.24078477

APA (software): Baladi, S. (2026). AetherRuntime v2.0.0: Reference Implementation of the Falsification-First Runtime Assurance Architecture (Version 2.0.0). PyPI. https://pypi.org/project/aetherruntime-arch/

@techreport{baladi2026aetherruntime,
  author       = {Baladi, Samir},
  title        = {AetherRuntime: A Falsification-First Investigation of
                  Runtime Assurance 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.24078477},
  url          = {https://doi.org/10.5281/zenodo.24078477}
}

@software{baladi2026aetherruntime_v2,
  author       = {Baladi, Samir},
  title        = {{AetherRuntime} v2.0.0: Reference Implementation of the
                  Falsification-First Runtime Assurance Architecture},
  year         = {2026},
  month        = {November},
  publisher    = {PyPI},
  version      = {2.0.0},
  doi          = {10.5281/zenodo.24078477},
  url          = {https://pypi.org/project/aetherruntime-arch/},
  note         = {Reference implementation. Available via pip install aetherruntime-arch.}
}

@misc{baladi2026aetherruntime_figshare,
  author       = {Baladi, Samir},
  title        = {AetherRuntime: A Falsification-First Investigation of
                  Runtime Assurance in the Aether Family},
  year         = {2026},
  month        = nov,
  publisher    = {Figshare},
  doi          = {10.6084/m9.figshare.34955746},
  url          = {https://doi.org/10.6084/m9.figshare.34955746},
  note         = {Preprint. Archived version of the AetherRuntime manuscript.}
}

@misc{baladi2026aetherruntime_osf,
  author       = {Baladi, Samir},
  title        = {{AetherRuntime: A Falsification-First Investigation of
                  Runtime Assurance in the Aether Family}},
  year         = {2026},
  month        = nov,
  day          = {9},
  publisher    = {OSF},
  doi          = {10.17605/OSF.IO/KZU7P},
  url          = {https://doi.org/10.17605/OSF.IO/KZU7P},
  note         = {OSF Preregistration. Associated project: https://osf.io/ft7ez}
}