Documentation  /  The foundational model

HiNet Fractal-Holographic Foundational Model — Definitive Plan

Status: Architecture decision (lead-architect call). Supersedes the earlier "local RAG node" framing of the iCore as a retrieval container; the vault/consent/identity work survives unchanged as the container, but the iCore is now a full, owned, continually-personalized LLM.

Date basis: mid-2026. Version/date-sensitive facts are flagged [verified] (web-checked this cycle) or [inferred] (reasoned synthesis). Where a research brief over-claimed (notably the Exo version string), this plan corrects it.

1. North Star

HiNet builds a network where every human owns an iCore that is, by itself, a complete and useful LLM — booted from a shared open-weight base ("shared DNA") and then hyper-tuned to its owner for life — and where any consenting assembly of iCores composes into a single, more capable LLM, recursively from pair → family → team → domain/country → whole network, with every scale a usable model. This must hold for both decentralized training and decentralized inference.

The single property that defines success is the strict two-part predicate, satisfied simultaneously and honestly:

(A) the part is a whole — an iCore generates coherent tokens standalone, owned, offline; and (B) the whole is bigger — assembling iCores yields a single model with more capability and (in the weight-composed modes) more parameters, not merely an output vote — and the composition is decomposable, so an owner can leave and the assembly re-forms without them.

The non-negotiable that distinguishes HiNet from Petals: the owned atomic unit is a mind, not a layer-slice. You can generate a token from anchor ⊕ your-expert; you cannot generate a token from "layers 30–39." Where we cannot deliver a literally-bigger single model (the WAN edge), we say so out loud and never relabel a committee as a bigger model.

2. Base Model Decision

Chosen base (the shared DNA / first compatibility class): the Qwen3-MoE family, Apache-2.0. [verified — qwenlm.github.io/blog/qwen3; Apache-2.0]

Alternates (seated, not the spine): - DeepSeek-R1-Distill-Qwen-32B (MIT) — strongest dense reasoning iCore; shares Qwen2.5 tokenizer lineage, so it slots into the Qwen compatibility class. [verified — HF card] - OLMoE / OLMo-2-MoE (Ai2, fully open) — the conservative fallback base if the FlexOlmo frozen-anchor recipe (validated on OLMo-2) proves hard to retarget onto ultra-sparse Qwen3-MoE, and the maximal-weight-openness option if that becomes an ethos requirement. [verified — FlexOlmo arXiv:2507.07024 built on OLMo-2] - gpt-oss-20b/120b (Apache-2.0) — excellent standalone reasoning iCore, kept as a heterogeneous committee node only: MXFP4 packing means no framework trains it directly, which blocks the expert-surgery the weight-composition modes depend on. [verified — unsloth gpt-oss RL docs]

Disqualified as the mergeable spine: Llama 4 Scout — capable, but the Llama 4 Community License (AUP + 700M-MAU + "Built with Llama" branding) is non-permissive for a network that merges and redistributes owned weights. Committee node only. [verified — HF model card]

Dense vs MoE — the explicit call: MoE, decisively. Three reasons, all load-bearing: 1. MoE is the only architecture where the assembly can be literally bigger. Dense models can only be soup/TIES/DARE-merged into a same-size model (a hard capacity ceiling). Only MoE lets independently-trained whole-model derivatives recompose into one larger whole via a router (Branch-Train-MiX). [verified — BTX arXiv:2403.07816; merging surveys arXiv:2503.08998] This is predicate (B) made physically possible. 2. Experts are the natural fractal sub-unit, so personalization and consolidation map onto the architecture rather than being bolted on. 3. Laptop economics: ~3B active gives ~14B-class quality at 40–100+ tok/s on Apple Silicon while a high-total-param holographic assembly stays affordable on memory-bandwidth-bound unified RAM. [verified — willitrunai/llmcheck community benchmarks; re-measure on target]

RL-trainability: SFT/DPO/GRPO/ORPO/KTO all run natively on Apple Silicon via mlx-tune / Unsloth-MLX, including LoRA that targets MoE expert layers (SwitchLinear); GRPO ~10× faster on M-series for Qwen3-class. The per-iCore RL loop is laptop-feasible today. [verified — github.com/ARahim3/mlx-tune]

