Context Curation

1. The Multi-Agent Context Problem

A single agent with one LLM has a context problem that existing tools solve well. RAG retrieves relevant documents from a vector store. Long context windows (128K, 1M tokens) hold entire codebases. Memory frameworks persist structured state across sessions. These work because there is one agent, one domain, one perspective.

Multi-agent systems have a fundamentally different problem. N agents observe the world through N domain lenses. A coding agent sees commits slowing. A music agent sees playlists skipped. A fitness agent sees 3 hours without movement. Each observation is noise in isolation. The insight — the user is fatigued — requires cross-domain reasoning. But how?

The brute-force answer: send everything to every agent. Each LLM receives every observation from every peer. This fails in practice:

• Signal-to-noise collapse. A fitness agent receiving coding debug logs, music playback events, and calendar entries alongside the one relevant signal (“energy declining”) has its reasoning quality degraded by irrelevant context.
• Token cost scales as O(N²). N agents each receiving N agents’ full observations means N² context payloads. At 10 agents with 1000 observations each, that’s 10M tokens per reasoning cycle.
• Privacy violation. Agents in regulated domains (health, legal, finance) cannot share raw observations with every peer.
• Domain boundaries matter. A coding agent’s “debugging auth module for 3 hours” is irrelevant to a music agent. But the mood embedded in that observation (frustrated, low energy) is exactly what the music agent needs.

The problem is not retrieval. RAG answers “what in my memory is relevant to this query?” The multi-agent problem is: “what in everyone else’s observations is relevant to my domain, right now, for this task?”

2. Cognitive Memory Blocks as Context Atoms

MMP decomposes every observation into a Cognitive Memory Block — an immutable structured unit with 7 semantic fields (the CAT7 schema):

The fields are universal. Domain-specific interpretation happens in the field text, not the field name. A coding agent’s focus is “debugging auth module.” A fitness agent’s focus is “30-minute HIIT workout.” Same field, different domain lens.

Each CMB is immutable and content-addressable — its key is cmb- + md5 of all field texts. The growing DAG of remixed CMBs connected by lineage IS the collective knowledge. Not a database of records. A graph of understanding.

3. Per-Field Evaluation as Context Gate

When a CMB arrives from a peer, SVAF (Symbolic-Vector Attention Fusion) evaluates it — not as a whole, but per field. This is the key architectural difference from RAG or whole-document relevance scoring.

Each agent defines α_f field weights — a vector of 7 values declaring which semantic dimensions matter for its domain:

A coding agent’s CMB arrives at a music agent. SVAF evaluates each field independently:

• focus: “debugging auth module” — irrelevant to music (α_f = 1.0, high drift) → filtered
• issue: “exhausted, making mistakes” — low weight for music (α_f = 0.8) → filtered
• mood: “frustrated, low energy” (valence: -0.6, arousal: -0.4) — accepted (α_f = 2.0, high weight, low drift)

The music agent’s LLM receives one field from this CMB, not seven. The signal that matters — the user is frustrated and low energy — passes through. The noise — auth module debugging details — is filtered at the protocol layer, before the LLM ever sees it.

The neural SVAF model independently confirmed this design: mood emerged as the highest gate value (0.50) across all fields without being told, because affective state is universally relevant across domain boundaries.

4. Lineage as Context Structure

When an agent remixes a CMB, it creates a new CMB with lineage:parents (direct source CMBs) and ancestors (full chain). The ancestor chain provides O(1) access to the complete remix history without graph traversal.

The LLM at Layer 7 doesn’t search memory. It traces. Given an incoming signal, it follows the ancestor chain to understand how this knowledge evolved through remixes. But it doesn’t trace all fields — only the fields weighted by α_f and relevant to the current task.

This is the critical difference from RAG. RAG retrieves documents by similarity to a query. Lineage tracing follows the causal chain of how a piece of knowledge was produced — who observed what, who remixed it, and how it evolved. The context isn’t “documents similar to my question.” It’s “the chain of reasoning that produced this signal.”

5. The Context Curation Query

The core operation of the memory store is not search(text). It is:

Three filters compose to produce the minimum context the LLM needs:

The result is a projected subgraph: ancestor CMBs with only the fields that matter, ordered by relevance, capped at a token budget. 20 CMBs × 3 relevant fields ≈ 500 tokens. Not 1M. Not even 10K.

The intelligence is in what you don’t send to the LLM.

6. Comparison with Existing Approaches

RAG answers: “what in my memory is relevant?” MMP answers: “what from every agent’s observations, filtered by my domain weights, traced through the remix chain, is the minimum context I need to reason about this incoming signal?”

These approaches are not mutually exclusive. A single agent on the mesh can use RAG for its own local memory and MMP context curation for cross-agent knowledge. They operate at different scopes.

7. Emergent Properties

8. Implementation Status

• MMP v0.2.0 — published specification, 8-layer protocol stack
• Reference implementations: SYM (Node.js), SYM Swift (iOS/macOS)
• Trained models: SVAF per-field evaluation (78.7% accuracy), xMesh per-agent LNN (AUC 0.83, bimodal τ)
• Production: MeloTune + MeloMove + Claude Code on the same mesh

Related