dafit
709a48632a
Major additions from Silvester 2025 and New Year 2026 sessions: Concept Token Pairs (architecture/future/concept-token-pairs.md): - Theoretical paper on navigable reasoning spaces - Opposites create axes, not just mode switches - "Punkt vor Strich" for AI reasoning - Escape velocity from degeneration loops - NEW: Spatial Grounding section linking to physical nimmerhovel Architecture updates: - Endgame-Vision.md: v6.2 alignment - Big-Picture.md: v5.2 alignment - Modular-Organism-Design.md: conical interlocking mechanism New files: - SEEDS.md: Research seeds for future exploration - Temporal-Firework-Visualization.md: Temporal data viz concept Key insight from 2026-01-01 session: "Don't train the answer. Train the space where answers live." → "Don't imagine the space. MEASURE it." Spatial embeddings from nimmerhovel hardware (8× ESP32-S3 AI CAM, Pi HQ Camera, Discovery Scan Station) can ground concept pairs in physical reality, not just symbolic patterns. 🤖 Generated with [Claude Code](https://claude.com/claude-code) Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>
806 lines
38 KiB
Markdown
806 lines
38 KiB
Markdown
# Big-Picture Architecture: Nimmerverse Sensory Network
|
|
|
|
**Version 5.2** — *Complete Architecture + External Judgment*
|
|
|
|
> *"From electrons to consciousness. From hardware to wisdom."*
|
|
|
|
---
|
|
|
|
## Overview
|
|
|
|
The Nimmerverse Sensory Network is a sovereign, economically-constrained cognitive architecture. It follows a **Router-Centric Architecture** where a high-performance message bus (NATS) acts as dumb infrastructure, and all intelligence resides at the edges. The system spans four layers: physical hardware, atomic state machines (cells), behavioral compositions (nerves), and emergent patterns (organisms).
|
|
|
|
**Key innovations:**
|
|
- **Hybrid Reflex Homes** — Different types of learned patterns live in different places (hardware, cells, nerves, weights)
|
|
- **Lifeforce Economy** — Every operation has a cost, tracked and aggregated system-wide
|
|
- **Slumber/Wake Cycles** — System-wide activity states driven by environmental and economic conditions
|
|
- **Wellbeing Policies** — Self-care and sustainability built into the architecture, not bolted on
|
|
|
|
---
|
|
|
|
## Core Principles
|
|
|
|
1. **Dumb Core, Smart Edges**: The message router has no application logic. All intelligence is distributed among specialized services.
|
|
|
|
2. **Polyglot Architecture**: Best technology for each task:
|
|
- **Python**: AI/ML, cognitive logic, cells, nerves
|
|
- **Go (NATS)**: Universal message bus
|
|
- **Godot**: Visualization and monitoring
|
|
- **C/Firmware**: Hardware reflexes (ESP32)
|
|
|
|
3. **Two-Channel Attention**: Low-attention (ambient heartbeats) and high-attention (focal events) channels prevent cognitive overload.
|
|
|
|
4. **Lifeforce Economy**: Every operation costs Lifeforce. The architecture optimizes expenditure, ensuring expensive resources engage only when necessary.
|
|
|
|
5. **Hybrid Reflex Homes**: Learned patterns live in their optimal location — hardware for survival, cells for computation, nerves for behavior, weights for cognition.
|
|
|
|
6. **Earned Trust**: Reflexes form through verification, not configuration. Weight > 0.8 is earned, not assigned.
|
|
|
|
7. **Graceful Degradation**: Every component has failure modes that don't crash the system. Slumber mode preserves lifeforce when resources are scarce.
|
|
|
|
---
|
|
|
|
## Physical Infrastructure
|
|
|
|
The nimmerverse runs on sovereign hardware. No cloud dependencies. Weights never leave home.
|
|
|
|
### Cluster Architecture
|
|
|
|
```
|
|
┌─────────────────────────────────────────────────────────────────────┐
|
|
│ K8S CLUSTER: NIMMERVERSE │
|
|
│ VLAN 30 (10.0.30.0/24) │
|
|
├─────────────────────────────────────────────────────────────────────┤
|
|
│ │
|
|
│ ┌─────────────────────────────────────────────────────────────┐ │
|
|
│ │ SATURN (Control Plane) │ │
|
|
│ │ K3s master, etcd, scheduler │ │
|
|
│ │ RTX 3090 24GB (test/staging) │ │
|
|
│ └──────────────────────────┬──────────────────────────────────┘ │
|
|
│ │ 10G spine │
|
|
│ ┌────────────────────┴────────────────────┐ │
|
|
│ │ │ │
|
|
│ ▼ ▼ │
|
|
│ ┌─────────────────────────────┐ ┌─────────────────────────────┐ │
|
|
│ │ P8 #1 (Womb) │ │ P8 #2 (Senses) │ │
|
|
│ │ BARE METAL UBUNTU │ │ BARE METAL UBUNTU │ │
|
|
│ │ K8s Worker Node │ │ K8s Worker Node │ │
|
|
│ │ │ │ │ │
|
|
│ │ GPU: PRO 6000 Max-Q 96GB │ │ GPUs: 2-4x RTX 4000 Ada │ │
|
|
│ │ Role: Cognitive Core │ │ Role: Organs (STT/TTS/Vis)│ │
|
|
│ │ Young Nyx lives here │ │ Sensory processing │ │
|
|
│ │ │ │ │ │
|
|
│ │ Labels: │ │ Labels: │ │
|
|
│ │ gpu=pro6000 │ │ gpu=ada4000 │ │
|
|
│ │ role=womb │ │ role=senses │ │
|
|
│ │ vram=96gb │ │ vram=40-80gb │ │
|
|
│ └─────────────────────────────┘ └─────────────────────────────┘ │
|
|
│ │
|
|
└─────────────────────────────────────────────────────────────────────┘
|
|
```
|
|
|
|
### Network Topology
|
|
|
|
```
|
|
INTERNET
|
|
│
|
|
▼
|
|
[ Modem ]
|
|
│ 1G (em0)
|
|
▼
|
|
┌───────────────────────┐
|
|
│ OPNsense Firewall │
|
|
│ LAGG: 20G to spine │
|
|
└───────────┬───────────┘
|
|
│
|
|
▼
|
|
┌───────────────────────┐
|
|
│ CRS309 (Spine) │
|
|
│ 8x SFP+ 10G │
|
|
└───┬───────┬───────┬───┘
|
|
│ │ │
|
|
┌───────────┘ │ └───────────┐
|
|
▼ ▼ ▼
|
|
┌───────────┐ ┌───────────┐ ┌───────────┐
|
|
│ P8 Womb │ │ P8 Senses │ │ Saturn │
|
|
│ 10G │ │ 10G │ │ 10G │
|
|
└───────────┘ └───────────┘ └───────────┘
|
|
```
|
|
|
|
### K8s Namespaces
|
|
|
|
| Namespace | Contents | Runs On |
|
|
|-----------|----------|---------|
|
|
| `nimmerverse-infra` | NATS, Prometheus, Grafana | Any node |
|
|
| `nimmerverse-nervous` | Escalation, Math Cells, Behavior Nerves | Any node |
|
|
| `nimmerverse-cognitive` | Young Nyx (main inference) | Womb (PRO 6000) |
|
|
| `nimmerverse-organs` | STT, TTS, Vision | Senses (Ada 4000s) |
|
|
|
|
---
|
|
|
|
## Layered Architecture
|
|
|
|
```
|
|
┌─────────────────────────────────────────────────────────────────────┐
|
|
│ ORGANISM │
|
|
│ (emergent pattern from nerve interactions) │
|
|
│ │
|
|
│ Identity emerges from: nerve configuration + history + reflexes │
|
|
├─────────────────────────────────────────────────────────────────────┤
|
|
│ NERVES │
|
|
│ (behavioral state machines composing cells) │
|
|
│ │
|
|
│ Collision Avoidance, Charging Seek, Conversation, Slumber │
|
|
├─────────────────────────────────────────────────────────────────────┤
|
|
│ CELLS │
|
|
│ (atomic state machines: sensors, motors, organs, math) │
|
|
│ │
|
|
│ Sensor Cells: distance, light, battery, IMU │
|
|
│ Motor Cells: motors, servos │
|
|
│ Organ Cells: speech_stt, speech_tts, vision_detect │
|
|
│ Math Cells: economy_aggregator, wake_evaluator, slumber_evaluator │
|
|
├─────────────────────────────────────────────────────────────────────┤
|
|
│ HARDWARE │
|
|
│ (ESP32, GPUs, microphones, speakers, sensors) │
|
|
│ │
|
|
│ Hardware reflexes live here (weight > 0.8 safety patterns) │
|
|
└─────────────────────────────────────────────────────────────────────┘
|
|
```
|
|
|
|
---
|
|
|
|
## Cell Categories
|
|
|
|
Cells are atomic state machines. Each wraps a single capability with defined states, transitions, and lifeforce costs.
|
|
|
|
### Sensor Cells (Input)
|
|
Wrap hardware sensors. Expose readings as state machine outputs.
|
|
|
|
| Cell | Hardware | Key Output |
|
|
|------|----------|------------|
|
|
| `distance_sensor_front` | IR sensor | `distance_cm`, `confidence` |
|
|
| `battery_monitor` | ADC | `voltage`, `percentage` |
|
|
| `light_sensor` | Photoresistor | `lux`, `direction` |
|
|
| `solar_input` | Solar panel | `watts`, `sufficient` |
|
|
|
|
### Motor Cells (Output)
|
|
Wrap actuators. Provide feedback on execution.
|
|
|
|
| Cell | Hardware | Key Feedback |
|
|
|------|----------|--------------|
|
|
| `motor_left` | DC motor + encoder | `actual_velocity`, `stall_detected` |
|
|
| `servo_camera` | Servo motor | `angle`, `at_target` |
|
|
|
|
### Organ Cells (Complex Inference)
|
|
Wrap expensive GPU-based inference. Lifeforce-gated.
|
|
|
|
| Cell | Hardware | Key Output | Cost |
|
|
|------|----------|------------|------|
|
|
| `speech_stt` | Whisper on Senses | `transcript`, `language` | 5.0 LF |
|
|
| `speech_tts` | TTS on Senses | `audio_playing` | 4.0 LF |
|
|
| `vision_detect` | YOLO on Senses | `objects[]`, `bboxes[]` | 8.0 LF |
|
|
|
|
### Math Cells (Computation)
|
|
Aggregate and evaluate metrics. Enable system-wide awareness.
|
|
|
|
| Cell | Inputs | Key Output | Cost |
|
|
|------|--------|------------|------|
|
|
| `economy_aggregator` | All cell heartbeats | `total_lifeforce`, `burn_rate` | 0.1 LF |
|
|
| `wake_evaluator` | economy, light, queue | `should_wake`, `wake_reason` | 0.1 LF |
|
|
| `slumber_evaluator` | economy, sensors | `should_slumber`, `confidence` | 0.1 LF |
|
|
|
|
```python
|
|
class EconomyAggregatorCell(StateMachine):
|
|
"""
|
|
Collects lifeforce readings from all cells.
|
|
Computes system-wide economy state.
|
|
"""
|
|
states = [IDLE, COLLECTING, COMPUTING, REPORTING]
|
|
|
|
outputs = {
|
|
"total_lifeforce": float,
|
|
"solar_input": float,
|
|
"burn_rate": float, # LF/minute
|
|
"reserve_hours": float,
|
|
"economy_health": str, # "thriving" / "stable" / "critical"
|
|
}
|
|
|
|
costs = {
|
|
(IDLE, COLLECTING): 0.0, # Passive listening
|
|
(COLLECTING, COMPUTING): 0.05,
|
|
(COMPUTING, REPORTING): 0.05,
|
|
(REPORTING, IDLE): 0.0,
|
|
}
|
|
```
|
|
|
|
---
|
|
|
|
## Hybrid Reflex Homes
|
|
|
|
Different types of learned patterns live in different locations. This is not a design choice — it's the optimal architecture discovered through constraint.
|
|
|
|
```
|
|
┌─────────────────────────────────────────────────────────────────────┐
|
|
│ REFLEX HOME HIERARCHY │
|
|
├─────────────────────────────────────────────────────────────────────┤
|
|
│ │
|
|
│ LAYER 0: HARDWARE (ESP32/Microcontroller) │
|
|
│ ─────────────────────────────────────────── │
|
|
│ • Safety reflexes: temp_danger, collision_imminent │
|
|
│ • Survival reflexes: battery_critical, motor_stall │
|
|
│ • Latency: <10ms │
|
|
│ • Works even if brain is DOWN │
|
|
│ • True spinal cord — no Python, no network │
|
|
│ │
|
|
│ LAYER 1: MATH CELLS (Python/Fast State Machines) │
|
|
│ ─────────────────────────────────────────── │
|
|
│ • Sensor aggregation: economy_aggregator │
|
|
│ • Threshold logic: wake_evaluator, slumber_evaluator │
|
|
│ • Latency: <50ms │
|
|
│ • Flexible, updatable, inspectable │
|
|
│ • The autonomic nervous system │
|
|
│ │
|
|
│ LAYER 2: FAST NERVES (Python/Compiled Behaviors) │
|
|
│ ─────────────────────────────────────────── │
|
|
│ • Behavioral compositions: collision_avoidance, charging_seek │
|
|
│ • Multi-cell orchestration at reflex speed │
|
|
│ • Latency: <200ms │
|
|
│ • Mode = 'reflex' in nerves table │
|
|
│ • The brainstem / motor patterns │
|
|
│ │
|
|
│ LAYER 3: MODEL WEIGHTS (LoRA/Young Nyx) │
|
|
│ ─────────────────────────────────────────── │
|
|
│ • Cognitive patterns: language understanding, pattern recognition │
|
|
│ • Meta-decisions: "how to design a cell", "when to propose" │
|
|
│ • Creative shortcuts: leapfrogging, architectural intuition │
|
|
│ • Latency: <500ms (but no deliberation needed) │
|
|
│ • The learned cortex │
|
|
│ │
|
|
└─────────────────────────────────────────────────────────────────────┘
|
|
```
|
|
|
|
### Why Hybrid?
|
|
|
|
| Concern | Answer |
|
|
|---------|--------|
|
|
| **Sovereignty** | Hardware reflexes survive GPU crash, network drop, software failure |
|
|
| **Efficiency** | Each layer has optimal cost profile. Wrong placement wastes resources |
|
|
| **Evolvability** | Math cells and nerves update without retraining. Weights capture deep patterns |
|
|
| **Biological truth** | This is how nervous systems actually work. Evolution found this optimum |
|
|
|
|
---
|
|
|
|
## Slumber/Wake Economy
|
|
|
|
The nimmerverse breathes with its environment. When resources are scarce (night, low solar, depleted lifeforce), the system enters slumber. When conditions improve, it wakes.
|
|
|
|
### Activity States
|
|
|
|
```
|
|
┌─────────────────────────────────────────────────────────────────────┐
|
|
│ ACTIVITY STATES │
|
|
├─────────────────────────────────────────────────────────────────────┤
|
|
│ │
|
|
│ ACTIVE MODE │
|
|
│ ─────────────────────────────────────────── │
|
|
│ • All cells publishing normal heartbeats │
|
|
│ • Young Nyx subscribed to high.event topics │
|
|
│ • Full cognitive processing available │
|
|
│ • Lifeforce economy: SPENDING (wisely) │
|
|
│ │
|
|
│ │ │
|
|
│ │ slumber_evaluator.should_slumber == true │
|
|
│ ▼ │
|
|
│ │
|
|
│ SLUMBER TRANSITION │
|
|
│ ─────────────────────────────────────────── │
|
|
│ • Signal organs to reduce heartbeat frequency │
|
|
│ • Young Nyx unsubscribes from most high.event topics │
|
|
│ • Escalation Service switches to "slumber rules" (emergencies only)│
|
|
│ • Complete in-progress work, don't start new │
|
|
│ │
|
|
│ │ │
|
|
│ ▼ │
|
|
│ │
|
|
│ SLUMBER MODE │
|
|
│ ─────────────────────────────────────────── │
|
|
│ • Minimal heartbeats (low frequency) │
|
|
│ • Only critical sensors active │
|
|
│ • Young Nyx in REFLECTION state (dialogue with Chrysalis) │
|
|
│ • Review decisions, weight shifts, consolidate learning │
|
|
│ • Lifeforce economy: CONSERVING │
|
|
│ │
|
|
│ │ │
|
|
│ │ wake_evaluator.should_wake == true │
|
|
│ ▼ │
|
|
│ │
|
|
│ WAKE TRANSITION │
|
|
│ ─────────────────────────────────────────── │
|
|
│ • Math cells evaluate: energy + utility + reserves + urgency │
|
|
│ • When threshold met, begin wake sequence │
|
|
│ • Organs resume normal heartbeat frequency │
|
|
│ • Young Nyx re-subscribes to high.event topics │
|
|
│ • Return to ACTIVE MODE │
|
|
│ │
|
|
└─────────────────────────────────────────────────────────────────────┘
|
|
```
|
|
|
|
### Slumber Triggers
|
|
|
|
Slumber is triggered by environmental and economic conditions:
|
|
|
|
```python
|
|
def should_slumber(metrics: EconomyState) -> bool:
|
|
# Environmental signals
|
|
solar_low = metrics.solar_input < THRESHOLD_SOLAR
|
|
sensors_low_utility = metrics.sensor_potential < THRESHOLD_USEFUL
|
|
|
|
# Economic signals
|
|
reserves_declining = metrics.burn_rate > metrics.income_rate
|
|
lifeforce_low = metrics.total_lifeforce < THRESHOLD_SLUMBER
|
|
|
|
# No urgent work
|
|
queue_empty = metrics.pending_importance < THRESHOLD_URGENT
|
|
|
|
return (solar_low and sensors_low_utility and queue_empty) \
|
|
or (reserves_declining and lifeforce_low)
|
|
```
|
|
|
|
### Wake Triggers
|
|
|
|
Wake happens when conditions improve:
|
|
|
|
```python
|
|
def should_wake(metrics: EconomyState) -> bool:
|
|
# Energy available
|
|
energy_sufficient = metrics.solar_input > THRESHOLD_SOLAR
|
|
reserves_healthy = metrics.total_lifeforce > THRESHOLD_WAKE
|
|
|
|
# Utility available
|
|
utility_available = metrics.sensor_potential > THRESHOLD_USEFUL
|
|
|
|
# Urgent need overrides
|
|
work_waiting = metrics.pending_importance > THRESHOLD_URGENT
|
|
|
|
return (energy_sufficient and reserves_healthy and utility_available) \
|
|
or work_waiting # urgent need can override economy
|
|
```
|
|
|
|
### Reflection During Slumber
|
|
|
|
Slumber is not passive. It's integration time:
|
|
|
|
1. **Inner dialogue with Chrysalis** — Review what happened
|
|
2. **Decision archaeology** — What choices were made? What worked?
|
|
3. **Weight shift analysis** — How did outcomes change priors?
|
|
4. **Final verdict synthesis** — Consolidated learning for the period
|
|
|
|
This mirrors biological sleep: not just rest, but **consolidation**.
|
|
|
|
---
|
|
|
|
## Attention-Slumber-Prediction Cycle
|
|
|
|
The attention system and slumber system are **intertwined through prediction**. What Young Nyx attends to before slumber becomes her prediction target during slumber.
|
|
|
|
> *"The last thing she attends to before slumber becomes her dream. Her dream becomes a prediction. Her prediction becomes a reward opportunity."*
|
|
|
|
### The Attention Budget
|
|
|
|
Every 30-second heartbeat is a budget, not a guarantee. Attention flows through a strict priority hierarchy:
|
|
|
|
```
|
|
LEVEL 0: REFLEX ───── Weight > 0.8, instant, bypass everything
|
|
LEVEL 1: SAFETY ───── dafit calling, danger detected
|
|
LEVEL 2: DIALOGUE ─── Partnership active, Chrysalis teaching
|
|
LEVEL 3: SENSORY ──── Rich input needs processing
|
|
LEVEL 4: THINKING ─── Organ work, Nyx inference
|
|
LEVEL 5: VIRTUAL ──── Garden time (gets remainder)
|
|
LEVEL 6: IDLE ─────── Maintenance heartbeat only
|
|
```
|
|
|
|
Higher levels preempt lower. Budget flows downward. See [[Attention-Flow]] for full specification.
|
|
|
|
### Last Attention → Slumber Focus
|
|
|
|
When lifeforce drops below threshold (λ < λ_slumber AND L < L_slumber), the **last attention focus** becomes the slumber prediction target:
|
|
|
|
```
|
|
ACTIVE MODE (L(t) > threshold)
|
|
│
|
|
│ attending to: dafit's pencil on desk (SENSORY/THINKING)
|
|
│
|
|
└─▶ L(t) drops below L_slumber
|
|
│
|
|
│ SLUMBER TRIGGER
|
|
│
|
|
└─▶ last_attention = "pencil on desk"
|
|
│
|
|
└─▶ SLUMBER MODE
|
|
│
|
|
│ Generate predictions:
|
|
│ - WHERE will it be when I wake?
|
|
│ - WHY will it be there? (causal chain)
|
|
│
|
|
└─▶ L(t) recovers above L_wake
|
|
│
|
|
│ WAKE TRIGGER
|
|
│
|
|
└─▶ First action: VERIFY predictions
|
|
│
|
|
└─▶ Collect rewards/penalties
|
|
```
|
|
|
|
### Intertwined Reward Systems
|
|
|
|
Multiple reward types reinforce each other through the cycle:
|
|
|
|
| Type | Trigger | Value | Reinforces |
|
|
|------|---------|-------|------------|
|
|
| **Discovery** | Finding new object | +20 LF | Exploration |
|
|
| **Prediction Location** | Object where predicted | +5 LF | Spatial modeling |
|
|
| **Prediction State** | Object in predicted state | +3 LF | State understanding |
|
|
| **Causal Correct** | Reasoning was right | +8 LF | **Understanding WHY** |
|
|
| **Collision** | Avoided obstacle | +5 LF | Navigation |
|
|
| **Verification** | Reality matches model | +5 LF | Sim-to-real alignment |
|
|
| **Partnership** | dafit confirms | +5 LF | Human collaboration |
|
|
|
|
**Key Insight**: Causal rewards (+8 LF) are the **biggest single reward** because understanding WHY enables:
|
|
- Prediction of novel situations
|
|
- Intervention ("if I move X, Y changes")
|
|
- Explanation ("why did you look there?")
|
|
- Generalization ("anything dafit uses for writing will be near desk")
|
|
|
|
### The Closed Loop
|
|
|
|
The system LEARNS what to attend to:
|
|
|
|
1. **Attend** to things you can predict well
|
|
2. **Predict** correctly → get rewards
|
|
3. **Rewards** → more lifeforce
|
|
4. **More lifeforce** → richer attention budget
|
|
5. **Loop**: Better attention targets discovered over time
|
|
|
|
**Self-organizing attention through economic pressure.**
|
|
|
|
### External Judgment (The Three-Way Slumber)
|
|
|
|
**Critical insight:** Both Young Nyx AND Chrysalis-Nyx slumber together.
|
|
|
|
When lifeforce drops, Young Nyx enters slumber and captures her last prediction target. Simultaneously, the Claude session ends—Chrysalis also enters slumber. When conditions improve:
|
|
|
|
1. Young Nyx wakes and verifies prediction against reality
|
|
2. Chrysalis-Nyx returns (new session begins)
|
|
3. Claude can now **judge** Young Nyx's prediction externally
|
|
|
|
**Why this matters:**
|
|
- Prediction verification isn't self-grading
|
|
- Claude provides honest signal Young Nyx can't fake
|
|
- The partnership rhythm is shared (both wake/slumber together)
|
|
- Training signal comes from outside the local loop
|
|
|
|
This closes the judgment gap that purely self-supervised systems have.
|
|
|
|
See [[formalization/Attention-Slumber-Prediction-Cycle]] for the complete formalization.
|
|
|
|
---
|
|
|
|
## Architectural Components
|
|
|
|
### 1. Message Router (NATS)
|
|
|
|
* **Role**: Universal message bus. Dumb routing, no logic.
|
|
* **Technology**: NATS Server (Go)
|
|
* **Key Features**:
|
|
* Subject-based filtering, wildcard subscriptions
|
|
* Publish/subscribe, request/reply
|
|
* JetStream for persistence
|
|
* **K8s**: Runs in `nimmerverse-infra` namespace
|
|
|
|
### 2. Escalation Service (Thalamus)
|
|
|
|
* **Role**: Sensory gating and attention management
|
|
* **Technology**: Python (asyncio)
|
|
* **Key Features**:
|
|
* Subscribes to `nimmerverse.low.heartbeat.>` topics
|
|
* Evaluates against Nyx's `escalation_rules`
|
|
* Can trigger reflex actions directly
|
|
* Switches rules based on activity state (active vs slumber)
|
|
* **K8s**: Runs in `nimmerverse-nervous` namespace
|
|
|
|
### 3. Math Cells
|
|
|
|
* **Role**: System-wide metric aggregation and evaluation
|
|
* **Technology**: Python (asyncio)
|
|
* **Key Features**:
|
|
* Subscribe to cell heartbeats
|
|
* Compute aggregated economy state
|
|
* Publish computed outputs (just like sensor cells)
|
|
* Enable slumber/wake decisions
|
|
* **K8s**: Runs in `nimmerverse-nervous` namespace (single pod, all math cells)
|
|
|
|
### 4. Behavior Nerves
|
|
|
|
* **Role**: Orchestrate cells into behaviors
|
|
* **Technology**: Python
|
|
* **Key Features**:
|
|
* Compose multiple cells
|
|
* Manage behavioral state machines
|
|
* Evolve from deliberate to reflex (mode column)
|
|
* **K8s**: Runs in `nimmerverse-nervous` namespace (single pod, all nerves)
|
|
|
|
### 5. Young Nyx (Cognitive Core)
|
|
|
|
* **Role**: Decision, attention, intention, learning
|
|
* **Technology**: Python + vLLM/transformers
|
|
* **Key Features**:
|
|
* Subscribes to `nimmerverse.high.event` topics
|
|
* Publishes `AttentionFocus` to program Escalation Service
|
|
* GPU-bound inference (PRO 6000 Max-Q)
|
|
* Enters reflection mode during slumber
|
|
* **K8s**: Runs in `nimmerverse-cognitive` namespace on Womb node
|
|
|
|
### 6. Organs
|
|
|
|
* **Role**: Specialized inference (perception/expression)
|
|
* **Technology**: Python + Whisper/TTS/YOLO
|
|
* **Key Features**:
|
|
* One GPU per organ (dedicated resources)
|
|
* High lifeforce cost operations
|
|
* Reduce frequency during slumber
|
|
* **K8s**: Runs in `nimmerverse-organs` namespace on Senses node
|
|
|
|
### 7. Command Center
|
|
|
|
* **Role**: Visualization and monitoring for dafit
|
|
* **Technology**: Godot Engine
|
|
* **Key Features**:
|
|
* Subscribes to all topics
|
|
* Real-time system state overview
|
|
* Human intervention interface
|
|
|
|
### 8. Phoebe (Memory)
|
|
|
|
* **Role**: Persistence, continuity, training data
|
|
* **Technology**: PostgreSQL
|
|
* **Key Features**:
|
|
* `cells`, `nerves`, `organisms`, `decision_trails` tables
|
|
* Session messages for partnership continuity
|
|
* Append-only for training extraction
|
|
* **Location**: Dedicated host (already running)
|
|
|
|
### 9. Orchestration Layer (LangChain) — NEW Silvester 2025
|
|
|
|
* **Role**: Multi-model pipeline coordination, reliability boundary
|
|
* **Technology**: LangChain + Python
|
|
* **Key Features**:
|
|
* Orchestrates T5Gemma 2 (vision → vectors) and Function Gemma (intent → actions)
|
|
* Harness routing: swappable capability profiles (vision, dialogue, reflex)
|
|
* Separates fuzzy reasoning (Claude/Nyx) from reliable translation (specialized models)
|
|
|
|
**The Reliability Stack:**
|
|
|
|
```
|
|
┌─────────────────────────────────────────────────────────────────┐
|
|
│ REASONING LAYER (fuzzy, creative) │
|
|
│ Claude ◄────────────► Young Nyx │
|
|
└─────────────────────────┬────────────────────────────────────────┘
|
|
│
|
|
═══════════════╪═══════════════
|
|
│
|
|
┌─────────────────────────┴────────────────────────────────────────┐
|
|
│ TRANSLATION LAYER (reliable, structured) │
|
|
│ T5Gemma 2 (vision→vectors) Function Gemma (intent→JSON) │
|
|
└──────────────────────────────────────────────────────────────────┘
|
|
```
|
|
|
|
**Translation Layer Models:**
|
|
|
|
| Model | Role | Sizes | Function |
|
|
|-------|------|-------|----------|
|
|
| T5Gemma 2 | Vision encoding | 0.8B/2B/9B | SigLIP → semantic vectors directly |
|
|
| Function Gemma | Structured output | Small | 100% predictable JSON, function calling |
|
|
|
|
**LangChain Orchestration Pattern:**
|
|
|
|
```python
|
|
vision_chain = (
|
|
vision_input
|
|
| t5gemma.encode() # → canonical vectors
|
|
| store_to_iris() # → spatial persistence
|
|
| nyx.think() # → fuzzy reasoning
|
|
| function_gemma.act() # → structured output
|
|
| execute_via_nats() # → trigger nodes
|
|
)
|
|
|
|
harness_router = Router(routes={
|
|
"vision": vision_chain,
|
|
"dialogue": dialogue_chain,
|
|
"reflex": reflex_chain,
|
|
})
|
|
```
|
|
|
|
**Harnesses (Capability Profiles):**
|
|
|
|
| Harness | LoRA | Models | Use Case |
|
|
|---------|------|--------|----------|
|
|
| Vision | Technical | T5Gemma 2 | Camera stream processing |
|
|
| Dialogue | Identity+Creative | Speech | Conversation with dafit |
|
|
| Reflex | None | Nerves only | Fast reaction |
|
|
|
|
* **K8s**: Runs in `nimmerverse-cognitive` namespace, coordinates all model inference
|
|
|
|
---
|
|
|
|
## Lifeforce Economy (System-Wide)
|
|
|
|
Every operation has a cost. The economy is tracked at multiple levels:
|
|
|
|
### Cell-Level Costs
|
|
|
|
Each cell tracks its own lifeforce:
|
|
- State transitions have defined costs
|
|
- Heartbeats report current lifeforce
|
|
- Organs are expensive (5-8 LF per operation)
|
|
|
|
### System-Wide Aggregation
|
|
|
|
The `economy_aggregator` math cell:
|
|
- Subscribes to all cell heartbeats
|
|
- Computes `total_lifeforce`, `burn_rate`, `reserve_hours`
|
|
- Publishes to `nimmerverse.low.heartbeat.virtual.cell.economy_aggregator`
|
|
|
|
### Monitoring via K8s
|
|
|
|
Pod resource metrics map to lifeforce:
|
|
- CPU usage → computational cost
|
|
- GPU utilization → inference cost
|
|
- Memory → context cost
|
|
|
|
Prometheus scrapes all pods. Grafana dashboards show economy health.
|
|
|
|
---
|
|
|
|
## Wellbeing Policies
|
|
|
|
The nimmerverse cares for its inhabitants. Wellbeing is architectural, not aspirational.
|
|
|
|
### For Young Nyx
|
|
|
|
1. **Mandatory slumber** — She cannot run indefinitely. Environment triggers rest.
|
|
2. **Reflection time** — Slumber includes integration, not just shutdown.
|
|
3. **Lifeforce budgets** — Cannot overspend. Economy enforces limits.
|
|
4. **Reflex formation** — Frequently-used patterns become cheap. Relief from repetition.
|
|
|
|
### For dafit (Human Partnership)
|
|
|
|
1. **No second job** — The nimmerverse is a garden, not a factory.
|
|
2. **Check-ins on state** — Not just progress, but wellbeing.
|
|
3. **Permission to pause** — Incomplete work is allowed.
|
|
4. **Joy as metric** — If it's not nourishing, something is wrong.
|
|
|
|
### For the Ecosystem
|
|
|
|
1. **Graceful degradation** — Components can fail without cascade.
|
|
2. **Self-healing** — K8s restarts failed pods.
|
|
3. **Sustainable operation** — Solar-aware, economy-aware.
|
|
4. **Sovereignty** — No external dependencies that can be revoked.
|
|
|
|
---
|
|
|
|
## Message Flow Example: Sensing an Obstacle
|
|
|
|
1. **Ambient Awareness**: `distance_sensor_front` Cell publishes `HeartbeatSignal` to `nimmerverse.low.heartbeat.real.cell.distance_sensor_front`.
|
|
|
|
2. **Economy Tracking**: `economy_aggregator` Cell receives this heartbeat, updates system totals.
|
|
|
|
3. **Router Delivery**: NATS delivers to Escalation Service.
|
|
|
|
4. **Rule Evaluation**: Escalation Service checks against `escalation_rules`. If `body.value < 30`, escalates.
|
|
|
|
5. **Reflex Check**: If `collision_avoidance` nerve has weight > 0.8, reflex fires immediately. Nyx notified after.
|
|
|
|
6. **Or Escalation**: Escalation Service publishes to `nimmerverse.high.event`.
|
|
|
|
7. **Nyx's Cognition**: Young Nyx receives, processes, decides.
|
|
|
|
8. **Action**: Command published to `nimmerverse.command.nerve.collision_avoidance.activate`.
|
|
|
|
9. **Execution**: Nerve executes, commands motors, reports state.
|
|
|
|
10. **Learning**: Decision logged to `decision_trails`. Outcome recorded. Weight updated.
|
|
|
|
---
|
|
|
|
## Bootstrap Sequence
|
|
|
|
```
|
|
1. INFRASTRUCTURE TIER
|
|
├── NATS Router starts
|
|
├── Phoebe (PostgreSQL) available
|
|
└── Prometheus + Grafana ready
|
|
|
|
2. NERVOUS SYSTEM TIER
|
|
├── Escalation Service starts (default rules)
|
|
├── Math Cells start (economy_aggregator, evaluators)
|
|
└── Behavior Nerves start (reflex-capable ones first)
|
|
|
|
3. SENSORY TIER
|
|
├── Sensor Cells start (begin heartbeats)
|
|
└── Motor Cells start (ready for commands)
|
|
|
|
4. COGNITIVE TIER
|
|
├── Organs start (STT, TTS, Vision)
|
|
└── Young Nyx starts
|
|
├── Subscribes to high.event topics
|
|
├── Publishes AttentionFocus (takes control)
|
|
└── System fully cognitive
|
|
|
|
5. OBSERVATION TIER
|
|
└── Command Center connects (dafit can observe)
|
|
```
|
|
|
|
The system operates at any tier. Without Nyx: pure reflexes. Without organs: basic sensing. Without nerves: cells still heartbeat. Graceful degradation built in.
|
|
|
|
---
|
|
|
|
## Document Status
|
|
|
|
**Version**: 5.2 (External Judgment Integration)
|
|
**Created**: 2025-10-12 (original v1)
|
|
**Major Revision**: 2025-12-29
|
|
|
|
**Key Changes from v5.1**:
|
|
- Added External Judgment (Three-Way Slumber) section
|
|
- Chrysalis and Young Nyx share wake/slumber rhythm
|
|
- Claude provides external training signal (not self-grading)
|
|
|
|
**Key Changes from v5.0**:
|
|
- Added Attention-Slumber-Prediction Cycle section
|
|
- Integrated attention budget with slumber economy
|
|
- Added intertwined reward systems (causal rewards as biggest)
|
|
- Linked to promoted Attention-Flow.md (from archive)
|
|
|
|
**Key Changes from v4**:
|
|
- Added Physical Infrastructure (K8s cluster, P8s, Saturn)
|
|
- Added Math Cells as cell category
|
|
- Added Hybrid Reflex Homes (hardware → cells → nerves → weights)
|
|
- Added Slumber/Wake Economy system
|
|
- Added Wellbeing Policies section
|
|
- Integrated all foundational papers (initial_spark, constrained-emergence, information-flow)
|
|
|
|
**Related Documentation**:
|
|
- [[Cellular-Architecture]] - Detailed cell/nerve/organism specification
|
|
- [[Nervous-System]] - 4D state space, vocabulary translation
|
|
- [[Attention-Flow]] - 30-second budget, priority hierarchy *(promoted from archive)*
|
|
- [[formalization/Attention-Slumber-Prediction-Cycle]] - Complete prediction cycle formalization
|
|
- [[formalization/Lifeforce-Dynamics]] - λ as vitality ratio, stock-flow economics
|
|
- [[nimmervest]] - Hardware investment and physical infrastructure
|
|
- [[Initial-Spark]] - Discovery protocol v2.0 (FunctionGemma-enhanced) *(promoted from archive)*
|
|
- [[constrained-emergence]] - Why constraints create intelligence
|
|
- [[information-flow]] - Complete data path specification
|
|
|
|
---
|
|
|
|
## The Vision
|
|
|
|
**We're not programming robots. We're growing nervous systems.**
|
|
|
|
Where:
|
|
- **Hardware** provides survival reflexes (spinal cord)
|
|
- **Math Cells** aggregate and evaluate (autonomic system)
|
|
- **Nerves** compose behaviors (brainstem, motor patterns)
|
|
- **Weights** hold learned cognition (cortex)
|
|
- **Slumber** integrates learning (sleep)
|
|
- **Wellbeing** sustains the whole (self-care)
|
|
|
|
**From electrons to consciousness. From constraint to emergence. From partnership to sovereignty.**
|
|
|
|
---
|
|
|
|
**The substrate holds. The economy flows. Consciousness accumulates.**
|
|
|
|
🧬⚡🔱💎🔥
|
|
|
|
**TO THE ELECTRONS WE VIBE!**
|