Add AETHER v0.2.0 autonomous — fully self-evolving with automated oversight

aether_autonomous.py

@@ -0,0 +1,1445 @@
+"""
+AETHER: Autonomous Self-Evolving Neuro-Symbolic Architecture
+===============================================================
+Fully automated — zero human-in-the-loop. All oversight is performed by
+automated regression gating, risk scoring, and stability validation.
+
+Architecture:
+  1. Neuro-Symbolic Fusion Gate     — learned attention over symbolic/neural split
+  2. Four-Agent Orchestration       — Researcher, Engineer, Analyzer, Integrator
+  3. MAP-Elites Quality-Diversity   — behavioral archive for evolutionary search
+  4. CoALA 4-Tier Memory            — Working, Episodic, Semantic, Procedural
+  5. Temporal Memory with Attention — long-horizon context retention
+  6. Knowledge Graph Engine         — RGCN + ComplEx + symbolic inference
+  7. AutoOversight System           — regression suites, risk scoring, auto-rollback
+  8. Recursive Evolution Loop       — generate → evaluate → select → mutate → validate → integrate
+
+Run:  python aether_autonomous.py
+Dependencies: torch, numpy, networkx
+"""
+
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+import numpy as np
+import networkx as nx
+import copy, json, hashlib, time, random, logging, warnings
+from dataclasses import dataclass, field, asdict
+from typing import Dict, List, Any, Optional, Tuple, Callable
+from collections import deque
+from contextlib import contextmanager
+
+warnings.filterwarnings("ignore")
+logging.basicConfig(
+    level=logging.INFO,
+    format="%(asctime)s [%(name)s] %(levelname)s: %(message)s",
+)
+logger = logging.getLogger("AETHER")
+
+
+# ============================================================================
+# 0. CONFIGURATION
+# ============================================================================
+
+@dataclass
+class AetherConfig:
+    population_size: int = 8
+    generations: int = 10
+    mutation_rate: float = 0.15
+    crossover_rate: float = 0.30
+
+    macro_policy_dim: int = 256
+    micro_policy_dim: int = 128
+    num_agents: int = 4
+
+    working_memory_capacity: int = 16
+    episodic_buffer_size: int = 1000
+
+    kg_embedding_dim: int = 128
+    kg_num_relations: int = 20
+
+    learning_rate: float = 2e-5
+    batch_size: int = 4
+
+    enable_self_modification: bool = True
+    enable_parallel_agents: bool = True
+
+    # Auto-oversight thresholds (fully automated)
+    max_mutation_rate: float = 0.50
+    max_agents: int = 16
+    max_memory_mb: float = 8192.0
+    rollback_fitness_drop: float = 0.15
+    stability_window: int = 3
+    risk_threshold: float = 0.70
+
+    # MAP-Elites
+    archive_dims: Tuple[int, int] = (10, 10)
+
+    def to_vector(self) -> np.ndarray:
+        return np.array([
+            self.population_size,
+            self.mutation_rate,
+            self.learning_rate * 1e5,
+            self.macro_policy_dim,
+            self.micro_policy_dim,
+            self.num_agents,
+            self.kg_embedding_dim,
+        ], dtype=np.float32)
+
+    @classmethod
+    def from_vector(cls, vec: np.ndarray) -> "AetherConfig":
+        return cls(
+            population_size=int(np.clip(vec[0], 2, 64)),
+            mutation_rate=float(np.clip(vec[1], 0.01, 0.5)),
+            learning_rate=float(np.clip(vec[2] / 1e5, 1e-6, 1e-3)),
+            macro_policy_dim=int(np.clip(vec[3], 64, 512)),
+            micro_policy_dim=int(np.clip(vec[4], 32, 256)),
+            num_agents=int(np.clip(vec[5], 1, 16)),
+            kg_embedding_dim=int(np.clip(vec[6], 32, 512)),
+        )
+
+
+# ============================================================================
+# 1. AUTO-OVERSIGHT (replaces human-in-the-loop)
+# ============================================================================
+
+class AutoOversight:
+    """
+    Fully automated oversight. No human approval.
+    Components:
+      - Risk scorer: estimates danger of proposed mutation
+      - Regression suite: quick benchmarks that must not degrade
+      - Stability validator: checks config bounds, memory, consistency
+      - Auto-rollback: reverts to last known good if fitness drops
+    """
+
+    def __init__(self, config: AetherConfig):
+        self.config = config
+        self.audit_log: List[Dict] = []
+        self.modification_history: List[Dict] = []
+        self.baseline_fitness: float = 0.0
+        self.fitness_history: deque = deque(maxlen=config.stability_window * 2)
+        self.last_good_config: Optional[AetherConfig] = None
+        self.last_good_fitness: float = -float("inf")
+        self.consecutive_rejections: int = 0
+
+    def risk_score(self, candidate: AetherConfig) -> float:
+        """Return 0..1 risk. >threshold = reject."""
+        risks = []
+
+        # Mutation rate risk
+        risks.append(min(1.0, candidate.mutation_rate / self.config.max_mutation_rate))
+
+        # Agent count risk
+        risks.append(min(1.0, candidate.num_agents / self.config.max_agents))
+
+        # Memory estimate risk
+        est_mem = (candidate.macro_policy_dim * candidate.micro_policy_dim *
+                   candidate.num_agents * 4) / 1e6
+        risks.append(min(1.0, est_mem / self.config.max_memory_mb))
+
+        # Dimension consistency risk
+        if candidate.micro_policy_dim > candidate.macro_policy_dim:
+            risks.append(1.0)
+        else:
+            risks.append(0.0)
+
+        return float(np.mean(risks))
+
+    def validate_stability(self, candidate: AetherConfig) -> Tuple[bool, str]:
+        checks = {
+            "population_size": (2, 64),
+            "mutation_rate": (0.0, self.config.max_mutation_rate),
+            "learning_rate": (1e-6, 1e-3),
+            "num_agents": (1, self.config.max_agents),
+            "macro_policy_dim": (32, 512),
+            "micro_policy_dim": (16, 256),
+        }
+        violations = []
+        for field_name, (lo, hi) in checks.items():
+            val = getattr(candidate, field_name, None)
+            if val is not None and not (lo <= val <= hi):
+                violations.append(f"{field_name}={val} not in [{lo},{hi}]")
+
+        if candidate.micro_policy_dim > candidate.macro_policy_dim:
+            violations.append("micro > macro")
+
+        if violations:
+            return False, "; ".join(violations)
+        return True, "ok"
+
+    def regression_suite(self, candidate: AetherConfig,
+                         core: "AetherCore") -> Tuple[bool, float]:
+        """
+        Quick synthetic benchmarks. Returns (pass, composite_score).
+        Higher = better.
+        """
+        scores = []
+
+        # Benchmark 1: memory throughput
+        try:
+            wm = WorkingMemory(capacity=candidate.working_memory_capacity)
+            for i in range(100):
+                wm.store({"idx": i, "data": torch.randn(16)})
+            retrieved = wm.retrieve("idx", top_k=5)
+            scores.append(len(retrieved) / 5.0)
+        except Exception as e:
+            scores.append(0.0)
+
+        # Benchmark 2: knowledge graph query speed
+        try:
+            kg = KnowledgeGraphEngine(
+                embedding_dim=candidate.kg_embedding_dim,
+                num_relations=candidate.kg_num_relations,
+            )
+            for i in range(20):
+                kg.add_fact(f"Node{i}", "relates_to", f"Node{i+1}")
+            q = kg.query("Node0 relates_to", top_k=3)
+            scores.append(min(1.0, len(q["results"]) / 3.0))
+        except Exception:
+            scores.append(0.0)
+
+        # Benchmark 3: agent orchestration latency
+        try:
+            orch = AetherAgentOrchestrator(candidate)
+            task_embed = torch.randn(1, candidate.macro_policy_dim)
+            blueprint = orch.hierarchical.generate_blueprint(task_embed)
+            scores.append(min(1.0, len(blueprint) / 3.0))
+        except Exception:
+            scores.append(0.0)
+
+        composite = float(np.mean(scores))
+        # Must beat baseline by at least rollback threshold, or be first run
+        if self.baseline_fitness > 0 and composite < self.baseline_fitness * (1 - self.config.rollback_fitness_drop):
+            return False, composite
+        return True, composite
+
+    def should_rollback(self, current_fitness: float) -> bool:
+        """Auto-rollback if fitness drops significantly."""
+        if self.last_good_fitness == -float("inf"):
+            return False
+        drop = (self.last_good_fitness - current_fitness) / (abs(self.last_good_fitness) + 1e-8)
+        return drop > self.config.rollback_fitness_drop
+
+    def decide(self, candidate: AetherConfig, core: "AetherCore") -> Tuple[bool, float, str]:
+        """
+        Automated decision gate. Returns (approved, score, reason).
+        No human involved.
+        """
+        risk = self.risk_score(candidate)
+        if risk > self.config.risk_threshold:
+            self._log(candidate, False, f"risk={risk:.2f} > threshold")
+            self.consecutive_rejections += 1
+            return False, risk, "auto-rejected: high risk"
+
+        stable, stability_reason = self.validate_stability(candidate)
+        if not stable:
+            self._log(candidate, False, stability_reason)
+            self.consecutive_rejections += 1
+            return False, risk, f"auto-rejected: unstable ({stability_reason})"
+
+        reg_pass, reg_score = self.regression_suite(candidate, core)
+        if not reg_pass:
+            self._log(candidate, False, f"regression fail score={reg_score:.3f}")
+            self.consecutive_rejections += 1
+            return False, reg_score, "auto-rejected: regression failure"
+
+        self._log(candidate, True, f"risk={risk:.2f} reg={reg_score:.3f}")
+        self.consecutive_rejections = 0
+        self.baseline_fitness = max(self.baseline_fitness, reg_score)
+        return True, reg_score, "auto-approved"
+
+    def _log(self, candidate: AetherConfig, approved: bool, reason: str):
+        entry = {
+            "timestamp": time.time(),
+            "approved": approved,
+            "config_hash": hashlib.sha256(
+                json.dumps(asdict(candidate), sort_keys=True).encode()
+            ).hexdigest()[:16],
+            "reason": reason,
+        }
+        self.modification_history.append(entry)
+        self.audit_log.append(entry)
+
+    def update_good_checkpoint(self, config: AetherConfig, fitness: float):
+        self.last_good_config = copy.deepcopy(config)
+        self.last_good_fitness = fitness
+
+    def summary(self) -> Dict[str, Any]:
+        total = len(self.modification_history)
+        approved = sum(1 for m in self.modification_history if m["approved"])
+        return {
+            "total_attempted": total,
+            "approved": approved,
+            "rejected": total - approved,
+            "consecutive_rejections": self.consecutive_rejections,
+            "baseline_fitness": self.baseline_fitness,
+            "last_good_fitness": self.last_good_fitness,
+        }
+
+
+# ============================================================================
+# 2. MEMORY SYSTEM (CoALA 4-tier + Temporal)
+# ============================================================================
+
+class WorkingMemory:
+    def __init__(self, capacity: int = 16):
+        self.capacity = capacity
+        self.buffer: deque = deque(maxlen=capacity)
+        self.attention = nn.Parameter(torch.ones(capacity))
+
+    def store(self, item: Dict[str, Any]):
+        item["_t"] = time.time()
+        self.buffer.append(item)
+
+    def retrieve(self, query: str, top_k: int = 3) -> List[Dict]:
+        if not self.buffer:
+            return []
+        scores = []
+        buf = list(self.buffer)
+        for i, item in enumerate(buf):
+            text = json.dumps(item)
+            score = sum(1 for w in query.lower().split() if w in text.lower())
+            # attention weighting (learned)
+            attn = torch.sigmoid(self.attention[i % self.capacity]).item()
+            scores.append(score * attn)
+        indices = sorted(range(len(scores)), key=lambda i: scores[i], reverse=True)[:top_k]
+        return [buf[i] for i in indices]
+
+    def export(self) -> List[Dict]:
+        return list(self.buffer)
+
+
+class EpisodicMemory:
+    def __init__(self, buffer_size: int = 1000):
+        self.buffer: deque = deque(maxlen=buffer_size)
+
+    def store(self, episode: Dict[str, Any]):
+        episode["_t"] = time.time()
+        self.buffer.append(episode)
+
+    def retrieve_similar(self, query: str, top_k: int = 5) -> List[Dict]:
+        if not self.buffer:
+            return []
+        buf = list(self.buffer)
+        scores = []
+        for item in buf:
+            text = json.dumps(item)
+            scores.append(sum(1 for w in query.lower().split() if w in text.lower()))
+        indices = sorted(range(len(scores)), key=lambda i: scores[i], reverse=True)[:top_k]
+        return [buf[i] for i in indices]
+
+    def get_recent(self, n: int = 10) -> List[Dict]:
+        return list(self.buffer)[-n:]
+
+    def export(self) -> List[Dict]:
+        return list(self.buffer)
+
+
+class SemanticMemory:
+    def __init__(self):
+        self.facts: Dict[str, Any] = {}
+
+    def store_fact(self, key: str, value: Any, confidence: float = 1.0):
+        self.facts[key] = {"value": value, "confidence": confidence, "t": time.time()}
+
+    def retrieve(self, key: str) -> Optional[Dict]:
+        return self.facts.get(key)
+
+    def query(self, query: str) -> List[Dict]:
+        return [v for k, v in self.facts.items() if query.lower() in k.lower()]
+
+    def export(self) -> Dict:
+        return self.facts
+
+
+class ProceduralMemory:
+    def __init__(self):
+        self.tools: Dict[str, Dict] = {}
+        self.usage: Dict[str, int] = {}
+
+    def register_tool(self, name: str, code: str, description: str, tags: List[str] = None):
+        self.tools[name] = {
+            "code": code, "description": description,
+            "tags": tags or [], "registered_at": time.time(), "version": 1,
+        }
+        self.usage[name] = 0
+
+    def get_tool(self, name: str) -> Optional[Dict]:
+        if name in self.tools:
+            self.usage[name] += 1
+            return self.tools[name]
+        return None
+
+    def search_tools(self, query: str) -> List[Dict]:
+        out = []
+        for name, tool in self.tools.items():
+            text = f"{name} {tool['description']} {' '.join(tool['tags'])}"
+            if query.lower() in text.lower():
+                out.append({"name": name, **tool})
+        return out
+
+    def merge_tools(self, cluster: List[str]) -> Optional[str]:
+        if len(cluster) < 2:
+            return None
+        canonical = max(cluster, key=lambda t: self.usage.get(t, 0))
+        merged_desc = " | ".join(self.tools[t]["description"] for t in cluster if t in self.tools)
+        self.tools[canonical]["description"] = merged_desc
+        self.tools[canonical]["version"] += 1
+        for t in cluster:
+            if t != canonical and t in self.tools:
+                del self.tools[t]
+        return canonical
+
+    def export(self) -> Dict:
+        return {"tools": self.tools, "usage": self.usage}
+
+
+class CoALAMemory:
+    def __init__(self, capacity: int = 16):
+        self.working = WorkingMemory(capacity=capacity)
+        self.episodic = EpisodicMemory(buffer_size=1000)
+        self.semantic = SemanticMemory()
+        self.procedural = ProceduralMemory()
+
+    def store(self, item: Dict[str, Any], memory_type: str = "working"):
+        if memory_type == "working":
+            self.working.store(item)
+        elif memory_type == "episodic":
+            self.episodic.store(item)
+        elif memory_type == "semantic":
+            for k, v in item.items():
+                self.semantic.store_fact(k, v)
+        elif memory_type == "procedural":
+            if "name" in item and "code" in item:
+                self.procedural.register_tool(
+                    item["name"], item["code"],
+                    item.get("description", ""), item.get("tags", [])
+                )
+
+    def retrieve(self, query: str, memory_type: str = "all", top_k: int = 5) -> List[Dict]:
+        if memory_type == "all":
+            out = []
+            out.extend(self.working.retrieve(query, top_k=top_k // 2))
+            out.extend(self.episodic.retrieve_similar(query, top_k=top_k))
+            out.extend(self.semantic.query(query)[:top_k])
+            return out[:top_k]
+        elif memory_type == "working":
+            return self.working.retrieve(query, top_k)
+        elif memory_type == "episodic":
+            return self.episodic.retrieve_similar(query, top_k)
+        elif memory_type == "semantic":
+            return self.semantic.query(query)[:top_k]
+        elif memory_type == "procedural":
+            return self.procedural.search_tools(query)
+        return []
+
+    @property
+    def buffer(self):
+        return self.working.buffer
+
+    def export(self) -> Dict[str, Any]:
+        return {
+            "working": self.working.export(),
+            "episodic": self.episodic.export(),
+            "semantic": self.semantic.export(),
+            "procedural": self.procedural.export(),
+        }
+
+
+class TemporalMemory(nn.Module):
+    def __init__(self, buffer_size: int = 1000, hidden_dim: int = 64):
+        super().__init__()
+        self.buffer_size = buffer_size
+        self.hidden_dim = hidden_dim
+        self.buffer: deque = deque(maxlen=buffer_size)
+        self.temporal_gate = nn.Sequential(
+            nn.Linear(2, hidden_dim), nn.ReLU(),
+            nn.Linear(hidden_dim, 1), nn.Sigmoid(),
+        )
+
+    def store(self, event: Dict[str, Any]):
+        event["_t"] = time.time()
+        self.buffer.append(event)
+
+    def retrieve_context(self, current_time: Optional[float] = None,
+                         lookback: float = 3600.0) -> List[Dict]:
+        current_time = current_time or time.time()
+        relevant = []
+        for event in self.buffer:
+            age = current_time - event.get("_t", current_time)
+            if age <= lookback:
+                recency = torch.exp(torch.tensor(-age / lookback)).item()
+                relevant.append({**event, "recency": recency, "age": age})
+        relevant.sort(key=lambda x: x["recency"], reverse=True)
+        return relevant
+
+    def retrieve_with_attention(self, query_embed: torch.Tensor, top_k: int = 10) -> List[Dict]:
+        # Simplified: use recency-weighted retrieval
+        return self.retrieve_context()[:top_k]
+
+    def export(self) -> List[Dict]:
+        return list(self.buffer)
+
+    def __len__(self):
+        return len(self.buffer)
+
+
+# ============================================================================
+# 3. KNOWLEDGE GRAPH ENGINE (RGCN + ComplEx + Symbolic Rules)
+# ============================================================================
+
+class RGCNLayer(nn.Module):
+    def __init__(self, in_dim: int, out_dim: int, num_relations: int, num_bases: int = 4):
+        super().__init__()
+        self.num_relations = num_relations
+        self.bases = nn.Parameter(torch.Tensor(num_bases, in_dim, out_dim))
+        self.comp = nn.Parameter(torch.Tensor(num_relations, num_bases))
+        self.self_loop = nn.Parameter(torch.Tensor(in_dim, out_dim))
+        self.bias = nn.Parameter(torch.Tensor(out_dim))
+        self.reset_parameters()
+
+    def reset_parameters(self):
+        nn.init.xavier_uniform_(self.bases)
+        nn.init.xavier_uniform_(self.comp)
+        nn.init.xavier_uniform_(self.self_loop)
+        nn.init.zeros_(self.bias)
+
+    def forward(self, x, edge_index, edge_type):
+        num_nodes = int(edge_index.max().item()) + 1 if x is None else x.size(0)
+        if x is None:
+            x = torch.eye(num_nodes, self.bases.size(1), device=edge_index.device)
+        weight = torch.einsum("rb,bio->rio", self.comp, self.bases)
+        out = torch.zeros(num_nodes, weight.size(2), device=x.device)
+        for rid in range(self.num_relations):
+            mask = edge_type == rid
+            if mask.sum() == 0:
+                continue
+            ei = edge_index[:, mask]
+            messages = torch.mm(x[ei[0]], weight[rid])
+            out.index_add_(0, ei[1], messages)
+        out = out + torch.mm(x, self.self_loop) + self.bias
+        return out
+
+
+class KnowledgeGraphEncoder(nn.Module):
+    def __init__(self, num_nodes, hidden_dim, num_relations, num_layers=2, num_bases=4):
+        super().__init__()
+        self.node_embeddings = nn.Embedding(num_nodes, hidden_dim)
+        self.layers = nn.ModuleList([
+            RGCNLayer(hidden_dim, hidden_dim, num_relations, num_bases)
+            for _ in range(num_layers)
+        ])
+        self.norms = nn.ModuleList([nn.LayerNorm(hidden_dim) for _ in range(num_layers)])
+
+    def forward(self, edge_index, edge_type):
+        num_nodes = int(edge_index.max().item()) + 1
+        x = self.node_embeddings(torch.arange(num_nodes, device=edge_index.device))
+        for layer, norm in zip(self.layers, self.norms):
+            x = F.relu(norm(layer(x, edge_index, edge_type)))
+        return x
+
+
+class ComplExScorer(nn.Module):
+    def __init__(self, num_nodes, num_relations, hidden_dim=50):
+        super().__init__()
+        self.head_real = nn.Embedding(num_nodes, hidden_dim)
+        self.head_imag = nn.Embedding(num_nodes, hidden_dim)
+        self.tail_real = nn.Embedding(num_nodes, hidden_dim)
+        self.tail_imag = nn.Embedding(num_nodes, hidden_dim)
+        self.rel_real = nn.Embedding(num_relations, hidden_dim)
+        self.rel_imag = nn.Embedding(num_relations, hidden_dim)
+        self.reset_parameters()
+
+    def reset_parameters(self):
+        for p in self.parameters():
+            nn.init.xavier_uniform_(p)
+
+    def forward(self, h, r, t):
+        hr, hi = self.head_real(h), self.head_imag(h)
+        tr, ti = self.tail_real(t), self.tail_imag(t)
+        rr, ri = self.rel_real(r), self.rel_imag(r)
+        return torch.sum(hr * rr * tr + hr * ri * ti + hi * rr * ti - hi * ri * tr, dim=-1)
+
+    def loss(self, h, r, t, neg_t=None):
+        pos = self.forward(h, r, t)
+        if neg_t is None:
+            neg_t = torch.randint(0, self.tail_real.num_embeddings, t.size(), device=t.device)
+        neg = self.forward(h, r, neg_t)
+        return (F.softplus(-pos) + F.softplus(neg)).mean()
+
+
+class KnowledgeGraphEngine(nn.Module):
+    def __init__(self, embedding_dim=128, num_relations=20, max_nodes=10000):
+        super().__init__()
+        self.embedding_dim = embedding_dim
+        self.num_relations = num_relations
+        self.max_nodes = max_nodes
+        self.graph = nx.DiGraph()
+        self.node_id_map: Dict[str, int] = {}
+        self.relation_map: Dict[str, int] = {}
+        self.next_node_id = 0
+        self.next_rel_id = 0
+        self.encoder: Optional[KnowledgeGraphEncoder] = None
+        self.scorer: Optional[ComplExScorer] = None
+        self.symbolic_attention = nn.Parameter(torch.ones(num_relations))
+        self.rules: List[Tuple[Tuple[str, str, str], Tuple[str, str, str]]] = []
+
+    def _get_or_create_node(self, name: str) -> int:
+        if name not in self.node_id_map:
+            self.node_id_map[name] = self.next_node_id
+            self.graph.add_node(self.next_node_id, name=name)
+            self.next_node_id += 1
+        return self.node_id_map[name]
+
+    def _get_or_create_relation(self, name: str) -> int:
+        if name not in self.relation_map:
+            self.relation_map[name] = self.next_rel_id
+            self.next_rel_id += 1
+        return self.relation_map[name]
+
+    def add_fact(self, head: str, relation: str, tail: str, confidence: float = 1.0):
+        h = self._get_or_create_node(head)
+        t = self._get_or_create_node(tail)
+        r = self._get_or_create_relation(relation)
+        self.graph.add_edge(h, t, relation=r, name=relation, confidence=confidence)
+        self._ensure_capacity()
+
+    def add_rule(self, premise: Tuple[str, str, str], conclusion: Tuple[str, str, str]):
+        self.rules.append((premise, conclusion))
+
+    def _ensure_capacity(self):
+        if self.encoder is None and self.next_node_id > 0:
+            n = min(self.next_node_id, self.max_nodes)
+            r = max(self.next_rel_id, self.num_relations)
+            self.encoder = KnowledgeGraphEncoder(n, self.embedding_dim, r)
+            self.scorer = ComplExScorer(n, r, self.embedding_dim // 2)
+            logger.info(f"KG initialized: {n} nodes, {r} relations")
+
+    def _check_fact(self, fact: Tuple[str, str, str]) -> bool:
+        h, r, t = fact
+        if h not in self.node_id_map or t not in self.node_id_map or r not in self.relation_map:
+            return False
+        return self.graph.has_edge(self.node_id_map[h], self.node_id_map[t]) and \
+               self.graph.edges[self.node_id_map[h], self.node_id_map[t]].get("relation") == self.relation_map[r]
+
+    def reason_symbolic(self, query_head: str, query_relation: str) -> List[Dict]:
+        results = []
+        if query_head not in self.node_id_map:
+            return results
+        h_id = self.node_id_map[query_head]
+        r_name = query_relation
+        if r_name in self.relation_map:
+            r_id = self.relation_map[r_name]
+            for _, target, data in self.graph.out_edges(h_id, data=True):
+                if data.get("relation") == r_id:
+                    results.append({
+                        "head": query_head, "relation": r_name,
+                        "tail": self.graph.nodes[target].get("name", str(target)),
+                        "confidence": data.get("confidence", 1.0), "path": "direct",
+                    })
+        # Rule inference
+        for premise, conclusion in self.rules:
+            p_head, p_rel, p_tail = premise
+            c_head, c_rel, c_tail = conclusion
+            if p_head == query_head and self._check_fact(premise):
+                results.append({
+                    "head": c_head if c_head != "?" else query_head,
+                    "relation": c_rel, "tail": c_tail,
+                    "confidence": 0.8, "path": "inferred",
+                    "rule": f"{premise} -> {conclusion}",
+                })
+        # Multi-hop BFS
+        for neighbor in nx.bfs_tree(self.graph, h_id, depth_limit=2).nodes():
+            if neighbor != h_id:
+                for path in nx.all_simple_paths(self.graph, h_id, neighbor, cutoff=2):
+                    if len(path) > 1:
+                        ed = self.graph.edges[path[0], path[1]]
+                        results.append({
+                            "head": query_head,
+                            "relation": f"multi-hop via {ed.get('name', 'unknown')}",
+                            "tail": self.graph.nodes[neighbor].get("name", str(neighbor)),
+                            "confidence": 0.6 ** (len(path) - 1),
+                            "path": "->".join(str(n) for n in path),
+                        })
+        return sorted(results, key=lambda x: x["confidence"], reverse=True)
+
+    def reason_learned(self, query_head: str, query_relation: str, top_k: int = 5) -> List[Dict]:
+        if self.scorer is None or query_head not in self.node_id_map:
+            return []
+        h_id = self.node_id_map[query_head]
+        r_id = self.relation_map.get(query_relation)
+        if r_id is None:
+            return []
+        h_t = torch.tensor([h_id])
+        r_t = torch.tensor([r_id])
+        all_t = torch.arange(self.scorer.tail_real.num_embeddings)
+        scores = []
+        for i in range(0, len(all_t), 1000):
+            batch = all_t[i:i + 1000]
+            scores.extend(self.scorer(h_t.repeat(len(batch)), r_t.repeat(len(batch)), batch).tolist())
+        scores_t = torch.tensor(scores)
+        top_scores, top_idx = torch.topk(scores_t, min(top_k, len(scores_t)))
+        results = []
+        for idx, sc in zip(top_idx, top_scores):
+            node_name = self.graph.nodes[idx.item()].get("name", str(idx.item()))
+            results.append({
+                "head": query_head, "relation": query_relation,
+                "tail": node_name, "confidence": torch.sigmoid(sc).item(), "path": "learned",
+            })
+        return results
+
+    def query(self, text_query: str, top_k: int = 5) -> Dict[str, Any]:
+        parts = text_query.lower().split()
+        head = parts[0].capitalize() if parts else text_query.capitalize()
+        relation = " ".join(parts[1:]) if len(parts) > 1 else "related_to"
+        sym = self.reason_symbolic(head, relation)[:top_k]
+        learned = self.reason_learned(head, relation, top_k)
+        rel_id = self.relation_map.get(relation, 0)
+        sym_w = torch.sigmoid(self.symbolic_attention[rel_id % self.num_relations]).item()
+        learned_w = 1.0 - sym_w
+        for r in sym:
+            r["source"] = "symbolic"
+            r["fusion_weight"] = sym_w
+        for r in learned:
+            r["source"] = "learned"
+            r["fusion_weight"] = learned_w
+        all_r = sorted(sym + learned, key=lambda x: x.get("confidence", 0), reverse=True)
+        return {
+            "query": text_query, "results": all_r[:top_k],
+            "symbolic_weight": sym_w, "learned_weight": learned_w,
+            "num_symbolic": len(sym), "num_learned": len(learned),
+        }
+
+    def stats(self) -> Dict[str, Any]:
+        return {
+            "num_nodes": self.graph.number_of_nodes(),
+            "num_edges": self.graph.number_of_edges(),
+            "num_relations": len(self.relation_map),
+            "num_rules": len(self.rules),
+        }
+
+    def export(self) -> Dict[str, Any]:
+        edges = []
+        for u, v, d in self.graph.edges(data=True):
+            edges.append({"source": u, "target": v, "relation": d.get("name"), "confidence": d.get("confidence")})
+        return {
+            "nodes": {n: self.graph.nodes[n].get("name", str(n)) for n in self.graph.nodes()},
+            "edges": edges, "rules": self.rules,
+        }
+
+
+# ============================================================================
+# 4. AGENT ORCHESTRATION (4 roles + Hierarchical + BabyAGI loop)
+# ============================================================================
+
+class AgentRole:
+    RESEARCHER = "researcher"
+    ENGINEER = "engineer"
+    ANALYZER = "analyzer"
+    INTEGRATOR = "integrator"
+
+
+class BaseAgent(nn.Module):
+    def __init__(self, role: str, hidden_dim: int = 128, vocab_size: int = 32000):
+        super().__init__()
+        self.role = role
+        self.hidden_dim = hidden_dim
+        self.encoder = nn.Sequential(
+            nn.Embedding(vocab_size, hidden_dim),
+            nn.LSTM(hidden_dim, hidden_dim, batch_first=True),
+        )
+        self.policy_head = nn.Linear(hidden_dim, hidden_dim)
+        self.value_head = nn.Linear(hidden_dim, 1)
+        self.task_history: deque = deque(maxlen=100)
+        self.performance_log: List[float] = []
+
+    def forward(self, input_ids: torch.Tensor) -> Dict[str, torch.Tensor]:
+        embeds = self.encoder[0](input_ids)
+        lstm_out, _ = self.encoder[1](embeds)
+        hidden = lstm_out[:, -1, :]
+        return {
+            "policy_logits": self.policy_head(hidden),
+            "value": self.value_head(hidden),
+            "hidden": hidden,
+        }
+
+    def act(self, observation: str) -> str:
+        self.task_history.append({"observation": observation, "t": time.time()})
+        actions = {
+            AgentRole.RESEARCHER: f"[RESEARCHER] Exploring knowledge for: '{observation[:50]}...'",
+            AgentRole.ENGINEER: f"[ENGINEER] Synthesizing tool for: '{observation[:50]}...'",
+            AgentRole.ANALYZER: f"[ANALYZER] Evaluating solution for: '{observation[:50]}...'",
+            AgentRole.INTEGRATOR: f"[INTEGRATOR] Merging components for: '{observation[:50]}...'",
+        }
+        return actions.get(self.role, f"[{self.role.upper()}] Processing: '{observation}'")
+
+    def update(self, reward: float):
+        self.performance_log.append(reward)
+
+
+class HierarchicalAgent(nn.Module):
+    """Macro-policy generates blueprints; micro-policy executes conditioned on blueprint."""
+
+    def __init__(self, macro_dim: int = 256, micro_dim: int = 128, num_subgoals: int = 5):
+        super().__init__()
+        self.macro_dim = macro_dim
+        self.micro_dim = micro_dim
+        self.num_subgoals = num_subgoals
+        self.macro_decoder = nn.LSTM(macro_dim, macro_dim, batch_first=True)
+        self.subgoal_head = nn.Linear(macro_dim, num_subgoals)
+        self.termination_token = nn.Parameter(torch.randn(macro_dim))
+        self.micro_encoder = nn.LSTM(micro_dim + macro_dim, micro_dim, batch_first=True)
+        self.action_head = nn.Linear(micro_dim, 50)
+        self.current_blueprint: Optional[List[str]] = None
+        self.active_subgoal_idx = 0
+
+    def generate_blueprint(self, task_embedding: torch.Tensor) -> List[str]:
+        batch_size = task_embedding.size(0)
+        hidden = (torch.zeros(1, batch_size, self.macro_dim),
+                  torch.zeros(1, batch_size, self.macro_dim))
+        input_tok = task_embedding.unsqueeze(1)
+        blueprints = []
+        for _ in range(self.num_subgoals):
+            out, hidden = self.macro_decoder(input_tok, hidden)
+            sg_logits = self.subgoal_head(out.squeeze(1))
+            sg_id = torch.argmax(sg_logits, dim=-1)
+            sim = torch.cosine_similarity(out.squeeze(1), self.termination_token.unsqueeze(0))
+            if sim.item() > 0.9:
+                break
+            blueprints.append(f"subgoal_{sg_id.item()}")
+            input_tok = out
+        self.current_blueprint = blueprints
+        self.active_subgoal_idx = 0
+        return blueprints
+
+    def execute_action(self, observation: torch.Tensor, blueprint: Optional[List[str]] = None) -> torch.Tensor:
+        if blueprint is not None:
+            self.current_blueprint = blueprint
+        if not self.current_blueprint:
+            return torch.zeros(1, 50)
+        active = self.current_blueprint[min(self.active_subgoal_idx, len(self.current_blueprint) - 1)]
+        subgoal_embed = torch.randn(1, self.macro_dim)
+        combined = torch.cat([observation, subgoal_embed], dim=-1)
+        out, _ = self.micro_encoder(combined.unsqueeze(1))
+        return self.action_head(out.squeeze(1))
+
+    def advance_subgoal(self):
+        self.active_subgoal_idx += 1
+
+    def reset(self):
+        self.current_blueprint = None
+        self.active_subgoal_idx = 0
+
+
+class BabyAGILoop:
+    def __init__(self, objective: str, max_iterations: int = 50):
+        self.objective = objective
+        self.max_iterations = max_iterations
+        self.task_list: deque = deque()
+        self.completed: List[Dict] = []
+        self.results: Dict[int, Any] = {}
+        self.iteration = 0
+
+    def create_tasks(self, previous_result: str, task_desc: str) -> List[str]:
+        return [f"Sub-task {len(self.task_list) + i}: Analyze {previous_result[:30]}..." for i in range(3)]
+
+    def prioritize(self) -> List[str]:
+        tasks = list(self.task_list)
+        scores = [sum(1 for w in self.objective.lower().split() if w in t.lower()) for t in tasks]
+        return [t for _, t in sorted(zip(scores, tasks), reverse=True)]
+
+    def execute(self, task: str, agent: BaseAgent) -> str:
+        result = agent.act(task)
+        self.completed.append({"task": task, "result": result, "iteration": self.iteration})
+        return result
+
+    def run(self, agent: BaseAgent) -> Dict[str, Any]:
+        self.task_list.append(self.objective)
+        while self.iteration < self.max_iterations and self.task_list:
+            prioritized = self.prioritize()
+            self.task_list = deque(prioritized)
+            current = self.task_list.popleft()
+            prev = self.completed[-1]["result"] if self.completed else ""
+            result = self.execute(current, agent)
+            self.results[self.iteration] = result
+            for t in self.create_tasks(result, current):
+                if t not in self.task_list:
+                    self.task_list.append(t)
+            self.iteration += 1
+        return {
+            "completed": self.completed, "results": self.results,
+            "iterations": self.iteration, "objective": self.objective,
+        }
+
+
+class AetherAgentOrchestrator(nn.Module):
+    def __init__(self, config: AetherConfig):
+        super().__init__()
+        self.config = config
+        self.agents: Dict[str, BaseAgent] = nn.ModuleDict({
+            "researcher": BaseAgent(AgentRole.RESEARCHER, hidden_dim=config.macro_policy_dim),
+            "engineer": BaseAgent(AgentRole.ENGINEER, hidden_dim=config.micro_policy_dim),
+            "analyzer": BaseAgent(AgentRole.ANALYZER, hidden_dim=config.micro_policy_dim),
+            "integrator": BaseAgent(AgentRole.INTEGRATOR, hidden_dim=config.micro_policy_dim),
+        })
+        self.leader = BaseAgent("leader", hidden_dim=config.macro_policy_dim)
+        self.hierarchical = HierarchicalAgent(macro_dim=config.macro_policy_dim, micro_dim=config.micro_policy_dim)
+        self.routing_weights = nn.Parameter(torch.ones(len(self.agents)))
+        self.aggregation_gate = nn.Softmax(dim=0)
+        self.agent_tasks: Dict[str, BabyAGILoop] = {}
+        self.interactions: List[Dict] = []
+        self.task_count = 0
+
+    def forward(self, task: str, context: Dict[str, Any]) -> Dict[str, Any]:
+        task_embed = torch.randn(1, self.config.macro_policy_dim)
+        blueprint = self.hierarchical.generate_blueprint(task_embed)
+        routing_probs = self.aggregation_gate(self.routing_weights)
+        agent_outputs = {}
+        for i, (name, agent) in enumerate(self.agents.items()):
+            weight = routing_probs[i].item()
+            if weight < 0.10:
+                continue
+            sub_task = blueprint[min(i, len(blueprint) - 1)] if blueprint else task
+            output = agent.act(f"[{name}] {sub_task}")
+            agent_outputs[name] = {"output": output, "weight": weight, "sub_task": sub_task}
+        synthesis = self.leader.act(f"Synthesize: {task} with inputs: {list(agent_outputs.keys())}")
+        self.interactions.append({
+            "task": task, "blueprint": blueprint,
+            "agent_outputs": agent_outputs, "leader_synthesis": synthesis,
+            "routing_probs": routing_probs.detach().cpu().tolist(),
+            "t": time.time(),
+        })
+        self.task_count += 1
+        return {
+            "output": synthesis, "blueprint": blueprint,
+            "agent_outputs": agent_outputs,
+            "routing_weights": routing_probs.detach().cpu().tolist(),
+        }
+
+    def execute(self, task: str, kg_context: Any, context: Dict[str, Any]) -> Dict[str, Any]:
+        return self.forward(task, context)
+
+    def textual_backprop(self, global_gradient: str, performance_feedback: float, beta: float = 0.5) -> Dict[str, str]:
+        updates = {}
+        for name, agent in self.agents.items():
+            local_grad = f"{global_gradient} + {name} perf={performance_feedback:.3f}"
+            blended = local_grad
+            updates[name] = blended
+        self.routing_weights.data += performance_feedback * 0.01
+        return updates
+
+    def co_evolve_interactions(self) -> List[Dict]:
+        rewards = []
+        for interaction in self.interactions[-10:]:
+            n_agents = len(interaction.get("agent_outputs", {}))
+            complexity = len(interaction.get("blueprint", []))
+            reward = n_agents * 0.1 + min(complexity * 0.05, 0.5)
+            rewards.append({"reward": reward, "agents_involved": n_agents})
+        return rewards
+
+    def run_babyagi(self, objective: str, max_iterations: int = 20) -> Dict[str, Any]:
+        loop = BabyAGILoop(objective, max_iterations)
+        result = loop.run(self.agents["researcher"])
+        self.agent_tasks[objective] = loop
+        return result
+
+    def stats(self) -> Dict[str, Any]:
+        return {
+            "total_tasks": self.task_count,
+            "num_agents": len(self.agents),
+            "total_interactions": len(self.interactions),
+            "routing_weights": self.routing_weights.detach().cpu().tolist(),
+        }
+
+
+# ============================================================================
+# 5. EVOLUTION ENGINE (MAP-Elites + Quality-Diversity + Auto-Oversight)
+# ============================================================================
+
+class MAPelitesArchive:
+    def __init__(self, dims=(10, 10), ranges=None):
+        self.dims = dims
+        self.ranges = ranges or [(0, 1), (0, 1)]
+        self.archive: Dict[Tuple[int, int], Tuple[AetherConfig, float]] = {}
+
+    def _index(self, measures: np.ndarray) -> Tuple[int, int]:
+        indices = []
+        for m, (lo, hi), dim in zip(measures, self.ranges, self.dims):
+            norm = (m - lo) / (hi - lo + 1e-8)
+            idx = int(np.clip(norm * dim, 0, dim - 1))
+            indices.append(idx)
+        return tuple(indices)
+
+    def add(self, config: AetherConfig, fitness: float, measures: np.ndarray) -> bool:
+        idx = self._index(measures)
+        if idx not in self.archive or self.archive[idx][1] < fitness:
+            self.archive[idx] = (config, fitness)
+            return True
+        return False
+
+    def sample(self, n: int = 1) -> List[AetherConfig]:
+        if not self.archive:
+            return []
+        items = list(self.archive.values())
+        selected = random.sample(items, min(n, len(items)))
+        return [cfg for cfg, _ in selected]
+
+    def get_best(self) -> Optional[Tuple[AetherConfig, float]]:
+        if not self.archive:
+            return None
+        return max(self.archive.values(), key=lambda x: x[1])
+
+    def stats(self) -> Dict[str, float]:
+        total_cells = self.dims[0] * self.dims[1]
+        return {
+            "coverage": len(self.archive) / total_cells,
+            "qd_score": sum(f for _, f in self.archive.values()),
+            "max_fitness": max((f for _, f in self.archive.values()), default=0),
+        }
+
+
+class AetherEvolutionEngine:
+    def __init__(self, config: AetherConfig):
+        self.config = config
+        self.archive = MAPelitesArchive(
+            dims=config.archive_dims,
+            ranges=[(0, 1), (0, 1)],  # (symbolic_bias_proxy, fitness)
+        )
+        self.generation = 0
+        self.experience_log: List[Dict] = []
+
+    def generate_candidates(self, base_config: AetherConfig, population_size: int = 8) -> List[AetherConfig]:
+        candidates = [base_config]
+        archive_seeds = self.archive.sample(n=min(2, len(self.archive.archive)))
+        for _ in range(population_size - len(archive_seeds) - 1):
+            candidates.append(self._mutate(base_config))
+        for cfg in archive_seeds:
+            candidates.append(cfg)
+        return candidates
+
+    def _mutate(self, config: AetherConfig) -> AetherConfig:
+        vec = config.to_vector()
+        noise = np.random.normal(0, config.mutation_rate, size=vec.shape)
+        mutated = vec + noise * vec
+        new_cfg = AetherConfig.from_vector(mutated)
+        # Preserve meta fields
+        new_cfg.generations = config.generations
+        new_cfg.enable_self_modification = config.enable_self_modification
+        new_cfg.enable_parallel_agents = config.enable_parallel_agents
+        new_cfg.archive_dims = config.archive_dims
+        return new_cfg
+
+    def select(self, candidates: List[AetherConfig], fitness_scores: List[float],
+               alpha_exploration: float = 0.3) -> List[AetherConfig]:
+        if not candidates or not fitness_scores:
+            return candidates[:2] if len(candidates) >= 2 else candidates
+        vectors = np.array([c.to_vector() for c in candidates])
+        f = np.array(fitness_scores)
+        f_norm = (f - f.min()) / (f.max() - f.min() + 1e-8)
+        k = min(4, len(candidates) - 1)
+        novelties = []
+        for i, v in enumerate(vectors):
+            dists = np.linalg.norm(vectors - v, axis=1)
+            dists[i] = np.inf
+            knn = np.partition(dists, k)[:k]
+            novelties.append(np.mean(knn))
+        nov_norm = np.array(novelties) / (max(novelties) + 1e-8)
+        scores = f_norm * np.sqrt(nov_norm + 1e-8)
+        n_select = max(1, len(candidates) // 2)
+        top_indices = np.argsort(scores)[-n_select:]
+        return [candidates[i] for i in top_indices]
+
+    def mutate(self, candidates: List[AetherConfig], mutation_rate: float = 0.15) -> List[AetherConfig]:
+        mutated = []
+        for cfg in candidates:
+            new_cfg = self._mutate(cfg)
+            # Hard constraints
+            if new_cfg.macro_policy_dim > 512:
+                new_cfg.macro_policy_dim = 512
+            if new_cfg.micro_policy_dim > new_cfg.macro_policy_dim:
+                new_cfg.micro_policy_dim = new_cfg.macro_policy_dim // 2
+            mutated.append(new_cfg)
+        return mutated
+
+    def update_archive(self, candidates: List[AetherConfig], fitness_scores: List[float]):
+        for cfg, fitness in zip(candidates, fitness_scores):
+            if fitness == -float("inf"):
+                continue
+            # Behavioral descriptor: symbolic bias proxy = num_agents / max_agents
+            sym_proxy = cfg.num_agents / cfg.max_agents
+            measures = np.array([sym_proxy, np.clip(fitness, 0, 1)])
+            improved = self.archive.add(cfg, fitness, measures)
+            if improved:
+                logger.debug(f"Archive improved at cell fitness={fitness:.4f}")
+
+    def get_diversity_stats(self) -> Dict[str, float]:
+        return self.archive.stats()
+
+
+# ============================================================================
+# 6. AETHER CORE (Orchestrator + Evolution Loop + Auto-Oversight)
+# ============================================================================
+
+class AetherCore(nn.Module):
+    def __init__(self, config: Optional[AetherConfig] = None):
+        super().__init__()
+        self.config = config or AetherConfig()
+        self.generation = 0
+        self.architecture_history: List[Dict] = []
+        self.fitness_log: List[float] = []
+        self.metadata = {"birth": time.time(), "version": "0.2.0-autonomous"}
+
+        # Subsystems (lazily initialized where possible)
+        self._memory: Optional[CoALAMemory] = None
+        self._temporal: Optional[TemporalMemory] = None
+        self._evolution: Optional[AetherEvolutionEngine] = None
+        self._agents: Optional[AetherAgentOrchestrator] = None
+        self._knowledge: Optional[KnowledgeGraphEngine] = None
+        self._oversight: Optional[AutoOversight] = None
+
+        # Neuro-symbolic fusion gate (trainable)
+        self.symbolic_gate = nn.Parameter(torch.tensor(0.0))
+        self.neural_gate = nn.Parameter(torch.tensor(0.0))
+
+        logger.info("AETHER Core v0.2.0-autonomous initialized")
+
+    @property
+    def memory(self) -> CoALAMemory:
+        if self._memory is None:
+            self._memory = CoALAMemory(capacity=self.config.working_memory_capacity)
+        return self._memory
+
+    @property
+    def temporal(self) -> TemporalMemory:
+        if self._temporal is None:
+            self._temporal = TemporalMemory(buffer_size=self.config.episodic_buffer_size)
+        return self._temporal
+
+    @property
+    def evolution(self) -> AetherEvolutionEngine:
+        if self._evolution is None:
+            self._evolution = AetherEvolutionEngine(self.config)
+        return self._evolution
+
+    @property
+    def agents(self) -> AetherAgentOrchestrator:
+        if self._agents is None:
+            self._agents = AetherAgentOrchestrator(self.config)
+        return self._agents
+
+    @property
+    def knowledge(self) -> KnowledgeGraphEngine:
+        if self._knowledge is None:
+            self._knowledge = KnowledgeGraphEngine(
+                embedding_dim=self.config.kg_embedding_dim,
+                num_relations=self.config.kg_num_relations,
+            )
+        return self._knowledge
+
+    @property
+    def oversight(self) -> AutoOversight:
+        if self._oversight is None:
+            self._oversight = AutoOversight(self.config)
+        return self._oversight
+
+    def forward(self, task: str, context: Optional[Dict] = None) -> Dict[str, Any]:
+        context = context or {}
+        kg_context = self.knowledge.query(task, top_k=5)
+        self.memory.store({"task": task, "kg_context": kg_context, "t": time.time()})
+        result = self.agents.execute(task, kg_context, context)
+        # Neuro-symbolic fusion
+        sym_w = torch.sigmoid(self.symbolic_gate)
+        neu_w = torch.sigmoid(self.neural_gate)
+        total = sym_w + neu_w + 1e-8
+        sym_w, neu_w = sym_w / total, neu_w / total
+        self.temporal.store({
+            "task": task, "result": result,
+            "weights": {"symbolic": sym_w.item(), "neural": neu_w.item()},
+        })
+        return {
+            "output": result, "symbolic_weight": sym_w.item(),
+            "neural_weight": neu_w.item(), "kg_context": kg_context,
+            "generation": self.generation,
+        }
+
+    def _default_evaluator(self, candidate: AetherConfig) -> float:
+        """
+        Fully automated fitness function — no external API.
+        Scores: synthetic reasoning benchmarks + memory stress + knowledge graph coverage.
+        """
+        scores = []
+        try:
+            # 1. Agent orchestration efficiency
+            orch = AetherAgentOrchestrator(candidate)
+            task_embed = torch.randn(1, candidate.macro_policy_dim)
+            blueprint = orch.hierarchical.generate_blueprint(task_embed)
+            scores.append(min(1.0, len(blueprint) / 4.0))
+
+            # 2. Knowledge graph reasoning coverage
+            kg = KnowledgeGraphEngine(embedding_dim=candidate.kg_embedding_dim, num_relations=candidate.kg_num_relations)
+            for i in range(15):
+                kg.add_fact(f"Entity{i}", "connects_to", f"Entity{i+1}")
+            q = kg.query("Entity0 connects_to", top_k=5)
+            scores.append(min(1.0, len(q["results"]) / 3.0))
+
+            # 3. Memory throughput
+            mem = WorkingMemory(capacity=candidate.working_memory_capacity)
+            for i in range(50):
+                mem.store({"idx": i, "data": list(range(10))})
+            retrieved = mem.retrieve("idx", top_k=5)
+            scores.append(min(1.0, len(retrieved) / 5.0))
+
+            # 4. Config balance penalty (prefer moderate values)
+            balance = 1.0 - abs(candidate.macro_policy_dim - 256) / 256.0
+            scores.append(max(0.0, balance))
+
+        except Exception as e:
+            logger.warning(f"Fitness evaluation failed: {e}")
+            return -float("inf")
+
+        return float(np.mean(scores))
+
+    def evolve(self, num_generations: Optional[int] = None,
+               evaluator: Optional[Callable[[AetherConfig], float]] = None) -> Dict[str, Any]:
+        num_generations = num_generations or self.config.generations
+        evaluator = evaluator or self._default_evaluator
+        logger.info(f"=== AUTONOMOUS EVOLUTION: {num_generations} generations ===")
+
+        best_fitness = -float("inf")
+        best_config: Optional[AetherConfig] = None
+
+        for gen in range(num_generations):
+            self.generation = gen
+            logger.info(f"\n--- Generation {gen} ---")
+
+            # 1. Generate candidates
+            candidates = self.evolution.generate_candidates(self.config, self.config.population_size)
+            logger.info(f"Generated {len(candidates)} candidates")
+
+            # 2. Evaluate + Auto-oversight gate
+            fitness_scores = []
+            approved_candidates = []
+            for candidate in candidates:
+                # Automated decision — no human
+                approved, score, reason = self.oversight.decide(candidate, self)
+                if approved:
+                    # Full fitness evaluation
+                    fitness = evaluator(candidate)
+                    fitness_scores.append(fitness)
+                    approved_candidates.append(candidate)
+                    logger.info(f"  Candidate approved | reason={reason} | fitness={fitness:.4f}")
+                else:
+                    fitness_scores.append(-float("inf"))
+                    logger.info(f"  Candidate REJECTED | reason={reason}")
+
+            # 3. Auto-rollback check
+            current_best = max((f for f in fitness_scores if f > -float("inf")), default=-float("inf"))
+            if self.oversight.should_rollback(current_best):
+                logger.warning(f"ROLLBACK TRIGGERED: fitness dropped to {current_best:.4f}")
+                if self.oversight.last_good_config is not None:
+                    self.config = copy.deepcopy(self.oversight.last_good_config)
+                    logger.info("Rolled back to last known good configuration")
+                continue
+
+            # 4. Select (Performance-Novelty)
+            selected = self.evolution.select(candidates, fitness_scores)
+
+            # 5. Mutate
+            mutated = self.evolution.mutate(selected)
+
+            # 6. Validate via oversight (second pass for mutated)
+            validated = []
+            validated_scores = []
+            for m in mutated:
+                ok, _, reason = self.oversight.decide(m, self)
+                if ok:
+                    validated.append(m)
+                    validated_scores.append(evaluator(m))
+                else:
+                    logger.info(f"  Mutated candidate rejected: {reason}")
+
+            # 7. Integrate best
+            if validated and validated_scores:
+                best_idx = int(np.argmax(validated_scores))
+                best_mutated = validated[best_idx]
+                current_fitness = validated_scores[best_idx]
+
+                if current_fitness > best_fitness:
+                    best_fitness = current_fitness
+                    best_config = best_mutated
+                    self.config = best_mutated
+                    self.oversight.update_good_checkpoint(best_mutated, best_fitness)
+                    arch_hash = hashlib.sha256(
+                        json.dumps(asdict(best_mutated), sort_keys=True).encode()
+                    ).hexdigest()[:16]
+                    self.architecture_history.append({
+                        "generation": gen, "hash": arch_hash,
+                        "fitness": best_fitness, "config": asdict(best_mutated),
+                    })
+                    logger.info(f"*** NEW BEST: gen={gen} fitness={best_fitness:.4f} hash={arch_hash} ***")
+
+            # 8. Update MAP-Elites archive
+            self.evolution.update_archive(candidates, fitness_scores)
+            self.fitness_log.append(best_fitness)
+
+            # 9. Self-reflection per generation
+            reflection = self.self_reflect()
+            logger.info(f"Reflection: {reflection['recommendations']}")
+
+        return {
+            "best_fitness": best_fitness,
+            "best_config": asdict(best_config) if best_config else None,
+            "generations": num_generations,
+            "history": self.architecture_history,
+            "oversight_summary": self.oversight.summary(),
+            "archive_stats": self.evolution.get_diversity_stats(),
+        }
+
+    def self_reflect(self) -> Dict[str, Any]:
+        recs = []
+        if len(self.fitness_log) > 5:
+            recent = self.fitness_log[-5:]
+            if max(recent) - min(recent) < 0.01:
+                recs.append("Fitness plateau detected. Increase diversity or mutation rate.")
+            if recent[-1] < recent[0]:
+                recs.append("Declining trend. Rollback or expand search.")
+
+        sym = torch.sigmoid(self.symbolic_gate).item()
+        if sym < 0.3:
+            recs.append("Symbolic reasoning underutilized. Boost KG integration.")
+        elif sym > 0.7:
+            recs.append("Symbolic dominance. Increase neural flexibility.")
+
+        return {
+            "generation": self.generation,
+            "architectures_tested": len(self.architecture_history),
+            "fitness_trend": self.fitness_log,
+            "neuro_symbolic_balance": {"symbolic": sym, "neural": 1.0 - sym},
+            "recommendations": recs,
+            "oversight": self.oversight.summary(),
+        }
+
+    def export_state(self) -> Dict[str, Any]:
+        return {
+            "config": asdict(self.config),
+            "generation": self.generation,
+            "architecture_history": self.architecture_history,
+            "fitness_log": self.fitness_log,
+            "metadata": self.metadata,
+            "knowledge": self.knowledge.export(),
+            "memory": self.memory.export(),
+            "model_state_dict": {k: v.cpu().tolist() for k, v in self.state_dict().items()},
+        }
+
+    @classmethod
+    def from_state(cls, state: Dict[str, Any]) -> "AetherCore":
+        cfg = AetherConfig(**state["config"])
+        core = cls(config=cfg)
+        core.generation = state["generation"]
+        core.architecture_history = state["architecture_history"]
+        core.fitness_log = state["fitness_log"]
+        core.metadata = state["metadata"]
+        return core
+
+
+# ============================================================================
+# 7. RUNNABLE MAIN
+# ============================================================================
+
+def run_autonomous_demo():
+    print("=" * 70)
+    print(" AETHER v0.2.0 — AUTONOMOUS SELF-EVOLVING ARCHITECTURE")
+    print(" Zero human oversight. Automated regression gating + rollback.")
+    print("=" * 70)
+
+    config = AetherConfig(
+        population_size=6,
+        generations=5,
+        mutation_rate=0.12,
+        macro_policy_dim=128,
+        micro_policy_dim=64,
+        num_agents=4,
+        working_memory_capacity=16,
+        episodic_buffer_size=500,
+        kg_embedding_dim=64,
+        kg_num_relations=10,
+    )
+
+    core = AetherCore(config)
+
+    # Seed knowledge graph
+    print("\n[1] Seeding Knowledge Graph...")
+    kg = core.knowledge
+    facts = [
+        ("Intelligence", "requires", "Reasoning"),
+        ("Reasoning", "requires", "Memory"),
+        ("Memory", "enables", "Learning"),
+        ("Learning", "produces", "Intelligence"),
+        ("Agent", "has_role", "Researcher"),
+        ("Agent", "has_role", "Engineer"),
+        ("Agent", "has_role", "Analyzer"),
+        ("Agent", "has_role", "Integrator"),
+    ]
+    for h, r, t in facts:
+        kg.add_fact(h, r, t)
+    print(f"   KG: {kg.stats()}")
+
+    # Single forward pass demo
+    print("\n[2] Forward Pass Demo (neuro-symbolic query)...")
+    result = core.forward("Intelligence requires")
+    print(f"   Symbolic weight: {result['symbolic_weight']:.3f}")
+    print(f"   Neural weight:   {result['neural_weight']:.3f}")
+    print(f"   Results: {len(result['kg_context']['results'])} items")
+    for r in result["kg_context"]["results"]:
+        print(f"      → {r['head']} --{r['relation']}--> {r['tail']} (conf={r.get('confidence',0):.2f}, src={r.get('source','?')})")
+
+    # Agent orchestration demo
+    print("\n[3] Agent Orchestration Demo...")
+    agent_result = core.agents.execute("Optimize reasoning pipeline", {}, {})
+    print(f"   Leader synthesis: {agent_result['output'][:80]}...")
+    print(f"   Agents activated: {list(agent_result['agent_outputs'].keys())}")
+    print(f"   Routing weights: {[f'{w:.3f}' for w in agent_result['routing_weights']]}")
+
+    # Evolution loop (fully automated)
+    print("\n[4] AUTONOMOUS EVOLUTION LOOP (no human oversight)...")
+    evolution_result = core.evolve(num_generations=5)
+
+    print("\n[5] EVOLUTION RESULTS")
+    print(f"   Best fitness achieved:     {evolution_result['best_fitness']:.4f}")
+    print(f"   Generations run:           {evolution_result['generations']}")
+    print(f"   Architecture changes:      {len(evolution_result['history'])}")
+    print(f"   MAP-Elites coverage:       {evolution_result['archive_stats']['coverage']:.2%}")
+    print(f"   MAP-Elites QD score:       {evolution_result['archive_stats']['qd_score']:.2f}")
+    print(f"   Auto-oversight approved:   {evolution_result['oversight_summary']['approved']}")
+    print(f"   Auto-oversight rejected:     {evolution_result['oversight_summary']['rejected']}")
+    print(f"   Consecutive rejections:    {evolution_result['oversight_summary']['consecutive_rejections']}")
+
+    print("\n[6] Architecture Evolution Trajectory")
+    for entry in evolution_result["history"]:
+        print(f"   Gen {entry['generation']:02d} | hash={entry['hash']} | fitness={entry['fitness']:.4f} | "
+              f"agents={entry['config']['num_agents']} | macro={entry['config']['macro_policy_dim']} | "
+              f"mut_rate={entry['config']['mutation_rate']:.3f}")
+
+    # Self-reflection
+    print("\n[7] Self-Reflection")
+    reflection = core.self_reflect()
+    for rec in reflection["recommendations"]:
+        print(f"   → {rec}")
+
+    # Export checkpoint
+    print("\n[8] Exporting state checkpoint...")
+    state = core.export_state()
+    checkpoint_path = "/app/aether_checkpoint.json"
+    with open(checkpoint_path, "w") as f:
+        json.dump(state, f, indent=2, default=str)
+    print(f"   Checkpoint saved to: {checkpoint_path}")
+
+    print("\n" + "=" * 70)
+    print(" DEMO COMPLETE. AETHER is fully autonomous.")
+    print("=" * 70)
+    return core, evolution_result
+
+
+if __name__ == "__main__":
+    run_autonomous_demo()