nimmerverse-sensory-network/architecture/Gateway-Architecture.md

Gateway Architecture: Resonant Gates and Tier Routing

ONE JOB: Route signals through resonant gates based on wave correlation and accumulated trust.

The Thalamus Pattern — gates that accumulate correlation and route to appropriate tiers.

---

Overview

The Gateway is not a switch. It's a network of resonant gates that:

1. Accumulate wave correlation from incoming signals
2. Transition between states (OPEN/STABLE/CLOSED) based on correlation
3. Route verified signals to the appropriate processing tier
4. Feed traces back for learning

Core Principle: Gates don't flip on single signals. Correlated waves push gates toward OPEN.

CELLS ──∿∿∿──► GATE ──∿∿∿──► GATE ──∿∿∿──► FUNCTION GEMMA ──► YOUNG NYX
        waves      │          │                   │
                   │          │                   │
            correlation   correlation      structured JSON
               builds       builds

---

The Ternary Gate Model

Gates have three states, not two. Binary logic doesn't model brains.

State	Meaning	What's Happening
OPEN	Actively forwarding	Signal passes upstream, gate is firing
STABLE	Resting, accumulating	Watching, learning, waiting for threshold
CLOSED	Actively blocking	Inhibited, suppressed, refractory

                      correlated signals
                           ↓ ↓ ↓
                      ════════════
    CLOSED ◄───────── STABLE ─────────► OPEN
           anti-correlation    correlation
           destructive         constructive
           interference        interference
                      ════════════
                           ↑ ↑ ↑
                      isolated signals
                      (noise → stay stable)

STABLE is not "off" — it's the resting state where:

• Context accumulates
• Correlation is measured
• Learning happens
• Energy is conserved
• Ready to transition either direction

---

Wave Correlation Drives Transitions

Gates accumulate correlation scores from incoming waves. Multiple signals agreeing push toward OPEN.

class ResonantGate:
    """A gate is a resonance chamber, not a switch."""

    state: float = 0.0  # -1.0 (CLOSED) ← 0.0 (STABLE) → +1.0 (OPEN)
    tier: int           # Which tier this gate routes to
    domain: str         # What domain (math, vision, speech, etc.)

    def receive_wave(self, signal: Wave, timestamp: float):
        # Correlate with recent signals in same time window
        correlation = self.correlate_with_recent(signal, timestamp)

        # Correlated waves → push toward OPEN
        # Anti-correlated → push toward CLOSED
        # Uncorrelated → decay toward STABLE

        self.state += correlation * signal.confidence
        self.state *= DECAY_FACTOR  # always drift back to stable

        if self.state > OPEN_THRESHOLD:
            self.forward_to_tier()    # gate opens, signal promoted
            self.trace("opened", signal)
        elif self.state < CLOSE_THRESHOLD:
            self.suppress()           # gate closes, signal blocked
            self.trace("closed", signal)
        # else: stay stable, keep accumulating evidence

    def correlate_with_recent(self, signal: Wave, timestamp: float) -> float:
        """
        Measure how well this signal correlates with recent signals.

        Correlation is HIGH when:
        - Multiple cells emit similar semantic content
        - Signals arrive in same time window
        - Confidence levels are similar

        Correlation is LOW/NEGATIVE when:
        - Signal contradicts recent signals
        - Isolated signal with no support
        - Signal outside expected range
        """
        recent = self.get_signals_in_window(timestamp, WINDOW_MS)
        if not recent:
            return 0.0  # No correlation data, stay stable

        return compute_semantic_similarity(signal, recent)

Why this matters:

Scenario	Gate Response
Single signal	Not enough to open (noise resistance)
Correlated burst	Constructive interference → OPENS
Contradicting signals	Destructive interference → CLOSES
Silence	Decay to STABLE (energy conservation)
Time gap	Only recent correlations matter (temporal attention)

---

Gate Hierarchy and Tier Routing

Gates form layers. Each layer gates access to the next tier.

TIER 4: YOUNG NYX (cognitive)
════════════════════════════════════════════════════════════════
       ▲
       │ structured JSON only
  ┌────┴────────────────────────────────┐
  │         FUNCTION GEMMA              │  ← THE BOUNDARY
  │    (always structured output)       │
  └────┬────────────────────────────────┘
       │