License posture (X-005): spine and all contributable artifacts must be Apache-2.0/MIT so merged weights can be redistributed. This is a hard gate on every base admitted to a compatibility class.

2A. The Ownership & Learning Model — one brain, one filter, a coupled twin

(Canonical mental model, added after design discussion. Resolves "why are there two of me?" and grounds §3–§5.)

One brain. Each owner has a single mind — the frozen shared anchor + their personal adaptation + their private memory. By definition personalized; when the owner thinks for themselves or talks in private, there is no filter. This is the private mind.

One filter (mind ↔ tongue). "Public mode" is not a second mind. It is the same brain operating through a context-conditioned disclosure filter — parameterized by who is asking, private vs public, the social setting. The owner chooses how much of their private knowledge/data to disclose, if at all, when answering for others. The filter runs at two timescales:

• Runtime — conversing. Answering this asker: the private brain produces the answer and the filter shapes the emitted text for the context. Only filtered text leaves; raw data and weights never do. → maps to output-level / committee composition (§3.3). The privacy-native default.
• Consolidation — teaching. The same filter governs what is allowed into a generalized, de-identified public projection of the brain — the artifact others can actually learn from / compose with. → maps to weight-level composition (MoErging/BTX, §3.3). The deeper, opt-in act.

Conversing and teaching are the two ways one brain externalizes intelligence; both are "the same brain bearing on context."

The coupled twin (why two artifacts exist — and why they are not independent):

private mind  Δ_private   — raw experience + interactions, NO filter; never leaves;
     │                       the folded standalone W = B + Δ_private is made of this
     │   nightly distillation, under the disclosure filter + a leakage gate
     ▼
public twin   Δ_public    — generalized, de-identified projection of Δ_private; anchor-locked
                             → composes into qCores; the ONLY contributable artifact

They co-evolve every sleep cycle: (1) the private mind learns from the day's raw experience; (2) the brain then distills a refreshed public twin from the private mind over generalized, de-identified reformulations, gated by a leakage check (canary / membership-inference probes) before Δ_public is eligible to be shared. The public twin is therefore never stale and never an independent mind — it is a running, privacy-filtered re-projection of the private one. (Bidirectional bonus: forming the teachable version regularizes the private mind too — the learning-by-teaching effect; private→public is the primary direction.) This refines the FDLoRA dual-adapter (§4): the two adapters are coupled by the nightly distillation link, not trained independently.

Cost & open risk (honest): ~2× per-night training (private SFT + public distillation), and the generalize → anonymize → leakage-gate transform is the genuine open research piece — done wrong it either leaks private data or destroys the public twin's usefulness (DP noise can also break mergeability — §10 Q4). A thing to prototype and measure (centerpiece of E2), not assume.

Right-sizing — more is not better. The network assembles the minimal sufficient qCore for the contextual generality of the input, never the biggest one. Narrow/personal query → just the owner's own iCore (often the private mind alone). Domain query → the one relevant expert. Broad/cross-domain → a few experts. Maximally general → escalate toward the net. "The whole is bigger" is a statement about available capacity, never about always spending it; over-assembling should actively hurt (routing noise, latency, cost). The router's contextual-generality classification (§3.3, Mode-0) is the real intelligence.

How owner data enters the brain (ingestion). Three consent-gated, local-first intake paths feed one pipeline (SourceRecord + ConsentGrant → normalize → Memory/Fact/Conversation/Preference records → training views → sleep cycle): - Interaction capture — chats with the owner's own iCore + edits / accept-reject / regenerate. Highest-signal, consented by construction; drives the sleep cycle most directly. - Local imports/exports (POC path) — point at a folder, Obsidian vault, code repo, or platform export (Gmail/Drive Takeout, ChatGPT export, Notion). No OAuth. - Account connectors (scale path) — local OAuth connectors (Gmail, Calendar, Drive, Notion, Slack, GitHub, X, browser history). Crucially the connector runs on the owner's device with their own tokens, pulling into their own vault — HiNet never sees tokens or data. Per-source sensitivity class + retention + provenance in the audit log. Connectors are a node-container concern (Tauri app + hinetd), built with the container; E1 needs none of it (public datasets stand in for owner data).

3. The Fractal-Holographic Architecture

