{"slug": "conceptual-blueprint-for-a-low-energy-cognitive-organism-not-a-transformer-not-a", "title": "Conceptual blueprint for a low-energy cognitive organism. Not a transformer; not token prediction; not a working ML model.", "summary": "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.", "body_md": "| from dataclasses import dataclass, field | |\n| from typing import Any, Dict, List, Tuple | |\n| @dataclass | |\n| class Event: | |\n| source: str | |\n| features: Dict[str, float] | |\n| context: Dict[str, Any] = field(default_factory=dict) | |\n| class PredictiveMicrofield: | |\n| \"\"\"Sparse local perception with prediction-error adaptation.\"\"\" | |\n| def __init__(self, name: str): | |\n| self.name, self.schema, self.state = name, {}, {} | |\n| def perceive(self, event: Event, goal: str = \"\") -> Dict[str, Any]: | |\n| active = {k: v for k, v in event.features.items() if abs(v) > 0.03} | |\n| predicted = {k: self.schema.get(k, 0.0) for k in active} | |\n| error = {k: active[k] - predicted.get(k, 0.0) for k in active} | |\n| self.state = {\"active\": active, \"predicted\": predicted, \"error\": error, \"goal\": goal} | |\n| return self.state | |\n| def adapt(self, reward: float = 1.0, rate: float = 0.08) -> None: | |\n| for k, e in self.state.get(\"error\", {}).items(): | |\n| self.schema[k] = self.schema.get(k, 0.0) + rate * reward * e | |\n| class MemoryGarden: | |\n| \"\"\"Fast episodic index, slow schemas, consolidation, and forgetting.\"\"\" | |\n| def __init__(self): | |\n| self.episodes: List[Tuple[Event, Dict[str, Any]]] = [] | |\n| self.schemas: Dict[str, float] = {} | |\n| def remember(self, event: Event, percept: Dict[str, Any]) -> None: | |\n| self.episodes.append((event, percept)) | |\n| def retrieve(self, cues: Dict[str, float], k: int = 3): | |\n| score = lambda ep: sum(ep[0].features.get(c, 0.0) * v for c, v in cues.items()) | |\n| return sorted(self.episodes, key=score, reverse=True)[:k] | |\n| def consolidate(self) -> None: | |\n| for event, _ in self.episodes[-64:]: | |\n| for key, value in event.features.items(): | |\n| self.schemas[key] = 0.95 * self.schemas.get(key, 0.0) + 0.05 * value | |\n| self.episodes = self.episodes[-256:] | |\n| class ResonantWorkspace: | |\n| \"\"\"Counterfactual reasoning by settling competing futures into coherence.\"\"\" | |\n| def imagine(self, memories, goal: str): | |\n| return [{\"source\": e.source, \"features\": e.features, \"goal\": goal} for e, _ in memories] | |\n| def choose(self, futures): | |\n| return min(futures or [{}], key=lambda f: f.get(\"uncertainty\", 0.0)) | |\n| class EnergyGovernor: | |\n| \"\"\"Glia-like budgeting: activate only fields likely to matter.\"\"\" | |\n| def select(self, event: Event, fields: List[PredictiveMicrofield]): | |\n| return fields[: max(1, min(len(fields), 1 + len(event.features) // 4))] | |\n| class AURORA: | |\n| def __init__(self): | |\n| names = (\"body\", \"space\", \"social\", \"causal\") | |\n| self.fields = [PredictiveMicrofield(n) for n in names] | |\n| self.memory, self.workspace, self.energy = MemoryGarden(), ResonantWorkspace(), EnergyGovernor() | |\n| def perceive(self, event: Event, goal: str = \"\"): | |\n| chosen = self.energy.select(event, self.fields) | |\n| percept = {f.name: f.perceive(event, goal) for f in chosen} | |\n| self.memory.remember(event, percept) | |\n| return percept | |\n| def reason(self, goal: str, cues: Dict[str, float]): | |\n| return self.workspace.choose(self.workspace.imagine(self.memory.retrieve(cues), goal)) | |\n| def adapt(self, reward: float = 1.0) -> None: | |\n| for field in self.fields: field.adapt(reward) | |\n| def sleep_cycle(self) -> None: self.memory.consolidate() | |\n| def share_schema(self) -> Dict[str, float]: return dict(self.memory.schemas) | |\n| def learn_from_community(self, schema: Dict[str, float]) -> None: | |\n| for k, v in schema.items(): self.memory.schemas[k] = 0.5 * self.memory.schemas.get(k, v) + 0.5 * v |", "url": "https://wpnews.pro/news/conceptual-blueprint-for-a-low-energy-cognitive-organism-not-a-transformer-not-a", "canonical_source": "https://gist.github.com/johnoconnor0/6c0d3e1481bd08787ad271cab2fbf33f", "published_at": "2026-05-25 02:05:26+00:00", "updated_at": "2026-05-29 00:43:10.225798+00:00", "lang": "en", "topics": ["artificial-intelligence", "machine-learning", "ai-research", "neural-networks"], "entities": [], "alternates": {"html": "https://wpnews.pro/news/conceptual-blueprint-for-a-low-energy-cognitive-organism-not-a-transformer-not-a", "markdown": "https://wpnews.pro/news/conceptual-blueprint-for-a-low-energy-cognitive-organism-not-a-transformer-not-a.md", "text": "https://wpnews.pro/news/conceptual-blueprint-for-a-low-energy-cognitive-organism-not-a-transformer-not-a.txt", "jsonld": "https://wpnews.pro/news/conceptual-blueprint-for-a-low-energy-cognitive-organism-not-a-transformer-not-a.jsonld"}}