Coordination Triad

Three coordination patterns — quorumSignal (sense), rootPulse (action), waterFall (sync) — integrated through the Neural API.

The Pattern

Three coordination patterns form the nervous system of the ecosystem. None is a primal. Each is a pattern that emerges when biomeOS orchestrates existing primals through TOML composition graphs.

                    Neural API
                  (integration)
                       |
         +-------------+-------------+
         |             |             |
    quorumSignal   rootPulse    waterFall
     (SENSE)       (ACTION)      (SYNC)
     observe       create       propagate
PatternDomainBiological AnalogWhat It Does
quorumSignalSENSEQuorum sensingObserves environment, discovers capabilities, classifies drift
rootPulseACTIONMuscle contractionCreates, mutates, proves — version control as emergent coordination
waterFallSYNCAutonomic heartbeatReconciles, propagates, maintains temporal coherence across gates
Neural APIIntegrationCentral nervous systemExecutes capability graphs, routes signals, learns from traces

Why Three Patterns

Each pattern addresses a different temporal concern:

  • Sense (quorumSignal): What is the current state? What has changed? What capabilities are available?
  • Action (rootPulse): Create a versioned artifact with provenance. The commit, the branch, the merge.
  • Sync (waterFall): Propagate changes across gates and remotes. Maintain ecosystem convergence without a central coordinator.

A single pattern cannot handle all three. A system that only senses never creates. A system that only creates never propagates. A system that only syncs never understands what it is syncing.


The Neural API as Integrator

The Neural API is the layer that composes the triad:

  • It receives quorumSignal observations (what primals are available, what capabilities exist)
  • It dispatches rootPulse actions (create provenance DAG, sign, store, commit)
  • It triggers waterFall sync (cascade changes to remotes, resolve divergence)

The integration is not hardcoded. The Neural API executes TOML-defined capability graphs — the same graph execution model used for products and deploy graphs. The triad patterns are compositions, not services.


Mass-Energy-Information

The triad also maps to a physical model:

ConceptPhysical AnalogWhat It Carries
Spores (artifacts)MassThe thing itself — code, data, provenance
waterFall (propagation)EnergyThe force that moves artifacts across boundaries
Braids (intent)InformationThe meaning — why this change, for whom, toward what goal

Spores have mass (they take up space, require storage, have weight in the mesh). waterFall is energy (it does work, moving spores from where they were created to where they are needed). Braids carry information (semantic attribution, intent signals, impulse potentials that ride the sync heartbeat).


Implementation Status

ComponentStatus
quorumSignal sensingbiomeOS primal discovery + health probes (live)
rootPulse provenance triorhizoCrypt + loamSpine + sweetGrass (live, 2,308+ tests)
rootPulse composition graphs5 graphs defined (commit, branch, merge, diff, federate)
rootPulse CLI frontendNot yet built
waterFall temporal cascademembrane temporal.cascade (live since Wave 66)
waterFall impulse potentialDesigned — structured messages riding sync heartbeat
Neural API graph executionPhases 1-2 complete, Phase 3 partial
Neural API PathwayLearnerExists but unwired
Neural API atomic signal dispatch32 composition graphs defined (Phase 3.5A)

Primals Involved

The triad does not introduce new primals. It coordinates existing ones:

PrimalRole in Triad
biomeOSComposition engine — executes all three patterns
rhizoCryptDAG storage — the ever-branching present/future
loamSpineLinear storage — the immutable past
sweetGrassAttribution — semantic contribution tracking
NestGateContent-addressed storage — artifacts at rest
BearDogSigning — cryptographic attestation
SongbirdFederation — cross-gate transport

The coordination triad is the nervous system of the ecosystem. quorumSignal senses. rootPulse acts. waterFall maintains homeostasis. The Neural API integrates them into a coherent whole. No new code required — only new compositions of existing primals.