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-field 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 field’s unconditional delivery is a Section 9.3 delivery mechanism, separate from this admission evaluation.) The encoder that maps field text to vectors SHOULD use semantic embeddings (e.g. sentence-transformers) rather than lexical hashing — per-field evaluation quality is bounded by encoder quality (Section 18.7), so thresholds are meaningful only within a pinned encoder.

The SVAF evaluation computes per-field drift between the incoming CMB and local anchor CMBs, applies per-agent field weights (α_f), combines with temporal drift, and produces a 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  (default 0.10)   // nearest-anchor basis, §9.2.1
κ = aligned   if totalDrift ≤ T_aligned    (default 0.25)
κ = guarded   if totalDrift ≤ T_guarded    (default 0.50)
κ = rejected  otherwise

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 field drift D lies in ( (Tguarded − λ) / (1 − λ),  Tguarded / (1 − λ) ) — at the defaults (λ = 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 Per-Field Drift δ_f (Admission Interface)

δ_f ∈ [0,1] is the per-field admission drift computed for each CAT7 field 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 field vector x_f and the receiver’s local anchor set A (its prior memory). Output: δ_f ∈ [0,1] — 0 means the field is already represented in memory (no information gain); 1 means maximally novel or foreign relative to memory.

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 fields. If A holds no anchor carrying field f, δ_f is undefined and that field MUST be excluded from the fieldDrift aggregation and the redundancy max — not treated as maximally novel. If no field 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.

These invariants make admission well-defined and rule out two failure modes: self-referential collapse (the incoming block in its own baseline ⇒ every field redundant) and cold-start starvation (empty memory ⇒ every field 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 field f the incoming CMB carries a vector x_f, and each anchor a ∈ A that carries f with a matching-dimension vector v_a,f:

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 field 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. Given fixed field vectors (carrying no text, so nothing is re-encoded), the encoder and adaptive timescale off, and pinned τ, signal age, and each anchor’s stored-time + confidence, the baseline produces a deterministic δ_f, totalDrift, and κ. A conformance test vector fixes these and asserts the exact values — it tests the math, not the encoder — so the baseline is reproducible across implementations even though live admission is receiver-divergent by design (different encoders, different α_f).

The redundancy test is the key addition: a signal is redundant if every field falls below T_redundant — meaning no field carries novel content relative to local anchors. If any field is novel (e.g., same topic but different intent), the signal passes. This preserves per-field 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 lineage (parents + ancestors) 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:

• — Group-bound (autonomous). A CMB broadcast to a channel/group with no to recipient. The receiver evaluates it autonomously: SVAF gates both memory admission and delivery. A group-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 Field Extraction

Mood is a CAT7 field 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 field with this property.

When SVAF rejects a CMB (totalDrift > T_guarded), the receiving node MUST still inspect the mood field. If the mood field contains a non-neutral value (text ≠ "neutral"), the implementation MUST deliver the mood field’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 field 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”) fields 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 field 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, field 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