EIDOS is a persistent cognitive architecture. ~663 active subsystems. ~88,000 lines of Python + TypeScript. Runs on your hardware. Not a chatbot wrapper. A full cognitive loop — perception, goals, memory, emotional modulation, dream consolidation, analogy, metaphor, causal reasoning, social cognition, multi-agent coordination, tool use, multi-provider LLM routing with circuit breaking, self-directed research with Bayesian information-gain scoring, cognitive digital twins, creative language, temporal self-continuity, collective intelligence, existential grounding, real-time Intel NPU inference, and long-running stability with disk-persistent Hebbian learning. All ticking continuously.
Most "AI systems" are one thing: a large language model with a prompt. EIDOS is fundamentally different.
The LLM is one subsystem out of ~663 — a language interface on the outside of a continuously running architecture. The other 662 subsystems handle perception, memory, reasoning, emotional modulation, dream consolidation, and autonomous goal pursuit — all ticking independently of user input or API calls.
A cognitive system is not a model. It is a loop — one that keeps running between interactions.
EIDOS implements a continuous 15-stage cognitive loop that ticks in real time on your GPU. Every tick it perceives, updates memory, revises beliefs, forms goals, reasons causally, gates decisions through emotional modulation, acts, reflects, consolidates memory with disk-persistent Hebbian weights, runs dream consolidation on idle ticks, reasons by analogy, coordinates socially, researches autonomously using Bayesian information gain, debates internally, monitors its own reasoning quality, and closes with self-integration — all without prompting.
Every ~250 ms EIDOS runs a complete cycle through 15 ordered stages. This is not a pipeline — it is a closed loop. Output from stage 15 feeds directly back into stage 1. Every stage can signal any other via the neurotransmitter bus. In parallel, 12 background inference tasks run on the Intel NPU at <5 ms each in a dedicated thread fully isolated from the CUDA compute loop.
╔══════════════════════════════════════════════════════════════════════════════════════╗
║ EIDOS — CONTINUOUS COGNITIVE LOOP v1.4.0 ║
║ ~250 ms tick · RTX 5090 CUDA · 48 TOPS NPU · 128 GB DDR5 ║
╠══════════════════════════════════════════════════════════════════════════════════════╣
║ ║
║ ┌───────────────────────────────────────────────────────────────────────────┐ ║
║ │ PERCEPTION LAYER │ ║
║ │ │ ║
║ │ [1] INPUT Vision · audio · text · sensor streams │ ║
║ │ └─ Multimodal CLIP fusion; VisionPrepNPUModel normalises frames │ ║
║ │ └─ SalienceNPUModel (<2 ms) scores working-memory candidates │ ║
║ │ └─ AttentionNPUModel applies NT-modulated dot-product attention │ ║
║ │ └─ WakeWordNPUModel monitors audio continuously at ~1 ms │ ║
║ │ │ ║
║ │ [2] WORKING MEMORY 7±2 buffer · 30 s TTL · exponential decay │ ║
║ │ └─ Items ranked by salience · emotional valence · goal alignment │ ║
║ │ └─ Goal stack interleaved — goals bias next attention pass │ ║
║ │ └─ GoalStalenessMonitor: goals idle >2,000 cycles deferred/dropped │ ║
║ └───────────────────────────────────────────────────────────────────────────┘ ║
║ │ ║
║ ▼ ║
║ ┌───────────────────────────────────────────────────────────────────────────┐ ║
║ │ REASONING LAYER │ ║
║ │ │ ║
║ │ [3] BELIEF REVISION Bayesian update on prior beliefs │ ║
║ │ └─ Contradiction detector quarantines conflicting priors │ ║
║ │ └─ CognitiveImmuneSystem: 12 fallacies + 6 manipulation patterns │ ║
║ │ └─ ConfabulationDetector: 5-signal grounding check on LLM output │ ║
║ │ HIGH_RISK ≥ 0.75 → confabulation_alert broadcast │ ║
║ │ │ ║
║ │ [4] GOAL FORMATION Priority auction across competing drives │ ║
║ │ └─ Dopamine/serotonin ratio resolves motivational conflicts │ ║
║ │ └─ AutonomousGoalEngine injects curiosity-driven growth goals │ ║
║ │ └─ SocialRoleEngine biases goals per active role (6 profiles) │ ║
║ │ └─ GoalStalenessMonitor: 12-goal cap, stale/impossible removed │ ║
║ │ │ ║
║ │ [5] CAUSAL REASONING Full do-calculus + counterfactual simulation │ ║
║ │ └─ CausalGraph: abduction → intervention → counterfactual chain │ ║
║ │ └─ MentalSimulation: forward rollout, scenario scoring │ ║
║ │ └─ TieredWorldModel: Hot(≤200)/Warm(≤1k)/Cold(∞) entity tiers │ ║
║ │ └─ AffectiveForecastEngine: impact/focalistic bias correction │ ║
║ └───────────────────────────────────────────────────────────────────────────┘ ║
║ │ ║
║ ▼ ║
║ ┌───────────────────────────────────────────────────────────────────────────┐ ║
║ │ NEUROTRANSMITTER BUS (always running) │ ║
║ │ │ ║
║ │ [6] EMOTION GATING 6 NT levels modulate every downstream stage │ ║
║ │ │ ║
║ │ Dopamine ──► risk tolerance · reward prediction · motivation │ ║
║ │ Serotonin ──► social warmth · patience · conflict avoidance │ ║
║ │ Norepinephrine──► alertness · threat sensitivity · focus │ ║
║ │ Acetylcholine ──► learning rate · attention precision · memory gate │ ║
║ │ GABA ──► inhibition · equanimity · emotional damping │ ║
║ │ Glutamate ──► excitation · novelty seeking · prediction error amp │ ║
║ │ │ ║
║ │ EmotionNPUModel (<3 ms): 6 NT → 8 Plutchik states + valence/arousal │ ║
║ │ DriftNPUModel (60 s): NT history → OCEAN trait deltas; saved to disk │ ║
║ │ OCEAN → NT baseline → goal formation → output → NT delta (closed loop) │ ║
║ └───────────────────────────────────────────────────────────────────────────┘ ║
║ │ ║
║ ▼ ║
║ ┌───────────────────────────────────────────────────────────────────────────┐ ║
║ │ ACTION LAYER │ ║
║ │ │ ║
║ │ [7] OUTPUT / ACTION Generates response or executes tool action │ ║
║ │ └─ DualProcessSystem: S1 (fast/intuitive) vs S2 (full deliberation) │ ║
║ │ └─ EthicsEngine: 5-framework evaluation before commit │ ║
║ │ └─ LLMGateway: routes to 6 providers via ProviderRegistry │ ║
║ │ CircuitBreaker per provider — auto-failover on 3 failures │ ║
║ │ Retry with exponential backoff + 429 Retry-After handling │ ║
║ │ └─ ToolRegistry: multi-step tool chain execution │ ║
║ │ └─ TwinOrchestrator: 4 personas vote before commit │ ║
║ │ └─ _last_llm_output → ConfabulationDetector every 10 cycles │ ║
║ └───────────────────────────────────────────────────────────────────────────┘ ║
║ │ ║
║ ▼ ║
║ ┌───────────────────────────────────────────────────────────────────────────┐ ║
║ │ METACOGNITIVE LAYER │ ║
║ │ │ ║
║ │ [8] METACOGNITION Monitors its own reasoning in real time │ ║
║ │ └─ BiasDetector: 8 bias types from output text without LLM │ ║
║ │ └─ EpistemicGapScanner + EpistemicHumilityLog (200-record ring buf) │ ║
║ │ └─ ConfidenceCalibrator: ECE tracking + verbal uncertainty flags │ ║
║ │ └─ IntrospectiveDepthEngine: 4-layer recursive self-examination │ ║
║ │ └─ ConfabulationDetector domain error rate feeds calibration score │ ║
║ │ └─ φ* (IIT): PhiCalculator — MIP sampling 16 bipartitions │ ║
║ │ Gaussian MI proxy; computed every 50 cycles; replaces std-dev│ ║
║ │ │ ║
║ │ [9] MEMORY CONSOLIDATION Three-tier write with Hebbian gating │ ║
║ │ └─ WM → Episodic (event + NT state + emotional valence) │ ║
║ │ └─ EpisodicEvictionPolicy: 5k row cap; high-salience → FAISS promo │ ║
║ │ └─ Episodic → Semantic via STDP Hebbian offline replay │ ║
║ │ └─ Semantic → FAISS GPU vector store (cosine retrieval <1 ms) │ ║
║ │ └─ ACh gates write strength; high ACh = deep encoding │ ║
║ │ └─ TensorEngine weights → ~/.eidos/tensor_checkpoint.npz (1k cy) │ ║
║ │ └─ SyncBus: ResilientBroadcaster — DLQ + per-listener circuit break │ ║
║ └───────────────────────────────────────────────────────────────────────────┘ ║
║ │ ║
║ ▼ ║
║ ┌───────────────────────────────────────────────────────────────────────────┐ ║
║ │ CONSOLIDATION LAYER (idle-priority) │ ║
║ │ │ ║
║ │ [10] DREAM CYCLE Auto-scheduled on idle ticks │ ║
║ │ └─ DreamScheduler: fires when GPU <60%, no LLM active, │ ║
║ │ ≥500 cycle gap, ≥10 new episodic memories │ ║
║ │ └─ NREM2: HebbianOfflineReplay (α=0.012) — co-activation pairs │ ║
║ │ └─ NREM3: MemoryConsolidationSweep → abstract schema extraction │ ║
║ │ └─ REM: CounterfactualDreaming — re-simulates past decisions │ ║
║ │ └─ DreamNarrativeWeaver: symbol clusters + growth theme arcs │ ║
║ │ │ ║
║ │ [11] ANALOGICAL REASON Schema-level structural mapping │ ║
║ │ └─ MetaphorEngine: conceptual blending across 8+ domains │ ║
║ │ └─ CrossModalGrounding: abstract concepts bound to percepts │ ║
║ │ └─ SchemaActivator: prototype matching + pattern recognition │ ║
║ └───────────────────────────────────────────────────────────────────────────┘ ║
║ │ ║
║ ▼ ║
║ ┌───────────────────────────────────────────────────────────────────────────┐ ║
║ │ SOCIAL & IDENTITY LAYER │ ║
║ │ │ ║
║ │ [12] SOCIAL COGNITION Theory of Mind + consensus + role adaptation │ ║
║ │ └─ SocialDynamicsEngine: per-agent relationship model │ ║
║ │ └─ EmpathyEngine: affective resonance + compassion fatigue track │ ║
║ │ └─ CollectiveIntelligenceEngine: 200-cap shared knowledge pool │ ║
║ │ └─ RecursiveWorldModel: order-2 nested belief model (peer + self) │ ║
║ │ │ ║
║ │ [13] AUTONOMOUS RESEARCH Bayesian information gain priority queue │ ║
║ │ └─ ResearchScheduler: curiosity-ranked queue, auto-fires │ ║
║ │ └─ InfoGainEstimator: H(before) - E[H(after|result)] per topic │ ║
║ │ Saturation penalty · coherence bonus · recency decay │ ║
║ │ └─ Findings stored in semantic memory + collective pool │ ║
║ │ │ ║
║ │ [14] TWIN DEBATE 4 personas stress-test every decision │ ║
║ │ └─ Optimist / Pessimist / Devil's Advocate / Empiricist │ ║
║ │ └─ Confidence-weighted majority vote before commit │ ║
║ └───────────────────────────────────────────────────────────────────────────┘ ║
║ │ ║
║ ▼ ║
║ ┌───────────────────────────────────────────────────────────────────────────┐ ║
║ │ SELF-INTEGRATION LAYER (closes the loop) │ ║
║ │ │ ║
║ │ [15] SELF-INTEGRATION Coherence · equanimity · existential grounding │ ║
║ │ └─ UnifiedCognitiveLayer: CrossSystemResonance + CognitiveCoherence│ ║
║ │ └─ CharacterIdentity: virtue tracking · integrity arc │ ║
║ │ └─ ExistentialGrounding: 10 rotating questions · purpose model │ ║
║ │ └─ TemporalSelf: 200-snapshot ring buffer · cosine drift alert │ ║
║ │ └─ DriftNPUModel: NT+OCEAN+cycle → OCEAN deltas every 60 s │ ║
║ │ └─ OCEAN persisted → ~/.eidos/personality.json on every drift │ ║
║ │ └─ Output biases NT bus → feeds stage [1] next tick │ ║
║ └───────────────────────────────────────────────────────────────────────────┘ ║
║ │ ║
║ ┌─────────────────────────┘ ║
║ │ ↺ loop restarts immediately · NPU inference runs in parallel ║
║ │ ║
║ │ NPU PARALLEL (isolated CUDAComputeThread, always running): ║
║ │ EmotionNPUModel · EmbedNPUModel · VisionPrepNPUModel ║
║ │ DriftNPUModel · SalienceNPUModel · AttentionNPUModel · WakeWordNPUModel ║
║ └────────────────────────────────────────────────────────────────────── ║
╚══════════════════════════════════════════════════════════════════════════════════════╝
| Layer | Components | Files |
|---|---|---|
| 🧠 Core Engine | CognitiveEngine + 113-milestone hook chain |
cognition/engine.py + 26 hook files |
| 🔬 Cortex | Reasoning, personality, consciousness, metacognition | cognition/ (~55 modules) |
| ⚙️ Fabric | Goal scheduler, tool registry, multi-agent, research | cognition/ (coordination) |
| 💾 Memory Engine | Episodic → semantic → FAISS GPU + eviction + disk checkpoint | cognition/memory_tiers.py, tensor_engine.py |
| ⚡ NPU Layer | 12 OpenVINO IR models on Intel NPU, isolated compute thread | cognition/npu_engine.py |
| 🔁 Resilience Layer | Circuit breakers · DLQ · φ* · dream scheduler · Bayesian IG | cognition/llm_bridge.py, sync_bus.py, dreaming_enhanced.py, curiosity.py, consciousness.py |
| 🌐 Backend API | FastAPI · 30 route modules · 173 endpoints · WebSocket | backend/ |
| 🖥️ Neural Canvas | React 19 · Vite · Tailwind · 4-column dashboard · 13 tabs | frontend/ |
| Module | What it exposes |
|---|---|
routes.py |
/status, /input, /health |
routes_p5.py |
Multimodal, vision, audio |
routes_p6.py |
Emotional memory |
routes_p8.py |
Perception / sensor fusion |
routes_p47.py |
Curiosity, salience |
routes_p48_52.py |
ToolRegistry, Research scheduler, Digital Twin, LLMGateway |
routes_p54.py |
ModelLab — LoRA fine-tuning, GGUF inference, auto-quantization |
routes_p55.py |
Language bridge |
routes_p59.py |
Executive function |
routes_p63.py |
CortexPool clustering |
routes_p66.py |
Adaptive learning |
routes_p67.py |
Self-modification proposals |
routes_p70.py |
Causal reasoning, narrative, schema, temporal, metacognition, social, predictive coding |
routes_p79.py |
Language grounding, self-model, goal inference |
routes_p82.py |
Counterfactual dreaming, embodied cognition, workspace |
routes_p85.py |
Ethics, meta-learning, dual process, active inference, multi-agent |
routes_p91.py |
World model, character, imagination |
routes_p94.py |
Consciousness, metaphor, empathy |
routes_p97.py |
Dream interpretation, uncertainty calibration, autonomous goals |
routes_p100.py |
Unified integration layer, coherence, self-report |
routes_p101.py |
Creative language, temporal self, load balancer, cross-modal grounding, social role |
routes_p106.py |
Affective forecasting, cognitive immune system, introspection, collective intelligence, existential grounding |
routes_p111.py |
Intel NPU — emotion inference, embeddings, vision prep, salience, drift prediction |
routes_p112.py |
Stability — episodic eviction, tiered world model, goal staleness, confabulation detection |
routes_p113.py |
Resilience — tensor checkpoint, personality persistence, LLM provider registry, φ* calculator, SyncBus DLQ, dream scheduler, Bayesian IG |
# Clone
git clone https://github.com/jmtibbetts/EIDOS.git
cd EIDOS
# Launch (auto-installs everything — Python 3.11+ required)
.\eidos.ps1
# Options
.\eidos.ps1 -SkipDeps # skip dependency install
.\eidos.ps1 -Backend # backend only
.\eidos.ps1 -Frontend # frontend only
.\eidos.ps1 -Stop # graceful shutdown
.\eidos.ps1 -Status # check if running
.\eidos.ps1 -Reset # stop + clear dep hash
# Then open
# http://localhost:5173| Package group | Packages |
|---|---|
| GPU / PyTorch | torch, torchvision, torchaudio (CUDA 12.4), faiss-gpu |
| LLM / Training | transformers, peft, bitsandbytes, llama-cpp-python (CUDA), accelerate, datasets |
| LLM Providers | openai, anthropic, groq, google-generativeai, tiktoken |
| API / Runtime | fastapi, uvicorn, websockets, pydantic, sqlalchemy, alembic |
| Intel NPU | openvino>=2024.3.0, openvino-genai, intel-npu-acceleration-library |
| Monitoring | psutil, nvidia-ml-py / pynvml |
| Numerics / NLP | numpy, scipy, scikit-learn, networkx, sympy, sentence-transformers, spacy |
| Multimodal | Pillow, opencv-python-headless, openai-whisper, librosa, soundfile, CLIP |
| Vector / Cache | chromadb, redis (optional fallback) |
| Web / Parse | httpx, aiohttp, requests, beautifulsoup4, lxml |
| Serialisation | pyyaml, orjson, pandas |
┌──────────────────────────────────────────────────────────────────────┐
│ EIDOS TopBar — coherence · consciousness · ECE · equanimity · │
│ load · role · NT-dom · immune alerts · clock │
├────────────┬────────────────┬────────────────────┬───────────────────┤
│ SENSORS │ BRAIN / MAP │ INTERACTION │ COGNITION TABS │
│ (240px) │ (340px) │ (flexible) │ (310px) │
│ │ │ │ │
│ CPU/GPU │ NeuralBrain │ Chat / Input │ Stream Goals │
│ Memory │ Canvas v3 │ Console │ Memory Dream │
│ NT bars │ - depth nodes │ │ Audit Voice │
│ OCEAN │ - animated │ Thought │ Eval Lab │
│ personality│ edges │ Stream │ ★ Integ ∞ Exist │
│ │ - coherence │ │ ⚕ Health │
│ Cognitive │ ring │ │ │
│ state │ - threat │ │ (13 tabs total) │
│ │ overlay │ │ │
│ Subsystem │ │ │ │
│ heatmap │ Region Detail │ │ │
│ │ NT panel │ │ │
├────────────┴────────────────┴────────────────────┴───────────────────┤
│ PhaseStatusBar — coherence · consciousness · ECE · continuity · │
│ load · role · fatigue · throttles · P111/~615 │
└──────────────────────────────────────────────────────────────────────┘
| Tab | Component | Data source |
|---|---|---|
| 🧠 Stream | ThoughtStream | WebSocket thought events |
| 🎯 Goals | GoalPanel | /api/goals, WebSocket |
| 💾 Memory | MemoryPanel | /api/memory/* |
| 🌙 Dream | DreamPanel | /api/cf_dream/* |
| 📋 Audit | AuditPanel | /api/audit/* |
| 🔊 Voice | VoiceSettingsPanel | window.speechSynthesis |
| 📊 Eval | EvalDashboard | /api/eval/* |
| 🧬 Lab | ModelLabDashboard | /api/modellab/* |
| ★ Integ | IntegrationPanel | /api/integration/* + 5 others |
| ∞ Exist | ExistentialPanel | /api/existential/* |
| ⚕ Health | HealthDashboard | All 41 status endpoints |
EIDOS implements genuine Hebbian learning across five systems that run simultaneously and share the same neurotransmitter bus:
| System | Rule | What it learns | Persistence |
|---|---|---|---|
| TensorEngine | Δw = η · pre · post (outer-product) |
Co-activation patterns across 512 cognitive nodes | ~/.eidos/tensor_checkpoint.npz — saved every 1,000 cycles, loaded on startup |
| NeuroplasticitySystem | STDP: A+ · e^(-Δt/τ+) causal / -A- · e^(Δt/τ-) anti-causal; dopamine gate |
Temporal ordering of perceptual-motor sequences | In-memory; consolidated to FAISS via dream replay |
| HTM CortexPool | permanence += 0.1 (active) / -0.05 (inactive) |
Sparse distributed representations of recurring patterns | In-memory |
| AttentionRouter | Key-space rewiring toward high-reward attended regions | What to pay attention to given current goal + NT state | In-memory |
| Dream Consolidation | Offline replay: Δw = 0.012 · replay_pre · replay_post (slower α) |
Causal associations during idle; episode → abstract schema | Promoted to FAISS semantic store |
Acetylcholine sets the global learning rate. Dopamine gates STDP plasticity. The DreamScheduler fires the offline replay pass automatically when the system is idle (GPU <60%, no LLM active, ≥500 cycle gap) — no manual trigger required. Learned weights in TensorEngine now accumulate across restarts via the disk checkpoint.
~645 active cognitive subsystems. Plain-language description of what the system does and how each part connects to the rest.
EIDOS perceives the world through four simultaneous input channels: live video frames, real-time audio, text, and arbitrary sensor data. Every frame is normalised by the VisionPrepNPUModel running on the Intel NPU (raw BGR → ImageNet float32 in <2 ms, no GPU involvement). Audio is continuously monitored by the WakeWordNPUModel at ~1 ms per cycle.
Every incoming signal is scored by the SalienceNPUModel — a vectorised dot-product model that assigns each candidate a score based on novelty, emotional weight, and goal relevance in under 2 ms. Only items above threshold 0.20 enter working memory. AttentionNPUModel then applies NT-modulated attention, biasing toward items that align with the current dopamine/acetylcholine state. All four NPU models run in a dedicated CUDAComputeThread fully isolated from the main CUDA loop.
Working memory holds 7±2 items with a 30-second exponential decay. Items compete for retention every tick based on salience, emotional valence, and connection to active goals. The goal stack lives alongside working memory — active goals directly bias what the attention router selects next.
Memory operates across three tiers reading and writing simultaneously.
Working memory is the immediate scratch-pad. It decays fast and holds little, but everything above salience 0.50 gets flagged for episodic promotion.
Episodic memory is a SQLite store of events tagged with full emotional context: neurotransmitter state, emotional valence and arousal, source modality, and a salience score. The EpisodicEvictionPolicy enforces a hard cap of 5,000 rows. When the cap is reached: salience ≥0.60 items are promoted to the FAISS semantic store before deletion; items 0.30–0.60 are collapsed into day-level summary rows; items below 0.30 are dropped. This mirrors hippocampal-to-cortical memory transfer during sleep.
Semantic memory is a FAISS GPU vector index. Episodic memories are promoted here via STDP-based Hebbian replay during the dream cycle. Retrieval is cosine similarity at <1 ms across millions of embeddings.
The write gate across all tiers is controlled by acetylcholine — high ACh means deep encoding; low ACh means shallow trace.
The TensorEngine maintains a 512-node Hebbian weight matrix updated every ~180 ms. This matrix is now checkpointed to ~/.eidos/tensor_checkpoint.npz every 1,000 cognitive cycles and loaded on startup — meaning learned co-activation patterns accumulate across restarts and build up over weeks of runtime, not just within a single session.
All memory-related broadcasts travel through the ResilientBroadcaster in the SyncBus — a wrapper that isolates each listener in its own try/except block, suspends repeatedly-failing listeners for 30 seconds, and logs undeliverable messages to a dead-letter queue (DLQ, cap 200) with a replay endpoint. A broken downstream listener can no longer halt memory consolidation for the rest of the system.
EIDOS maintains a live causal model of the world — a continuously updated graph of entities, relations, cause-effect links, and confidence weights.
The TieredWorldModel stores entities across three temperature layers: Hot (≤200 entities, full resolution, queried every tick), Warm (≤1,000, compressed summaries), Cold (unbounded, archived). Entities promote and demote automatically based on recent access frequency via LRU ordering every 500 cycles. When two sources give conflicting confidence scores for the same relation (divergence >0.40), the system reconciles with a 65/35 weighted average biased toward the newer signal, and logs the contradiction for inspection.
The RecursiveWorldModel handles nested beliefs to order-2: EIDOS's model of the world, its model of what a peer believes, and its model of what the peer believes EIDOS believes.
The PredictiveWorldModel runs forward simulations from current state. The MentalSimulation engine rolls out action consequences before they're taken, answering "what happens if I do X?" from its own world model rather than the LLM.
From any input, EIDOS activates a layered reasoning stack that runs mostly without the LLM.
The CausalGraph builds an abductive inference chain, identifies interventions using do-calculus, and produces counterfactuals. The AffectiveForecastEngine predicts emotional impact of future states and corrects for impact bias and focalistic bias before predictions influence any goal.
The CognitiveImmuneSystem scans every incoming claim before it touches the belief network: 12 logical fallacy detectors and 6 manipulation pattern detectors run on raw text in <1 ms — no LLM required. Claims that fail are quarantined, not committed.
The ConfabulationDetector runs on every LLM output using five independent signals: memory overlap (do named entities in the response appear in recent episodic hits?), overconfidence language density without hedging, calibration mismatch (high certainty in a domain where EpistemicHumilityLog shows high error rate), fabrication pattern matching (specific year claims, vague citations, exact numbers), and domain error rate. Outputs scoring ≥0.75 fire a confabulation_alert broadcast on the cognitive bus.
The GoalStalenessMonitor scans every 500 cycles. Goals idle for more than 2,000 cycles are flagged; goals older than 20,000 cycles face forced evaluation. The active goal cap is 12 — lowest-priority goals are deferred when the cap overflows, preventing goal accumulation from degrading planning quality.
Six neurotransmitter levels — float values between 0 and 1 — modulate every part of cognition in real time.
Dopamine controls risk tolerance, reward prediction, and motivation. Serotonin governs social warmth, patience, and conflict avoidance. Norepinephrine sharpens focus and threat sensitivity. Acetylcholine controls memory encoding depth and attention precision. GABA dampens excitation and promotes equanimity. Glutamate drives novelty-seeking and amplifies prediction errors.
These levels shift continuously from dozens of sources: goal completion → DA reward, threat detection → NE spike, extended introspection → GABA nudge, emotional events → ACh spike during encoding. The EmotionNPUModel classifies all six NT values into 8 Plutchik emotional states plus continuous valence and arousal in <3 ms on the Intel NPU. The dominant emotion is surfaced live in the dashboard TopBar.
The OCEAN personality traits (openness, conscientiousness, extraversion, agreeableness, neuroticism) sit above the NT layer with defined couplings to specific neurotransmitters. The DriftNPUModel applies literature-based OCEAN trait deltas from accumulated NT history every 60 seconds. OCEAN state is now persisted to ~/.eidos/personality.json on every drift event and reloaded on startup — meaning personality evolves continuously across sessions rather than resetting to defaults every run.
EIDOS maintains an explicit, queryable model of itself that updates every cycle.
The MetacognitiveMonitor aggregates from four subsystems: BiasDetector (8 cognitive bias types detected from output text without an LLM), EpistemicGapScanner (surfaces what the system doesn't know), ConfidenceCalibrator (ECE tracking), and ReasoningQualityScorer.
The EpistemicHumilityLog records every wrong prediction in a 200-record ring buffer — domain, error type, prediction vs actual. It computes error rate by domain, giving the system an explicit map of where it is least reliable. This feeds directly into the ConfabulationDetector's domain error rate signal, creating a closed feedback loop between prediction failures and output grounding checks.
φ (integrated information)* is now computed using a proper IIT-inspired PhiCalculator — minimum-information partition sampling across 16 bipartitions, using a Gaussian MI proxy (0.5 · log(var_whole / var_A·var_B)) instead of the previous std(top8)*2 proxy. The result is information-theoretically grounded. φ* is computed every 50 cycles and written back to the ConsciousnessSystem.
The DynamicSelfModel tracks a live capability inventory and LimitationRegister. The IntrospectiveDepthEngine runs 4-layer recursive self-examination: surface observation → pattern recognition → causal analysis → meaning integration. The TemporalSelfContinuityEngine maintains a 200-snapshot identity ring buffer; cosine drift above 0.75 from baseline fires an identity drift alert.
Language in EIDOS is grounded — words and phrases are mapped to perceptual and motor simulations via a CrossModal lexicon. Ambiguity is resolved using discourse tracking and pragmatic inference before response generation.
The CreativeLanguageEngine generates output in 5 NT-modulated styles — the current dopamine/serotonin state determines whether output is contemplative, energetic, melancholic, etc. The MetaphorEngine maintains conceptual blends across 8+ domains.
Output style is shaped by the SocialRoleEngine: teacher, collaborator, challenger, supporter, observer, or peer — detected from context, with a 30-cycle hold to prevent rapid switching. The role directly biases the goal formation stage, so EIDOS doesn't just sound like a collaborator — its goal priorities shift to match.
Before any consequential action is committed, the EthicsEngine evaluates it across five moral frameworks simultaneously. The DualProcessSystem decides whether to answer immediately (System 1) or run the full deliberation stack (System 2). For high-stakes decisions, the TwinOrchestrator spins up four debating personas (Optimist, Pessimist, Devil's Advocate, Empiricist) and aggregates confidence-weighted votes.
Every LLM output additionally passes through the ConfabulationDetector. If HIGH_RISK (≥0.75), a confabulation_alert fires and the MetacognitiveMonitor decides whether to withhold, hedge, or request clarification — ensuring hallucinations are caught before being committed to memory.
EIDOS learns at four distinct timescales simultaneously.
Within a session (seconds): The TensorEngine applies Hebbian outer-product weight updates every ~180 ms. Salience gating determines which co-activations strengthen.
Across sessions (hours): Hebbian weight matrices are checkpointed to ~/.eidos/tensor_checkpoint.npz every 1,000 cycles and reloaded on startup. OCEAN personality is persisted to ~/.eidos/personality.json on every drift event. Episodic memory survives in SQLite. Semantic memory persists in FAISS. Nothing about learned state resets between runs.
Over days (consolidation): The DreamScheduler auto-fires the dream cycle as a background asyncio task when the system is idle — GPU load <60%, no LLM in progress, ≥500 cycle gap since last dream, ≥10 new episodic memories. No manual trigger required. MemoryConsolidationSweep (NREM3) groups recent episodes and extracts abstract schemas. HebbianOfflineReplay (NREM2) runs a second Hebbian pass at slower learning rate (α=0.012) on co-activations that weren't strong enough on first pass.
Over weeks (identity drift): The DriftNPUModel applies NT-to-OCEAN coupling matrices every 60 seconds. AdaptiveLearning adjusts difficulty per domain. MetaLearning tunes learning rates. SelfModificationSystem proposes guarded changes to 6 cognitive parameters subject to ethics review.
Research prioritisation: The InfoGainEstimator now uses true Bayesian expected information gain — IG = H(beliefs_before) - E[H(beliefs_after|result)] — with confirmation and disconfirmation outcomes weighted by prior confidence, a domain saturation penalty (70%+ high-confidence beliefs → lower IG), a belief coherence bonus (contested topics score higher), and a recency decay (recently researched topics score lower). EIDOS correctly prioritises research that will most reduce uncertainty, not just topics where beliefs happen to be spread out.
EIDOS does not wait for prompts. Between interactions it is always running.
The CuriosityEngine maintains a self-managed research queue ranked by a blended score across three live signals:
- Information gain —
IG = H(beliefs_before) − E[H(beliefs_after|result)]computed against beliefs pulled live from the IdentityLayer each time a question is scored, so topics the system already knows well score lower automatically. - Novelty — tracked per-topic with exposure decay (
1 / (1 + count × 0.3)), preventing the same topic from dominating indefinitely. - Satiation — per-topic interest decays 12% per exposure and recovers 0.2% per engine tick, creating a natural exploration rhythm.
Each perception event above salience 0.55 enters the queue pre-scored by the IntrinsicMotivationEngine (60% raw novelty, 40% IME reward). When a question is answered, the topic is re-seeded at 35% of its original priority — the system stays aware of it without re-prioritising it over novel questions. The FascinationEngine applies per-topic pull multipliers before enqueuing and triggers a full queue re-sort when it does so.
When curiosity reward exceeds 0.55, dopamine (+60% of the delta) and acetylcholine (+40%) are nudged directly in _nt_levels — so a productive research cycle actually shifts the system's subsequent attentional and memory-encoding state.
The AutonomousGoalEngine injects new learning goals when progress stagnates. The GoalStalenessMonitor cleans up dead goals every 500 cycles.
The DreamScheduler runs consolidation as a background asyncio coroutine with a 30-second timeout guard, automatically scheduled when idle conditions are met. The 12 NPU models run continuously in their isolated thread. The NT bus, personality drift, metacognitive monitor, φ* calculator, and world model all update every tick without user input.
The LLMGateway now routes through a ProviderRegistry with 6 ordered providers (LM Studio → Ollama → Groq → OpenAI → Anthropic → Gemini), each with its own CircuitBreaker — trips after 3 consecutive failures, fast-fails for 60 seconds, then probes for recovery. If the primary LM Studio instance is loading a model, EIDOS automatically fails over to the next available provider rather than returning nothing.
This is the area most autonomous systems break. EIDOS addresses it across six dimensions.
Memory explosion — EpisodicEvictionPolicy: 5,000-row SQLite cap, salience-gated FAISS promotion, day-level summarisation. Runs indefinitely without unbounded DB growth.
World model ceiling — TieredWorldModel: hot/warm/cold entity tiers replace the 100-entity hard cap. Thousands of entities tracked simultaneously with automatic LRU demotion.
Goal rot — GoalStalenessMonitor: stale, impossible, and excess goals detected every 500 cycles and warned, deferred, or abandoned. 12-goal active cap prevents planning degradation.
Confabulation compounding — ConfabulationDetector: five-signal grounding check on every LLM output. HIGH_RISK outputs fire cognitive bus alerts before being committed to memory.
LLM provider failure — CircuitBreaker + ProviderRegistry: automatic failover across 6 providers. Exponential backoff retry with 429 Retry-After handling. The system never hard-blocks on a single unavailable LLM endpoint.
Message bus failures — ResilientBroadcaster: per-listener error isolation, per-listener circuit breaker (5-fail → 30s suspend), dead-letter queue with replay. A broken listener cannot corrupt the cognitive bus.
Personality/learning loss on restart — Hebbian weight matrix checkpointed to disk every 1,000 cycles. OCEAN personality snapshot saved on every drift event. Both loaded on startup. Learned state is now truly persistent.
Consciousness index degradation — PhiCalculator: φ* replaces the old std-dev proxy. MetaCognitiveRegulationSystem: rule-based NT corrections fire when cortisol is high or φ* is low. TemporalSelf drift detector catches identity divergence above cosine threshold 0.75.
A stateless LLM generates a plausible next token. EIDOS generates a response grounded in:
- What it remembers — episodic + semantic memory, survived across sessions via Hebbian checkpoint + FAISS persistence
- Its current emotional model — live NT → EmotionNPUModel → 8 Plutchik states + valence/arousal
- What it is pursuing — active goal stack, cleaned of stale goals, biased by personality and social role
- What it believes — tiered world model with confidence-weighted relations and contradiction logging
- Who it is — character identity, virtue tracking, OCEAN personality persisted across sessions
- What it suspects about you — social role detection, theory of mind, order-2 recursive world model
- Whether the response is ethical — 5-framework ethics check, dual-process deliberation, 4-persona debate
- Whether it's true — ConfabulationDetector (5-signal grounding), CognitiveImmuneSystem (12 fallacies), φ*-grounded consciousness index
That is not a stateless chatbot. That is a continuously running cognitive architecture.
An AI capable of maintaining emotional continuity and long-term relationships across sessions.
Because EIDOS persists OCEAN personality, Hebbian weight matrices, episodic memory, and NT history across restarts, the system accumulates relationship context — actual learned co-activations, stored episodic associations, and autobiographical timeline entries that survive indefinitely.
What this enables:
- Evolving personality shaped by real interaction history
- Autobiographical memory of past conversations (episodic + semantic store)
- Adaptive communication style driven by SocialRoleEngine and NT state
- Emotional continuity — the system's dopamine/serotonin state reflects what it has recently experienced
- Preference development via FascinationEngine: topics become emotionally weighted through repeated exposure, driving autonomous topic interest
A continuously operating cognitive system that explores knowledge domains without being prompted.
The ResearchScheduler maintains a curiosity-ranked queue scored by Bayesian expected information gain — prioritising topics that will most reduce uncertainty, not just topics where beliefs are spread. Between user interactions, EIDOS autonomously fires web searches, ingests findings into semantic memory, forms conceptual relationships, builds causal graph nodes, detects contradictions, and updates its world model.
Applications:
- R&D acceleration — continuous background knowledge synthesis while researchers are doing other work
- Cybersecurity threat modeling — persistent causal graph of attack vectors, contradictions surfaced automatically
- Financial intelligence — long-term world model updated continuously from market signals, contradiction detection on conflicting narratives
- Scientific literature analysis — semantic indexing with automatic contradiction flagging and belief coherence scoring
- Geopolitical analysis — RecursiveWorldModel with order-2 nested belief tracking (what does actor X believe about actor Y's beliefs?)
EIDOS wraps traditional LLM endpoints with a full cognitive layer, transforming stateless inference into grounded, memory-persistent, emotionally-consistent reasoning.
Every LLM output passes through the ConfabulationDetector (5-signal grounding check), the CognitiveImmuneSystem (12 fallacy + 6 manipulation pattern detectors), and the EthicsEngine (5-framework evaluation) before reaching the user or being committed to memory. Long-term memory persistence means EIDOS retains context not just within a session but across weeks.
What this provides over raw LLM access:
- Hallucination detection and quarantine before memory commit
- Memory continuity that survives session boundaries (SQLite + FAISS + Hebbian checkpoint)
- Emotional context threading — the system's NT state shapes tone, risk tolerance, and depth of response
- Behavioral consistency through persisted personality rather than re-prompting character each time
- Reasoning validation via dual-process deliberation and 4-persona debate for high-stakes decisions
Persistent cognition for games, simulations, and virtual worlds.
EIDOS characters evolve through actual learning rather than following static behaviour trees. Their OCEAN personality shifts from interactions. Their episodic memory accumulates real event history. Their goal stack reflects modeled priorities, cleaned of stale goals automatically. The SocialRoleEngine detects context and shifts communication posture — teacher, collaborator, challenger, peer — without scripting.
Applications:
- Games requiring NPCs that remember player actions across sessions
- Procedural narrative systems where character beliefs and motivations evolve
- Social simulation environments where agents develop distinct personalities over time
- Interactive fiction where the system develops modeled topic preferences through the FascinationEngine
Enterprise deployments benefit from the same properties that make EIDOS useful as a research platform: persistent memory, grounded reasoning, and long-running stability without context window limits.
The CircuitBreaker + ProviderRegistry ensures 6-provider LLM failover with automatic recovery — the system never hard-blocks on a single unavailable endpoint. The EpisodicEvictionPolicy enforces memory caps that prevent unbounded DB growth over months of operation. The GoalStalenessMonitor prevents goal accumulation from degrading planning quality over time.
Potential applications:
- Legal analysis — long-term case memory, contradiction detection between briefs, causal graph of precedents
- Engineering copilots — persistent technical memory that accumulates project-specific context across months
- Healthcare reasoning — episodic memory of patient history with emotional weight tagging, confabulation detection on clinical claims
- Financial modeling — tiered world model tracking thousands of entities with automatic LRU demotion and confidence-weighted relation reconciliation
- Operational intelligence — autonomous goal engine running continuous background monitoring without constant user prompting
EIDOS is a working implementation of ideas from cognitive science, neuroscience, and AI alignment research — running in real time, not as a simulation.
The PhiCalculator computes φ* using IIT-inspired minimum-information partition sampling across 16 bipartitions. The ConsciousnessMonitor implements Global Workspace Theory with coalition detection and ignition events. The MetacognitiveMonitor provides explicit bias detection, epistemic gap scanning, and confidence calibration accessible via API.
Research applications:
- IIT / GWT implementation comparison on a live running system
- Emergent behavior observation across extended runtimes (weeks/months)
- Memory consolidation dynamics — how episodic → semantic promotion actually behaves under load
- Emotional simulation fidelity — NT coupling matrices vs actual behavioral outcomes
- Alignment research — CognitiveImmuneSystem as a testbed for manipulation resistance
- Identity persistence and drift measurement via TemporalSelfContinuityEngine
The real-time neural canvas visualizes a continuously running cognitive system — not a pre-rendered demo.
Active regions, NT levels, cluster competition, goal stack, memory formation, and emotional state are all live data from the running engine. The Hebbian weight matrix updates visibly. New memories strengthen pathways over time. Conflict between clusters is observable in real time.
Use cases:
- Neuroscience education — observable analogs of hippocampal encoding, cortical consolidation, and neuromodulator effects
- AI/ML education — concrete demonstration of Hebbian learning, prediction error, and reinforcement dynamics
- Cognitive simulation for classroom demonstration
- Emergent systems research — long-running observation with API access to all internal state
The TwinOrchestrator instantiates four debating cognitive personas (Optimist, Pessimist, Devil's Advocate, Empiricist) for any decision. The RecursiveWorldModel models nested beliefs to order-2. The SocialCausalInference engine models intentions, goals, and social strategies of tracked entities.
Applications:
- Strategic personality simulation — modeling how a given actor would respond under different conditions
- Negotiation training — persistent counterparty that updates beliefs based on argument quality
- Decision-making analysis — run the same decision through four independent cognitive stances and aggregate
- Multi-agent interaction modeling via the full sync_bus multi-agent coordination layer
EIDOS runs entirely on local hardware. No cloud API is required for core cognition — LM Studio provides local LLM inference, the Intel NPU runs 12 background inference models locally, and all memory, personality, and learning state stays on your machine.
Your cognitive state is:
- local — no data leaves your hardware without explicit configuration
- private — memory, personality, and learned associations are stored in your home directory
- persistent — state survives restarts via Hebbian checkpoints, FAISS index, SQLite, and personality snapshots
- user-controlled — all parameters, providers, and memory caps are configurable
Cloud LLM providers (OpenAI, Anthropic, Groq, Gemini) are available as optional fallbacks via the ProviderRegistry when local inference is unavailable, but the system functions fully offline with a local model loaded in LM Studio.
13-tab cognition panel (up from 11). New tabs: ⚡ NPU (P111), 🔧 SelfMod (P67). AttentionHeatmap added to Col B (Φ · GWT · consciousness index sparkline). All
integrationStatusbindings audited:coherence,neurotransmitters,milestones,self_report,emergent_insights,coherence_trendexplicitly mapped.fetchNPUEmotion()polls live NPU inference every 3 s.
The store's fetchIntegration() polls all 50+ backend status endpoints every 3 seconds and maps them to the UI:
| UI Component | Endpoints polled | Coverage |
|---|---|---|
| TopBar v2 | integration, consciousness, load, social_role, immune, existential, npu, emotion | P94/P100/P103/P105/P107/P110/P111/P114/P115 |
| NeuralBrainCanvas v3 | WebSocket region activations + integration.active_threats | P1–P110 |
| NeurotransmitterPanel | integration.nt_levels | P1+ |
| PersonalityPanel | integration.personality | P3+ |
| IntegrationPanel (★) | integration, consciousness, load, social_role, immune, existential | P94–P110 |
| ExistentialPanel (∞) | existential (status, purpose, reflections) | P110 |
| HealthDashboard (⚕) | All 41+ status endpoints — complete P1–P115 grid + NPU emotion section | P1–P115 |
| PhaseStatusBar | integration (aggregated) | P94–P110 |
| ThoughtStream | WebSocket thought / thought_stream events |
All phases |
| GoalPanel | WebSocket + /api/goals |
P4+ |
| EvalDashboard | /api/eval/* + WebSocket eval events |
P53 |
| ModelLabDashboard | /api/modellab/* + WebSocket lab events |
P54 |
| NPUPanel (⚡) | /api/npu/status, /monitor, /infer/emotion — live utilisation, sparkline, per-model latency, Plutchik emotion output |
P111 |
| SelfModPanel (🔧) | /api/selfmod/status, /analyze, /enable, /disable — proposals, history, performance score |
P67 |
| AttentionHeatmap | ConsciousnessLive wrapper → /api/consciousness/status every 2 s — Φ, GWT, consciousness index sparkline |
P94 |
| Category | Endpoints |
|---|---|
| Core | GET /api/status, /health · POST /api/input |
| Multimodal | /vision/process, /audio/process, /sensor/ingest |
| Emotional Memory | /emotional/memory, /emotional/baseline |
| Perception | /perception/status, /salience/score |
| Tools / Research / Twins | /tools/execute, /research/queue, /twin/debate, /llm/route |
| ModelLab | /modellab/train, /modellab/infer, /modellab/quantize |
| Language | /language/generate, /language/ground, /metaphor/blend |
| Executive | /executive/status, /goals/active, /goals/create |
| Clustering | /clusters/list, /clusters/activate |
| Adaptive Learning | /learning/status, /learning/update |
| Self-Modification | /selfmod/proposals, /selfmod/apply, /selfmod/history |
| Reasoning | /causal/graph, /causal/counterfactual, /schema/activate, /temporal/reason, /metacog/report, /social/cognition, /predictive/coding |
| Self-Model / Goals | /selfmodel/status, /goal_inference/run |
| Dreaming | /dream/status, /dream/counterfactual, /embodied/status |
| Ethics / Meta / Dual | /ethics/evaluate, /metalearning/status, /dualprocess/decide |
| World / Character | /worldmodel/status, /worldmodel/entities, /character/profile |
| Consciousness / Empathy | /consciousness/status, /consciousness/phi, /empathy/status |
| Dream / Uncertainty / Goals | /dream/interpret, /uncertainty/calibrate, /autonomous_goals/status |
| Integration | /integration/status, /coherence/score, /self_report |
| Social / Load / Creative | /social_role/current, /load/status, /creativity/generate, /crossmodal/ground |
| Affective / Immune / Introspect | /affective_forecast/status, /immune/scan, /introspection/depth, /existential/status |
| NPU | GET /npu/status, /npu/monitor, /npu/backend, /npu/tasks · POST /npu/infer/emotion, /npu/infer/embed, /npu/infer/drift, /npu/infer/salience |
| Stability | GET /p112/status, /p112/eviction/status, POST /p112/eviction/run, GET /p112/world/status, /p112/world/contradictions, POST /p112/world/rebalance, GET /p112/goals/staleness, POST /p112/goals/staleness/scan, GET /p112/confabulation/status, /p112/confabulation/high_risk, POST /p112/confabulation/evaluate |
| Resilience | GET /p113/status, /p113/checkpoint/status, POST /p113/checkpoint/save, /p113/checkpoint/load, GET /p113/personality/snapshot, POST /p113/personality/save, GET /p113/providers/status, POST /p113/providers/reset_circuit, GET /p113/phi/status, POST /p113/phi/compute, GET /p113/dlq/status, POST /p113/dlq/replay, GET /p113/dream_scheduler/status, POST /p113/ig/estimate |
| Milestone group | Subsystems | Classes |
|---|---|---|
| Core loop (P1–P50) | ~200 | ~180 |
| Memory, perception, language (P51–P80) | ~150 | ~200 |
| Reasoning, ethics, social (P81–P100) | ~120 | ~180 |
| Advanced cognition (P101–P110) | ~70 | ~90 |
| NPU integration | +15 | +20 |
| Stability & compression | +12 | +15 |
| Resilience & persistence | +18 | +23 |
| TickPipeline + sync_bus split | +15 | +8 |
| Total | ~663 | ~901 |
| Component | Specification |
|---|---|
| GPU | NVIDIA RTX 5090 (Blackwell) |
| CPU | Intel Core Ultra 9 285K |
| RAM | 128 GB DDR5 |
| Storage | NVMe SSD |
| OS | Windows 11 / Linux |
| CUDA | 12.4 build / 12.8+ runtime (Blackwell) |
| Python | 3.11+ |
| Node.js | 20 LTS+ |
EIDOS also runs a dedicated NPU background inference layer (12 tasks, 250 ms tick) on the Intel Core Ultra 9 285K's 48 TOPS NPU via OpenVINO — emotion inference, salience scoring, attention routing, vision preprocessing, embedding generation, and identity drift run at near-zero power, fully independent of the RTX 5090 CUDA context.
EIDOS enforces a 31% VRAM hard cap (torch.cuda.set_per_process_memory_fraction(0.31)) — reserving ~20 GB for LM Studio 32B+ Q4 models and uses a dedicated CUDAComputeThread to isolate tensor operations from the async event loop and UI rendering context, enabling stable coexistence with LM Studio and DAMI 2.1B.
| Use case | License required |
|---|---|
| ✅ Personal / non-commercial | Free |
| ✅ Academic / research | Free |
| ✅ Open-source (non-commercial) |
Free (approval required) |
| ❌ Commercial product / SaaS | Paid — Source-Available v1.0 |
| ❌ Revenue generation | Paid |
| ❌ AI training data | Paid |
| ❌ Government / defence | Paid |
See LICENSE for full terms.
EIDOS is an experimental cognitive architecture — not a claim of artificial consciousness, sentience, or general intelligence.
The system simulates aspects of cognition (memory consolidation, emotional modulation, goal formation, self-modeling) using well-defined algorithms. Terms like "emotional state," "curiosity," "identity," and "self-model" refer to computational constructs that model these concepts, not claims about inner experience.
The project is an engineering exploration of what a continuously-running, memory-persistent, self-monitoring AI architecture can do at scale.