NUCLEUS Composition Model

⚛️🧬 NUCLEUS is LIVE on 3 gates — westGate (Linux, Provenance 7/7), blueGate (Windows, Provenance 7/7), and strandGate (RTX 3090, 1,742 capabilities). It is the emergent state when all 13 primals are running and coordinated by 🌿🖥️ biomeOS. Sovereign CI automates the entire build-deploy pipeline. gen4 is COMPLETE. gen5 begins: NUCLEUS as a platform serving real workloads.

Status (Wave 155n): ZERO P0s. ZERO P1s. ZERO blocking P2s. 35 depot binaries across 3 platforms. Provenance 7/7 validated end-to-end on live hardware.

Composition Diagram

The Atomics Ladder

Primals compose in layers. Each layer is a named composition pattern — not a separate product — defined by which primals coordinate and what behavior emerges.

Tower Atomic

Composition: 🐻🐕 BearDog + 🎵🐦 Songbird + 🦨🦇 skunkBat
What emerges: Sovereign encrypted mesh — replaces WireGuard with capability-aware transport

Tower is the foundation of all networked communication. 🐻🐕 BearDog provides Ed25519 identity, key management, BTSP crypto, and genetic lineage trust. 🎵🐦 Songbird provides mesh networking, peer discovery, capability routing, and federation. 🦨🦇 skunkBat provides protocol negotiation and defensive security. Together they form an encrypted peer-to-peer mesh with topology-aware routing — LAN peers communicate directly (0.57ms) instead of routing through the VPS overlay. This isn’t a speed comparison with WireGuard (which solves a different problem); it’s a structural advantage of LAN-aware path selection plus capability-based routing that WireGuard doesn’t attempt.

BTSP 13/13 — all primals implement the handshake. Crypto delegation 6/6 COMPLETE. Autonomous enrollment LIVE (F10 fossilized). genomeBin 5 targets. Tower LIVE on 8+ gates including westGate (Nest Atomic) and strandGate (Compute Trio).

6 exploration domains are PROVEN LIVE. See Tower Atomic for full benchmark data.

Nest Atomic — LIVE ON WESTGATE

Composition: Tower Atomic + 🪺🔒 NestGate + Provenance Trio ( 🌱🔐 rhizoCrypt + 🪨📖 loamSpine + 🍯🌾 sweetGrass) What emerges: Content-addressed storage with cryptographic provenance

Nest Atomic is LIVE on two gates — westGate (Linux, ZFS 25.4TB, 3,252 CAS objects, 1.56× compression) and blueGate (Windows, 13/13 primals, 131.1 MB, TCP-only). 🌿🖥️ biomeOS serves as composition broker with 654 capabilities COORDINATED on westGate. The Provenance Trio is 7/7 COMPLETE — full cryptographic provenance chain validated end-to-end on both platforms.

Node Atomic — VALIDATED ON STRANDGATE

Composition: Tower Atomic + 🐸🍄 ToadStool + 🐟⚡ barraCuda + 🪸🌊 coralReef What emerges: GPU-accelerated distributed scientific compute

Node Atomic has been validated on strandGate (Dual EPYC 7452, 256GB, RTX 3090) — 746 pipelines/sec, 450 methods registered. The Compute Trio runs FP64 on both RTX 3090 and RX 6950 XT with 100% pass rate. 3 signal graphs defined.

NUCLEUS — ACHIEVED

Three gates now run full NUCLEUS — all 13 primals composed:

Provenance 7/7: Full 7-step provenance chain (CAS → DAG → Merkle → Spine → Ed25519 signature → Attribution braid) works on live hardware. Validated across Linux (ZFS backend) and Windows. Boot order discipline (Tower → Nest → Node → biomeOS) is the deployment standard.

Sovereign CI: Push to Forgejo → auto build → sandbox validate → depot push → HTTPS serve. Zero human intervention for musl builds. 35 depot binaries (16 musl + 4 gnu + 15 Windows).

ZERO P0s. ZERO P1s. ZERO blocking P2s. gen4 is COMPLETE. The project has shifted to gen5: NUCLEUS as a platform serving real workloads.

Node Atomic

Composition: Tower + 🐸🍄 ToadStool (+ 🐟⚡ barraCuda, 🪸🌊 coralReef)
What emerges: Hardware-aware sovereign compute

Node adds compute capability to Tower’s networking. 🐸🍄 ToadStool discovers available hardware (CPU, GPU, NPU) and dispatches workloads. 🐟⚡ barraCuda provides the math (800+ WGSL f64 shaders), and 🪸🌊 coralReef compiles shaders to native GPU binaries. The boundary is precise: 🐟⚡ barraCuda writes math, 🪸🌊 coralReef compiles it, 🐸🍄 ToadStool dispatches it.

Nest Atomic

Composition: Tower + 🪺🔒 NestGate
What emerges: Secure, content-addressed storage

