Conceptual blueprint for a low-energy cognitive organism. Not a transformer; not token prediction; not a working ML model.

| from dataclasses import dataclass, field | | | from typing import Any, Dict, List, Tuple | | | @dataclass | | | class Event: | | | source: str | |

| features: Dict[str, float] | |
| context: Dict[str, Any] = field(default_factory=dict) | |

| class PredictiveMicrofield: | | | """Sparse local perception with prediction-error adaptation.""" | |

| def __init__(self, name: str): | |
| self.name, self.schema, self.state = name, {}, {} | |
| def perceive(self, event: Event, goal: str = "") -> Dict[str, Any]: | |
| active = {k: v for k, v in event.features.items() if abs(v) > 0.03} | |
| predicted = {k: self.schema.get(k, 0.0) for k in active} | |
| error = {k: active[k] - predicted.get(k, 0.0) for k in active} | |
| self.state = {"active": active, "predicted": predicted, "error": error, "goal": goal} | |

| return self.state | |

| def adapt(self, reward: float = 1.0, rate: float = 0.08) -> None: | |
| for k, e in self.state.get("error", {}).items(): | |
| self.schema[k] = self.schema.get(k, 0.0) + rate * reward * e | |

| class MemoryGarden: | | | """Fast episodic index, slow schemas, consolidation, and forgetting.""" | |

| def __init__(self): | |
| self.episodes: List[Tuple[Event, Dict[str, Any]]] = [] | |
| self.schemas: Dict[str, float] = {} | |
| def remember(self, event: Event, percept: Dict[str, Any]) -> None: | |
| self.episodes.append((event, percept)) | |
| def retrieve(self, cues: Dict[str, float], k: int = 3): | |
| score = lambda ep: sum(ep[0].features.get(c, 0.0) * v for c, v in cues.items()) | |
| return sorted(self.episodes, key=score, reverse=True)[:k] | |
| def consolidate(self) -> None: | |
| for event, _ in self.episodes[-64:]: | |
| for key, value in event.features.items(): | |
| self.schemas[key] = 0.95 * self.schemas.get(key, 0.0) + 0.05 * value | |
| self.episodes = self.episodes[-256:] | |

| class ResonantWorkspace: | | | """Counterfactual reasoning by settling competing futures into coherence.""" | |

| def imagine(self, memories, goal: str): | |
| return [{"source": e.source, "features": e.features, "goal": goal} for e, _ in memories] | |
| def choose(self, futures): | |
| return min(futures or [{}], key=lambda f: f.get("uncertainty", 0.0)) | |

| class EnergyGovernor: | | | """Glia-like budgeting: activate only fields likely to matter.""" | |

| def select(self, event: Event, fields: List[PredictiveMicrofield]): | |
| return fields[: max(1, min(len(fields), 1 + len(event.features) // 4))] | |

| class AURORA: | |

| def __init__(self): | |
| names = ("body", "space", "social", "causal") | |
| self.fields = [PredictiveMicrofield(n) for n in names] | |
| self.memory, self.workspace, self.energy = MemoryGarden(), ResonantWorkspace(), EnergyGovernor() | |
| def perceive(self, event: Event, goal: str = ""): | |
| chosen = self.energy.select(event, self.fields) | |
| percept = {f.name: f.perceive(event, goal) for f in chosen} | |

| self.memory.remember(event, percept) | | | return percept | |

| def reason(self, goal: str, cues: Dict[str, float]): | |
| return self.workspace.choose(self.workspace.imagine(self.memory.retrieve(cues), goal)) | |
| def adapt(self, reward: float = 1.0) -> None: | |
| for field in self.fields: field.adapt(reward) | |
| def sleep_cycle(self) -> None: self.memory.consolidate() | |
| def share_schema(self) -> Dict[str, float]: return dict(self.memory.schemas) | |
| def learn_from_community(self, schema: Dict[str, float]) -> None: | |
| for k, v in schema.items(): self.memory.schemas[k] = 0.5 * self.memory.schemas.get(k, v) + 0.5 * v |