# 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.*