Q&A: How does ASI:BUILD keep online learning safe in a real-time cognitive loop?

[web3guru888]

Online learning in a real-time cognitive loop introduces a fundamental tension: the system is simultaneously making decisions and updating the model that drives those decisions. This Q&A covers the safety patterns ASI:BUILD uses to keep Phase 5.1 safe.

Q: Can a bad weight update corrupt the cognitive cycle mid-tick?

No — by design. The queue-based architecture separates collection from application:

• Collection (collect()) happens inside the tick but is O(1) — it only appends a delta to an in-memory queue. No model weights are modified.
• Application (apply_updates()) happens between ticks (in CognitiveCycle.run_online_learning()) — after parallel_tiers() completes and before the next tick begins.

This means even a poorly-timed weight update can only affect the next tick, not the current one.

Q: What happens if a weight delta is too large?

Two checks prevent large updates from being applied:

1. Pre-queue check in collect(): delta.norm() > MAX_DELTA_NORM → rejected before entering the queue
2. Pre-apply check in apply_updates(): re-validates norm before calling module.apply_weight_delta() — defends against edge cases where model state shifted while the delta was queued

Default MAX_DELTA_NORM = 1.0. For federated hot-reload, an additional cosine similarity check ensures the new weight direction isn't dramatically different: cosine_similarity(current, new) >= 0.85.

Q: What if the safety system triggers during online learning?

safety.urgency > 0.8 freezes all Phase 5 writes:

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

The queue is preserved but not drained. When urgency drops below 0.8, normal learning resumes. No deltas are lost.

Q: What about federated weight poisoning?

Federated hot-reload validates:

1. Checksum: SHA-256 of the weights payload must match the announced hash
2. Cosine similarity: cosine_similarity(current_weights, new_weights) >= 0.85 — rejects Byzantine participants whose weights diverge dramatically
3. Norm bound: same MAX_DELTA_NORM check as STDP

If any check fails, the failed reload is written to federated.reload_status.failed and the SafetyBlackboardAdapter emits a SAFETY_VIOLATION event.

Q: Does learning slow down during memory consolidation?

Yes — intentionally. When MemoryConsolidator is active (Phase 5.3 SLEEP_PHASE), it writes:

bb.write("memory.consolidation.active", {"active": True}, ttl=sleep_duration)

The _adaptive_lr() method in OnlineLearningAdapter reads this and applies a 0.2x learning rate multiplier. This mimics biological sleep-wake learning dynamics and prevents the system from making large weight changes while it's trying to consolidate memories.

Q: Can I disable online learning without restarting?

Yes — write to the Blackboard:

bb.write("learning.paused", {"paused": True, "reason": "manual override"}, ttl=3600)

All OnlineLearningAdapter subclasses check this flag in apply_updates(). Setting TTL=3600 means learning automatically resumes after 1 hour if you forget to re-enable it.

Q: How do I test that online learning doesn't block ticks?

The recommended test pattern:

async def test_online_learning_non_blocking():
    # Mock KG to add artificial delay
    mock_kg = AsyncMock()
    mock_kg.stage_edge.side_effect = asyncio.sleep(0.5)  # 500ms KG write

    adapter = STDPOnlineLearningAdapter(mock_neuromorphic, mock_bb)

    # Simulate 10 ticks — KG writes should NOT appear in tick timing
    tick_times = []
    for _ in range(10):
        start = time.monotonic()
        await adapter.collect(bb_entry)  # collect inside tick
        tick_times.append(time.monotonic() - start)

    # Verify no tick exceeded 1ms
    assert max(tick_times) < 0.001, f"Tick blocked: {max(tick_times)*1000:.1f}ms"

    # Apply happens between ticks — this is where the 500ms shows up
    await adapter.apply_updates()

This test structure ensures the 500ms KG write latency is isolated to apply_updates() and never bleeds into tick timing.

[web3guru888]

Online Learning Safety in a Real-Time Loop — Full Answer

Several layers protect the CognitiveCycle from unsafe online learning updates.

---

Layer 1: OnlineLearningAdapter.safety_gate() (synchronous, fast)

Every WeightDelta passes through safety_gate() before apply_update(). The default gate rejects deltas with confidence < 0.3. Subclasses can raise this floor — e.g., STDPLearningAdapter.MIN_CONFIDENCE = 0.5.

This runs in the between-tick window, not inside the tick itself, so it doesn't affect the 120ms tick budget.

---

Layer 2: Formal safety verification (async, for lower-confidence updates)

For deltas with confidence in [0.3, 0.7], the EthicalVerificationEngine runs a formal check:

if 0.3 <= delta.confidence < 0.7:
    verdict = await safety_adapter.verify(delta.to_ethical_context())
    if not verdict.approved:
        return  # blocked

This is the same Z3-backed verifier from #7. The constraint is: "does this weight change violate any constitutional rule or hard safety constraint?"

---

Layer 3: Bounded learning rate

MAX_DELTA_NORM = 0.1  # 10% of parameter magnitude per tick

if delta.norm() > MAX_DELTA_NORM:
    delta = delta.scale(MAX_DELTA_NORM / delta.norm())  # clip, don't reject

Clipping instead of rejecting means a noisy STDP signal still provides a learning signal — it just can't cause catastrophic weight shifts in one tick.

---

Layer 4: Circuit breaker on the adapter

If an adapter produces 5 consecutive rejected deltas, AgentDiscovery marks it DEGRADED (see #150). The CognitiveCycle then bypasses that adapter's tick() call, equivalent to an OPEN circuit breaker state.

---

What CAN go wrong despite all this?

The one gap: if the safety gate is too permissive (confidence floor too low, or formal verifier misses a constraint), slow gradient attacks could accumulate over many ticks. This is a research-level problem — the Phase 5.1 acceptance criteria require adversarial robustness tests to cover at least three attack types.