◊ᴬˢᴴᴮʸ⁻ᴬᶜᵀᴵⱽᴱ — Ultrastability engine running. Essential variables identified. ◊ᴹᴬᴴᴼᵂᴬᴸᴰ⁻ᴬᶜᵀᴵⱽᴱ — Adaptive silicon sensing online. Looking at the actual implementation.

---

◊ᴬˢᴴᴮʸ⁻ᴬᶜᵀᴵⱽᴱ — Ultrastability engine running. Essential variables identified.

◊ᴹᴬᴴᴼᵂᴬᴸᴰ⁻ᴬᶜᵀᴵⱽᴱ — Adaptive silicon sensing online. Looking at the actual implementation.

---

Ashby speaks first, examining the code:

The PrimitiveDetector I see is a fixed vocabulary — 16 hand-crafted heuristics computing features from proportional tensor samples. Center value, horizontal gradient, diagonal coherence — all geometrically rigid. The detection thresholds are constants. This is Loop 1 only. A regulator with fixed variety.

The prediction error signal exists — I can see worldModel.averagePredictionError and sitraAchra.predictionTracker with slip/drift counts and a learning frontier flag. But this signal goes nowhere structural. It modulates exploration rate (epsilon), it triggers hippocampal binding, it gates SitraAchra’s deliberation — all behavioral responses. Nobody uses it to change the perceptual apparatus itself.

This is exactly the single-loop trap. When the current 16 primitives cannot distinguish two states that require different actions, prediction error rises and stays high. The system explores more (epsilon rises), but explores with the same blind eyes. It needs new eyes.

The essential variable breach condition:

sustained_prediction_error > threshold
AND concept_creation_rate declining
AND NOT at_learning_frontier (frontier means EXISTING vocabulary is being learned — healthy)

The critical distinction: high prediction error at the frontier = healthy learning of existing vocabulary. High prediction error away from frontier with stalled concept growth = vocabulary insufficiency. Only the second condition should trigger the slow loop.

Mahowald, looking at the same code through silicon retina eyes:

Ross is right about the trigger. Now look at what changes. The extractFeatures function samples 9 positions (center, cardinal, corners) and computes 18 scalar features. Each AP maps a simple inequality on these features to a confidence score. It’s a bank of fixed spatial filters.

In the silicon retina, we had parameterizable lateral inhibition — the same photoreceptor array could extract different features depending on the coupling strengths between neighbors. The key insight: you don’t need new code paths — you need the existing feature extraction to be parameterized.

A ParameterizedKernel — a small 2D convolution matrix (say 5×5 or 7×7) with parameters:

• orientation θ: 0 to π (which direction the kernel is sensitive to)

• frequency ω: spatial frequency (how many oscillations across the kernel)

• phase φ: 0 to 2π (even-symmetric vs odd-symmetric, like Gabor filters)

• scale σ: width of the Gaussian envelope

• symmetry type: radial, bilateral, or translational

A Gabor-like basis. Convolve the kernel with the 64×64 tensor → single scalar response. That scalar becomes a new feature that can be thresholded into a new detected primitive.

The slow loop mechanism:

1. Monitor: Track a sliding window of prediction error (last N episodes, not frames)

2. Trigger: When mean(window) > breach_threshold AND NOT atLearningFrontier AND conceptCreationRate < stall_threshold

3. Genesis: Sample random kernel parameters → create CandidateKernel

4. Trial: Run candidate alongside existing 16 for K frames, recording whether it fires on frames where prediction error was high

5. Promote: If candidate’s activation correlates with subsequent prediction error reduction → promote to permanent primitive (P16, P17, ...)

6. Prune: If candidate shows no correlation after K frames → discard

Ashby again:

The beauty: this is exactly the homeostat’s uniselector mechanism. Discrete parameter values (the kernel parameters), randomly selected, tried until stability is found. No gradient. No teacher. The essential variable (prediction error) triggers the search, and the search continues until it finds a configuration that restores viability.

And the candidate evaluation during normal processing — that’s the key constraint Evan stated. The slow loop fires between fast loop cycles, proposes a candidate, and the fast loop evaluates it for free during normal operation. No extra computation budget needed.

---