Resonance MoE

Complete Build Framework — Authorized Access

Incorrect passcode. Try again.

⚡ Resonance MoE — Complete Build Framework

A Living Deliverable: Resonance-Based MoE Inference Architecture for Constrained Hardware

📅 Created: Nov 16, 2026 👤 Author: Lamar Andre Chisolm 📊 Status: Build-Ready 🔬 Classification: Original Architecture
🎯 Project Overview

What this is: A complete, validated framework for building a resonance-based Mixture-of-Experts (MoE) inference system that runs large language models on constrained hardware (4GB RAM target). This document is a living deliverable — a password-protected, self-contained web application that serves as the single source of truth for building this system.

The core innovation: Instead of loading an entire model into RAM, the system treats the model as an organized energy landscape on disk. A resonance index in RAM predicts which parameter clusters will activate for any given input. Only the resonant parameters are loaded — guided by prediction, not search. The disk is never scanned. The answer is attracted.

Target model: GLM-5.2 — 744B total parameters, 40B active per token, 256 routed experts, 8 selected per token, 1 shared expert. Sparse attention optimized.

The reframing: The question was never "fit 138GB into 4GB." The question was "fit what actually fires into 4GB." The rest doesn't need to be in RAM. It needs to be accessible.

What this document contains:

  • Complete 6-step architecture specification
  • Technical assessment — what's sound, what needs validation
  • 6-experiment build roadmap with success criteria
  • Living deliverable creation methodology (9 phases)
  • 5-layer research and verification standard
  • Four-class task classification system
  • Four-tier execution pipeline
  • Success metrics and quality control gates
  • System handoff protocol for fresh OpenClaw/Hermes deployment

Origin: This architecture was conceived intuitively by Lamar Chisolm in approximately 20 minutes, without prior study of existing MoE offloading research. Subsequent technical examination confirmed that several components have established research foundations, while the unified resonance-based retrieval system represents a potentially novel contribution.

⚡ The 6-Step Resonance MoE Architecture

Step 1: Redefine the Domain

Stop seeing the model as 744B parameters that need to be loaded. GLM-5.2 is a Mixture-of-Experts model. 744B total, but only 40B activate per token. That's 5.4% of the model actually working at any moment. The other 94.6% is sitting dormant.

Apply the hot/cold principle: within that 40B active set, parameters follow a power-law distribution. A small fraction fires constantly. The rest fire rarely. So the REAL per-token active footprint is even smaller than 40B.

At 1.58-bit quantization, 40B parameters = ~7.5GB. But the hot fraction — the 10-20% doing 80% of the work — is ~1.5-3GB. That fits in 4GB.

# The math
Total params:       744B
Active per token:   40B (5.4%)
At 1.58-bit:        40B × 1.58 / 8 = 7.9 GB
Hot fraction (15%): 7.9 × 0.15 = ~1.2 GB
Warm (on-demand):   ~1.5-2 GB per token
Resonance index:    ~100-500 MB
System overhead:    ~200 MB
Total RAM:          ~3-4 GB ✓

Step 2: Reorganize Disk as an Energy Landscape

Current model storage: Parameters written sequentially as a file. One giant blob. To find parameter X, you seek to its byte offset. Card catalog.

New storage: Parameters organized on disk by functional similarity. Parameters that co-activate are stored in spatial proximity. This creates physical regions of related data — basins on the storage surface.

This isn't theoretical. The model's attention patterns tell you which parameters fire together. You cluster them, then write them to disk in that order. The disk now has a physical topology that mirrors the model's functional topology.

Technical note: NVMe SSDs use NAND flash, not magnetic platters. The concept is Locality-Optimized Parameter Storage (LOPS) — grouping experts by co-activation patterns, layer relationships, router similarity, and predicted sequential activation.


Step 3: Build a Resonance Index in RAM

The index is small. It doesn't contain parameters. It contains the SIGNATURES of parameter clusters — which input patterns each cluster responds to.

Think of it as a map of the basins of attraction on the disk. Each entry says: "If the query looks like X, the relevant parameters are in disk region Y."

