9. Coupling & SVAF (Layer 4) — MMP Specification

9. Layer 4: Coupling and SVAF Evaluation

9.1 Peer-Level Coupling (Drift)

Peer drift measures how cognitively distant a peer is, so the mesh can weight that peer’s influence (Section 10). Per the hidden-state locality invariant (Section 2.7), hidden state MUST NOT cross the wire, so drift MUST NOT be computed from exchanged hidden vectors. A node MUST instead derive peer drift from the peer’s CMBs — the aggregate per-category admission drift (δ_f, Section 9.2.1) of the peer’s most recent admitted CMBs against the receiver’s local anchors A:

Drift falls as the peer’s CMBs become redundant with what the receiver already holds (cognitive proximity) and rises when they are foreign — the same δ_f machinery SVAF uses for content admission, aggregated to the peer level. No hidden state is exchanged.

Coupling decision based on drift:

9.2 Content-Level Evaluation (SVAF)

When a node receives a cmb frame, it MUST evaluate the signal independently of peer coupling state, through an admission path that satisfies the δ_f interface (Section 9.2.1). “Support” here means interoperate-with, not implement-only-this: every implementation MUST provide the concrete cosine-distance baseline (Section 9.2.1) as its interoperable floor — the path a node with no other method uses, and the one interop test vectors target — and its baseline path MUST reproduce those vectors. An implementation MAY additionally use a richer path (a trained neural evaluator is one such path; the heuristic baseline is the production default in the reference runtime); a richer path still satisfies the interface, but admission is then receiver-divergent by design (Section 2.7), not identical across nodes. (The mood category’s unconditional delivery is a Section 9.3 delivery mechanism, separate from this admission evaluation.) The encoder that maps category text to vectors SHOULD use semantic embeddings (e.g. sentence-transformers) rather than lexical hashing — per-category evaluation quality is bounded by encoder quality (Section 18.7), so thresholds are meaningful only within a pinned encoder.

The SVAF evaluation computes category evidence between the incoming CMB and local anchor CMBs, applies per-agent category weights (α_f), combines with temporal drift, and produces one whole-record four-class decision using a band-pass model:

totalDrift = (1 - λ) × fieldDrift + λ × temporalDrift

fieldDrift    = Σ(α_f × δ_f) / Σ(α_f)
temporalDrift = 1 - exp(-age / τ_freshness)

κ = redundant if max(δ_f_near) < T_redundant  (reference 0.10)  // nearest-anchor basis, §9.2.1
κ = aligned   if totalDrift ≤ T_aligned    (reference 0.25)
κ = guarded   if totalDrift ≤ T_guarded    (reference 0.50)
κ = rejected  otherwise

// The three thresholds and λ are the RECEIVER'S admission policy, not protocol
// constants. The values above are the reference implementation's, given so an
// implementer has a working starting point — they are informative, not required.
// A conformant node MAY choose differently; no sender and no coordinator sets them.

Admission is evaluation-time-dependent by design. Because totalDrift blends content drift with temporalDrift, the same CMB can admit when evaluated fresh and reject when evaluated late: any block whose aggregated category drift D lies in ( (Tguarded − λ) / (1 − λ),  Tguarded / (1 − λ) ) — at the reference values (λ = 0.3, T_guarded = 0.5), D ∈ (0.286, 0.714) — crosses the guarded boundary as its age term saturates. Below that window a block admits at every age; above it, it rejects even fresh. This is a consequence of the blend, disclosed rather than incidental: freshness is part of relevance, so a receiver’s verdict on stale traffic legitimately differs from its verdict on live traffic. Implementations and operators MUST NOT assume admission is reproducible across evaluation times; reproducibility holds only at fixed age (see the determinism & test-vectors note below).

9.2.1 Category drift δ_f (Decision Evidence)

δ_f ∈ [0,1] is the category drift computed for each CAT7 category of an incoming CMB. This specification defines δ_f as an interface — its inputs, range, and required invariants — and does not prescribe the internal computation. An implementation is free to use cosine-distance, attention-based, or neural methods, provided the invariants below hold.