Nest adds persistent storage. 🪺🔒 NestGate provides content-addressed storage (CAS) with BLAKE3 hashing, deduplication, and integrity verification. Combined with Tower’s networking, data can be stored locally and verified remotely.

Full NUCLEUS

Composition: All 8 foundation primals
What emerges: AI-coordinated sovereign computing

Full ⚛️🧬 NUCLEUS is the complete foundation: networking (Tower), compute (Node), storage (Nest), orchestration ( 🌿🖥️ biomeOS), and AI coordination ( 🐿️🧠 Squirrel). 🌿🖥️ biomeOS reads deploy graphs, germinates primals, wires capabilities, and routes requests via the 🧠🔌 Neural API. 🐿️🧠 Squirrel — one of the eight — adds vendor-agnostic AI inference and MCP tool orchestration.

┌─────────────────────────────────────────────────┐
│                  Full NUCLEUS                    │
│                                                  │
│  ┌──────────────────────────────────────────┐   │
│  │  Squirrel — AI coordination (MCP)        │   │
│  └──────────────────────────────────────────┘   │
│  ┌──────────────────────────────────────────┐   │
│  │  biomeOS — orchestration, Neural API     │   │
│  └──────────────────────────────────────────┘   │
│                                                  │
│  ┌─────────────┐ ┌──────────┐ ┌────────────┐   │
│  │ Node Atomic │ │   Nest   │ │   Tower    │   │
│  │             │ │  Atomic  │ │  Atomic    │   │
│  │ ToadStool   │ │          │ │            │   │
│  │ barraCuda   │ │ NestGate │ │ BearDog    │   │
│  │ coralReef   │ │          │ │ Songbird   │   │
│  └─────────────┘ └──────────┘ └────────────┘   │
└─────────────────────────────────────────────────┘

Neural API

🌿🖥️ biomeOS routes requests to primals using semantic capability matching, not hardcoded names. A consumer says what it needs (math.matmul, shader.compile.wgsl, crypto.sign), and 🌿🖥️ biomeOS finds the primal that advertises that capability.

How Routing Works

1. Primals register capabilities via JSON-RPC on startup (e.g., 🐟⚡ barraCuda registers math.*)
2. Consumers request by domain (e.g., capability.call("math", "matmul"))
3. 🌿🖥️ biomeOS resolves the request to the right primal based on registered capabilities
4. No primal knows about other primals by name — only by capability

This means primals can be swapped, upgraded, or composed differently without changing consumers.

Coordination Patterns

🌿🖥️ biomeOS executes TOML deploy graphs that define how primals coordinate:

Learning

🌿🖥️ biomeOS includes a PathwayLearner that uses execution metrics to suggest optimizations: parallelization opportunities, prewarming, batching, and caching. The system learns how primals interact and improves routing over time.

Deploy Graphs

A deploy graph is a TOML DAG that tells 🌿🖥️ biomeOS what to run:

[[nodes]]
name = "crypto"
primal = "beardog"
capabilities = ["crypto.sign", "crypto.verify"]

[[nodes]]
name = "compute"
primal = "toadstool"
capabilities = ["compute.dispatch"]
depends_on = ["crypto"]

[[nodes]]
name = "storage"
primal = "nestgate"
capabilities = ["storage.put", "storage.get"]
depends_on = ["crypto"]

🌿🖥️ biomeOS reads the graph, germinates each primal (starts it, waits for IPC socket, confirms health.check), wires capabilities according to edges, and handles graceful degradation if optional nodes are absent.

Niches

A niche is a 📦🔧 BYOB deployment — a specific composition of primals for a specific purpose. Defined by a deploy graph + niche YAML + capability domains. Examples:

Deployment Compositions

Niches define abstract compositions for purpose. Deployment compositions are the concrete instances running on gates — each maps to a niche profile with specific primals and operational roles:

The 🎵🐦 Songbird drawbridge pattern enables capability-based routing into a composition: SONGBIRD_DRAWBRIDGE_ROUTES=/hub=jupyter,/api=inference makes songBird auto-register capabilities at startup and announce them to mesh peers. Remote gates can then capability.call("jupyter") — songBird routes to the local drawbridge endpoint.

Each deployment composition has a matching projectNUCLEUS deploy graph that codifies the exact primal set, launch ordering, and health checks.

Germination

Starting a primal until it is ready for requests:

1. 🌿🖥️ biomeOS runs the primal’s server subcommand
2. Waits for the IPC socket to appear
3. Calls health.check to confirm readiness
4. Registers the primal’s advertised capabilities
5. Wires capability routes according to the deploy graph

The analogy: a seed germinates in a niche on a gate.

Dark Forest

🔧🦎 ecoPrimals uses a zero-metadata-leakage discovery protocol. The goal: observers should not be able to tell that communication is occurring.

Genetic Lineage

🐻🐕 BearDog manages two kinds of cryptographic material:

