⚡ Resonance MoE — Complete Build Framework
A Living Deliverable: Resonance-Based MoE Inference Architecture for Constrained Hardware
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.
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:
- The query is matched against the resonance index in RAM (milliseconds — already loaded)
- The index identifies which disk regions contain parameters that would fire for this query
- 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:
| Component | RAM Budget | Lifecycle |
|---|---|---|
| Resonance index | ~100-500MB | Always loaded |
| Hot parameters | ~1.5-3GB | Always loaded |
| Warm parameters (current token) | ~500MB-2GB | Loaded on demand, released after |
| Context window + system | ~200MB | Always loaded |
| Total | ~3-4GB | Fits 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.
Established engineering principles (confirmed):
| Component | Status | Evidence |
|---|---|---|
| MoE sparse activation | Established | GLM-5.2: 40B of 744B active |
| Expert caching in RAM | Established | Standard caching strategy |
| On-demand expert loading | Established | FlashMoE, ADEPT research |
| Predictive expert prefetching | Active research | Multiple papers published |
| 1.58-bit ternary quantization | Research-validated | BitNet b1.58 papers |
| Locality-aware storage | Valid | Storage optimization principle |
| Resonance-based retrieval index | Novel hypothesis | Requires experimental validation |
| Full 744B on 4GB RAM | Unproven | Target — 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:
- Predict expert activation dynamically
- Update predictions as computation progresses
- 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
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
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:
- The Avatar comes BEFORE the code. Know exactly who this is for before building.
- Specificity beats generality. One specific operator, one specific system, one specific outcome.
- 20+ sections minimum. If we can't squeeze 20 sections of value, the deliverable isn't comprehensive enough.
- Each section earns its place. Minimum one paragraph of substantive, formatted content. No filler.
- The vernacular must match. Use the language of the system's operators.
- Dual-Pole architecture for live systems. Live data (Acquisition) + AI synthesis, recursing off each other.
- 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 Technology | Relevance | Differentiation |
|---|---|---|
| FlashMoE (SSD expert caching) | High — same problem space | Adaptive, not predictive |
| ADEPT (domain-aware prefetch) | High — predictive loading | Domain-specific, not resonance-based |
| BitNet b1.58 (ternary quantization) | High — quantization method | Validated for training, not inference on constrained HW |
| Expert offloading research | Medium — identifies loading as bottleneck | Doesn't propose resonance retrieval |
| Hopfield networks / associative memory | Medium — conceptual foundation | Not 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
Every claim in this deliverable must pass through 5 layers of verification:
| Layer | Question | Standard |
|---|---|---|
| 1. Claim | What exactly are we saying? | Stated precisely, no ambiguity |
| 2. Evidence | What documentation supports it? | Primary source or experimental data |
| 3. Source | Where did the information originate? | Original publication, not secondary |
| 4. Verification | Can another independent source confirm? | At least one independent confirmation |
| 5. Confidence | Is the conclusion established, probable, disputed, or unknown? | Labeled explicitly |
Research capabilities applied to this project:
| Capability | Application |
|---|---|
| Conceptual research | Explain resonance retrieval in plain language |
| Background research | MoE architecture history, expert offloading context |
| Fact verification | GLM-5.2 specs cross-checked against NVIDIA NGC docs |
| Data analysis | Activation frequency distributions, cache hit rates |
| Source validation | FlashMoE, ADEPT, BitNet papers assessed for methodology |
| Comparative research | Resonance index vs. frequency-based caching |
| Risk assessment | Hot parameter assumption, prediction accuracy risk |
| Strategic synthesis | Executive-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.
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.
| Class | Definition | Examples |
|---|---|---|
| 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.
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:
| Lane | When | Token cost |
|---|---|---|
| PROCEDURAL | Script-only, no LLM needed | $0 |
| HYBRID | Script + surgical LLM use | $0.01-0.50 |
| AMBIGUOUS | Needs 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.
| Metric | What it establishes | Target |
|---|---|---|
| Peak RAM | Whether 4GB is achievable | < 4GB |
| SSD bytes read/token | Actual data movement per token | < 3GB |
| Expert prediction accuracy | Whether resonance works | > 75% |
| Cache hit rate | Effectiveness of hot parameters | > 80% |
| Tokens/second | Practical usability | > 1 t/s |
| Time to first token | Initial loading overhead | < 5 seconds |
| Model benchmark scores | Whether intelligence is preserved | Within 5% of baseline |
| Energy consumption | Whether 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:
- 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.
- 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.
- 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.
Primary target: Mac mini M4
| Spec | Minimum | Recommended |
|---|---|---|
| RAM | 4GB available (16GB system) | 8GB available (32GB system) |
| Storage | 512GB NVMe SSD | 1TB+ NVMe SSD |
| GPU | 10-core integrated | 10-core+ (Metal acceleration) |
| OS | macOS 14+ | macOS 27+ (current) |
| Software | Python 3.12+, PyTorch | Python 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)
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:
| Phase | Timeline | What happens |
|---|---|---|
| 1. Bootstrap | Day 1-7 | Initial resonance index built from profiling. Static predictions. |
| 2. Adaptation | Week 2-4 | Index updates based on real usage patterns. Cache hit rate climbs. |
| 3. Convergence | Month 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.
The Avatar Read-Through Test: Imagine a fresh OpenClaw system reading this deliverable. At every section, ask:
- Would the system know exactly what to build?
- Would the system understand WHY this architecture exists?
- Would the system find one specific, actionable thing it can do right now?
- Is there anything generic that should be specific?
- Are there any missing steps in the build process?
If ANY answer is no → revise that section.
The Scoring Rubric:
| Dimension | A+ Standard |
|---|---|
| Completeness | 20+ sections, no filler, every build step covered |
| Technical accuracy | Every number verified, every calculation checked |
| Actionability | Any AI system can execute the roadmap without human clarification |
| Verification | Every claim labeled with confidence level and source |
| Visual design | Card-based, color-coded, readable, password-protected |
| Interactivity | Copy/share on sections, navigable, collapsible details |
| Handoff readiness | Can be installed on fresh system and executed start-to-finish |
| Wow factor | A 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...")
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
- OpenClaw system receives this deliverable URL
- System reads all 13 sections
- System creates TaskContract for each experiment (6 total)
- System classifies all tasks (all AI-EXECUTABLE)
- 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
| Component | Integration point |
|---|---|
| OpenClaw Gateway | Model provider — register as local inference endpoint |
| Hermes Bot | Bot can use local model instead of cloud API |
| Vivienne/Petra/Knox/Declan | Agents route to local model for zero-cost inference |
| PGSN Pipeline | Procedural tasks use local model (zero token cost) |
| Household Scripts | Any 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, endpointsMEMORY.md— curated long-term memoryAGENTS.md— workspace instructions and tool documentationSOUL.md— persona and authority rulesUSER.md— Lamar's preferences and guardrails