Backbone: the "Holographic Spectrum." It wins two of four judge lenses (owner-personalization, roadmap-buildability) and is itself the synthesis the field's most-faithful (MoE-of-iCores) and most-feasible (BTM) proposals converge toward. I graft the decisive pieces of both onto it (§3.4). The backbone is chosen because it is the only design that makes the holographic fidelity a runtime decision rather than a single fixed claim — it picks the highest-fidelity composition mode the bandwidth/compatibility permits, and never hides a committee behind a "bigger model" label.

3.1 The atomic iCore (the "part") — a whole LLM, two faces

iCore =
  FROZEN shared_DNA            (a Qwen3-MoE base checkpoint, locally replicated)
  ⊕ private mind  Δ_private    (PRIVATE — raw experience/voice/memory/secrets; NO filter; never leaves)
  ⊕ public twin   Δ_public     (CONSENTED — generalized, de-identified projection of Δ_private (§2A);
                                anchor-locked FFN expert + router embedding; the ONLY contributable artifact)
  + tiny dense drafter         (1.7–4B, same lineage — cold-start, speculative decode, last-resort whole)

The private mind and public twin are one coupled brain, not two minds — the public twin is a nightly leakage-gated distillation of the private one (§2A). This is a complete, locally-runnable LLM. Remove the network and it still answers. It passes the strict "part" test that Petals fails (an inert layer-slice) and that a bare MoE expert fails (a routerless FFN emits nothing). [verified — distributed-inference survey; FlexOlmo expert non-separability]

Honesty note grafted from the holographic-fidelity judge: the wholeness of the adapter-bearing iCore is carried by the frozen anchor traveling with it. To make the "owner holds a mind" guarantee unconditional, every iCore ships two faces (graft from BTM-Holography): - the live face = anchor ⊕ adapters (composable, decomposable, the default), and - a folded standalone checkpoint W_i = B + Δ_i produced on demand by folding the personal LoRA + chosen experts down into full weights — the owner's offline backup and ultimate sovereignty escape hatch. Even if the MoE trunk were ever stripped, the owner still holds a runnable mind. This is the single strongest fidelity insurance available and it directly hardens the one conditional weakness of the anchor-carried atom.

3.2 The assembly (the "whole") — the frozen-anchor invariant

The keystone is FlexOlmo's frozen-anchor invariant [verified — arXiv:2507.07024]: every contributor trains its shareable expert alongside a frozen copy of the shared DNA acting as an anchor. Because all deltas are deltas-against-the-same-anchor, they land in the same loss basin (linear mode connectivity; Git Re-Basin arXiv:2306.05641) and stay mutually composable. Therefore:

qCore(S) = anchor ⊕ compose( { shareable_expert_i : i ∈ S } )

and the invariant anchor ⊕ {any subset of deltas} is always a valid runnable LLM gives us all three non-negotiables for free: - any subset of iCores is a usable model (fractality), - opt-out = drop a delta, no retraining (consent/revocation), and - composition is associative → the tree closes.

Adding experts adds parameters and skills → the assembly is genuinely bigger in the weight-composed modes (predicate B), not an averaged same-size model.

3.3 The spectrum router — composition mode by scope (the core mechanism)

A model passport (base_model_id, tokenizer hash, chat-template hash, expert/router contract, LoRA target-module set — this is spec task M1-001) yields a compatibility distance between any two candidates. The router then picks the highest-holographic-fidelity mode the scope and bandwidth physically permit, and labels its fidelity explicitly:

The router rule (graft from the holographic-fidelity judge): prefer the highest-fidelity weight-level mode reachable; fall to committee only when no weight-level composition is physically reachable. This operationalizes the success predicate as a runtime decision.

Right-sizing comes first (Mode-0, §2A): before choosing a fidelity mode, the router sizes the assembly to the contextual generality of the input — narrow/personal → the owner's own iCore alone; domain → one expert; broad → a few; maximally general → escalate. More is not better: over-assembling adds routing noise, latency, and cost, and should lose. The fidelity-mode choice above only applies to whatever minimal member set Mode-0 selects.

3.3.1 The fidelity ↔ singularity trade-off (E1-grounded)

