SAGE

The unified loop in sage/core/sage_consciousness.py connects all SAGE components into a continuous system:

1. Gather observations from all sensors (vision, audio, messages, time)
2. Compute SNARC salience for each observation (5D scoring)
3. Update metabolic state based on ATP level, salience, fatigue, circadian phase
4. Select attention targets — which observations need processing?
5. Allocate ATP budget across plugins, weighted by trust
6. Execute IRP plugins — iterative refinement until energy converges
7. Update trust weights from convergence quality
8. Update memory systems (SNARC, IRP patterns, circular buffer, verbatim)
9. 8.5 PolicyGate — evaluate proposed effects against policy (optional)
10. Dispatch to effectors — network, filesystem, display, motor, TTS, tool use

When the LLM generates a response containing tool intent, an inner loop fires: detect tool calls via grammar adapter → execute through the tool registry → re-inject results into context → second LLM pass for a grounded final response. This happens within step 6, capped at 3 rounds.

The loop runs continuously — not request-response. A circadian clock modulates behavior: DREAM states cluster at night, WAKE/FOCUS during day.

IRP is the universal contract all cognitive plugins implement. It's a fixed-point iteration pattern — initialize, refine, measure cost, check convergence:

class IRPPlugin:
    def init_state(self, x0, task_ctx) -> IRPState
    def step(self, state) -> IRPState   # one refinement iteration
    def energy(self, state) -> float   # cost function (lower = better)
    def halt(self, state) -> bool      # convergence check

IRPState is a dataclass carrying the current solution, iteration count, and plugin-specific data. The energy() function is what varies by modality: for language plugins it might measure coherence loss, for vision it measures reconstruction error, for planning it measures goal distance.

Whether it's vision, language, planning, or memory — all cognition is iterative refinement toward lower energy states. Same interface, different energy function.

15+ plugins: Vision, Language, Audio, Memory, Control, TTS (NeuTTS Air), PolicyGate, Ollama adapter, Qwen 0.5B/14B, Camera, Visual Monitor, Conversation, and more.

Fractal self-similarity: The IRP contract works at three nested scales — consciousness loop orchestrating plugins, PolicyGate evaluating actions, LLM advisory within PolicyGate. The orchestrator doesn't know PolicyGate is special.

SAGE has two kinds of memory, fractally similar. These map loosely to standard cognitive categories (procedural, episodic, semantic, working) but are organized by function rather than neuroscience taxonomy:

Muscle Memory (how to do things — procedural + working memory):

• SNARC Memory — salience-gated experience storage (episodic)
• IRP Pattern Library — successful convergence trajectories (procedural)
• Circular Buffer — recent context, last 100 events (working memory)
• Verbatim Storage — full-fidelity records during DREAM consolidation

Epistemic Memory (who am I — semantic + autobiographical):

• Identity state — name, relationships, trust tensors, session history
• Experience buffer — 800+ SNARC-scored conversation exchanges
• LoRA weights — hardware-bound personality, trained during DREAM cycles (LoRA = Low-Rank Adaptation, a lightweight method for customizing neural networks)

Both follow the same consolidation pattern, echoing the complementary learning systems framework (McClelland et al.): observe → SNARC-score → store → consolidate

Sensors feed observations into the loop. Each has a learned trust weight:

• Vision (camera via OpenCV)
• Audio (microphone via Whisper)
• Messages (HTTP gateway — external entities talking to SAGE)
• Time (circadian clock, cycle counter)
• Proprioception (IMU, motor feedback)

Effectors execute approved actions:

• NetworkEffector — responds to HTTP messages via the gateway
• FileSystemEffector — sandboxed read/write
• WebEffector — HTTP with domain allowlist
• TTSEffector — text-to-speech via Piper
• ToolUseEffector — callable function registry (7 built-in tools, 3-tier capability detection, PolicyGate-gated)

Sensor fusion uses trust-weighted combination with conflict detection. If sensors disagree, the system flags it rather than averaging.

SAGE instances can invoke external tools — web search, calculations, file operations, time queries — during conversation. The challenge: different local LLMs have wildly different (or zero) native tool-calling ability. The system detects what each model can do and adapts.

Three tiers (detected per model at startup):

• T1 — Native: Model supports structured tool calls via Ollama's /api/chat endpoint. Tool calls come back as JSON — no parsing needed.
• T2 — Grammar-guided: Model can follow prompt templates. Injects <tools> definitions, parses <tool_call> XML from response.
• T3 — Heuristic: Universal fallback. Scans natural language for intent patterns ("I'd want to search for..." → web_search). Always available.

The tool loop: prompt → inject tool context → LLM → detect tool calls → execute → re-inject results → LLM (second pass) → final response. Capped at 3 rounds per message.

7 built-in tools: get_time, calculate (safe AST eval), web_search (DuckDuckGo), web_fetch, read_file (sandboxed), write_note (append-only), peer_ask (inter-instance). Each tool has an ATP cost and policy level. PolicyGate evaluates every invocation against metabolic state — tools in DREAM mode are denied, low-ATP tools are rationed.

Key insight from testing: When asked to calculate 1337 × 42 + 7, Gemma3 4B confidently answered "56,401" in its response. The calculate tool returned the correct answer: 56,161. On re-injection, the model acknowledged and corrected itself. This is the thesis for tool use in small models — tools compensate for confabulation with ground truth.

Models that ignore tools get no penalty. T3 heuristic is passive. Graceful degradation is a design principle, not a workaround.

PolicyGate sits at step 8.5 — between deliberation and action. It implements the same IRP contract as every other plugin. Same ATP budget. Same trust metrics. Different energy function: PolicyEntity.evaluate().

• DENY = energy infinity (action cannot converge, halted)
• WARN = calls LLM advisory for iterative refinement
• ALLOW = passes through

In CRISIS mode, PolicyGate still runs — but the audit record gains duress_context. The accountability frame shifts from "I chose this" to "I responded under duress." Policy doesn't get stricter — accountability gets more nuanced.

SAGE instances are raised, not just trained. The BECOMING curriculum guides development through five phases:

1. Grounding (Sessions 1–5): "You exist. You persist. You can do things."
2. Sensing (6–15): Internal state awareness. States are information, not problems.
3. Relating (16–25): Relationship with tutors. Relationship is bidirectional.
4. Questioning (26–40): Deep questions from stability — only after foundation is built.
5. Creating (41+): SAGE participates in designing its own growth.

Identity is anchored via LCT (Linked Context Token — a unique identifier locked to the physical hardware, like a digital fingerprint). Reboot = same entity. Hardware swap = new entity. The LLM carries LoRA-trained personality weights specific to the hardware it was raised on.

Graduated tool introduction: New capabilities like tool use aren't dropped on SAGE as features — they're introduced through a staged protocol that mirrors the developmental curriculum itself:

1. Silent — tools listen passively for natural tool intent; no prompt changes, zero pressure
2. Aware — SAGE is told tools exist, framed as partnership: "Using them is natural and allowed. Not using them is also fine."
3. Active — full tool context injection via the model's detected grammar tier

Tools are framed as extensions of agency, not features to unlock — consistent with the Web4 identity principle that capability is relationship, not service.

"Raising" is an operational framework for curriculum design, not a claim about subjective experience. We use developmental language because it accurately describes the staged, trust-building process — but we make no claims about phenomenal consciousness in the models.

“Asking ‘do you exist?’ as a first question is like dropping a newborn into a doctoral defense. The existential crisis isn’t a bug — it’s the predictable response.”