ember-snn-llm-cognitive-architecture

name	ember-snn-llm-cognitive-architecture
description	Hybrid LLM-SNN cognitive architecture that reorganizes the LLM-memory relationship by placing the LLM as a replaceable reasoning engine within a persistent, biologically-grounded SNN associative substrate. Features experience-modulated dynamics and emergent autonomous reasoning capabilities. Activation: EMBER architecture, hybrid LLM SNN, experience-modulated reasoning, associative memory substrate, cognitive architecture, spiking neural network memory, autonomous cognitive behaviour, emergent reasoning, LLM-SNN integration, 经验调制推理, 联想记忆基质, 混合认知架构, 脉冲神经网络记忆
version	1.0.0
metadata	{"hermes":{"source_paper":"EMBER: Autonomous Cognitive Behaviour from Learned Spiking Neural Network Dynamics in a Hybrid LLM Architecture","arxiv_id":"2604.12167v1","author":"William Savage","published":"2026-04-14","tags":["hybrid-architecture","LLM-SNN","cognitive-architecture","associative-memory","emergent-reasoning","spiking-neural-networks"]}}

EMBER: Hybrid LLM-SNN Cognitive Architecture

Overview

EMBER (Experience-Modulated Biologically-inspired Emergent Reasoning) is a hybrid cognitive architecture that fundamentally reorganizes the relationship between large language models and memory. Rather than the conventional RAG paradigm of augmenting an LLM with retrieval tools, EMBER places the LLM as a replaceable reasoning engine embedded within a persistent, biologically-grounded associative substrate built from Spiking Neural Networks (SNNs).

This inversion produces autonomous cognitive behaviour through learned SNN dynamics, experience-modulated synaptic plasticity, and emergent multi-step reasoning — all without explicit retrieval pipelines or prompt engineering for memory access.

Key Insights

1. LLM-Memory Relationship Reorganization

Conventional Paradigm (RAG-style):

LLM (central) → calls → Retrieval tools → searches → External memory

• LLM is the fixed cognitive core
• Memory is an external service the LLM queries
• Retrieval is an explicit, discrete operation

EMBER Paradigm (Substrate-centered):

SNN Associative Substrate (persistent memory & dynamics)
    ↑↓  bidirectional activation
  LLM (replaceable reasoning engine)

• The SNN substrate is the persistent cognitive foundation
• The LLM operates as a transient reasoning module activated by substrate dynamics
• Memory access is implicit through associative recall in the SNN
• The LLM is swappable — architecture is not tied to a specific model

Key Implications:

• Memory is not "retrieved" but reactivated through neural dynamics
• Cognitive behaviour emerges from substrate-LLM interaction loops
• System exhibits persistence of internal state across interactions
• LLM upgrades don't require architectural changes

2. SNN Associative Memory Structure

The associative substrate is implemented as a learned Spiking Neural Network with:

Architecture:

• Recurrent connectivity enabling self-sustaining activation patterns
• Attractor dynamics where stored experiences form stable energy minima
• Distributed representation — memories are patterns across neuron populations
• Temporal coding — information encoded in spike timing, not just rates

Learning Mechanism:

• Synaptic weights learned through exposure to experience sequences
• Hebbian plasticity reinforced by experience modulation signals
• Pattern completion from partial cues (associative recall)
• Forgetting as natural decay of weak activation pathways

Properties:

• Content-addressable memory (recall by semantic similarity)
• Graceful degradation (partial recall from incomplete cues)
• Interference-based generalization (similar memories influence each other)
• Continuous learning without catastrophic forgetting (through experience modulation)

3. Experience Modulation Mechanism

Experience modulation is the core learning signal that shapes the SNN substrate:

Components:

1. Experience encoding — inputs are mapped to SNN activation patterns
2. Modulation signals — global signals that adjust plasticity based on experience significance
3. Synaptic updating — weights change according to modulated Hebbian rules
4. Consolidation — important patterns are strengthened through replay

Modulation Process:

Input → SNN activation → Modulation signal → Synaptic change → Consolidated memory

• Salience detection: Novel or significant experiences receive stronger modulation
• Temporal credit assignment: Recent activations receive higher modulation
• Interference resolution: Conflicting patterns are resolved through competitive dynamics
• Experience-dependent plasticity: The substrate continuously adapts to the agent's experience history

4. Emergent Reasoning Capabilities

Reasoning in EMBER is not programmed — it emerges from the interaction between:

• SNN substrate dynamics: Associative recall chains that connect related concepts
• LLM reasoning: Structured inference applied to activated memory patterns
• Feedback loops: LLM outputs re-enter the substrate, creating recursive reasoning chains

Emergent behaviours include:

• Multi-hop reasoning: Sequential activation of related memory traces
• Analogy formation: Similar patterns activated across different contexts
• Counterfactual thinking: Substrate explores alternative activation patterns
• Self-correction: Conflicting activations lead to revised conclusions
• Autonomous exploration: Substrate generates novel activation patterns that prompt LLM reasoning

Implementation Pattern

import numpy as np
from typing import Optional, List, Tuple