Two ways to combine N iCores, with opposite profiles — both measured in E1 (§ E1 Results): best-single 0.556, merge-all 0.667, oracle-routing 0.934. - Weight-merge → one bigger single model (add task-vectors Δ_p = W_p − W_base to the base). Cheap to serve, persistent — but pays an interference tax: shared parameters encode every pack, so summed deltas partially cancel (sign conflicts + magnitude domination). E1: ~28%/pack loss. Interference grows with delta depth/magnitude (overfit/rank/full-FT), member count (~98%@2 → ~82%@11 tasks), and encoding overlap. - Routing / committee → a system of models (run the right specialist(s) per query). No interference (≈ ceiling) — but it's N models (memory/compute) and needs an accurate router. - The axis: fidelity (routing) ↔ singularity/efficiency (merge). Knobs that move along it: delta magnitude (DoRA/lower-rank/less-overfit → smaller, more-orthogonal deltas merge closer to ceiling), member count, merge algorithm (TIES/DARE trim+sign-elect), and re-basing. Empirical lesson: routing the right specialist beat merging all (0.934 > 0.667) — "more isn't better," confirmed. - Closing the merge gap (research 2026-06-22, full detail Personalization-Engine §5b): interference ∝ delta magnitude, not the averaging rule. The biggest lever is a post-merge distillation pass (SAMerging — short KL-distill of each iCore's outputs into the merged weights on a tiny unlabeled probe → ~96.5% of ceiling), plus bounded deltas, Localize-and-Stitch / RegMean / TSV, DiLoCo re-basing (H≈500), and cluster (T≤8) + route at scale. A static small base is structurally capped below the 8–9B recovery band → for the ceiling use TALL-masks (localized per-iCore masks = soft routing).

3.3.2 Dynamic composition selection (per-prompt mechanism)

1. Competence signatures — each iCore advertises a signature (training/competence-embedding centroid + self-description + passport).
2. Per-prompt routing — embed the prompt → score relevance vs every signature → ranked candidate set + generality estimate (optionally refined by a cheap confidence/perplexity probe).
3. Right-size the set — take the minimal sufficient members (top-k above threshold, capped by a latency/cost budget), not all (per §2A and the E1 "more-isn't-better" result).
4. Pick the mode by fidelity-need × budget — max fidelity + can run N → route/committee; one persistent low-latency model → a (pre-)merged qCore (bounded-delta + TIES); different DNA → committee (text only).
5. Hierarchical at scale — router-of-routers (domain/group → specialist) for thousands of iCores.
6. Two timescales — per-prompt selection at inference; frequently co-activated sets are pre-merged into standing qCores + base re-based during background consolidation (amortize the common compositions, route the rare ones live).
7. Feedback — answer/accept outcomes refine signatures + which qCores to cache.

Open risk: routing accuracy is itself a hard learned problem (an early embedding-router mis-routed a domain badly); the 0.934 ceiling assumes good routing, so the router is a first-class component to build + evaluate, not an afterthought.

flowchart TD
    Owner[Human Owner] --> ICore["iCore = frozen DNA + private mind + public twin (§2A)"]
    ICore -->|standalone, offline| LocalAnswer[Usable LLM alone]
    ICore --> Passport[Model Passport / compatibility distance  M1-001]
    Passport --> Router{Spectrum Router  M1-004 / M4-002}
    Router -->|different DNA| MoA["Committee / MoA — bigger SYSTEM, text only"]
    Router -->|same DNA, default| MoErge["MoErging router-of-routers — bigger SINGLE LLM, decomposable"]
    Router -->|same DNA, WAN/offline, oversized| Merge["BTM TIES/DARE merge — one same-size checkpoint"]
    Router -->|same DNA, LAN, long-lived, consented| BTX["Distributed-MoE / BTX promotion — served by Exo LAN"]
    MoErge --> Q1[qCore = larger LLM]
    Merge --> Q1
    BTX --> Q1
    MoA --> Q1
    Q1 -->|recursive: qCore is just a bigger expert set| Router
    Q1 --> QN["domain / country / network qCore"]

3.4 Where it is genuinely holographic vs where it degrades (honest)

