aeon-ai

aeon-ai

Self-reflective symbolic AI — real-time phase-transition detection & native self-reflection loop — GenesisAeon v0.2.0

”A system that thinks — a memory that sings.”

aeon-ai is the core Python library of the GenesisAeon project: a fractal, self-reflective AI architecture that integrates fieldtheory Lagrangian dynamics, mirror-machine cognition, symbolic sigil activation, and CREP quality evaluation into a unified pipeline.

---

Theoretical Foundation

Fieldtheory Lagrangian — AeonLayer

The core weighting dynamics are governed by the fieldtheory Lagrangian:

$$L(S_A, S_V, \delta, t) = \frac{S_A \cdot S_V}{S_A + S_V} - \frac{1 + \delta}{t^2}$$

The first term is the harmonic mean of the two signal amplitudes, encoding inter-channel resonance. The second term is a temporal penalty that decays as $t^{-2}$, reflecting the dissipation of symbolic tension over time.

Analytical gradients:

$$\frac{\partial L}{\partial S_A} = \frac{S_V^2}{(S_A + S_V)^2}, \quad \frac{\partial L}{\partial S_V} = \frac{S_A^2}{(S_A + S_V)^2}, \quad \frac{\partial L}{\partial t} = \frac{2(1+\delta)}{t^3}$$

---

CREP Quality Metric — CREPEvaluator

CREP is the four-dimensional symbolic quality metric from the unified-mandala stack:

$$\text{CREP} = \frac{4}{\dfrac{1}{C} + \dfrac{1}{R} + \dfrac{1}{E} + \dfrac{1}{P}}$$

Each dimension is a float in $[0, 1]$; the combined score is their harmonic mean.

A weighted variant is also available:

$$\text{CREP}w = \sum{i \in {C,R,E,P}} w_i \cdot \text{dim}_i, \quad \sum w_i = 1$$

---

UTAC-Logistic — MirrorCore

The Universal Transformation and Adaptation Coefficient governs the INTEGRATE phase of the Mirror Machine:

$$\text{UTAC}(x) = \frac{L}{1 + e^{-k(x - x_0)}}$$

---

Mirror Machine Pipeline

The self-reflection loop processes every input through four canonical phases:

INIT → REFLECT → INTEGRATE → EMIT

1. INIT — Receive raw signal, compute initial entropy
2. REFLECT — Apply $n$-deep recursive tanh-mirror transformation
3. INTEGRATE — Merge with context memory via UTAC-Logistic
4. EMIT — Produce observable output, update persistent memory

---

Phase-Transition Detection — PhaseDetector (v0.2.0)

Real-time detection of Mirror Machine phase transitions using a UTAC-Logistic trigger:

$$\Phi_{\text{trigger}}(H) = \frac{L}{1 + e^{-k(H - H_0)}}$$

A collapse is detected when consecutive output values converge:

$$\Delta_{\text{collapse}} = \left| x_n - x_{n-1} \right| < \epsilon_{\text{stab}}$$

Three transition types are emitted: FORWARD, COLLAPSE, UTAC_TRIGGER, FORCED.

---

Native Self-Reflection Loop — SelfReflector (v0.2.0)

A closed-loop iterative engine coupling CREP score, Lagrangian gradient, and Sigillin bridges over at most 7 iterations with convergence check:

$$S_A^{(i+1)} = S_A^{(i)} + \eta \cdot \frac{\partial L}{\partial S_A}$$

$$S_V^{(i+1)} = S_V^{(i)} + \eta \cdot \frac{\partial L}{\partial S_V}$$

$$\text{convergence: } \left|\text{CREP}^{(i)} - \text{CREP}^{(i-1)}\right| < \varepsilon$$

Where $\eta$ is the UTAC-modulated step size and CREP is evaluated at each iteration.

---

Architecture Overview

┌────────────────────────────────────────────────────────────────┐
│                        Orchestrator v0.2.0                      │
│                                                                  │
│  FieldBridge ──▶ CosmicMoment                                   │
│       │                │                                         │
│       ▼                ▼                                         │
│  AeonLayer(δ, t) ──▶ Lagrangian L                               │
│       │                                                          │
│       ▼                                                          │
│  MirrorCore ──▶ INIT → REFLECT → INTEGRATE → EMIT               │
│       │                │                                         │
│       ▼                ▼                                         │
│  PhaseDetector ──▶ PhaseTransitionEvent[]  (v0.2.0)             │
│       │                                                          │
│       ▼                                                          │
│  CREPEvaluator ──▶ CREPScore(C, R, E, P)                        │
│       │                                                          │
│       ▼                                                          │
│  SigillinBridge ──▶ { sigil_id: activation_score }              │
└────────────────────────────────────────────────────────────────┘

