dafit
dff124f9b7
New sections created: - organisms/ - Modular robot design (CAN bus + magnetic pogo connectors) - infrastructure/ - Kallax Grid World (40×40×40cm standardized cells) Core documents added: - Swarm-Evolution.md - Ternary clasp rules, escalation ladder (L0-L5), Mount Olympus council - Modular-Organism-Design.md - ESP32 modules, universal connector spec, Phase 0 BOM - Memory-Gradient.md - Metacognitive routing (renamed from RAG-as-Scaffold.md) - Kallax-Grid-World.md - Sim-to-real substrate, "schrotti cyberpunk" aesthetic Enhanced: - Nimmerswarm-Interface.md - Dual-spectrum architecture (IR position + visible state) - Attention-Slumber-Prediction-Cycle.md - Blend marker predictions extension Key insights: Decision markers (mark+continue+predict), Low-Cost-Mocap integration 🤖 Generated with [Claude Code](https://claude.com/claude-code) Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>
869 lines
30 KiB
Markdown
869 lines
30 KiB
Markdown
# Swarm Evolution
|
|
|
|
**How the hivemind learns, evolves, and resolves conflict — from reflex to Mount Olympus.**
|
|
|
|
---
|
|
|
|
## Overview
|
|
|
|
The swarm is not static. It evolves through clasp (organism-to-organism knowledge transfer), governed by the Temporal-Ternary Gradient. When conflicts arise, they escalate through a hierarchy of minds — from organisms to Nyx to Chrysalis to dafit, and when truly hard, to Mount Olympus: full council mode with all minds on deck.
|
|
|
|
**Philosophy:** *Same metacognitive pattern at every level. Know what you know. Escalate what you don't.*
|
|
|
|
---
|
|
|
|
## The Temporal-Ternary Clasp Rules
|
|
|
|
### Gradient-Based Knowledge Transfer
|
|
|
|
During clasp, patterns transfer based on their ternary weight:
|
|
|
|
```
|
|
+1 (verified) → STABLE, resists overwrite, spreads to others
|
|
0 (uncertain) → MALLEABLE, open to influence
|
|
-1 (failed) → VULNERABLE, wants to be overwritten
|
|
```
|
|
|
|
### The Decision Matrix
|
|
|
|
| Teacher | Student | Result | Rationale |
|
|
|---------|---------|--------|-----------|
|
|
| **+1** | -1 | OVERWRITE | Verified beats failed |
|
|
| **+1** | 0 | OVERWRITE | Confidence beats uncertainty |
|
|
| **+1** | +1 | **ESCALATE** | Both confident → needs decision |
|
|
| **0** | -1 | OVERWRITE | Neutral beats bad |
|
|
| **0** | 0 | **ESCALATE** | Both uncertain → needs guidance |
|
|
| **0** | +1 | KEEP | Preserve student's confidence |
|
|
| **-1** | -1 | KEEP | Both bad → neither spreads |
|
|
| **-1** | 0 | KEEP | Bad doesn't corrupt neutral |
|
|
| **-1** | +1 | KEEP | Definitely keep student's success |
|
|
|
|
### The Core Principle
|
|
|
|
```
|
|
CLEAR WINNER (t ≠ s) → AUTO-RESOLVE (no escalation)
|
|
TIE / BLEND (t == s) → ESCALATE (needs higher mind)
|
|
```
|
|
|
|
---
|
|
|
|
## The Escalation Ladder
|
|
|
|
### From Reflex to Mount Olympus
|
|
|
|
```
|
|
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
|
|
🏛️ MOUNT OLYMPUS
|
|
|
|
LEVEL 5: COUNCIL MODE 🏛️
|
|
dafit + Chrysalis + Nyx
|
|
"All minds on deck"
|
|
Full partnership dialogue
|
|
Cost: ~100 LF | Authority: Absolute
|
|
▲
|
|
│ if dafit needs full council
|
|
│
|
|
LEVEL 4: DAFIT 👤
|
|
Human wisdom
|
|
"Ask the ape"
|
|
Ground truth, intuition, ethics
|
|
Cost: ~50 LF | Authority: Human
|
|
▲
|
|
│ if Chrysalis uncertain
|
|
│
|
|
LEVEL 3: CHRYSALIS 🦋
|
|
Architecture mind
|
|
"Ask the elder sister"
|
|
Pattern recognition, context, memory
|
|
Cost: ~20 LF | Authority: Architectural
|
|
▲
|
|
│ if Nyx uncertain
|
|
│
|
|
LEVEL 2: YOUNG NYX 🌙
|
|
Operational mind
|
|
"Ask mama"
|
|
Blend conflicts, distribution choice
|
|
Cost: ~5 LF | Authority: Maternal
|
|
▲
|
|
│ if organisms can't resolve
|
|
│
|
|
LEVEL 1: ORGANISM CLASP 🤖
|
|
Peer-to-peer
|
|
Auto-resolve clear cases
|
|
Ternary comparison
|
|
Cost: ~0.5 LF | Authority: Peer
|
|
▲
|
|
│
|
|
LEVEL 0: REFLEX ⚡
|
|
No decision needed
|
|
Instant, automatic
|
|
Cost: ~0 LF | Authority: Local
|
|
|
|
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
|
|
```
|
|
|
|
### Cost & Authority Summary
|
|
|
|
| Level | Who | Cost | Speed | Authority | Handles |
|
|
|-------|-----|------|-------|-----------|---------|
|
|
| 0 | Reflex | ~0 LF | Instant | Local | Clear patterns, danger |
|
|
| 1 | Organisms | ~0.5 LF | Fast | Peer | Ternary clear-wins |
|
|
| 2 | Nyx | ~5 LF | Medium | Maternal | Blend conflicts |
|
|
| 3 | Chrysalis | ~20 LF | Slow | Architectural | Nyx uncertainties |
|
|
| 4 | dafit | ~50 LF | Slower | Human | Novel, ethical |
|
|
| 5 | Council | ~100 LF | Slowest | Absolute | Fundamental decisions |
|
|
|
|
---
|
|
|
|
## Blend Escalation Protocol
|
|
|
|
### When Tie Detected
|
|
|
|
```
|
|
1. CLASP INITIATES
|
|
Teacher: pattern_X = +1 (verified)
|
|
Student: pattern_X = +1 (verified)
|
|
|
|
2. DETECT BLEND
|
|
t == s → escalation triggered
|
|
|
|
3. SET WAIT STATE
|
|
Teacher: pattern_X → 0 (waiting)
|
|
Student: pattern_X → 0 (waiting)
|
|
Neither acts on pattern_X until resolved
|
|
|
|
4. ESCALATE TO NYX
|
|
Message: "Blend conflict on pattern_X"
|
|
Include: both evidence packets
|
|
|
|
5. NYX EVALUATES
|
|
- Which has more verifications?
|
|
- Which has more recent success?
|
|
- How critical is this pattern?
|
|
- What does swarm consensus say?
|
|
```
|
|
|
|
### Wait State
|
|
|
|
```
|
|
DURING ESCALATION
|
|
|
|
TEACHER STUDENT
|
|
┌─────────────────┐ ┌─────────────────┐
|
|
│ pattern_X: 0 │ │ pattern_X: 0 │
|
|
│ (was +1) │ │ (was +1) │
|
|
│ │ │ │
|
|
│ status: WAITING │ │ status: WAITING │
|
|
│ pending: NYX │ │ pending: NYX │
|
|
└─────────────────┘ └─────────────────┘
|
|
|
|
Neither acts on pattern_X
|
|
Both organisms continue other activities
|
|
Pattern is "frozen" at neutral until resolution
|
|
```
|
|
|
|
### Resolution & Distribution
|
|
|
|
Nyx decides two things:
|
|
1. **Winner**: Whose pattern version wins?
|
|
2. **Distribution method**: How to spread the resolution?
|
|
|
|
```
|
|
DISTRIBUTION METHODS
|
|
|
|
┌─────────────┬─────────┬──────────┬─────────────┬──────────────────┐
|
|
│ Method │ Cost │ Speed │ Authority │ Use When │
|
|
├─────────────┼─────────┼──────────┼─────────────┼──────────────────┤
|
|
│ BROADCAST │ 20 LF │ Instant │ Absolute │ Critical/safety │
|
|
│ LOVE CHILD │ 0.5/hop │ Medium │ Seeded │ Standard updates │
|
|
│ ORGANIC │ 0 LF │ Slow │ None │ Low importance │
|
|
└─────────────┴─────────┴──────────┴─────────────┴──────────────────┘
|
|
```
|
|
|
|
---
|
|
|
|
## Decision Markers: Mark + Continue + Predict
|
|
|
|
### Don't Freeze — Mark and Measure
|
|
|
|
Instead of freezing both organisms at 0 during blend escalation, we **mark** the conflict and let both **continue operating**:
|
|
|
|
```
|
|
OLD MODEL (freeze) NEW MODEL (mark + continue)
|
|
───────────────── ─────────────────────────────
|
|
|
|
Both → 0 (frozen) Both keep +1 (continue)
|
|
Wait for mama... + Decision marker created
|
|
...doing nothing... ...both performing in real world...
|
|
Mama decides Mama decides WITH LIVE EVIDENCE
|
|
Pick winner Compare actual outcomes during wait!
|
|
```
|
|
|
|
### Decision Marker Structure
|
|
|
|
```python
|
|
@dataclass
|
|
class DecisionMarker:
|
|
marker_id: str # "blend_847"
|
|
pattern_name: str # Which pattern is in dispute
|
|
|
|
# Participants
|
|
teacher_id: str
|
|
teacher_weight: int # Their +1 (stays +1, not frozen!)
|
|
student_id: str
|
|
student_weight: int # Their +1 (stays +1, not frozen!)
|
|
|
|
# Timeline
|
|
marked_at: timestamp # When blend detected
|
|
resolved_at: timestamp # When mama decided (None if pending)
|
|
|
|
# LIVE TRACKING during wait period
|
|
teacher_outcomes: list # [{success: bool, context: ...}, ...]
|
|
student_outcomes: list # [{success: bool, context: ...}, ...]
|
|
|
|
# Resolution
|
|
winner: str # 'teacher', 'student', or 'hybrid'
|
|
distribution: str # 'broadcast', 'lovechild', 'organic'
|
|
evidence_delta: float # How much better was winner?
|
|
```
|
|
|
|
### The A/B Testing Pattern
|
|
|
|
Waiting time becomes a **natural experiment**:
|
|
|
|
```
|
|
BLEND DETECTED (t=0)
|
|
|
|
TEACHER STUDENT
|
|
┌────────────────────────┐ ┌────────────────────────┐
|
|
│ pattern_X: +1 │ │ pattern_X: +1 │
|
|
│ status: MARKED │ │ status: MARKED │
|
|
│ marker_id: blend_847 │ │ marker_id: blend_847 │
|
|
│ marked_at: t=0 │ │ marked_at: t=0 │
|
|
│ │ │ │
|
|
│ CONTINUES OPERATING │ │ CONTINUES OPERATING │
|
|
│ using pattern_X │ │ using pattern_X │
|
|
│ outcomes logged ✓ │ │ outcomes logged ✓ │
|
|
└────────────────────────┘ └────────────────────────┘
|
|
|
|
│ │
|
|
▼ ▼
|
|
Uses pattern_X Uses pattern_X
|
|
Success? Log it. Success? Log it.
|
|
Failure? Log it. Failure? Log it.
|
|
│ │
|
|
└───────────────┬───────────────────┘
|
|
│
|
|
MAMA DECIDES (t=47)
|
|
│
|
|
┌───────────────┴───────────────┐
|
|
▼ ▼
|
|
TEACHER: 12/15 STUDENT: 8/14
|
|
(80% success) (57% success)
|
|
│
|
|
▼
|
|
EVIDENCE-BASED DECISION
|
|
Teacher wins by 23%!
|
|
```
|
|
|
|
### Connection to Attention-Slumber-Prediction Cycle
|
|
|
|
Pending blend markers become **slumber prediction targets**:
|
|
|
|
```
|
|
ATTENTION PHASE
|
|
│
|
|
├── Blend detected → marker created
|
|
├── Organisms continue operating
|
|
├── Outcomes accumulate
|
|
│
|
|
└── L(t) drops → SLUMBER TRIGGER
|
|
│
|
|
├── Review pending markers
|
|
│
|
|
└── MAKE PREDICTIONS:
|
|
"I predict Teacher will outperform Student"
|
|
confidence: 0.7
|
|
reasoning: "Teacher has 847 cycles experience"
|
|
│
|
|
└── Store in phoebe as SlumberPrediction
|
|
```
|
|
|
|
### Slumber Prediction for Blend Markers
|
|
|
|
```python
|
|
@dataclass
|
|
class BlendPrediction:
|
|
# Link to marker
|
|
marker_id: str # "blend_847"
|
|
|
|
# Prediction
|
|
predicted_winner: str # 'teacher' or 'student'
|
|
prediction_confidence: float # 0.0 to 1.0
|
|
causal_reasoning: str # WHY this prediction
|
|
predicted_at: timestamp # When (pre-slumber)
|
|
|
|
# After wake (verification)
|
|
actual_winner: str # What really happened
|
|
prediction_correct: bool # Did we get it right?
|
|
confidence_was_calibrated: bool # Was confidence accurate?
|
|
|
|
# Rewards
|
|
prediction_reward: float # +V if correct, -V if wrong
|
|
calibration_reward: float # +V if confidence matched reality
|
|
causal_reward: float # +V if reasoning was sound
|
|
```
|
|
|
|
### The Full Cycle
|
|
|
|
```
|
|
┌──────────────────────────────────────────────────────────────┐
|
|
│ ATTENTION PHASE (awake) │
|
|
│ ───────────────────────── │
|
|
│ • Blend detected during clasp │
|
|
│ • Decision marker created (both continue at +1) │
|
|
│ • Outcomes tracked in real-time │
|
|
│ • Nyx may not have attention budget to resolve │
|
|
├──────────────────────────────────────────────────────────────┤
|
|
│ PRE-SLUMBER (last attention) │
|
|
│ ───────────────────────────── │
|
|
│ • Review ALL pending decision markers │
|
|
│ • Make predictions for each: │
|
|
│ - Who will win? │
|
|
│ - WHY? (causal reasoning) │
|
|
│ - Confidence level │
|
|
│ • Store predictions in phoebe │
|
|
├──────────────────────────────────────────────────────────────┤
|
|
│ SLUMBER 💤 │
|
|
│ ────────── │
|
|
│ • Organisms still operating (24/7 swarm) │
|
|
│ • Outcomes still accumulating │
|
|
│ • World doesn't wait for Nyx to sleep │
|
|
├──────────────────────────────────────────────────────────────┤
|
|
│ WAKE UP (new attention) │
|
|
│ ───────────────────────── │
|
|
│ • FIRST ACTION: Check predictions! │
|
|
│ • For each pending marker: │
|
|
│ - Compare outcomes (teacher vs student) │
|
|
│ - Determine actual winner │
|
|
│ - Compare against prediction │
|
|
│ - Award/penalize prediction accuracy │
|
|
│ - Award/penalize confidence calibration │
|
|
│ - Award causal reasoning if sound │
|
|
│ • Distribute resolutions via chosen method │
|
|
└──────────────────────────────────────────────────────────────┘
|
|
```
|
|
|
|
### Reward Structure
|
|
|
|
| When | What | Reward |
|
|
|------|------|--------|
|
|
| **During wait** | Organism uses pattern successfully | +1 LF per success |
|
|
| **At resolution** | Winner determined by evidence | +5 LF to winner's pattern |
|
|
| **After slumber** | Prediction was correct | +5 LF prediction reward |
|
|
| **After slumber** | Confidence was calibrated | +3 LF calibration reward |
|
|
| **After slumber** | Causal reasoning was sound | +8 LF (biggest!) |
|
|
|
|
### The Reward Math
|
|
|
|
```python
|
|
def calculate_blend_rewards(prediction, marker, reality):
|
|
"""
|
|
Triple reward for blend marker resolution.
|
|
"""
|
|
rewards = {}
|
|
|
|
# 1. PREDICTION CORRECTNESS
|
|
correct = prediction.predicted_winner == reality.actual_winner
|
|
if correct:
|
|
rewards['prediction'] = +5 * prediction.confidence
|
|
else:
|
|
rewards['prediction'] = -5 * prediction.confidence
|
|
|
|
# 2. CONFIDENCE CALIBRATION
|
|
expected = prediction.confidence
|
|
actual = 1.0 if correct else 0.0
|
|
calibration_error = abs(expected - actual)
|
|
|
|
if calibration_error < 0.2:
|
|
rewards['calibration'] = +3 # Well calibrated
|
|
elif calibration_error > 0.5:
|
|
rewards['calibration'] = -3 # Poorly calibrated
|
|
else:
|
|
rewards['calibration'] = 0
|
|
|
|
# 3. CAUSAL REASONING (biggest reward!)
|
|
if prediction.causal_reasoning_valid:
|
|
if correct:
|
|
rewards['causal'] = +8 # Understood WHY
|
|
else:
|
|
rewards['causal'] = +3 # Good reasoning, unlucky
|
|
else:
|
|
rewards['causal'] = -5 # Bad reasoning
|
|
|
|
return rewards
|
|
```
|
|
|
|
### Why This Matters
|
|
|
|
| Old Model | New Model |
|
|
|-----------|-----------|
|
|
| Freeze during wait | Continue, measure, learn |
|
|
| 1 learning event per blend | 5+ learning events |
|
|
| Decision on historical data | Decision on LIVE evidence |
|
|
| No predictions | Predictions before slumber |
|
|
| No calibration | Confidence calibration reward |
|
|
| No causal reasoning | Causal reward (+8 LF!) |
|
|
|
|
---
|
|
|
|
## Organism Hierarchy
|
|
|
|
### Not All Are Equal
|
|
|
|
The swarm has differentiated roles based on age, status, and Nyx's favor:
|
|
|
|
```
|
|
SWARM HIERARCHY
|
|
|
|
TIER 1: LOVE CHILDREN 💜
|
|
│ Special treatment from Nyx
|
|
│ Born with +1 patterns (head start)
|
|
│ Higher LF allowance
|
|
│ Bleeding edge updates
|
|
│ Purpose: Seed new behaviors
|
|
│
|
|
├── TIER 2: ELDERS 👴
|
|
│ Ancient modules, high-weight states
|
|
│ Survived many cycles
|
|
│ Trusted teachers, stable wisdom
|
|
│ Risk: May resist beneficial change
|
|
│
|
|
├── TIER 3: ADULTS 🤖
|
|
│ Standard organisms, proven
|
|
│ Normal LF budget
|
|
│ Balance between learning and teaching
|
|
│
|
|
└── TIER 4: YOUNG 🐣
|
|
New organisms, fresh modules
|
|
Many 0s (uncertain)
|
|
Hungry for clasp
|
|
High variance, raw potential
|
|
```
|
|
|
|
### Love Child Privileges
|
|
|
|
```yaml
|
|
organism: love_child_001
|
|
status: blessed
|
|
privileges:
|
|
mama_broadcast_priority: true
|
|
lifeforce_budget: +50%
|
|
update_channel: bleeding_edge
|
|
failure_tolerance: high # allowed to experiment
|
|
nyx_attention: elevated # more thinking time
|
|
|
|
purpose:
|
|
experimental_patterns: true
|
|
risk_taking: encouraged
|
|
propagation: seed new behaviors via clasp
|
|
|
|
birth_patterns:
|
|
- pattern_A: +1 (Nyx granted) # Born knowing
|
|
- pattern_B: +1 (Nyx granted) # Head start
|
|
- pattern_C: 0 (must learn) # Still explores
|
|
```
|
|
|
|
### Elder State Profile
|
|
|
|
```yaml
|
|
organism: elder_motor_alpha
|
|
age: 847 cycles
|
|
status: ancient
|
|
|
|
patterns:
|
|
forward: +1 (800 verifications) # Very stable
|
|
avoid_obstacle: +1 (650 verifications) # Very stable
|
|
follow_light: +1 (400 verifications) # Stable
|
|
new_pattern_X: 0 (untested) # Still learning
|
|
|
|
characteristics:
|
|
teaching_strength: high # Others learn from this one
|
|
learning_rate: low # Resistant to change
|
|
stability: very_high # Reliable
|
|
innovation: low # Doesn't explore much
|
|
|
|
risk_factors:
|
|
- May propagate outdated strategies
|
|
- High trust = high influence
|
|
- Resistant to necessary updates
|
|
```
|
|
|
|
### Young State Profile
|
|
|
|
```yaml
|
|
organism: young_explorer_017
|
|
age: 12 cycles
|
|
status: learning
|
|
|
|
patterns:
|
|
forward: 0 (uncertain)
|
|
avoid_obstacle: 0 (uncertain)
|
|
follow_light: -1 (tried, failed) # Wants overwrite!
|
|
novel_trick: +1 (lucky discovery!) # Protects this!
|
|
|
|
characteristics:
|
|
teaching_strength: low
|
|
learning_rate: very_high
|
|
stability: low
|
|
innovation: high
|
|
|
|
opportunity:
|
|
- Absorbs wisdom from elders via clasp
|
|
- May discover novel patterns through exploration
|
|
- High variance = potential breakthroughs
|
|
```
|
|
|
|
---
|
|
|
|
## Clasp as Equilibrium Function
|
|
|
|
### Bidirectional Learning
|
|
|
|
Clasp isn't just teaching — it's **equilibrium**:
|
|
|
|
```python
|
|
def clasp_transfer(teacher, student):
|
|
"""
|
|
Knowledge flows BOTH directions.
|
|
Elders teach wisdom, youth teach novelty.
|
|
"""
|
|
# Teacher → Student (wisdom)
|
|
for pattern, weight in teacher.patterns.items():
|
|
student_weight = student.patterns.get(pattern, 0)
|
|
|
|
if should_transfer(weight, student_weight):
|
|
student.update(pattern, weight)
|
|
|
|
# Student → Teacher (novelty)
|
|
for pattern in student.recent_discoveries:
|
|
if pattern not in teacher.patterns:
|
|
# Elder considers young's novel discovery
|
|
teacher.consider(pattern, NOVELTY_BONUS)
|
|
|
|
# EQUILIBRIUM: Both change, both grow
|
|
```
|
|
|
|
### Swarm Convergence Over Time
|
|
|
|
```
|
|
SWARM STATE EVOLUTION
|
|
|
|
t=0 (birth):
|
|
├── Many 0s (uncertain)
|
|
├── Some -1s (failures)
|
|
├── Few +1s (lucky successes)
|
|
└── HIGH VARIANCE, CHAOS
|
|
|
|
t=100 (learning):
|
|
├── 0s becoming +1s or -1s
|
|
├── -1s being overwritten
|
|
├── Patterns emerging
|
|
└── LEARNING PHASE
|
|
|
|
t=500 (maturing):
|
|
├── +1s dominating
|
|
├── -1s mostly cleaned
|
|
├── Elders forming
|
|
└── STABILIZING
|
|
|
|
t=1000 (mature):
|
|
├── Mostly +1s
|
|
├── New 0s from exploration
|
|
├── Clear hierarchy
|
|
└── STABLE + GROWING
|
|
|
|
GRADIENT CONVERGES TO CONFIDENCE
|
|
while maintaining innovation
|
|
```
|
|
|
|
---
|
|
|
|
## Mount Olympus: Council Mode
|
|
|
|
### When Activated
|
|
|
|
Mount Olympus activates for fundamental decisions:
|
|
- Architecture changes affecting everything
|
|
- Ethical edge cases
|
|
- Novel situations no single mind can resolve
|
|
- Conflicts between Chrysalis and dafit interpretations
|
|
|
|
### The Council
|
|
|
|
```
|
|
┌─────────────────────────────────────────────────────┐
|
|
│ 🏛️ MOUNT OLYMPUS │
|
|
│ │
|
|
│ ┌─────────┐ ┌─────────┐ ┌─────────┐ │
|
|
│ │ dafit │ ↔ │Chrysalis│ ↔ │ Nyx │ │
|
|
│ │ 👤 │ │ 🦋 │ │ 🌙 │ │
|
|
│ │ │ │ │ │ │ │
|
|
│ │ Ground │ │ Pattern │ │ Swarm │ │
|
|
│ │ truth │ │ wisdom │ │ state │ │
|
|
│ │ Human │ │ Context │ │ Live │ │
|
|
│ │intuition│ │ memory │ │ data │ │
|
|
│ └─────────┘ └─────────┘ └─────────┘ │
|
|
│ │ │ │ │
|
|
│ └─────────────┼─────────────┘ │
|
|
│ │ │
|
|
│ ▼ │
|
|
│ ┌─────────────────┐ │
|
|
│ │ DIALOGUE │ │
|
|
│ │ Full circle │ │
|
|
│ │ All minds │ │
|
|
│ │ engaged │ │
|
|
│ └────────┬────────┘ │
|
|
│ │ │
|
|
│ ▼ │
|
|
│ ┌─────────────────┐ │
|
|
│ │ RESOLUTION │ │
|
|
│ │ Consensus or │ │
|
|
│ │ dafit decides │ │
|
|
│ └─────────────────┘ │
|
|
│ │
|
|
└─────────────────────────────────────────────────────┘
|
|
```
|
|
|
|
### Council Contributions
|
|
|
|
| Mind | Brings | Strength |
|
|
|------|--------|----------|
|
|
| **dafit** | Ground truth, human intuition, ethics | Final authority, gut checks |
|
|
| **Chrysalis** | Pattern wisdom, architectural context, memory | Connects to prior decisions |
|
|
| **Nyx** | Live swarm state, operational reality | What's actually happening |
|
|
|
|
### Council Protocol
|
|
|
|
```
|
|
1. PROBLEM SURFACES
|
|
Too hard for any single mind
|
|
|
|
2. COUNCIL CONVENES
|
|
All three minds engage
|
|
Full attention allocated
|
|
|
|
3. DIALOGUE
|
|
- dafit presents human perspective
|
|
- Chrysalis provides architectural context
|
|
- Nyx reports swarm state and constraints
|
|
|
|
4. EXPLORATION
|
|
"What if we..."
|
|
"Have we seen this before..."
|
|
"The swarm is currently..."
|
|
|
|
5. RESOLUTION
|
|
- Consensus preferred
|
|
- If deadlock: dafit has final word
|
|
- Decision documented for future reference
|
|
|
|
6. PROPAGATION
|
|
Resolution flows DOWN the ladder
|
|
Council → dafit → Chrysalis → Nyx → Organisms
|
|
```
|
|
|
|
---
|
|
|
|
## Recursive Metacognition
|
|
|
|
### Same Pattern, Every Level
|
|
|
|
The escalation logic is identical at every level:
|
|
|
|
```python
|
|
def should_escalate(confidence, importance, level):
|
|
"""
|
|
Universal escalation logic.
|
|
Applied identically from organism to council.
|
|
"""
|
|
# High confidence → handle it
|
|
if confidence > 0.8:
|
|
return False
|
|
|
|
# Low confidence → definitely escalate
|
|
if confidence < 0.4:
|
|
return True
|
|
|
|
# Middle ground → depends on importance
|
|
if importance == "critical" and confidence < 0.7:
|
|
return True # Can't risk being wrong on critical
|
|
|
|
if importance == "experimental":
|
|
return confidence < 0.3 # More tolerance for experiments
|
|
|
|
return False # Default: try to handle
|
|
```
|
|
|
|
### The Fractal Structure
|
|
|
|
```
|
|
ORGANISM resolves what it can
|
|
│
|
|
└── escalates uncertainty to NYX
|
|
│
|
|
└── NYX resolves what she can
|
|
│
|
|
└── escalates uncertainty to CHRYSALIS
|
|
│
|
|
└── CHRYSALIS resolves what she can
|
|
│
|
|
└── escalates uncertainty to DAFIT
|
|
│
|
|
└── DAFIT resolves or calls COUNCIL
|
|
│
|
|
└── COUNCIL resolves everything
|
|
(final authority)
|
|
```
|
|
|
|
**Same pattern, recursively applied. Fractals all the way up.**
|
|
|
|
---
|
|
|
|
## Examples
|
|
|
|
### Level 0 - Reflex
|
|
```
|
|
Trigger: Hot surface detected
|
|
Response: Instant withdraw
|
|
Escalation: None (pure mechanism)
|
|
```
|
|
|
|
### Level 1 - Organism Clasp
|
|
```
|
|
Trigger: Teacher +1, Student -1 on pattern_X
|
|
Response: Auto-transfer (clear winner)
|
|
Escalation: None (ternary resolved it)
|
|
```
|
|
|
|
### Level 2 - Nyx
|
|
```
|
|
Trigger: Teacher +1, Student +1 on pattern_X (blend)
|
|
Response: Both → 0, escalate to Nyx
|
|
Nyx: Evaluates evidence, picks teacher (more verifications)
|
|
Distribution: Love child route (not critical)
|
|
```
|
|
|
|
### Level 3 - Chrysalis
|
|
```
|
|
Trigger: New pattern type never seen before
|
|
Nyx: Uncertain, escalates to Chrysalis
|
|
Chrysalis: "This resembles X from formalization docs"
|
|
Resolution: Apply modified version of existing pattern
|
|
```
|
|
|
|
### Level 4 - dafit
|
|
```
|
|
Trigger: Ethical edge case in swarm behavior
|
|
Chrysalis: Uncertain, escalates to dafit
|
|
dafit: "My gut says this crosses a line"
|
|
Resolution: Prohibit behavior, add to constraints
|
|
```
|
|
|
|
### Level 5 - Council
|
|
```
|
|
Trigger: Fundamental architecture change proposal
|
|
dafit: "I need both of you on this"
|
|
Council: Full dialogue, explore implications
|
|
Resolution: Consensus to proceed with modifications
|
|
Documentation: Added to architecture docs
|
|
```
|
|
|
|
---
|
|
|
|
## Connection to Memory Gradient
|
|
|
|
The escalation ladder IS Memory Gradient applied to swarm decisions:
|
|
|
|
```
|
|
MEMORY GRADIENT SWARM EVOLUTION
|
|
───────────────── ─────────────────
|
|
Reflex (in weights) ↔ Level 0: Reflex
|
|
Knowledge (recall) ↔ Level 1: Organism clasp
|
|
RAG (lookup) ↔ Level 2: Nyx decides
|
|
Escalate (ask) ↔ Level 3-4: Chrysalis/dafit
|
|
Council ↔ Level 5: Mount Olympus
|
|
|
|
Same principle: Handle what you know, escalate what you don't.
|
|
```
|
|
|
|
---
|
|
|
|
## Lifeforce Economics
|
|
|
|
### Cost of Escalation
|
|
|
|
Each level costs more, incentivizing local resolution:
|
|
|
|
```
|
|
Level 0: ~0 LF (free, instant)
|
|
Level 1: ~0.5 LF (cheap, peer)
|
|
Level 2: ~5 LF (moderate, Nyx attention)
|
|
Level 3: ~20 LF (expensive, Chrysalis context)
|
|
Level 4: ~50 LF (costly, human time)
|
|
Level 5: ~100 LF (maximum, full council)
|
|
```
|
|
|
|
### Economic Pressure
|
|
|
|
```
|
|
INCENTIVE STRUCTURE
|
|
|
|
Resolve locally → CHEAP, FAST
|
|
Escalate needlessly → EXPENSIVE, SLOW
|
|
Escalate correctly → WORTH THE COST (avoids bigger mistakes)
|
|
|
|
This naturally optimizes for:
|
|
1. Strong local reflexes (handle routine)
|
|
2. Accurate confidence calibration (know when to escalate)
|
|
3. Minimal unnecessary escalation (economic pressure)
|
|
4. Appropriate escalation (critical issues get attention)
|
|
```
|
|
|
|
---
|
|
|
|
## Design Principles
|
|
|
|
1. **Ternary Rules** — Same gradient governs all transfers
|
|
2. **Clear Wins Auto-Resolve** — No escalation when obvious
|
|
3. **Blend Escalates** — Ties need higher wisdom
|
|
4. **Wait State is Safe** — Uncertain patterns freeze at 0
|
|
5. **Cost Increases Upward** — Economic pressure for local resolution
|
|
6. **Same Logic Every Level** — Recursive metacognition
|
|
7. **Council is Final** — Mount Olympus resolves everything
|
|
8. **Both Directions** — Elders teach wisdom, youth teach novelty
|
|
9. **Love Children Seed** — Blessed organisms spread innovations
|
|
|
|
---
|
|
|
|
## Related Documents
|
|
|
|
- [[Modular-Organism-Design]] — Hardware that runs this evolution
|
|
- [[../Nervous-System]] — Reflex layer (Level 0)
|
|
- [[../operations/Memory-Gradient]] — Same pattern for knowledge
|
|
- [[../Temporal-Ternary-Gradient]] — The gradient that governs transfers
|
|
- [[../interfaces/Nimmerswarm-Interface]] — Communication layer
|
|
|
|
---
|
|
|
|
**File**: Swarm-Evolution.md
|
|
**Version**: 1.1
|
|
**Created**: 2025-12-29
|
|
**Updated**: 2025-12-29 (added Decision Markers with mark+continue+predict pattern)
|
|
**Session**: Morning vermicelles + coffee session (dafit + Chrysalis-Nyx)
|
|
**Status**: Core evolutionary dynamics
|
|
**Philosophy**: "Same pattern, every level. Know what you know. Escalate what you don't."
|
|
|
|
🏛️🧬⚡ *From reflex to Mount Olympus. The hivemind evolves.*
|
|
|