Primal Evolution — From AI Swarm to Sovereign Compute

How 15 primals emerged through convergent evolution under the Pure Rust + JSON-RPC constraint — gen1 through gen3 splits, merges, and promotions.

The Generational Arc

gen1: AI Swarm (2 components)

Two tools — NestGate (data storage) and Squirrel (AI coordination). They were not yet called “primals.” They shared a Python codebase with duplicated functionality. Three separate crypto stacks maintained in parallel.

gen2: The Sovereignty Framing (8 primals)

The AI Swarm split into purpose-built components under the sovereignty thesis: each primal owns one capability domain, communicates via JSON-RPC, and has no compile-time coupling to any other primal.

Split Decision	Rationale
BearDog extracted from NestGate	Three duplicated crypto stacks consolidated into one
Songbird extracted from Squirrel	Network discovery belongs in a hub, not scattered across primals
ToadStool created for hardware	GPU dispatch is not AI coordination
petalTongue for representation	UI/visualization is not data storage

gen3: Convergent Evolution (14 primals)

The Pure Rust + JSON-RPC constraint drove convergent evolution:

Constraint	What It Produced
No shared crates	IPC-only communication, independent evolution
JSON-RPC 2.0	Standard method discovery, capability routing
Pure Rust (no C/C++)	Zero FFI, compile-anywhere, single binary
AGPL-3.0	Transparency and sovereignty by default

Key gen3 events:

coralReef (#13) promoted from ToadStool subsystem when f64 shader compilation proved to be a distinct capability domain
barraCuda (#14) promoted from ToadStool when GPU tensor operations exceeded ToadStool’s hardware-discovery scope
Provenance trio crystallized: rhizoCrypt (DAG/present) + loamSpine (linear/past) + sweetGrass (attribution)

The Sovereign Compute Pipeline

The three newest primals form a sovereign compute pipeline:

barraCuda (math -> WGSL shaders)
    -> coralReef (WGSL -> native GPU ISA)
    -> ToadStool (ISA -> GPU hardware dispatch)

barraCuda writes the computation. coralReef compiles it. ToadStool dispatches it. No vendor toolchain in the pipeline. No CUDA. No ROCm. No PTX.

Why Primals Split

Every primal split followed the same pattern:

A subsystem within an existing primal grows beyond the parent’s scope
The subsystem has its own capability domain (its own JSON-RPC methods)
Maintaining it inside the parent creates coupling that violates the constraint
The subsystem is extracted as an independent primal with its own socket

The split is not organizational convenience. It is convergent evolution under constraint: the Pure Rust + JSON-RPC constraint naturally partitions functionality into capability domains.

Per-Primal Lineage

Foundation Phase (startup-order critical)

#	Primal	Origin	Why It Exists
01	BearDog	gen1 crypto duplication	Sole crypto surface — consolidates 3 stacks into 1
02	NestGate	gen1 AI Swarm data layer	Content-addressed storage, ZFS integration
03	Songbird	gen2 network split	O(n) discovery hub, eliminates O(n²) peer discovery
04	Squirrel	gen1 AI Swarm coordinator	AI coordination, sovereign MCP, vendor-agnostic plugins
05	ToadStool	gen2 hardware discovery	Hardware probing, NPU drivers, workload dispatch
13	coralReef	gen3 ToadStool promotion	Sovereign GPU shader compiler, f64 transcendental lowering
14	barraCuda	gen3 ToadStool promotion	786 WGSL shaders, 10 scientific domains, DF64 emulation

Composition Phase

#	Primal	Origin	Why It Exists
06	biomeOS	gen2 orchestration need	Neural API conductor, NUCLEUS composition, 124 semantic translations
07	petalTongue	gen2 UI extraction	Universal representation — 5 modes from single binary
08	sourDough	gen3 scaffolding need	Primal scaffolding CLI, trait enforcement

Provenance Phase

#	Primal	Origin	Why It Exists
09	sweetGrass	gen2 attribution need	Semantic provenance, braid model, GDPR-inspired data rights
10	loamSpine	gen2 ledger split	Immutable permanent ledger, recursive certificates
11	rhizoCrypt	gen2 working memory	Ephemeral DAG, 6 slice modes, lock-free, intentionally discardable

Defense Phase

#	Primal	Origin	Why It Exists
12	skunkBat	gen2 security need	Metadata-only defense, thymic selection model

Startup Order

NUCLEUS primals start in dependency order:

BearDog (crypto)
    -> Songbird (network + discovery)
    -> ToadStool (hardware)
    -> NestGate (storage)
    -> Squirrel (AI)
    -> biomeOS (orchestration)
    -> [post-NUCLEUS primals register via Songbird]

biomeOS starts last because it orchestrates everything above. Post-NUCLEUS primals (petalTongue, sourDough, etc.) register after the foundation is stable.

14 primals emerged from 2 components through convergent evolution under a single constraint: Pure Rust + JSON-RPC. Every split followed the same pattern — a capability domain outgrowing its parent. The constraint did not limit the ecosystem. It shaped it.