This is the Hopfield energy landscape compressed into an index. 744B parameters → maybe 100-500MB of index entries. Fits easily in 4GB alongside the hot parameters.

# Resonance Index Structure
{
  "cluster_id": "expert_042_layer_17",
  "input_signature": [0.23, -0.41, 0.88, ...],  // compressed embedding
  "disk_region": {
    "offset": 45212586240,
    "length": 15728640,
    "priority": "warm"
  },
  "co_activation": ["expert_018_layer_17", "expert_042_layer_18"],
  "activation_frequency": 0.12
}

Step 4: Query Arrives — Activate by Resonance, Not Search

A query comes in. Instead of scanning the disk:

  1. The query is matched against the resonance index in RAM (milliseconds — already loaded)
  2. The index identifies which disk regions contain parameters that would fire for this query
  3. Only those regions are loaded — guided by the index, not by sequential scan

The disk was never searched. The answer was attracted. The index told you where the resonance would be, and you went straight there.


Step 5: Load Only the Activated Clusters

For any given query, the activated parameter clusters might be 2-5GB. The hot ones are already in RAM. The warm ones get loaded from the specific disk regions the index pointed to. The cold ones never get touched.

You're not loading 138GB. You're not even loading 40GB. You're loading what actually fires for this specific input — maybe 2-5GB, guided by resonance, arriving from known locations on the disk.

# NVMe Performance
SSD read speed:    3,000-7,000 MB/s
Load 2GB:          0.3-0.7 seconds
With prefetching:  load overlaps with computation
Net latency:       near zero (pipelined)

NVMe SSD reads at 3,000-7,000 MB/s. Loading 2GB of targeted parameters takes 0.3-0.7 seconds. With prefetching (the index knows what the next layer will need while the current layer is computing), the load overlaps with computation. Net latency: near zero.


Step 6: Compute and Discard

The activated parameters compute the token. Then they're released from RAM if they're not hot. The next token's query hits the resonance index again, loads its activated clusters, computes, releases.

4GB RAM is enough because at no point do you need the whole model in memory:

ComponentRAM BudgetLifecycle
Resonance index~100-500MBAlways loaded
Hot parameters~1.5-3GBAlways loaded
Warm parameters (current token)~500MB-2GBLoaded on demand, released after
Context window + system~200MBAlways loaded
Total~3-4GBFits in 4GB ✓

Summary: The 138GB model lives on disk as an organized landscape. RAM only holds what's resonating right now. The system doesn't remember everything — it knows where everything is and retrieves what it needs, when it needs it.

🔬 Technical Assessment

Established engineering principles (confirmed):

ComponentStatusEvidence
MoE sparse activationEstablishedGLM-5.2: 40B of 744B active
Expert caching in RAMEstablishedStandard caching strategy
On-demand expert loadingEstablishedFlashMoE, ADEPT research
Predictive expert prefetchingActive researchMultiple papers published
1.58-bit ternary quantizationResearch-validatedBitNet b1.58 papers
Locality-aware storageValidStorage optimization principle
Resonance-based retrieval indexNovel hypothesisRequires experimental validation
Full 744B on 4GB RAMUnprovenTarget — not yet demonstrated

Critical distinction: Reducing the amount of model data transferred into RAM is not the same as reducing the amount of model data required to compute each token. This distinction determines whether the architecture works.

Mathematical corrections needed:

  • 1.58-bit calculation: 40B × 1.58 / 8 = 7.9GB (not 1.5-3GB). To reach 1.5-3GB, must demonstrate that only ~19-38% of active parameters need to be accessed per token.
  • 138GB model: At 1.58 bits: 744B × 1.58 / 8 = 146.9GB (before metadata). The 138GB figure needs packing assumptions explained.
  • Hot parameter assumption: Expert popularity ≠ parameter contribution. An infrequently-activated expert may be essential for specific reasoning. Discarding it could cause significant degradation.

Key technical obstacle — resonance index:

The expert router makes decisions at different layers based on evolving hidden states. Knowing the original question doesn't necessarily tell you every expert that will be selected later. A viable system needs to:

  1. Predict expert activation dynamically
  2. Update predictions as computation progresses
  3. Recover gracefully when predictions are wrong