TIER 3: ORGANS (GPU inference)
════════════════════════════════════════════════════════════════
       ▲              ▲              ▲
  ┌────┴────┐    ┌────┴────┐    ┌────┴────┐
  │  GATE   │    │  GATE   │    │  GATE   │
  │ vision  │    │ speech  │    │ hearing │
  │ state:? │    │ state:? │    │ state:? │
  └────┬────┘    └────┬────┘    └────┬────┘
       │              │              │
TIER 1-2: CELLS/NERVES (CPU)
════════════════════════════════════════════════════════════════
       ▲              ▲              ▲
  ┌────┴────┐    ┌────┴────┐    ┌────┴────┐
  │  GATE   │    │  GATE   │    │  GATE   │
  │  math   │    │ battery │    │ sensors │
  │ state:? │    │ state:? │    │ state:? │
  └────┬────┘    └────┬────┘    └────┬────┘
       │              │              │
TIER 0: RAW SIGNALS (cells emit waves)
════════════════════════════════════════════════════════════════
  cell  cell  cell  cell  cell  cell  cell
    ∿∿∿   ∿∿∿   ∿∿∿   ∿∿∿   ∿∿∿   ∿∿∿   ∿∿∿

Each gate:

• Has its own state (OPEN/STABLE/CLOSED)
• Routes to a specific tier
• Accumulates correlation independently
• Traces all transitions for learning

---

Tier Definitions

Tier	Gate Opens When	Latency	Format
0	Hardware reflex (no gate, direct)	<10ms	numbers
1	Math/battery cells correlate	<50ms	states
2	Nerve-level patterns correlate	<200ms	behaviors
3	Organ-level signals correlate	<2000ms	vectors
4	Function Gemma boundary crossed	<4000ms	JSON
5	Partnership escalation	variable	dialogue

Key insight: Higher tiers see less traffic but higher trust. By the time a signal reaches Young Nyx, it's been correlated through multiple gates.

---

Function Gemma: The Structured Boundary

Function Gemma is the gate to cognition. It guarantees:

• Schema compliance: Every event follows a typed contract
• Predictable JSON: No hallucination, no free-form text
• Bidirectional: Sensors → JSON events, Decisions → JSON commands

┌─────────────────────────────────────────────────────────────────────────┐
│   BELOW THE LINE: Numbers, States, Vectors (gates accumulating)         │
│   ═══════════════════════════════════════════════════════════           │
│                                                                         │
│   Tier 0-2: numbers, states, behaviors                                  │
│   Tier 3: vectors, embeddings                                           │
│                                                                         │
│                    │ (gate opens when correlated)                       │
│                    ▼                                                    │
│   ┌─────────────────────────────────────┐                               │
│   │       FUNCTION GEMMA GATE           │                               │
│   │   (structured JSON boundary)        │                               │
│   │                                     │                               │
│   │  • Transforms correlated signals    │                               │
│   │  • Produces typed JSON events       │                               │
│   │  • No hallucination possible        │                               │
│   │  • Runs on CPU (Threadripper)       │                               │
│   └─────────────────┬───────────────────┘                               │
│                     │                                                   │
│   ═══════════════════════════════════════════════════════════           │
│   ABOVE THE LINE: Structured Events (trusted, validated)                │
│                                                                         │
│   {                                                                     │
│     "event_type": "attention_required",                                 │
│     "domain": "math",                                                   │
│     "correlated_signals": [...],                                        │
│     "confidence": 0.87,                                                 │
│     "suggested_action": "calculate"                                     │
│   }                                                                     │
│                                                                         │
└─────────────────────────────────────────────────────────────────────────┘

Function Gemma + Gate Model:

• Gate accumulates correlation from Tier 0-3 signals
• When gate OPENS, Function Gemma transforms to JSON
• Young Nyx sees clean, structured events
• Decisions flow back down through the same gates

---

Connection to Dual Garden Architecture

Gates behave differently in Virtual vs Real gardens:

Property	Virtual Garden	Real Garden
Gate tracing	FULL (every transition logged)	Gate signals only
Correlation learning	Active (training data)	Trust accumulated
State transitions	Frequent (exploration)	Verified (action)
Threshold	Lower (easy to open)	Higher (must be confident)

Signal Flow Between Gardens

