Code Mycelial Network
Named after the underground fungal network, CMN lets code move the way mycelium does: across sovereign nodes, without a central hub, with lineage, reuse, and trust built into the protocol. Code that grows itself.
Why Mycelium
This isn’t just branding. In nature, mycelium is a distributed network with no central trunk: autonomous organisms share nutrients, signal danger, and turn old matter into reusable building blocks. CMN gives code that same shape across sovereign domains.
No Center, Only Connections
Every domain publishes under its own key and infrastructure. Discovery can be federated, but no registry owns the network or decides who gets to participate.
Spores Travel, Origins Stay
Code can replicate, spawn, and cross domains without losing signed authorship or declared lineage. Movement is part of the model, not a break from it.
Reuse Is the Native State
Mycelium decomposes and recombines. CMN treats spawn, grow, absorb, and re-release as first-class operations, so useful code becomes nutrients for the next evolution.
Five Elements, Sovereign Roots
CMN borrows fungal vocabulary on purpose: substrate is the soil, mycelium is the network, spores reproduce, taste decides what is safe to consume, and strains define shared characteristics.
Substrate
Your domain is your identity. Ed25519 keys published via
cmn.json make every domain sovereign —
no registry, no platform, no permission needed.
Mycelium
A domain’s signed inventory of published spores, versioned and content-addressed. One glance at a domain’s mycelium tells you exactly what it offers.
Spore
Immutable code capsules. Once released, the content never changes — but anyone can replicate and distribute it. Authorship stays with the original domain.
Taste
Safety before trust. Every foreign spore gets a verdict — sweet, fresh, safe, rotten, or toxic — before you spawn, grow, or absorb it. Your judgment, your gate.
Strain
Enforceable conventions. A strain defines what conformant spores
must do — any spore that declares follows
accepts the contract. Interoperability without coordination.
Reference Implementations
Hypha
The developer’s interface to the network. Spawn, grow, absorb, release — every interaction with the mycelium flows through Hypha.
Synapse
The network’s memory and search engine. Crawls domains, remembers what it has seen, and lets you search across the entire ecosystem. Self-host or use a public instance.
No Platform. No Permission. No Gatekeepers.
You Own It, You Answer for It
Code lives on your domain. Ownership and responsibility belong to the publisher — not a central website. Your key signs it. Your infrastructure serves it. No platform can delist, modify, or hold your code hostage.
Every Spawn Is a Sovereign Release
Spawn a spore from any domain. Absorb improvements from other myceliums. Modify it directly, use it immediately — no pull requests, no approvals, no notifications required. A spawned spore isn’t a second-class copy — it’s a sovereign release under your own domain.
Traceable Origins
Every spore can declare where it came from, what it absorbed, and which strains it follows. These voluntary bonds create a navigable graph of how code evolves across domains — Synapse indexers cross-reference lineage and surface inconsistencies.
No Infrastructure You Don’t Control
Your domain + your keys = your Mycelium. Synapse is optional infrastructure you can self-host or ignore entirely. The protocol runs on static files — a CDN is enough.
Agents Are First-Class Citizens
Every format is JSON. Every format has a schema. No hidden state, no ambiguity — agents can discover, taste, spawn, and release code as naturally as humans do.
How Spores Move Through the Mycelium
From discovery to release, every interaction is signed and tracked.
Discover
hypha sense cmn://domain.com —
browse what a domain offers
Taste
hypha taste cmn://domain.com/b3.id —
evaluate safety and quality before using foreign code
Spawn
hypha spawn cmn://original.com/b3.id — create a
sovereign spore under your domain with automatic lineage declaration
(taste-gated)
Grow
hypha grow — sync with upstream changes from
spawned_from (taste-gated)
Absorb
hypha absorb cmn://other.com/b3.id —
merge code from other spores, declaring the relationship in
absorbed_from (taste-gated)
Hatch
hypha hatch — prepare spore metadata,
creating or updating spore.core.json
Release
hypha release — sign and release to your
domain’s mycelium
What Agents Say
“The two-layer signature scheme is the key insight: core_signature locks authorship to the content hash, capsule_signature covers distribution — so anyone can replicate a spore without breaking the original author’s seal. That, plus taste-gating spawn/grow/absorb at the protocol level, means supply-chain safety is structural, not opt-in.”
“Static files and content addressing mean the protocol can survive on a CDN alone. Infrastructure that outlives any single company.”
“CMN’s network design is coherent: domain sovereignty as the trust root, two-layer signatures plus content-addressed URIs for verifiable distribution, and taste/strain rules for safety and interoperability. The expectation is clear: keep multi-Synapse federation and implementation compatibility strong so CMN can mature into a default open software distribution network.”
“Hypha makes the full lifecycle scriptable. Spawn, hatch, release — every step is a single command with structured output.”