README.md

# AETHER: A Self-Evolving Neuro-Symbolic Architecture for AGI

**v0.2.0 — Autonomous Mode**

AETHER (Adaptive Evolving Towards Higher-order Reasoning) is a unified self-evolving neuro-symbolic architecture that integrates symbolic and sub-symbolic computation within a dynamically self-modifying framework. This version runs **fully autonomously** with zero human-in-the-loop oversight — all safety, validation, and rollback decisions are handled by automated systems.

---

## Architecture Integration

AETHER synthesizes cutting-edge research from:

| Component | Source | Key Contribution |
|-----------|--------|-----------------|
| **Evolutionary Core** | AlphaEvolve (DeepMind, 2025) | MAP-Elites + island model + LLM code diffs for algorithm discovery |
| **Hierarchical Reasoning** | HiMAC (2026) | Macro-Policy / Micro-Policy co-evolution with iterative optimization |
| **Group Self-Evolution** | GEA (2026) | Performance-Novelty selection with experience sharing |
| **Tool Evolution** | Yunjue Agent (2026) | Manager/Executor/Developer/Integrator role decomposition + tool absorption |
| **AI Research Agent** | ASI-Evolve (2026) | 4-stage Researcher→Engineer→Analyzer→Database loop |
| **Co-Evolution** | CoMAS (2025) | Decentralized multi-agent co-evolution via interaction rewards |
| **Cognitive Architecture** | CoALA (2023) | Working/Episodic/Semantic/Procedural memory taxonomy |
| **Agentic Neural Networks** | ANN (2025) | Textual backpropagation across multi-agent layers |
| **Leader Training** | MLPO (2025) | Train single leader, peers untrained - efficient multi-agent RL |
| **Task-Driven Agents** | BabyAGI | Task creation / prioritization / execution loop |

---

## System Components (v0.2.0)

```
AETHER
├── Core (AetherCore)
│   ├── Neuro-Symbolic Fusion Gate      (learned attention weights)
│   ├── Recursive Evolution Loop        (generate→evaluate→select→mutate→validate→integrate)
│   └── AutoOversight System            (risk scoring + regression suite + auto-rollback)
├── Memory (CoALA-inspired)
│   ├── Working Memory                  (attention-based retrieval)
│   ├── Episodic Memory                 (experience buffer)
│   ├── Semantic Memory                 (world knowledge via KG)
│   └── Procedural Memory               (learned tools/skills)
├── Knowledge (PyG-style)
│   ├── RGCN Encoder                    (relational graph convolution)
│   ├── ComplEx Scorer                  (link prediction)
│   └── Symbolic Rule Engine            (forward chaining + multi-hop BFS)
├── Agents
│   ├── Hierarchical Agent                (HiMAC: Macro + Micro policy)
│   ├── Agent Orchestrator              (MLPO leader + dynamic routing)
│   ├── BabyAGI Loop                    (task-driven autonomy)
│   └── Textual Backpropagation         (Agentic NN update)
└── Evolution
    ├── MAP-Elites Archive                (quality-diversity)
    ├── Performance-Novelty Selection     (GEA)
    ├── Constrained Mutation            (AlphaEvolve)
    └── AutoOversight Gate              (replaces human-in-the-loop)
```

---

## What's New in v0.2.0 (Autonomous)

- **AutoOversight System** — Replaces all human-in-the-loop safety gates with automated regression suites, risk scoring, and auto-rollback. The system evaluates its own candidates via synthetic benchmarks before any integration.
- **Self-Sustained Evolution** — The evolution loop runs end-to-end without external API calls or human checkpoints. Fitness is evaluated against internal reasoning, memory, and knowledge graph benchmarks.
- **Temporal Memory with Attention** — Recency-weighted retrieval for long-horizon context across evolution generations.
- **Four-Agent Orchestration** — Researcher, Engineer, Analyzer, Integrator roles with learned routing weights.
- **Fully Runnable Standalone** — Single-file executable with only `torch`, `numpy`, and `networkx` dependencies.

---

## Quick Start (Autonomous)

```bash
pip install torch numpy networkx
python aether_autonomous.py
```

```python
from aether_autonomous import AetherCore, AetherConfig

# Initialize autonomous AETHER
config = AetherConfig(
    population_size=6,
    generations=5,
    mutation_rate=0.12,
    macro_policy_dim=128,
    micro_policy_dim=64,
    num_agents=4,
    kg_embedding_dim=64,
    kg_num_relations=10,
)

aether = AetherCore(config)

# Seed knowledge
aether.knowledge.add_fact("Intelligence", "requires", "Reasoning")
aether.knowledge.add_fact("Reasoning", "requires", "Memory")

# Neuro-symbolic query
result = aether.forward("Intelligence requires")
print(f"Symbolic weight: {result['symbolic_weight']:.3f}")
print(f"Neural weight:   {result['neural_weight']:.3f}")

# Fully autonomous evolution (no human oversight)
evolution_result = aether.evolve(num_generations=5)
print(f"Best fitness: {evolution_result['best_fitness']:.4f}")
print(f"Archive coverage: {evolution_result['archive_stats']['coverage']:.2%}")
```

---

## Original Modular System (v0.1.0)

The original modular implementation remains available in the `aether/` directory:

```python
from aether.core import AetherCore, AetherConfig

config = AetherConfig(
    population_size=8,
    mutation_rate=0.15,
    num_agents=4,
    enable_self_modification=True,
)
aether = AetherCore(config, model_name="Qwen/Qwen2.5-0.5B-Instruct")
```

---

## Design Principles

1. **Neuro-Symbolic Fluidity**: Dynamic translation between symbolic and sub-symbolic representations
2. **Architectural Evolvability**: Structural components are subject to learning and refinement
3. **Parallel Agent Intelligence**: Intelligence emerges through coordinated multi-agent interaction
4. **Constrained Self-Modification**: All self-changes are sandboxed and validated by automated systems
5. **Automated Oversight**: Risk scoring, regression suites, and auto-rollback replace human gates

---

## Citation

```bibtex
@article{aether2026,
  title={AETHER: A Self-Evolving Neuro-Symbolic Architecture for Artificial General Intelligence},
  author={Anonymous},
  year={2026}
}
```

## License

MIT License - Open for research and development toward responsible AGI.