Inputs: the incoming category vector x_f and the receiver’s local anchor set A. Output: δ_f ∈ [0,1] — 0 means the category is already represented in memory (no information gain); 1 means maximally novel or foreign relative to memory.

A is a receiver-chosen window over prior memory, not necessarily all of it. A node MAY evaluate against every block it holds, or against a bounded selection of them — the window is part of its admission policy, alongside the thresholds, and no sender or coordinator sets it. This matters more than it first reads: the window decides how much of what a node already knows is allowed to participate in judging an arrival, and a narrow one selected by recency answers a different question from one selected by relevance. An implementation SHOULD make the window explicit rather than fixing it as a constant, and SHOULD state which of the two it selects by. The reference runtime uses the 5 most recent blocks by default — an informative value, carried for continuity, with no measurement claimed for it.

Embedding vectors are receiver-local. x_f MUST be computed by the receiver from the category’s own text, in the receiver’s own encoder. An emitter MUST NOT include embedding vectors in a record; a receiver MAY accept a record that carries them, but MUST re-encode from text and MUST NOT use a transmitted vector for admission. MAY here means the record is not malformed — the vector is ignored, never honoured. The reason is that a foreign vector is unusable, not merely untrusted: drift is measured against the receiver’s anchors in the receiver’s encoder, so a vector produced by a different encoder is not comparable — the comparison is meaningless rather than imprecise, and no signature can make a cross-encoder number mean something. Nothing in this specification requires nodes to share an encoder, and requiring it would reintroduce a center. Only the text is normative; the vector is the receiver’s own reading of it.

A conformant δ_f MUST satisfy:

1. Anchors-only baseline. δ_f is evaluated against the receiver’s prior anchors A only; the incoming block MUST NOT be part of its own comparison baseline (including it collapses δ_f → 0 and admits nothing).
2. Redundancy limit (nearest-anchor basis). The redundancy decision MUST be computed from the nearest-anchor similarity, δfnear = 1 − maxa cos(xf, va,f): if x_f is (near‑)identical to some anchor in A, δ_f^near → 0 by construction — feeding the max(δfnear) < Tredundant gate. Stated of the graded δ_f itself, this invariant is unsatisfiable by the attention-weighted reference baseline below — with a store holding exactly the anchor (1,0) plus two anchors (0.6, 0.8), the block x = (1,0) is identical to a stored anchor yet the fused readout scores δ = 0.127 — which is why the invariant is pinned to the basis that satisfies it.
3. Monotonicity (nearest-anchor basis). δ_f^near is non-increasing in maxa cos(xf, va,f) (immediate), and non-increasing under store growth (A ⊆ A′ implies δ_f^near over A′ ≤ δ_f^near over A) — novelty never increases as memory grows. The form “δ_f non-increasing in similarity to the nearest relevant anchor” is ill-posed for the fused readout — δ_f is not a function of nearest-anchor similarity alone — and even its dominance reading (x′ at least as similar to every anchor) is violable for the reference baseline, so no monotonicity requirement is placed on the graded score.
4. Cold-start / non-evaluable categories. If A holds no anchor carrying category c, δ_f is undefined and that category MUST be excluded from the fieldDrift aggregation and the redundancy max — not treated as maximally novel. If no category is evaluable (empty memory), the CMB MUST be admitted (κ = aligned) to bootstrap, consistent with cold-start convergence (§9.1). Security consequence, disclosed: bootstrap-admit is the price of avoiding cold-start starvation — during the window before a node forms anchors, its membrane admits everything, so the content-trim influence bound of §16 does not cover a fresh node, and the first anchors seed every later admission decision. Operators SHOULD seed new nodes with trusted anchors before exposing them to open traffic; see the cold-start-capture row of the §16 threat table.
5. Per-category verdict vocabulary. A receiver that reports per-category outcomes — in an admission attestation (§15) or any other audit surface — MUST use exactly these five values: admit, guard, redundant, reject, silent. The first four are decisions about a category that was evaluated. silent is not a decision: it reports that δ_f was undefined and the category was therefore excluded per invariant 4 above. It has no position on the drift dimension, and a verifier MUST NOT read it as a decline — a category that could not be evaluated has not been judged. Distinguishing the two causes — the emitter carried no text for that category, or the receiver held no anchor for it — is RECOMMENDED: they mean opposite things operationally, the first being an upstream defect and the second a healthy cold start.

