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

A developer has published a conceptual blueprint for AURORA, a low-energy cognitive organism architecture that operates without transformers or token prediction. The system uses sparse predictive microfields, episodic memory consolidation, and resonant workspace reasoning to simulate perception, adaptation, and community learning. The design emphasizes energy efficiency through glia-like field selection and schema sharing between agents.

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