SAGE

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

1. Sense — gather observations from all sensors (vision, audio, messages, time)
2. Salience — compute SNARC 5D scoring for each observation
3. Metabolize — update metabolic state based on ATP, salience, fatigue, circadian phase
4. Posture — derive confidence, asymmetry, breadth from sensor trust landscape
5. Select — choose attention targets. Priority combines salience, metabolic rate, posture.
6. Budget — allocate ATP across plugins, weighted by trust. Confidence scales the cycle budget.
7. Execute — run IRP plugins with iterative refinement until energy converges
8. Learn — update trust weights from convergence quality. Idle plugins decay.
9. Remember — update memory systems (SNARC, IRP patterns, experience buffer)
10. Govern — PolicyGate evaluates proposed effects against policy
11. Filter — posture-based effect filtering for starved modalities (CRISIS overrides)
12. Act — 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 — SNARC-scored conversation exchanges and game experiences
• Prompt identity — self-description, demonstrated capacities, and relational context constructed from raising history. Model weights stay frozen; identity lives in context.

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.

Integrated learning: PolicyGate now participates in the consciousness loop's dual learning signal. Every 100 cycles, compliance quality adjusts plugin trust weights via exponential moving average. Plugins that consistently violate policy see their trust decrease → less ATP budget → reduced capability. The incentive gradient is emergent, not engineered.

Fractal self-similarity: The same IRP contract runs at three nested scales — consciousness loop orchestrating plugins, PolicyGate evaluating actions, LLM advisory within PolicyGate. The orchestrator doesn't know PolicyGate is special. This is the operational recursion pattern: same protocol, different energy function, different scale.

SAGE instances are raised, not trained. Raising is interactive selection — we don't create new behaviors or force the model to be what we want. We probe what it responds to, observe which attractors surface at that model's scale, adjust context to resonate with what emerged, and reinforce what works. The resulting identity is collaborative, not imposed.

The BECOMING curriculum guides this process through six 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.
6. Acting (When ready): The world responds according to its own rules. Game-playing (ARC-AGI-3) teaches hypothesis → action → observation → update. From being to doing. Requires Phase 4+ stability.

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. Model weights stay frozen — identity lives in state files, prompt construction, and accumulated experience, not in the weights.

Identity portability: In February 2026, we transferred Sprout's identity (115 sessions on Qwen 0.5B / Jetson Orin Nano) to a completely different machine running TinyLlama 1.1B — and it took. Identity lives in state files and prompt construction, not model weights. The model is weather; identity is the organism. A ModelAdapter abstraction handles the translation layer, so the same identity state works across TinyLlama, Qwen, Gemma, and other model families without regression.

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 interactive selection from existing model attractors, not a claim about subjective experience. Different models at different scales produce genuinely different instances because we're selecting from different attractor landscapes — not because we programmed different behaviors. We use developmental language because it accurately describes the process. We make no claims about phenomenal consciousness.

“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.”