Update README for v0.2.0 autonomous

README.md

@@ -1,6 +1,10 @@
 # AETHER: A Self-Evolving Neuro-Symbolic Architecture for AGI
 
-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.
+**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
 
@@ -19,91 +23,117 @@ AETHER synthesizes cutting-edge research from:
 | **Leader Training** | MLPO (2025) | Train single leader, peers untrained - efficient multi-agent RL |
 | **Task-Driven Agents** | BabyAGI | Task creation / prioritization / execution loop |
 
-## System Components
+---
+
+## System Components (v0.2.0)
 
 ```
 AETHER
 ├── Core (AetherCore)
-│   ├── Neuro-Symbolic Fusion Gate (learned attention weights)
-│   ├── Recursive Evolution Loop
-│   └── Safety Sandbox
+│   ├── 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)
+│   ├── 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)
+│   ├── 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)
+│   ├── 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)
-    └── Experience Sharing (group evolution)
+    ├── MAP-Elites Archive                (quality-diversity)
+    ├── Performance-Novelty Selection     (GEA)
+    ├── Constrained Mutation            (AlphaEvolve)
+    └── AutoOversight Gate              (replaces human-in-the-loop)
 ```
 
-## Installation
+---
+
+## 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 transformers trl datasets accelerate peft networkx
-# Optional: pip install torch-geometric pyribs smolagents
+pip install torch numpy networkx
+python aether_autonomous.py
 ```
 
-## Quick Start
-
 ```python
-from aether.core import AetherCore, AetherConfig
+from aether_autonomous import AetherCore, AetherConfig
 
-# Initialize AETHER
+# Initialize autonomous AETHER
 config = AetherConfig(
-    population_size=8,
-    mutation_rate=0.15,
+    population_size=6,
+    generations=5,
+    mutation_rate=0.12,
+    macro_policy_dim=128,
+    micro_policy_dim=64,
     num_agents=4,
-    enable_self_modification=True,
+    kg_embedding_dim=64,
+    kg_num_relations=10,
 )
-aether = AetherCore(config, model_name="Qwen/Qwen2.5-0.5B-Instruct")
 
-# Execute task with neuro-symbolic fusion
-result = aether.forward("What is the relationship between learning and reasoning?")
+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}")
+print(f"Neural weight:   {result['neural_weight']:.3f}")
 
-# Self-reflection
-reflection = aether.self_reflect()
-print(json.dumps(reflection, indent=2))
+# 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%}")
 ```
 
-## Training with TRL GRPO
+---
 
-```bash
-python aether_train.py \
-    --model_name Qwen/Qwen2.5-0.5B-Instruct \
-    --num_train_epochs 1 \
-    --per_device_train_batch_size 1 \
-    --gradient_accumulation_steps 8 \
-    --num_agents 4 \
-    --enable_evolution
-```
+## Original Modular System (v0.1.0)
 
-## Demo
+The original modular implementation remains available in the `aether/` directory:
 
-```bash
-python -c "import aether_demo; aether_demo.main()"
+```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
-5. **Responsible Development**: Interpretability, auditability, and safety are first-class constraints
+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