VIRTUAL GARDEN                           REAL GARDEN
══════════════                           ═══════════

Cells emit waves                         Receive verified signals
    │                                         ▲
    ▼                                         │
Gates accumulate correlation             No re-verification
    │                                         │
    ▼                                         │
Gate OPENS (threshold met) ──────────────────►│
    │                                         │
    │◄───────────── Verification outcome ─────┘
    │
Update correlation weights
(learning happens)

---

Gate Transition NATS Messages

Every gate transition is published for observability:

{environment}.gates.{domain}.transition

Example: dev.gates.math.transition

{
  "gate_id": "math-gate-1",
  "from_state": "stable",
  "to_state": "open",
  "correlation_score": 0.87,
  "trigger_signals": [
    {"source": "math_cell_1", "confidence": 0.6},
    {"source": "math_cell_2", "confidence": 0.7},
    {"source": "math_cell_3", "confidence": 0.5}
  ],
  "timestamp": "2026-02-14T18:30:00Z",
  "routed_to_tier": 2
}

Trace streams enable:

• Real-time attention visualization (which gates are OPEN?)
• Training data for Function Gemma (what patterns open gates?)
• Anomaly detection (unexpected gate behavior)
• Learning rate tuning (how fast do gates stabilize?)

---

Complete Signal Flow Example

Early Learning (Gate Learning to Correlate)

Math cells emit waves about "calculate 15 + 27"
         │
         ▼
    GATE (math): state = 0.0 (STABLE)
         │
    Receive wave from math_cell_1 (confidence 0.6)
    Correlate with recent: no other signals yet
    state += 0.6 * 0.0 = 0.0 (still stable)
         │
    Receive wave from math_cell_2 (confidence 0.7)
    Correlate: similar to math_cell_1!
    state += 0.7 * 0.8 = 0.56 (moving toward open)
         │
    Receive wave from math_cell_3 (confidence 0.5)
    Correlate: confirms pattern!
    state += 0.5 * 0.9 = 1.01 (OPENS!)
         │
         ▼
    GATE OPENS → route to Tier 2
         │
         ▼
    Tier 2 processes, escalates to Function Gemma
         │
         ▼
    Function Gemma: { "event_type": "math_request", ... }
         │
         ▼
    Young Nyx (qwen3 /no_think): "42"
         │
         ▼
    Result flows back down

After Learning (Gate Quickly Opens)

Math cells emit waves about "calculate 100 + 50"
         │
         ▼
    GATE (math): state = 0.0 (STABLE)
         │
    Receive wave from math_cell_1
    Correlate: matches learned pattern!
    state += high correlation → 0.9 (near threshold)
         │
    Receive wave from math_cell_2
    state += → 1.2 (OPENS immediately!)
         │
         ▼
    Fast routing, minimal escalation needed

Learning moves gates toward faster opening for familiar patterns.

---

Design Principles

1. Ternary states — OPEN/STABLE/CLOSED, not binary
2. Correlation drives transition — Single signals don't flip gates
3. Gates accumulate — State is a continuous value, not a flag
4. Decay to stable — Without input, gates drift back to resting
5. Traces are training data — Every transition teaches the system
6. Hierarchical trust — Higher tiers = more correlation required
7. Function Gemma is the boundary — Cognition only sees structured JSON
8. Virtual explores, Real verifies — Different gate behavior per garden

---

Related Documents

Document	Scope
Dual-Garden-Architecture.md	Virtual/Real garden dynamics
Deployment-Architecture.md	Where gates run (containers, userspace)
Nervous-System.md	4D space, node weights, vocabulary
Message-Protocol-Design.md	NATS subjects, message formats
Cellular-Architecture.md	How cells emit waves

---

Summary

OLD MODEL:                    NEW MODEL:
═══════════                   ═════════

Signal → Route                Signal → Gate (accumulating)
Binary decision               Ternary state
Single signal triggers        Correlation triggers
Stateless routing             Stateful resonance

         ▼                             ▼

    Switch                        Resonance
    (mechanical)                  (biological)

Gates are resonance chambers. Correlation is the driver. Learning happens in STABLE state.

---

Version: 2.0 | Created: 2026-01-03 | Updated: 2026-02-14

"The thalamus doesn't think. It resonates."