• Part = whole: TRUE, now unconditional thanks to the BTM folded-checkpoint graft. The live face is anchor-carried; the folded face is anchor-free. Either way the owner holds a mind.
• Whole = bigger single LLM: TRUE for MoErging and BTX/distributed-MoE. This is real capacity growth via added experts, composed train-free (FlexOlmo router-embedding concatenation [verified]).
• Degradation surfaces, stated plainly: 1. WAN heterogeneous edge → committee. Here "bigger" is a deliberative system, not more parameters. We label it. Improvement over both alternate proposals: where the same DNA is shared but WAN forbids per-token expert-parallel, we fall to a BTM single-checkpoint merge before a committee (graft from BTM) — a same-size single model still beats a vote on the success predicate. 2. BTX promotion is not cleanly decomposable. BTX averages the attention/embedding/norm trunk and re-learns routing, so a promoted expert can't be pulled back out as the original iCore. Mitigation (graft from Spectrum's own discipline + the decomposability ledger below): the default live qCore is MoErging (decomposable); irreversible BTX promotion is rare, opt-in, separately consented, long-lived only. 3. Router saturation past large N drifts toward effective-committee behavior. Mitigation: hierarchical router-of-routers (personal → team → domain → network), embedding-keyed (graft from Spectrum, fixes the MoE proposal's flat-router weakness). 4. Pure weight-merging has a hard capacity ceiling — it is a consolidation primitive, not the growth engine. Only MoE expert addition grows capacity.

The decomposability-vs-capacity ledger (graft, applied network-wide): every qCore is tagged DECOMPOSABLE (live MoErging / merge — exact opt-out, weights sovereign) or PROMOTED (BTX capacity-grown, not cleanly separable). Promotion is an opt-in consented act, logged. This preserves "not your weights, not your intelligence" while still allowing real capacity growth — and it makes the trade explicit rather than silent.

4. Atomic Per-iCore Training

Research-grounded correction (2026-06-21): personalization is hybrid — fine-tuning carries voice/skill/behavior; facts come from vault + RAG (Ovadia, OPPU, FineTuneBench; weight-injection of facts is capacity-limited and fragile). The weight side is a depth spectrum — LoRA → high-rank → DoRA → full fine-tune — tuned in bf16/int8 (not 4-bit) with diverse Self-QA augmentation + replay + eval-gate, and runs at the depth the hardware tier (pocket/laptop/cloud) allows. Deep deltas compose via task-vectors + anchor re-basing. Full method/tier detail: Personalization-Engine. The "coupled twin" below remains the contribution model; Δ_private may be a deep (DoRA/full-FT) delta, not just a thin LoRA.

All local on the owner's laptop via MLX (mlx-tune / Unsloth-MLX). The owner's RL hyper-tuning is fully owned and never ships gradients off-device — justified by the verified INTELLECT-3 retreat (frontier async-RL needed a centralized 512×H200 / 400 Gbps cluster because mid-generation weight sync defeats broadband). Heavy RL stays local on every candidate. [verified — implicator.ai INTELLECT-3 writeup]

Coupled dual-adapter (refines the FDLoRA pattern, arXiv:2406.07925 [verified]; see the canonical model §2A) — the two adapters are coupled by a nightly distillation link, not independent: - Δ_private (the private mind) — raw experience, voice, memory, secrets, idiolect. Private, never aggregated, never crosses the wire. "The model that is you"; the folded standalone W = B + Δ_private is made of this. - Δ_public (the public twin) — a generalized, de-identified projection distilled from Δ_private each sleep cycle under the disclosure filter + a leakage gate; anchor-locked FFN expert + router embedding. The only contributable artifact — "the lesson you keep ready to teach." Not a second mind; a privacy-filtered re-projection of the private one.

Fast/slow CLS "sleep cycle" (SuRe, arXiv:2511.22367) [verified] — the precise algorithm behind the spec's POST /consolidation/run + iCoreTrainingRound, and the direct answer to spec open-question #5 (evolution without catastrophic forgetting): - fast LoRA — high-LR adaptation on the day's interactions (hippocampus); - slow LoRA = EMA(fast) — the stable personal model (cortex); - surprise-prioritized replay buffer interleaved nightly to prevent forgetting; - Merge-before-Forget continual merge keeps the LoRA count bounded.

RL personalization from tiny signal: - DPO/P-DPO from implicit owner signals (edits, accept/reject, regenerate, dwell) for taste/style — beats RLHF baselines at 50–100 preferences, which is all one human produces. [verified — Drift arXiv:2502.14289; Reward-Factorization arXiv:2503.06358] - GRPO/RLVR where the owner has verifiable rewards (their code, math, domain).

Ownership & revocation (maps to ConsentGrant / AuditEvent): - Contribution = publishing ONE consented shareable expert + its router embedding; the personal LoRA is never eligible. - Revocation in live qCores is exact and free (graft the MoE proposal's mechanism): drop the router embedding from the concatenated router; the qCore stops routing to you, no retraining, no degradation to others (FlexOlmo opt-out [verified]). - Revocation after PROMOTION cannot mathematically un-bake a delta from a frozen BTX artifact; it prevents future inclusion and is logged. This is an explicit opt-in consent-UX item, not a silent default (the decomposability ledger enforces it). - Sovereignty escape hatch: fold to the standalone W_i checkpoint on demand (§3.1) — exportable, deletable, runnable forever even if HiNet vanishes.

5. Hierarchical Consolidation

Tiered merging up a tree on progressively slower clocks. Crucial split: live qCores ROUTE (sovereign, decomposable); promotions MERGE (capacity, consented).

Tier discovery (privacy-safe, no org chart): ELSA [verified search-surfaced — arXiv:2601.13824] builds semantic fingerprints from responses to a shared public probe set + symmetric-KL clustering → emergent teams/domains without exposing private data. This is automatic qCore formation.

The clocks (multi-timescale, rate roughly halving per tier up — CLS theory):

Merge fan-in discipline (graft from BTM): to bound the regression-to-mean that wounds large heterogeneous merges, cluster first (merge like-with-like), cap fan-in per merge, use Fisher/RegMean weighting — applied only on the rare same-DNA promotion tail where weight fusion is unavoidable.

Transport for any shared-weight step: SparseLoCo (Top-k 1–3% + 2-bit quant + error-feedback; outperforms full-precision DiLoCo at far lower comms; powered Covenant-72B over ~70 permissionless nodes) over a Hivemind DHT. [verified — arXiv:2508.15706] Deltas compress ~10–30× via DARE top-k before upload (graft from BTM's compress-before-transmit), so the simulated-peer transport is residential-bandwidth-honest from day one. TOPLOC contribution receipts on every published expert/delta feed the AuditEvent chain (graft from MoE proposal — fills spec M4-008).

6. Decentralized Training Stack (what runs now)

The decentralized-training projects are transport/consolidation plumbing, not the architecture. The architecture is the modular-composition layer (§3–5). This separation is the single most important conclusion of the training survey.

Verified bound that shapes the whole plan: decentralized frontier RL is unsolved (INTELLECT-3 retreated to centralized). HiNet keeps heavy RL local and reserves decentralization for low-frequency consolidation only.

7. Decentralized Inference Stack — and how this goes BEYOND Petals

The router (§3.3) selects the mode; transport differs per mode and is chosen by the highest-fidelity weight-level path that bandwidth permits.

Exo version correction (both alternate proposals over-stated it): Exo's public status is alpha (~v0.0.15); "EXO 1.0 / v1.0.71" is not a released public version — the DeepSeek-671B ~5.37 tok/s demo was a Thunderbolt LAN run on 8 M-class Macs. Treat Exo as a real but alpha intra-owner LAN transport, never the cross-owner composition semantics. [verified — exo repo public status; brief flagged the inflated string]

If a WAN layer-shard path is ever genuinely required, fork Parallax (the live Petals successor: two-phase scheduler, 3.2× latency / 3.6× throughput vs HexGen), not stalled Petals (last release Sept 2023). [verified — arXiv:2509.26182]

How this is beyond Petals, precisely: - Petals slices ONE monolith into transformer layer-blocks served across volunteers (pipeline parallelism). A block is not a usable LLM; the owner holds a slice, not a mind. It also leaks intermediate activations to peers. - HiNet's atomic owned unit is a whole LLM (anchor ⊕ expert, plus a foldable standalone checkpoint), and composition yields a bigger whole LLM (MoErging/BTX) or at worst a same-size single model (BTM merge) — and in the default modes only text/embeddings cross the wire, with activation-passing confined inside a consented LAN qCore. The owned unit coincides with the model; the composition is decomposable. That is the exact axis Petals fails.

8. POC / Experiment Roadmap

Phase A — Holographic atom + the make-or-break composition test (single 128GB Mac; ~2–3 weeks). E1 HAS PASSED — see HiNet-E1-Experiment-Design.

E1 (the flagship POC) — PASSED. Took Qwen3-30B-A3B as the frozen anchor, branched 3 persona experts (e.g. finance / medical / code) independently against the anchor via mlx-tune (FlexOlmo-style frozen-anchor LoRA on FFN + router embedding), and on a held-out mixed-domain eval set compared three composition modes: (a) text committee / MoA, (b) embedding-initialized MoErging / task-vector merge, (c) BTX-merged MoE. Result (full detail HiNet-E1-Experiment-Design): best-single 0.556 < task-vector-merged single 0.667 (+11pp) < oracle-routing ceiling 0.934 — a weight-level mode beat the best single iCore, so predicate (B) "whole is bigger" holds at the smallest scale, and the opt-out check was exact (dropping one expert's router embedding cleanly removed that persona with zero retraining and no degradation to the rest). E1 also settled fact-injection: bf16 full fine-tuning DOES inject facts (recall 0.27 → 0.97). The holographic-assembly thesis survived its make-or-break gate; the network tiers are cleared to proceed. Tools: Qwen3-30B-A3B, MLX + mlx-tune, mergekit/mergekit-moe, FlexOlmo reference code. Nodes: 1. Effort: ~2–3 weeks, 1–2 people.

Run alongside E1 (cheap, same machine): - E1b — folded-checkpoint atom. Fold persona-1's LoRA into a standalone W_1 = B + Δ_1; confirm it loads and answers offline with no router/anchor co-present. Proves the unconditional-ownership graft.

Phase B — Continual personalization without forgetting (single Mac; ~2 weeks). - E2 — sleep cycle + the coupled twin (§2A centerpiece). Implement SuRe (fast LoRA + EMA slow LoRA + surprise replay) + few-shot DPO from logged accept/reject over a simulated 30-day stream to evolve Δ_private; then each cycle distill Δ_public from Δ_private over generalized, de-identified reformulations and run the leakage gate (planted canary secrets + a membership-inference probe) before Δ_public is eligible to share. Metrics: (a) private-fidelity ↑ while a frozen general benchmark stays flat (no catastrophic forgetting); (b) the public twin retains ≥ most of the private mind's generalized competence while the leakage gate shows zero canary recall and at-chance membership inference. This is where the generalize→anonymize→leakage transform (§10 Q4) is actually measured. Wires into iCoreTrainingRound.

Phase C — Latency/fidelity honesty + the router (2 Macs + tc/netem; ~3–4 weeks). - E3 — mode-vs-bandwidth. Run the E1 composed model with experts split across 2 Macs over (a) Thunderbolt LAN via Exo and (b) simulated residential WAN (tc/netem). Plot tok/s and per-token round-trips for distributed-MoE vs the BTM-merged single checkpoint vs an MoA committee. Success criterion: the spectrum router empirically picks the right mode per bandwidth and never deploys per-token cross-owner EP over WAN. Settles the core feasibility risk and builds the passport/compatibility-distance router (M1-001/M1-004/M4-002).

Phase D — Decentralized consolidation + verification dry run (3–4 simulated nodes, then LAN; ~4 weeks). - E4 — low-comms outer-sync. SparseLoCo over Hivemind to outer-sync the shared anchor across 3–4 nodes; prime-rl GRPO on a verifiable task; TOPLOC receipt on each contribution. Metric: comms volume, consolidated quality, and detection of a deliberately poisoned rollout. Exercises M4-008 receipts and the M7 epoch flow on localhost-first transport.

Build-order / status roadmap → Whitepaper §8 (single source of truth). This section is experiment design only; the live build-status roadmap (what is shipped vs building) is no longer tracked here.

9. Relationship to / Replacement of the earlier "local iCore node" POC

What we KEEP, essentially unchanged — the container: - node-identity, local-vault, consent-policy, audit-log, node-api, peer-protocol stubs (Milestones 2, 4, 6). The vault is still where raw data, embeddings, and now also adapters/experts and folded checkpoints live. ConsentGrant still gates every operation; AuditEvent is still the append-only chain — it now also records contribution receipts (TOPLOC) and the decomposability tag (DECOMPOSABLE vs PROMOTED) of every qCore the owner joins. - The MVP stack recommendation (Python + FastAPI + SQLite + model adapter + scheduled consolidation jobs) is correct and unchanged. POST /consolidation/run and iCoreTrainingRound are now concretely the SuRe sleep cycle (§4).

What CHANGES — the intelligence: - The iCore is no longer a RAG-over-a-remote-model node; it is a full owned LLM = frozen Qwen3-MoE DNA ⊕ Δ_private ⊕ Δ_public (the coupled twin, §2A), with local RL. The model-adapter's "future LoRA/adapter training" and "qCore routed inference" lines (spec §model-adapter) become first-class, implemented via MLX and the spectrum router. - The spec's holographic-inference options are now decided: default qCore = MoErging (option 2 done right, decomposable); committee (option 6) is the cross-base / WAN fallback, not the primary; distributed-MoE/Petals-like (option 5) is intra-owner LAN only. Memory/RAG (option 4) remains the retrieval substrate feeding the model, not the composition mechanism. - Milestone 1 is now answerable: M1-001 passport = the Qwen3-MoE compatibility class; M1-003 egoistic/communal = the coupled Δ_private/Δ_public dual-adapter (§2A); M1-004 spectrum scopes = the §3.3 router table; M1-006 revocation = drop-the-delta (live) / future-use-only + ledger (promoted).

Net: the earlier POC was the right container with an under-powered core. We swap the core for an owned, composable LLM and keep the container intact.

10. Open Research Questions & Risks

Blocking (must resolve before claiming the thesis or going to network scale): 1. Does the assembly actually beat the best single iCore? RESOLVED — E1 PASSED (HiNet-E1-Experiment-Design): best-single 0.556 < task-vector-merged single 0.667 (+11pp) < oracle-routing ceiling 0.934, so predicate (B) holds at the smallest scale; E1 also showed bf16 full fine-tuning injects facts (recall 0.27 → 0.97). The make-or-break gate is cleared. 2. FlexOlmo → Qwen3-MoE retarget. The frozen-anchor recipe is verified on OLMo-2; retargeting onto ultra-sparse Qwen3-MoE (different expert granularity/count) is unproven engineering. Mitigation: OLMoE/OLMo-2-MoE conservative fallback base; keep the retarget off the POC critical path by running E1 on whichever base lands first. 3. Router quality / saturation past large N. Embedding-initialized routing may need a periodic learned MoE-finetune (loses train-free purity) and a hierarchical router-of-routers to hold fidelity at thousands of iCores — and who pays for that finetune without a central operator is open.

Deferrable (real, but later-phase): 4. Privacy of published deltas / activations. A dense delta may memorize private data even after scrubbing (membership-inference / model-inversion); DP-noise may destroy mergeability. Activation-passing in LAN distributed-MoE leaks intermediates. Mitigation today: default modes cross only text/embeddings; confine activation-passing to consented LAN qCores. 5. Decomposability after promotion / machine unlearning. No published method both grows capacity (BTX) and lets a participant be pulled back out cleanly. Mitigation: keep promotion rare/opt-in; live qCores are MoErging-decomposable. 6. Trustless verification of training (not just inference). TOPLOC verifies rollouts; proving a contributed expert was honestly trained and isn't poisoned is open (Verde promising; Gensyn paused). Mitigation: eval-gate admission + TOPLOC receipts now; Verde later. 7. Anchor drift across base upgrades (across successive base-model releases). How far can the compatibility class drift before old deltas stop composing, and what is the migration/distillation path that preserves owners' personalization? Permutation alignment / Git Re-Basin at LLM scale is unsolved. 8. Decentralized frontier RL remains unsolved (INTELLECT-3 retreated). HiNet's design already routes around it by keeping heavy RL local; network-scope RL stays low-frequency. 9. Over-personalization / reward-hacking of the private personal LoRA (implicit reward models generalize poorly OOD). Mitigation: the dual-adapter wall keeps the private LoRA out of aggregation; needs an alignment/safety eval on the hyper-tuned iCore.

Out of scope here (by instruction): aCore agentic layer, token economics, on-chain settlement. The hooks (TOPLOC receipts, AuditEvent chain, consent grants) are placed so those layers can attach later without re-architecting the foundation.

Next: Personalization engine →  ·  All documentation →