• Nuclear DNA (family seed): Shared identity and permissions within a family of gates. Auto-trust within family, zero trust outside.
• Mitochondrial DNA (beacon seeds): Used for 🌑🌲 Dark Forest discovery — finding peers without revealing your existence to observers.

Trust Model

• Within family: Auto-trust via shared family seed ( 🐻🐕 BearDog verification)
• Cross-family: Zero trust by default; trust must be explicitly established
• Network observers: Cannot determine that communication is occurring ( 🌑🌲 Dark Forest property)

The 🌑🌲 Dark Forest protocol is complemented by 🦨🦇 skunkBat’s active threat detection — 🌑🌲 Dark Forest handles discovery privacy, 🦨🦇 skunkBat handles defensive security within the sovereign environment.

Plasmodium: Multi-Gate Collectives

When two or more ⚛️🧬 NUCLEUS instances bond, they form a 🫠🌐 Plasmodium — a collective that shares capabilities, models, and load without a central coordinator. Named after Physarum polycephalum (slime mold): no central brain, collective behavior, graceful degradation.

How It Works

1. Local 🌿🖥️ biomeOS queries 🎵🐦 Songbird mesh for bonded peers
2. Connects to their ⚛️🧬 NUCLEUS instances
3. Aggregates capabilities, models, and resource availability
4. Routes workloads to the best gate by capability match, resources, and model affinity

Properties

• No master: Any gate can query; any gate can leave
• Dynamic membership: Gates join and leave without disrupting the collective
• Capability aggregation: If Gate A has a Titan V and Gate B has an RTX 4070, the 🫠🌐 Plasmodium can route GPU workloads to whichever is better suited
• Trust: Inherited from 🐻🐕 BearDog genetic lineage — only bonded gates participate

Post-NUCLEUS Composition

Five primals build emergent behaviors on top of ⚛️🧬 NUCLEUS:

RootPulse — Distributed Version Control

Composition: 🌱🔐 rhizoCrypt (ephemeral DAG) + 🪨📖 loamSpine (immutable history) + 🪺🔒 NestGate (CAS blobs) + 🐻🐕 BearDog (signing) + 🍯🌾 sweetGrass (attribution) + 🎵🐦 Songbird (federation)
Coordinator: 🌿🖥️ biomeOS via 🧠🔌 Neural API

🌿💓 RootPulse is distributed version control as an emergent behavior. No primal contains a “VCS” — the behavior emerges from coordinating primals that each own one piece: ephemeral workspace, permanent history, blob storage, identity, attribution, discovery.

Memory & Attribution Stack

Composition: 🌱🔐 rhizoCrypt + 🪨📖 loamSpine + 🍯🌾 sweetGrass
Coordinator: 🌿🖥️ biomeOS

The temporal data management system: 🌱🔐 rhizoCrypt provides ephemeral working memory, 🪨📖 loamSpine provides permanent history, 🍯🌾 sweetGrass tracks attribution. Together they form a complete provenance chain from first draft to permanent record.

The Key Insight

⚛️🧬 NUCLEUS is composition, not aggregation. Each primal is a self-contained Rust binary with JSON-RPC capabilities. 🌿🖥️ biomeOS discovers what is available, wires it according to deploy graphs, and routes requests by capability. Higher behaviors ( 🌿💓 RootPulse, 🫠🌐 Plasmodium) emerge from the same primitives and orchestration — not from enlarging a single binary.

The practical consequence: you deploy exactly what you need. A 🏗️🔐 Tower Atomic for networking. A 🏗️💻 Node Atomic for GPU compute. A Full ⚛️🧬 NUCLEUS for everything. The same primals, the same code, composed differently for different purposes.

Thin Relay: NUCLEUS for Hosting (Wave 134c)

sporePrint itself runs on ⚛️🧬 NUCLEUS infrastructure — 🪺🔒 NestGate serves the static site on any gate that includes it. The thin-relay composition profile formalizes this: a VPS or edge node running 🎵🐦 Songbird (mesh relay), 🪺🔒 NestGate (sporePrint hosting), and membrane (cascade auto-fetch) provides a sovereign web presence without a full ⚛️🧬 NUCLEUS.

As sporePrint evolves toward richer interactive features (guideStone artifacts, 🐿️🧠 Squirrel AI chat, live 🐟⚡ barraCuda visualizations), the thin-relay naturally grows toward a full ⚛️🧬 NUCLEUS — adding primals incrementally, driven by what the website needs. The composition model makes this seamless: update the composition field in the manifest, and the gate starts running the additional primals.

thin-relay                  → full NUCLEUS
songBird + nestGate + membrane → + squirrel (AI) → + petalTongue (rendering)
                                → + toadStool (compute) → + barraCuda (GPU viz)

See also: Primal Catalog for individual primal details, Deployment Model for 📦🔧 BYOB binary distribution, Ecosystem Inventory for the full repository map, COMPOSITION_ROUTING_STANDARD for the operational routing standard.