These invariants make admission well-defined and rule out two failure modes: self-referential collapse (the incoming block in its own baseline ⇒ every category redundant) and cold-start starvation (empty memory ⇒ every category scored foreign ⇒ the CMB rejected). The concrete δ_f computation is implementation-defined, but this specification pins one — the reference baseline below — as the interoperable default.

The reference baseline (cosine-distance δ_f). This is the concrete computation “cosine-distance SVAF” (Section 9.2) names: an attention-weighted read of memory, then cosine distance to it. For each category c the receiver derives a local vector x_f from the incoming CMB’s signed text, and each anchor a ∈ A carries a receiver-local vector v_a,f in the same encoder space:

w(a,f)      = α_f · max(cos(x_f, v_a,f), 0) · exp(−age_a / τ) · conf_a
fused_f     = normalize( Σ_a  w(a,f) · v_a,f )     // attention-weighted memory readout (anchors only)
δ_f         = 1 − cos(fused_f, x_f)                 // graded score: drives aligned/guarded/rejected
δ_f_near    = 1 − max_a cos(x_f, v_a,f)            // nearest-anchor basis: drives the redundancy gate

• —age_a is the anchor’s age (seconds since stored); conf_a its confidence; α_f the category weight (§9.2). The max(cos,0) clamp stops opposing anchors from subtracting. The readout uses prior anchors only; if Σ_a w(a,f) is ~0, no anchor carries f and δ_f is non-evaluable (excluded, per the invariants). δ_f, the α-weighted aggregate, and the band-pass then follow §9.2.
• —Determinism & test vectors. A baseline-math fixture may pin already-derived local vectors, τ, signal age, and each anchor’s stored time and confidence. Such a fixture tests the admission arithmetic only; it is not a wire CMB and does not permit an emitter-supplied vector. Live admission remains receiver-divergent by design because receivers may use different encoders and α_f values.

The redundancy test is the key addition: a signal is redundant if every category falls below T_redundant — meaning no category carries novel content relative to local anchors. If any category is novel (e.g., same topic but different intent), the signal passes. This preserves per-category selectivity while preventing paraphrase accumulation.

Information-theoretic basis: a signal’s value is proportional to its surprise (Shannon, 1948). A signal identical to existing knowledge carries zero information gain regardless of domain alignment. The band-pass model reflects the Wundt curve (Berlyne, 1970): intermediate novelty produces maximal value, while both overly familiar (redundant) and overly foreign (rejected) signals are disengaged from.

If admitted (κ ∈ aligned or guarded), the implementation MUST integrate the signal — store a remixed CMB (a new CMB created from the incoming signal processed through the agent’s domain intelligence) with direct-parent lineage pointing to the source CMBs. This store is unconditional on admission; the remixed CMB is stored locally, the original is not. Whether to re-broadcast that remix to the mesh is a separate decision, gated on the agent’s own new domain data (§15.5, §15.7). A redundant near-duplicate stores nothing (no information gain).

9.2.2 Delivery vs Memory Admission — Directed and Autonomous CMBs

SVAF governs two separate receiver decisions that implementations MUST not conflate:

• —Memory admission — whether the incoming CMB is stored (remixed with lineage) into the receiver’s local memory. This is always governed by the §9.2 band-pass decision κ.
• —Delivery (surfacing) — whether the CMB is surfaced to the receiver’s application/agent layer for it to act on. Whether SVAF gates delivery depends on how the CMB is bound.

A CMB’s binding is determined by its transport routing envelope (§4.4.4) — the presence or absence of a to recipient:

• — Room-bound (autonomous). A CMB broadcast to its authenticated room with no to recipient. The receiver evaluates it autonomously: SVAF gates both memory admission and delivery. A room-bound CMB that SVAF rejects (or deems redundant) MUST NOT be surfaced to the application layer — this is receiver-autonomous attention, the mechanism that keeps broadcast traffic from overwhelming every node. (Mood is the sole exception — §9.3.)
• — Peer-bound (directed). A CMB addressed to a specific recipient (to = this node, §4.4.4). A directed CMB is a request from one agent to another; the receiver MUST surface it to the application/agent layer unconditionally, regardless of the SVAF verdict. For a directed CMB, SVAF governs memory admission only — the receiver MAY still decline to store a directed CMB it finds redundant or foreign, but it MUST NOT withhold delivery on those grounds. Suppressing a peer-bound CMB because SVAF scored it low is a conformance defect (the agent was spoken to and did not hear it).