SelfReflector (v0.2.0) — closed-loop coupling (max 7 iterations):
  AeonLayer → MirrorCore → CREPEvaluator ← SigillinBridge
       ↑_______________gradient update__________________|

---

Installation

pip install aeon-ai

With the full GenesisAeon stack (mirror-machine, fieldtheory, mandala-visualizer, …):

pip install 'aeon-ai[stack]'

---

Quick Start

from aeon_ai.agents import Orchestrator

# Full pipeline via Orchestrator
orch = Orchestrator(delta=0.1, mirror_depth=3)
result = orch.run(
    s_a=0.8,
    s_v=0.6,
    sigil_text=”mirror aeon genesis”,
)

print(f”Lagrangian L     = {result.lagrangian_out:.4f}”)
print(f”Reflection out   = {result.reflection.output_val:.4f}”)
print(f”Final output     = {result.final_output:.4f}”)
print(f”CREP score       = {result.crep_score.score:.4f}”)
print(f”Active sigils    = {result.sigil_activations}”)

Individual components

from aeon_ai import AeonLayer, lagrangian

# Direct Lagrangian computation
L = lagrangian(s_a=0.8, s_v=0.6, delta=0.1, t=1.0)

# AeonLayer (with optional advanced_weighting_systems base)
layer = AeonLayer.from_advanced_weighting_systems(delta=0.1)
output = layer.forward(s_a=0.8, s_v=0.6, t=1.0)
grad   = layer.gradient(s_a=0.8, s_v=0.6, t=1.0)

from aeon_ai import MirrorCore

core = MirrorCore(depth=3, utac_growth=2.0)
state = core.reflect(0.7, entropy=0.4)
print(state.output_val, state.entropy)

from aeon_ai import CREPEvaluator

ev = CREPEvaluator()
score = ev.evaluate(signal=[0.3, 0.7, 0.5, 0.9], text=”aeon of mirrors”)
print(score)  # CREPScore(C=..., R=..., E=..., P=..., score=...)

from aeon_ai import SigillinBridge

bridge = SigillinBridge()
activations = bridge.activate(“the mirror reflects the genesis of aeon”)
expanded    = bridge.poetic_expansion(“aeon rises”)

---

CLI

# Basic reflection run
aeon reflect --models trans,cnn --sigil “mirror aeon genesis” --entropy 0.4

# With custom signal parameters
aeon reflect --s-a 0.9 --s-v 0.5 --delta 0.2 --time-step 2.0

# With mandala visualisation + sonification (requires [stack])
aeon reflect --sigil “origin seed” --entropy 0.6 --visualize

# Machine-readable JSON output
aeon reflect --sigil “mirror” --json

# List all registered sigils
aeon sigils

# Package and stack status
aeon info

---

Module Reference

Full API documentation: genesisaeon.github.io/aeon-ai

---

Development

git clone https://github.com/GenesisAeon/aeon-ai
cd aeon-ai
pip install -e '.[dev]'

# Tests (99%+ coverage required)
pytest

# Linting
ruff check src tests
ruff format --check src tests

# Docs
mkdocs serve

---

GenesisAeon Stack

aeon-ai is designed to interoperate with the full GenesisAeon ecosystem:

All packages are optional; aeon-ai operates standalone with its own implementations.

---

Citation

If you use aeon-ai in academic work, please cite:

@software{aeon_ai_2025,
  author    = {GenesisAeon},
  title     = {aeon-ai: Real-time phase-transition detection and native self-reflection loop},
  version   = {0.2.0},
  year      = {2026},
  doi       = {10.5281/zenodo.19132293},
  url       = {https://github.com/GenesisAeon/aeon-ai}
}

DOI: 10.5281/zenodo.19132293

---

License

This repository is dual-licensed:

• Source code — GNU General Public License v3.0 or later (GPL-3.0-or-later)
• Documentation — Creative Commons Attribution 4.0 International (CC BY 4.0)

See LICENSE for the full split and scope of each license.