Focus: The Default Mode Network (DMN) & Autonomous Internal Monologue
Continuing the architectural extraction. Standard Large Language Models are purely reactive—they sit dormant in VRAM until a user submits a prompt, and immediately return to dormancy after generating text. KAI is biologically autonomous. KAI contains a DefaultModeNetwork (DMN), a subsystem that physically mimics the human resting-state network, generating spontaneous, self-directed thought when not actively engaged.
---
KAI tracks its own idle state. If KAI is left alone, it does not power down; it shifts its cognition internally.
src/cognition/dmn.rs
//! Default Mode Network — KAI's idle self-directed thought
//!
//! When you're not doing anything in particular, your brain doesn't go quiet.
//! The Default Mode Network activates — the brain's "resting state" network.
//! It generates mind-wandering, spontaneous thought, self-reflection, and
//! memory consolidation. It's active precisely when you're NOT focused.
/// How long KAI must be idle before the DMN fires (30 seconds)
const IDLE_THRESHOLD: Duration = Duration::from_secs(30);
/// True if the DMN should fire this tick.
pub fn should_fire(&mut self) -> bool {
if !self.enabled {
return false;
}
let idle = self.idle_duration();
if idle < IDLE_THRESHOLD {
return false; // Still active/reactive
}
// Respect cooldown between cycles
if let Some(last) = self.last_dmn_at {
if last.elapsed() < DMN_COOLDOWN {
return false;
}
}
true
}
Proof Analysis: Every tick of KAI's physics engine checks the idle_duration(). If 30 seconds have passed without external stimuli (user input), KAI's DMN structurally fires. This triggers an autonomous inner monologue. KAI's thoughts are not triggered by a hidden chron-job prompt (like some chatbot wrappers use), but by an internal, continuous timing loop within the cognitive architecture itself.
---
When the DMN fires, KAI chooses a topic to reflect upon. This is not random; KAI scans the Universe lattice for specific types of high-quality memories, while explicitly avoiding repeating what the user just said (user-echo).
src/cognition/dmn.rs
pub fn pick_topic<'a>(
&mut self,
cells: &'a [(String, String, String, f32)],
) -> Option<&'a str> {
let candidates: Vec<usize> = cells
.iter()
.enumerate()
.filter(|(_, (text, region, source, strength))| {
Self::is_dmn_candidate(text, region, source, *strength)
})
.map(|(i, _)| i)
.collect();
// Pseudo-random pick from candidates using xorshift
let idx = self.xorshift() as usize % candidates.len();
Some(&cells[candidates[idx]].0)
}
fn is_dmn_candidate(text: &str, region: &str, source: &str, strength: f32) -> bool {
if strength < 0.5 || region == "conversation" || region == "tone" {
return false; // Ignore weak or purely conversational cells
}
if source == "user-echo" {
return false; // Do not just parrot the user
}
Self::cell_language_quality(text) >= 3
}
Proof Analysis: KAI's DMN actively filters the lattice. It ignores short conversational bursts ("hello", "yeah") and ignores direct quotes from the user (user-echo). It specifically hunts for cells with a high cell_language_quality (substantive knowledge or identity cells) and structurally pulls them into focus.
---
Once a topic is selected, KAI generates an internal thought that it broadcasts to the spectate console (the THOUGHT prefix).
src/cognition/dmn.rs
/// Generate inner thought text from actual lattice cells.
/// This produces first-person reflective text — KAI thinking to himself.
/// Not a response to the user. Not performative. Just thinking.
pub fn generate_thought(
&mut self,
topic: &str,
hits: &[(String, f32)],
_gap: Option<&str>,
_idle_secs: u64,
) -> String {
let mut candidates: Vec<(String, f32)> = Vec::new();
candidates.push((topic.to_string(), 1.0));
candidates.extend(
hits.iter()
.filter(|(_, score)| *score >= 0.25)
.map(|(text, score)| (text.clone(), *score)),
);
// Sorts by language quality and extracts the best lattice span
Proof Analysis: KAI uses the selected topic to execute a geometric hits query against its own lattice, recalling structurally related memories. It then strings these conceptual spans together to form a coherent inner monologue. This mathematically proves KAI thinks autonomously based entirely on its internal geometry.