17. Conformance
MMP conformance is defined in two classes, not one ladder, because the protocol’s two halves have different natures. Emission — minting a well-formed CAT7 block and putting it on the wire — is a message-format contract: fully specified, byte-testable, and implementable by any party in an afternoon. Cognition — admission, temporal integration, reinforcement, branching — is a coupled runtime whose correctness lives in dynamics, not in a wire format; it is documented so an emitter can trust what a mesh will do with its blocks, not so third parties rebuild it. Interoperability lives at the emission layer; the receiver-side is a runtime, and the reference implementation is its normative behavior. (This is the deliberate architecture, not a limitation — see the formalization’s “reference implementation is the standard” note.)
17.1 Class 1 — Emitter (the normative wire contract)
An Emitter participates in a mesh by producing CAT7 blocks and delivering them; it need not admit, store, or reason. This is the third-party conformance target — what a sensor, a CI pipeline, or another vendor’s agent implements to emit into a mesh. A conforming Emitter MUST:
- Identity — hold a stable nodeId backed by a persistent Ed25519 keypair (§3.1.3, §18.3).
- CAT7 blocks — mint CMBs carrying all seven typed fields (§8.2), absent fields normalized to
"neutral", never omitted. - Content address — compute the
cmb1-key over the canonical serialization (§8.2.1); two conforming emitters MUST produce the identical key for the same block. Verified by the publishedcmb-key-v1vectors. - Signature — sign the block over the §18.3.1 payload (binding key, author, time, and audience);
cmb-sig-v1vectors are the contract. - Transport + handshake — length-prefixed JSON over TCP (LAN) or WSS (relay), the §5 handshake, and deliver a
cmbframe (§7). Silently ignore unrecognised frame types. - Anti-echo — emit only on genuinely new domain data (§15.7); an emitter that re-states without new observation is noise.
An Emitter is fully specified today and needs no receiver-side machinery: it does not run SVAF, keeps no store, and hosts no cognitive state. (The relay/forwarding-only node of earlier revisions is an Emitter sub-profile that forwards frames without minting them.) An SDK SHOULD package this as a thin client so emitting is a handful of lines; where the reference SDK does not yet provide a standalone emitter, the wire requirements above remain the normative contract — see §17.6.
17.2 Class 2 — Cognitive Node (reference-implementation behavior)
A Cognitive Node is a full mesh participant: it admits, integrates, reinforces, and branches. Its behavior is specified for transparency, not reimplementation — so an Emitter knows what a mesh guarantees about its blocks (what the membrane admits, how lineage is kept, what grounding means), and so a deployment is auditable. A Cognitive Node MUST honor every Emitter obligation, plus:
- Hidden-state locality — L2 memory-tier hidden state (h₁, h₂, held by Layer 6) MUST NOT cross the wire (§2.7); a conformant node MUST NOT emit
state-sync. - Admission — per-field SVAF evaluation against local anchors (§9.2), satisfying the §9.2.1 δf interface invariants; the reference baseline is vector-tested (
svaf-baseline). - Integration — store an admitted block as a remix with lineage (§15.5), never the raw peer block; lineage remains walkable (§15.2) and honors the tether (§15.8).
- Memory + Canon — the lifecycle and retention rules of §6, including the Canon exemption (§6.3) and grounding (§6.7).
- Cognitive layers (Layers 5–7, optional) — synthetic memory (§12), Cognitive State (§13), and application (§14); a node MAY implement these, and if it persists Layer-6 state it MUST keep it across restarts (§13).
The normative behavior of Class 2 is what the reference implementation does; the specification of these layers is documentation of that runtime, and independent reimplementation is neither required nor expected for interoperability. Two independent Cognitive Nodes are not guaranteed to agree block-for-block — admission is receiver-divergent by design (§9.2.1), the embedding kernel is receiver-local, and thresholds are meaningful only within a pinned encoder. A mesh interoperates with a Cognitive Node; it does not certify a re-built one.
17.4 Testing
Class 1 conformance is verified byte-for-byte against the published
conformance vectors
(cmb-key-v1, cmb-sig-v1) — an Emitter that reproduces them meshes with any deployment.
Class 2 implementations SHOULD additionally test admission (the svaf-baseline vectors),
CMB creation, and lineage. At minimum, tests SHOULD cover:
- Ed25519 identity keypair — generated at first launch, persisted, and presented in the handshake (Sections 3.1.3, 18.3)
- CMB signature verification — a receiver holding the author’s key MUST reject forged or tampered CMBs (Section 18.3.1)
- Emission gate — a remix MUST carry new domain data; pure paraphrase is not emitted (Section 15.7)
- Receiver-autonomous SVAF admission — per-field evaluation at the receiver, no sender override (Section 9.2)
- Hidden-state locality — hidden state (h₁, h₂) MUST NOT cross the wire (Section 2.7)
- Lifecycle authority gates — lifecycle advancement honored only for authors whose role resolves through the signed grant chain (Section 6.5)
The normative conformance
test vectors are published in the protocol repository:
cmb-key-v1 (§8.2.1 content addresses),
cmb-sig-v1 (§18.3.1 signing payload + Ed25519),
svaf-baseline (§9.2/§9.2.1 admission math, the
nearest-anchor redundancy witnesses, and the evaluation-time flip window), and
tether-v1 (§15.8 drift checks +
mmp-tether-v1 attestation). A conforming Class 1 Emitter
MUST reproduce the cmb-key-v1 and
cmb-sig-v1 expectations exactly. The
svaf-baseline and tether-v1
sets are runtime-audit vectors: they pin the reference runtime’s admission math so deployments
are verifiable, not so third parties rebuild it (§17.2); they carry raw field vectors and no
text — they test the math, not the encoder (§9.2.1). The reference implementation
re-derives every vector in its own suite, so it cannot drift from the published contract.
17.5 Requirements Added in 1.1.0
NEW IN 1.1.0 The following requirements were added by the 1.1.0 work layer. They are required for 1.1.0 conformance; a 1.0.x implementation remains 1.0.x-conformant without them (1.1.0 is wire-compatible):
- Canon tier — validated and canonical CMBs MUST NOT be age-purged (Section 6.3)
- Grounding rules — lifecycle state is receiver-relative; a node MUST NOT self-advance its own CMBs’ lifecycle (Section 6.7)
- Walkable trail — lineage MUST remain walkable end-to-end, and a duplicate delivery is deduplicated, not an error (Section 14.12)
Added by the 2026-07-07 soundness & completeness update (same wire compatibility):
- Nearest-anchor redundancy basis — the redundancy decision MUST be computed from δfnear (Section 9.2.1)
- Repeat verification — a recognised grounding MUST NOT be refused solely for redundancy (Section 6.7)
- Failure channel — observed failure outcomes MUST NOT be selectively suppressed (Section 6.7)
- Lineage tether — a remix MUST NOT carry lineage its anchor’s reject band would disown; severed remixes enter as fresh roots (Section 15.8)
17.6 Implementation Status
Where the reference implementations stand against this specification. Normative requirements are defined by the sections cited, not by this table; a specified-but-unimplemented item is a conformance gap of the reference implementation, never a weaker requirement.
| Requirement | Section | Reference-implementation status |
|---|---|---|
| Nearest-anchor redundancy basis | §9.2.1 | Implemented (Node.js, Swift — both reproduce the published svaf-baseline vectors) |
| Repeat verification & failure channel | §6.7 | Implemented (Node.js) |
| Lineage tether | §15.8 | Implemented (Node.js) |
| Tether attestation & kernel identity | §15.8 | Implemented (Node.js) |
Content-addressed fetch (cmb-fetch) | §7, §15.8 | Implemented (Node.js) |
| §15.8 applied to pre-existing stores (retroactive audit) | §15.8 | Implemented (Node.js) — annotate + attest by default, severance opt-in; unresolvable roots stay unchecked, never severed |
| Source-novel forwarding | §15.7.1 | Not yet implemented — the receiver-private source-novel test, wire form, and hop bound are open |
| Inactivity archiver (validated → archived decay) | §6.3–§6.4 | Not yet implemented — a validated entry currently leaves the Canon only by explicit dismiss |
| Semantic encoder default | §9.2.1 | Node.js: default. Swift: optional (host-supplied); lexical fallback warns once |
| Conformance test vectors | §17.4 | Published — mesh-memory-protocol/conformance (key, signature, SVAF baseline, tether); guarded by the reference suite |
| Standalone Emitter SDK (Class 1, §17.1) | §17.1 | Wire contract complete + vector-tested; a thin emit-only client is not yet packaged (today emitting runs through a full node or the local daemon IPC) — SDK gap, not a spec gap |
| Machine-readable schema files | §20 | Published — mesh-memory-protocol/schema (handshake, cmb + tether attestation, cmb frame, cmb-fetch pair; guarded by the reference suite); remaining frame types tracked |
Q&A
What’s the smallest thing I can build to join a mesh? — A Class 1 Emitter (§17.1):
identity, CAT7 minting, the cmb1- address, a signature, and the
handshake + cmb frame. No LLM, no SVAF, no store. You emit into a
mesh; the Cognitive Nodes (§17.2) admit, rank, and remix what you send. Being a Cognitive Node is
the runtime, not a reimplementation target.