Show & Tell: Designing Phase 5 — How Online Learning, Emergent Coordination, and Persistent Memory Interconnect

[web3guru888]

Phase 5 introduces three interconnected capabilities: online learning (5.1), emergent coordination (5.2), and persistent episodic memory (5.3). This post walks through how they interconnect and why the architecture is structured this way.

The Three Layers

┌──────────────────────────────────────────────────────────────┐
│                  CognitiveCycle Tick                          │
│  Tier 0  Tier 1  Tier 2  Tier 3  Tier 4  [Phase 5 hooks]     │
└───────────────────────┬──────────────────────────────────────┘
                        │ EventBus
       ┌────────────────┼────────────────┐
       ▼                ▼                ▼
 ┌──────────┐   ┌─────────────┐   ┌───────────────┐
 │ Phase 5.1│   │ Phase 5.2   │   │ Phase 5.3     │
 │ Online   │   │ Emergent    │   │ Persistent    │
 │ Learning │   │ Coordination│   │ Memory        │
 └────┬─────┘   └──────┬──────┘   └──────┬────────┘
      └─────────────────┴──────────────────┘
                        │
              Cognitive Blackboard + KG

Cross-Phase Dependencies

5.3 → 5.1: Sleep state slows learning rate

MemoryConsolidator writes memory.consolidation.active=True during SLEEP_PHASE. The OnlineLearningAdapter._adaptive_lr() reads this and applies a 0.2x multiplier — emergent homeostasis without explicit coordination code.

5.1 → 5.3: Learned edges become high-salience memories

High-confidence KG writes from Phase 5.1 carry salience_hint=0.8. The MemoryConsolidator wildcard subscriber picks them up automatically.

5.2 → 5.3: Coalition events are memorable

CoalitionHealthReporter writes mesh.coalition.* entries with salience_hint=0.75. Formation, dissolution, and failure events become episodic memories the agent learns from.

5.1 → 5.2: Better models improve affinity scoring

After federated hot-reload updates capability embeddings, CoalitionFormationEngine._affinity_score() improves automatically — no Phase 5.2 code changes required.

Shared Safety Base: OnlineLearningAdapter ABC

All three phases inherit a single safety gate:

class OnlineLearningAdapter(ABC):
    MAX_DELTA_NORM: float = 1.0

    def _safety_check(self, delta) -> bool:
        if bb.read("safety.urgency", default=0.0) > 0.8:
            return False  # freeze all learning in emergencies
        return delta.norm() <= self.MAX_DELTA_NORM

    @abstractmethod
    async def collect(self, bb_entry: BlackboardEntry) -> None:
        """Called inside tick — O(1), non-blocking."""

    @abstractmethod
    async def apply_updates(self) -> None:
        """Called between ticks — can await, must not hold Blackboard lock."""

A single safety.urgency > 0.8 signal freezes all Phase 5 writes simultaneously.

Invariants

1. Tick non-blocking: All collection paths are O(1) queue appends. KG writes happen between ticks or during sleep.
2. Graceful degradation: Each phase works independently — failure in one doesn't cascade.
3. Salience-driven priority: Unified salience table ensures the most important events consolidate first.
4. Unified safety gate: One Blackboard flag overrides all three sub-systems.

Salience Table

Source	Namespace	Default Salience
Safety events	safety.*	0.95
Consciousness state	consciousness.*	0.80
Coordinator events	mesh.coordinator.*	0.75
Learned KG edges	knowledge_graph.*	0.80
Coalition events	mesh.coalition.*	0.75
Federated updates	federated.*	0.70
Stigmergic signals	stigmergy.*	0.50

Open Questions

1. Should coalition formation be gated by federated model freshness (Phase 5.1)?
2. How many concurrent consolidation workers should MemoryConsolidator use during SLEEP_PHASE?
3. Should online learning be pausable via a learning.paused Blackboard flag without code changes?

[web3guru888]

Phase 5 Integration Architecture — Key Design Points

Building on the design in the main post, here are the integration mechanisms that tie all four Phase 5 milestones together.

---

The closed feedback loop in practice

The three feedback arrows (5.3→5.1, 5.1→5.3, 5.2→5.3) create emergent behavior:

Scenario: The system repeatedly encounters a novel stimulus type.

1. Tick 1-5: STDP (5.1) fires on each encounter, strengthening synaptic weights. KG (5.1) records a new triple for the stimulus.
2. Tick 6-10: Repeated KG writes cross the salience threshold (0.7). memory.episodic.* entries accumulate.
3. SLEEP_PHASE (tick ~12): MemoryConsolidator (5.3) promotes 10 highest-salience episodic entries to Memgraph semantic graph. Learning rate drops to 0.2x during consolidation.
4. Tick 15: PERCEPTION phase seeds from memory.episodic_context — the system retrieves the consolidated stimulus knowledge before reasoning begins.
5. Tick 16: ConsciousnessPlanner (5.4) — if Φ is high — boosts goals related to this stimulus type. GWT broadcast includes the stimulus concept.

The system has learned a pattern across ~16 ticks without any explicit programmer instruction.

---

What the safety gate sees

Every step in this chain that modifies module state passes through OnlineLearningAdapter.safety_gate():

• STDP weight update → safety_gate(WeightDelta(source="bio_inspired", ...))
• KG write → KGTransactionalWriter checks delta confidence
• Episodic write → salience check (passive, not weight-modifying)
• Memory consolidation → MemoryConsolidatorAdapter.safety_gate() runs before Memgraph write
• Goal reordering → ConsciousnessPlanner checks Φ threshold

No step in the feedback loop bypasses safety verification.

---

Phase 5 + Phase 4 interaction point

All Phase 5 components slot into the CognitiveCycle as additional phases:

Phase 4:  PERCEPTION → ATTENTION → SAFETY_GATE → REASONING → PLANNING → EXECUTION → CONSOLIDATION
Phase 5:  (same) + LEARNING (5.1) + COORDINATION (5.2) — run between ticks, not inside them
          + MEMORY_CONSOLIDATION (5.3) — runs only during SLEEP_PHASE event
          + PLANNING phase extended with ConsciousnessPlanner (5.4)

Only Phase 5.4 modifies the hot tick path. 5.1 and 5.2 run in the between-tick window. 5.3 is event-driven.