nimmerverse-sensory-network/architecture/organisms/Swarm-Evolution.md

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

@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

@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

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

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

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

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:

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:

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.