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

> Source: <https://gist.github.com/johnoconnor0/6c0d3e1481bd08787ad271cab2fbf33f>
> Published: 2026-05-25 02:05:26+00:00

| 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 |