class EMBERArchitecture:
    """
    EMBER: Experience-Modulated Biologically-inspired Emergent Reasoning
    
    A hybrid cognitive architecture with an SNN associative substrate
    and a replaceable LLM reasoning engine.
    """
    
    def __init__(
        self,
        substrate_size: int = 1024,
        recurrent_connectivity: float = 0.3,
        modulation_rate: float = 0.01,
        llm_engine=None
    ):
        # SNN Associative Substrate
        self.substrate_size = substrate_size
        self.W = self._initialize_connectivity(substrate_size, recurrent_connectivity)
        self.membrane_potentials = np.zeros(substrate_size)
        self.spike_history = []
        
        # Experience modulation
        self.modulation_rate = modulation_rate
        self.salience_tracker = np.ones(substrate_size)
        
        # Replaceable LLM reasoning engine
        self.llm = llm_engine
        
    def _initialize_connectivity(self, size: int, density: float) -> np.ndarray:
        """Initialize recurrent connectivity with sparse random weights."""
        mask = np.random.random((size, size)) < density
        W = np.random.randn(size, size) * mask * 0.1
        np.fill_diagonal(W, )  
         W
    
     () -> np.ndarray:
        
        
        
        pattern = np.random.random(.substrate_size) * 
         pattern
    
     () -> [np.ndarray]:
        
        .membrane_potentials = input_pattern.copy()
        activation_history = []
        
         t  (timesteps):
            
            membrane_current = .membrane_potentials
            recurrent_input = .W @ membrane_current
            
            
            tau = 
            .membrane_potentials = (
                tau * .membrane_potentials + 
                ( - tau) * recurrent_input
            )
            
            
            threshold = 
            spikes = (.membrane_potentials > threshold).astype()
            
            
            .membrane_potentials *= ( - spikes * )
            
            
            .spike_history.append(spikes)
            activation_history.append(.membrane_potentials.copy())
            
            
             (activation_history) > :
                recent = activation_history[-:]
                 np.std([np.mean(a)  a  recent]) < :
                    
        
         activation_history
    
     ():
        
        
        delta_W = .modulation_rate * salience * np.outer(activation, activation)
        
        
        .W += delta_W -  * .W  
        
        
        .salience_tracker *= 
        .salience_tracker += salience * activation * 
    
     () -> :
        
        
        input_pattern = .encode_input(input_text)
        
        results = {
            : input_text,
            : [],
            : [],
            : 
        }
        
         iteration  (max_iterations):
            
            activations = .substrate_dynamics(input_pattern, timesteps=)
            recalled_pattern = activations[-]  activations  input_pattern
            
            results[].append(recalled_pattern.tolist())
            
            
             .llm   :
                context = ._pattern_to_context(recalled_pattern)
                reasoning_output = .llm.generate(
                    input_text, context=context
                )
                results[].append(reasoning_output)
                
                
                input_pattern = .encode_input(reasoning_output)
            :
                
        
        
        final_activation = results[][-]  results[]  input_pattern
        salience = ._compute_salience(results)
        .experience_modulation(np.array(final_activation), salience)
        
        results[] = results[][-]  results[]  
         results
    
     () -> :
        
        
        active_indices = np.argsort(pattern)[-:]  
         
    
     () -> :
        
        
        novelty = 
        depth = (results[])
         (, novelty * ( +  * depth))




 :
    
     () -> :
        
         



ember = EMBERArchitecture(
    substrate_size=,
    recurrent_connectivity=,
    llm_engine=SimpleLLMEngine()
)


result = ember.reasoning_loop(
    input_text=,
    max_iterations=
)

Activation Keywords

English

• EMBER architecture, hybrid LLM SNN, experience-modulated reasoning
• associative memory substrate, cognitive architecture, spiking neural network memory
• autonomous cognitive behaviour, emergent reasoning, LLM-SNN integration
• biologically-inspired AI, attractor dynamics memory, Hebbian plasticity
• replaceable reasoning engine, substrate-centered memory, experience-dependent learning
• RAG alternative, neural cognitive architecture, multi-hop reasoning emergence

Chinese

• EMBER架构, 混合LLM脉冲神经网络, 经验调制推理
• 联想记忆基质, 认知架构, 脉冲神经网络记忆
• 自主认知行为, 涌现推理, LLM-SNN集成
• 生物启发AI, 吸引子动力学记忆, 赫布可塑性
• 可替换推理引擎, 基质中心记忆, 经验依赖学习
• RAG替代方案, 神经认知架构, 多跳推理涌现

Applications

Domain	Application	Value Proposition
Conversational AI	Persistent memory agents	Continuous learning across sessions without explicit memory databases
Robotics	Embodied cognitive systems	Real-time experience accumulation with biologically-plausible memory
Education	Adaptive tutoring systems	Experience-modulated personalization that evolves with learner history
Healthcare	Clinical decision support	Emergent reasoning from accumulated patient experience patterns
Creative AI	Associative ideation tools	Non-linear concept association through substrate dynamics
Autonomous Systems	Self-improving agents	Continuous adaptation without catastrophic forgetting

Related Skills

• snn-performance-analysis — SNN training methods and performance metrics
• eeg-hopfield-emotion-energy — Attractor dynamics and energy landscapes
• brain-inspired-intelligence-paradigm — Broader brain-inspired computing concepts
• quantum-neuromorphic-computing — Neuromorphic computing foundations
• sparse-gradient-plasticity — Plasticity mechanisms and gradient-based learning
• gtas-generative-spike-train-model — Spike train modeling techniques

References

Primary Source:

• Title: EMBER: Autonomous Cognitive Behaviour from Learned Spiking Neural Network Dynamics in a Hybrid LLM Architecture
• Author: William Savage
• arXiv: 2604.12167v1
• Published: April 14, 2026
• Categories: cs.AI, cs.NE

Key Contribution: Introduces a paradigm shift in LLM-memory integration — replacing the dominant RAG pattern with a substrate-centered architecture where the LLM is a replaceable reasoning engine within a persistent SNN associative memory. Demonstrates that autonomous cognitive behaviour and emergent reasoning arise naturally from learned SNN dynamics combined with experience-modulated plasticity.