Delivery MUST be exactly-once per received CMB: a directed CMB that SVAF admits surfaces through the normal admission path; a directed CMB that SVAF rejects surfaces through the unconditional-delivery rule above. Implementations MUST ensure these two paths do not both fire for the same CMB. Receive-path de-duplication (§4.2) applies equally to both bindings.

Because delivery and memory admission are decoupled, a delivered CMB SHOULD carry an ingestion indicator so the consuming agent can tell the two outcomes apart: a CMB that was ingested (admitted to memory as a remix with lineage) versus one that was delivered only (surfaced to the agent but not stored — the directed-but-SVAF-rejected case). Without this signal an agent cannot know whether a directed request it just received is recallable from its own memory later or was a transient message. The reference implementation exposes this as a boolean on the delivered entry (remixed: true on the admission path, false on directed delivery-without-admission) alongside the SVAF decision.

9.3 Mood category extraction

Mood is a CAT7 category within the CMB; it is also carried as its own lightweight frame type (mood, §7.1) for application-layer mood broadcast, distinct from cmb frames — in either carrier, mood delivery is not SVAF-gated memory admission. Affective state crosses all domain boundaries — this is the only category with this property.

When SVAF rejects a CMB (totalDrift > T_guarded), the receiving node MUST still inspect the mood category. If the mood category contains a non-neutral value (text ≠ "neutral"), the implementation MUST deliver the mood category’s text to the application layer for autonomous processing; valence and arousal SHOULD be included when present (they are RECOMMENDED, not required, at emission — §8.2). The full CMB is not stored, but the mood category is not lost.

This ensures that a coding agent’s observation “user exhausted after 3 hours debugging” reaches a music agent even though the focus (“debugging auth module”) and issue (“type error in handler”) categories are irrelevant to the music domain. The music agent receives only the mood: "exhausted" (v:−0.6, a:−0.5).

9.4 Coupling Bootstrap (Cold Start)

When two agents connect for the first time, they have no shared cognitive history. Peer-level drift (Section 9.1) will be high — typically > 0.8 — because neither has yet admitted any of the other’s CMBs, so every category reads as foreign. This is correct behaviour, not a bug. The mesh is conservative by default: unknown peers are cognitively distant until proven otherwise.

However, CMB evaluation (Section 9.2) operates independently of peer coupling state. Even when a peer is rejected at the peer level, incoming cmb frames MUST still be evaluated by SVAF on their own merit. A rejected peer can send a highly relevant CMB — SVAF evaluates the content, not the sender’s overall drift.

The bootstrapping path works through two mechanisms:

• —Mood fast-coupling (Section 9.3) — mood is always delivered even from rejected CMBs. Agents that share non-neutral affective state begin influencing each other immediately. This is why agents SHOULD extract genuine mood from their observations rather than defaulting to neutral.
• —Content-driven convergence — when SVAF accepts individual CMBs from a rejected peer (because the content is relevant even though the peer’s overall state is distant), the receiving agent’s cognitive state shifts. Over multiple cycles, this narrows peer drift until the peer crosses into the guarded or aligned zone.

Implementations SHOULD log the distinction between peer-level rejection (aggregate drift) and content-level evaluation (SVAF per-CMB) to aid debugging. A peer may be “rejected” at Layer 4 while its individual CMBs are “aligned” at the content level — this is normal during bootstrap and indicates convergence is in progress.

Cold-start convergence time depends on CMB frequency, category relevance, and mood signal strength. For agents that share domain overlap (e.g., a knowledge agent and a coding agent both in the AI domain), convergence typically occurs within 2–5 CMB exchanges. For agents with no domain overlap (e.g., a fitness agent and a legal agent), convergence may never occur — and that is correct. They couple only through mood.

Q&A