This is where the resonance index could become a genuine contribution — if it outperforms ordinary expert-frequency caching and predictive prefetching.

Levels of innovation in this proposal:

  • Established Sparse MoE activation, expert caching, quantization, offloading
  • Potentially innovative Unified predictive index combining expert co-activation, storage locality, and dynamic prefetching
  • Unproven Achieving useful GLM-5.2 inference with only 4GB total system RAM while maintaining acceptable quality and speed
🛠️ Build Roadmap — 6 Experiments

Principle: Do not attempt to build the entire architecture immediately. Establish a sequence of experiments that progressively validate or invalidate each hypothesis.

Experiment 1: Expert Activation Profiling

Goal: Record which experts activate across thousands of representative inputs.

Deliverable: An empirical activation-frequency distribution.

Success criteria: Clear power-law distribution visible. Top 10-20% of experts account for 70%+ of activations across diverse inputs.

Classification: AI-EXECUTABLE

Tools: Python, PyTorch, small MoE model (e.g., Mixtral 8x7B or smaller)

Time estimate: 2-4 hours

Experiment 2: Hot/Cold Analysis

Goal: Measure whether a small cache captures most expert accesses and how much model quality is lost when experts are unavailable.

Deliverable: Cache hit rates and quality measurements.

Success criteria: Cache hit rate >80% with top 20% experts. Quality degradation <5% on standard benchmarks.

Classification: AI-EXECUTABLE

Time estimate: 4-6 hours

Experiment 3: Resonance Index

Goal: Build a lightweight predictor that estimates future expert activation from input signatures.

Deliverable: Prediction accuracy, index size, and false-negative rate.

Success criteria: Prediction accuracy >75%. Index size <500MB. False-negative rate <10%.

Classification: AI-EXECUTABLE

Time estimate: 6-12 hours

This is the central experiment. If the resonance index outperforms frequency-based caching, the architecture has a genuine novel contribution.

Experiment 4: Storage Optimization

Goal: Compare ordinary expert storage against locality-organized storage (LOPS).

Deliverable: Actual SSD read performance and loading latency.

Success criteria: LOPS achieves >30% faster read times for multi-expert activation patterns vs. sequential storage.

Classification: AI-EXECUTABLE

Time estimate: 4-8 hours

Experiment 5: Hardware Validation

Goal: Measure performance on constrained hardware (Mac mini M4, 4GB RAM budget).

Deliverable: RAM consumption, tokens per second, latency, and accuracy.

Success criteria: Peak RAM <4GB. Tokens/second >1. Time to first token <5 seconds. Model benchmark scores within 5% of full-precision baseline.

Classification: AI-EXECUTABLE

Time estimate: 8-16 hours

Experiment 6: Independent Replication

Goal: Have another system/researcher reproduce the results using the same model, hardware, and test dataset.

Deliverable: Reproducible evidence package.

Success criteria: Results reproduced within 10% margin on independent run.

Classification: LAMAR-ONLY (requires Lamar's authorization for external sharing)

One-hour proof of concept (if you want to start immediately):

  • Minutes 0-10: Create activation map — simulate experts, record which fire for different inputs
  • Minutes 10-20: Create resonance index — associate input signatures with expert clusters
  • Minutes 20-35: Implement selective retrieval — load only predicted experts
  • Minutes 35-45: Add hot/warm/cold caching
  • Minutes 45-60: Test and measure — compare prediction accuracy, memory use, data transferred
📋 Living Deliverable Methodology — 9 Phases

Definition: A living deliverable is not a document. It is a password-protected, self-contained web application that serves as the single source of truth for a project. It contains all information needed to build, validate, and maintain the system — accessible anywhere, updatable in real-time, handoff-ready.

Core Philosophy — 7 Non-Negotiable Principles:

  1. The Avatar comes BEFORE the code. Know exactly who this is for before building.
  2. Specificity beats generality. One specific operator, one specific system, one specific outcome.
  3. 20+ sections minimum. If we can't squeeze 20 sections of value, the deliverable isn't comprehensive enough.
  4. Each section earns its place. Minimum one paragraph of substantive, formatted content. No filler.
  5. The vernacular must match. Use the language of the system's operators.
  6. Dual-Pole architecture for live systems. Live data (Acquisition) + AI synthesis, recursing off each other.
  7. Polarization over agreement. Cross-reference, find contradictions, resolve them. Friction between sources is where value is forged.

The 9 Phases:

PHASE 1 → Avatar Definition (First Principles)
PHASE 2 → Pickup / Middle / Dropoff Mapping
PHASE 3 → Vernacular & Color Extraction
PHASE 4 → Competitor/Existing Research Audit (Weighted Scoring)
PHASE 5 → 20+ Section Selection (Highest-Leverage Wins)
PHASE 6 → Naming & Brand Identity
PHASE 7 → Dual-Pole Architecture Design
PHASE 8 → Section Build (Card Layout + Format Standards)
PHASE 9 → Output Polish (Emojis, Bullets, Copy/Share, Chevrons)

Phase 1 — Avatar Definition: Define the exact person/system who will use this deliverable. For this project: a fresh OpenClaw or Hermes system on a Mac mini, receiving this document as its build instructions. The avatar is the system itself — it reads, interprets, and executes.

Phase 2 — Pickup/Middle/Dropoff:

  • Pickup: Fresh system, no context, no memory, no prior instructions. Empty Mac mini.
  • Middle: "The model doesn't need to remember everything — it needs to know where everything is and retrieve it on demand." This is the conceptual bridge.
  • Dropoff: A working resonance-based MoE inference system running GLM-5.2 (or any large MoE model) on 4GB RAM.

Phase 4 — Existing Research Audit: Before building, audit what already exists:

Existing TechnologyRelevanceDifferentiation
FlashMoE (SSD expert caching)High — same problem spaceAdaptive, not predictive
ADEPT (domain-aware prefetch)High — predictive loadingDomain-specific, not resonance-based
BitNet b1.58 (ternary quantization)High — quantization methodValidated for training, not inference on constrained HW
Expert offloading researchMedium — identifies loading as bottleneckDoesn't propose resonance retrieval
Hopfield networks / associative memoryMedium — conceptual foundationNot applied to MoE parameter retrieval

Phase 5 — Section Selection: This deliverable contains 13 sections covering: Overview, Architecture, Technical Assessment, Build Roadmap, Living Deliverable Method, Research Standard, Task Classification, Execution Pipeline, Success Metrics, Hardware, Self-Improving Loop, Quality Control, and System Handoff.

Phase 8 — Card Layout Standards:

  • Card-based layout with 14px border-radius
  • Emoji-prefixed headers with primary color accent
  • Color-coded callout boxes (highlight=yellow, warning=red, success=green, info=blue)
  • Minimum 1 paragraph + 3-5 bullets + 1 actionable element per section
  • Every section includes at least one specific number, data point, or code block
  • Copy/share buttons on every section
✅ 5-Layer Research & Verification Standard

Every claim in this deliverable must pass through 5 layers of verification:

LayerQuestionStandard
1. ClaimWhat exactly are we saying?Stated precisely, no ambiguity
2. EvidenceWhat documentation supports it?Primary source or experimental data
3. SourceWhere did the information originate?Original publication, not secondary
4. VerificationCan another independent source confirm?At least one independent confirmation
5. ConfidenceIs the conclusion established, probable, disputed, or unknown?Labeled explicitly

Research capabilities applied to this project:

CapabilityApplication
Conceptual researchExplain resonance retrieval in plain language
Background researchMoE architecture history, expert offloading context
Fact verificationGLM-5.2 specs cross-checked against NVIDIA NGC docs
Data analysisActivation frequency distributions, cache hit rates
Source validationFlashMoE, ADEPT, BitNet papers assessed for methodology
Comparative researchResonance index vs. frequency-based caching
Risk assessmentHot parameter assumption, prediction accuracy risk
Strategic synthesisExecutive-level overview of feasibility and innovation

Confidence levels used in this document:

  • Verified — Established by primary research or experimental evidence
  • Probable — Supported by existing research, not yet tested in this configuration
  • Hypothesis — Architecturally sound, requires experimental validation
  • Unproven — Target outcome, not yet demonstrated
  • Disputed — Evidence is contradictory or insufficient

Commitment to integrity: This deliverable distinguishes between verified facts, claims made by third parties, reasonable interpretations, estimates/projections, and unverified information. No assumption is represented as a fact. If evidence is insufficient, it is stated as such.

🗂️ Four-Class Task Classification System

Every task on the build roadmap is classified using this system. The burden of proof is on the classifier to justify why something is LAMAR-ONLY. Lamar's time is the scarcest resource.

ClassDefinitionExamples
LAMAR-ONLY Requires founder judgment, vision, or relationship capital Publishing research, IP decisions, partnership talks, strategic pivots
VA-EXECUTABLE Mechanical, repeatable, scriptable. Anyone following instructions can do it Running test scripts, documenting results, formatting output
VA-WITH-ASSETS VA executes after Lamar provides ONE input (approval, asset, code review) Testing after Lamar approves approach, deploying after Lamar provides credentials
AI-EXECUTABLE AI agent can do it directly with no human needed Writing code, running experiments, building indices, profiling activations

Output format for every task:

TASK: [name]
CLASSIFICATION: [LAMAR-ONLY | VA-EXECUTABLE | VA-WITH-ASSETS | AI-EXECUTABLE]
LAMAR TIME: [0 min | 5 min | 30 min | 2 hr | full day]
INSTRUCTION BLOCK: [if VA: copy-paste ready, includes deliverable,
  success criteria, tools needed, deadline, escalation path]
COMPLETION CHECK: [how to verify it was done correctly]

The Forwarder Rule: Any VA-executable task gets a fully self-contained instruction block. A person who has never seen this project should be able to copy-paste the block and get a usable deliverable back without Lamar touching it.

⚙️ Four-Tier Execution Pipeline

How work flows through the system:

Tier 0 (Vivienne): Intent interpretation
    → TaskContract JSON with lane + success criteria
    → Confidence < 0.7 → ASK LAMAR

Tier 1 (Petra): Library-first lookup
    → Search existing scripts/codex for reusable solution
    → If found → execute. If not → generate.

Tier 2 (Declan): Pure execution
    → Run the script/experiment
    → Capture ExecutionResult

Tier 3 (Sovereign): Validation
    → ValidationReport (PASS/FAIL/PROMOTE)
    → 3 successful runs + meta-review by different agent
    → Promote to permanent library

Lane allocation:

LaneWhenToken cost
PROCEDURALScript-only, no LLM needed$0
HYBRIDScript + surgical LLM use$0.01-0.50
AMBIGUOUSNeeds LLM throughout$0.50-5.00

Library promotion criteria:

  • 3 runs with 80%+ success rate
  • Meta-review by a different agent than the creator
  • Provenance file documenting origin

Decommission criteria:

  • 90 days idle
  • <60% success rate
  • Deprecated API dependency
  • Replaced by higher-trust solution

For this project: All 6 experiments in the build roadmap are classified as AI-EXECUTABLE. They can be run by an AI agent on a fresh system using the task contracts defined in this deliverable. Lamar's involvement is minimal — review results, approve next phase.

📊 Success Metrics — What Determines If It Works
MetricWhat it establishesTarget
Peak RAMWhether 4GB is achievable< 4GB
SSD bytes read/tokenActual data movement per token< 3GB
Expert prediction accuracyWhether resonance works> 75%
Cache hit rateEffectiveness of hot parameters> 80%
Tokens/secondPractical usability> 1 t/s
Time to first tokenInitial loading overhead< 5 seconds
Model benchmark scoresWhether intelligence is preservedWithin 5% of baseline
Energy consumptionWhether approach is efficient< 50W average

Comparison baseline: Results should be compared against conventional MoE inference and existing expert-offloading systems — not simply against loading the entire model into RAM.

The three gates that determine go/no-go:

  1. Gate 1 (after Experiment 2): Is there a clear power-law distribution? Does the hot 20% capture 70%+ of activations? → If no, the core assumption is invalidated.
  2. Gate 2 (after Experiment 3): Does the resonance index outperform frequency-based caching by a meaningful margin? → If no, the novel contribution doesn't hold. Pivot to standard offloading.
  3. Gate 3 (after Experiment 5): Does it fit in 4GB and produce usable tokens/second? → If no, the target is unachievable with current hardware. Document findings and adjust target.
🖥️ Hardware Requirements

Primary target: Mac mini M4

SpecMinimumRecommended
RAM4GB available (16GB system)8GB available (32GB system)
Storage512GB NVMe SSD1TB+ NVMe SSD
GPU10-core integrated10-core+ (Metal acceleration)
OSmacOS 14+macOS 27+ (current)
SoftwarePython 3.12+, PyTorchPython 3.14+, PyTorch with MPS

Why Mac mini M4:

  • NVMe SSD with 3,000+ MB/s read speeds — critical for on-demand loading
  • Unified memory architecture — no GPU-to-CPU transfer bottleneck
  • Metal Performance Shaders for GPU acceleration
  • Low power consumption (~50W) — efficient for sustained inference
  • Already the household infrastructure machine

Storage budget breakdown (138GB model on disk):

Model weights (1.58-bit):  ~147 GB
Resonance index data:      ~0.5 GB
Metadata + alignment:      ~2 GB
OS + software:             ~30 GB
Free space:                ~332 GB (512GB SSD)
                           ~852 GB (1TB SSD) ✓

Alternative hardware (for validation):

  • Linux box with NVMe SSD + 16GB RAM (test OS portability)
  • Raspberry Pi 5 with 8GB RAM + NVMe HAT (extreme constraint test)
🔄 Self-Improving Recursive Loop

Long-term vision: The resonance MoE system is not just an inference engine — it is a self-improving living deliverable. The recursive loop between model and scripts creates continuous optimization.

The recursive loop:

1. System runs inference using resonance index
2. Activation patterns are recorded
3. Patterns feed back into the resonance index
   → Prediction accuracy improves
   → Cache hit rate increases
   → RAM usage decreases (better prediction = less over-fetching)
4. System runs faster on same hardware
5. Goto 1

Three phases of self-improvement:

PhaseTimelineWhat happens
1. BootstrapDay 1-7Initial resonance index built from profiling. Static predictions.
2. AdaptationWeek 2-4Index updates based on real usage patterns. Cache hit rate climbs.
3. ConvergenceMonth 2+System stabilizes at optimal cache configuration. Predictions are highly accurate for the system's usage domain.

The bigger picture — Recursive Forge applied to self:

  • 1 pass: Basic resonance index (1x value)
  • 2 passes: Index + adaptive feedback (10x value)
  • 3 passes: Index + feedback + cross-domain transfer (50x value)
  • 4 passes: Full self-improving system + novel research contribution (200x value)

Connection to Lamar's cognitive architecture: The system mirrors the "recursive cross-domain architectural cognition" framework — it treats the entire reasoning environment as something that can be examined, challenged, and reconstructed. The system doesn't just run the model; it examines its own retrieval patterns and reconstructs its index to be more efficient.

🧪 Quality Control — The Final Gate

The Avatar Read-Through Test: Imagine a fresh OpenClaw system reading this deliverable. At every section, ask:

  1. Would the system know exactly what to build?
  2. Would the system understand WHY this architecture exists?
  3. Would the system find one specific, actionable thing it can do right now?
  4. Is there anything generic that should be specific?
  5. Are there any missing steps in the build process?

If ANY answer is no → revise that section.

The Scoring Rubric:

DimensionA+ Standard
Completeness20+ sections, no filler, every build step covered
Technical accuracyEvery number verified, every calculation checked
ActionabilityAny AI system can execute the roadmap without human clarification
VerificationEvery claim labeled with confidence level and source
Visual designCard-based, color-coded, readable, password-protected
InteractivityCopy/share on sections, navigable, collapsible details
Handoff readinessCan be installed on fresh system and executed start-to-finish
Wow factorA builder would screenshot the architecture and send it to a colleague

NEVER DO:

  • ❌ Hardcode values that should be parameterized
  • ❌ Generic placeholder data ("[your model here]")
  • ❌ "Check competitors" → SHOW the competitor data
  • ❌ Random numbers without sources
  • ❌ Sections under 1 paragraph
  • ❌ Math errors — verify every calculation
  • ❌ Fluff filler ("In today's fast-paced AI landscape...")
🚀 System Handoff Protocol — Fresh OpenClaw/Hermes Deployment

Purpose: This section provides everything a fresh OpenClaw or Hermes system needs to receive this deliverable and build the resonance MoE system from scratch on a Mac mini.

Step 1: System Preparation

# On fresh Mac mini (macOS 27+)
# 1. Install OpenClaw
npm install -g openclaw

# 2. Install Python 3.12+ (if not present)
brew install python@3.12

# 3. Install PyTorch with MPS support
pip3 install torch torchvision torchaudio

# 4. Install required packages
pip3 install numpy scipy scikit-learn matplotlib

# 5. Verify NVMe SSD speed
sudo diskutil info / | grep "Solid State"
# Should show: Yes

Step 2: Deliverable Ingestion

  1. OpenClaw system receives this deliverable URL
  2. System reads all 13 sections
  3. System creates TaskContract for each experiment (6 total)
  4. System classifies all tasks (all AI-EXECUTABLE)
  5. System begins Experiment 1

Step 3: Build Sequence

# Experiment 1: Expert Activation Profiling
python3 experiments/01_activation_profiling.py
# Output: activation_distribution.json

# Experiment 2: Hot/Cold Analysis  
python3 experiments/02_hot_cold_analysis.py
# Output: cache_hit_rates.json, quality_metrics.json

# Gate 1 Check: Power-law visible? Hot 20% → 70%+ activations?
# If NO → stop, report, reconsider architecture
# If YES → proceed

# Experiment 3: Resonance Index
python3 experiments/03_resonance_index.py
# Output: resonance_index.bin, prediction_accuracy.json

# Gate 2 Check: Resonance beats frequency caching?
# If NO → pivot to standard offloading, document findings
# If YES → proceed (this is the novel contribution)

# Experiment 4: Storage Optimization
python3 experiments/04_lops_comparison.py
# Output: lops_benchmark.json

# Experiment 5: Hardware Validation
python3 experiments/05_hardware_validation.py --ram-budget 4GB
# Output: system_metrics.json, benchmark_scores.json

# Gate 3 Check: Fits in 4GB? Usable t/s? Quality preserved?
# If NO → adjust target, document findings
# If YES → system is operational

# Experiment 6: Independent Replication
# Requires Lamar authorization for external sharing

Step 4: Operational State

Once all gates pass, the system should:

  • Load the resonance index on startup (~100-500MB into RAM)
  • Load hot parameters (~1.5-3GB into RAM)
  • Accept queries via API or CLI
  • Match query against resonance index → identify disk regions
  • Load warm parameters on demand → compute → release
  • Update resonance index based on observed activation patterns
  • Report metrics: RAM usage, t/s, cache hit rate, prediction accuracy

Step 5: Connection to Existing Infrastructure

ComponentIntegration point
OpenClaw GatewayModel provider — register as local inference endpoint
Hermes BotBot can use local model instead of cloud API
Vivienne/Petra/Knox/DeclanAgents route to local model for zero-cost inference
PGSN PipelineProcedural tasks use local model (zero token cost)
Household ScriptsAny script calling an LLM can use local endpoint

End state: A Mac mini running GLM-5.2 (or any large MoE model) locally on 4GB RAM, with zero per-token API cost, serving all household agents and scripts. The system self-optimizes its resonance index over time. The architecture can be replicated on any machine with an NVMe SSD.

Key Reference Documents (read these first on fresh system):

  • ~/.openclaw/vault/fixgenius-operational-state.md — current system state
  • ~/.openclaw/vault/fixgenius-credentials.md — all passwords, keys, endpoints
  • MEMORY.md — curated long-term memory
  • AGENTS.md — workspace instructions and tool documentation
  • SOUL.md — persona and authority rules
  • USER.md — Lamar's preferences and guardrails