PaperlayerView exact revision on arXiv

Source-linked AI summary

MELD: A Protocol for Merging Knowledge Across Distributed Agentic Memories

Lauri Lovén, Jaakko Sauvola, Jukka Riekki, Sasu Tarkoma

arXiv:2608.16357v1cs.DCcs.AIcs.MA

TL;DR

Agents lack a protocol for reconciling differently phrased, related, or contradictory knowledge across distributed memories. MELD provides an auditable merge procedure and status-CRDT binding, matching centralized recall, beating naive union at less storage, and reconverging 30/30 after partition healing.

  • Problem

    Agent infrastructure supports connectivity and tool sharing but lacks a protocol to reconcile differently phrased, related, or contradictory knowledge across distributed memories.

  • Method

    MELD admits incoming claims through five gated outcomes, applies one auditable Patch, and uses a publish/subscribe binding with a per-claim status CRDT.

  • Results

    Distributed merge matches centralized recall and exceeds naive union at less live storage, while the status CRDT reconverges 30/30 after partition healing against 11/30 for last-writer-wins.

  • Takeaways & Limitations

    MELD keeps sovereign brains coherent in per-claim status while leaving semantic graph adjudication local and contradictions unresolved for later adjudication.

  • Takeaways & Limitations

    MELD converges conflict status but does not determine which contradictory active claim should govern; normative resolution remains open.

Abstract

from arXiv · show

Autonomous agents share a transport and can call each other's tools, but they cannot share what they know: no protocol lets two agents' memories reconcile a fact phrased two ways, link related facts held apart, or reconcile contradictory knowledge without silently discarding either claim. We present MELD, a self-managing coherence mechanism for a federation of agent memories whose run-time model is the knowledge graph itself. Each brain admits every incoming claim through a five-outcome procedure (insert, merge, relate, conflict, or reject), decided from three signals (scoped claim-key identity, embedding similarity, and a natural-language-inference verdict) under context and freshness gates, and acting through exactly one auditable, authenticated Patch, the only object that mutates state. A binding onto standard publish/subscribe transport with a per-claim status CRDT keeps sovereign brains coherent in claim status without a coordinator: self-healing after partitions and under lossy routing, and self-protecting against silent rewrite by a peer, under a benign-fault model. MELD does not adjudicate truth; a detected contradiction is preserved for later adjudication, never silently resolved. On HotpotQA distractor, distributed merge is recall-non-inferior to a centralized store under a pre-specified equivalence test and recall-superior to naive union at about 11% less live storage; the merge classifier separates at AUC 0.968 with a 0.013 false-merge rate on adjudicated candidate pairs; the status CRDT reconverges in 30/30 real partition-heal trials where last-writer-wins manages 11/30; and semantic routing delivers about 3x fewer messages at matched recall. We evaluate on a real computing continuum spanning an operator-grade 5G edge, national HPC, and a local tier, with empirically calibrated thresholds.

1 Introduction

MELD addresses the missing protocol for reconciling knowledge across sovereign agent memories, where existing tool and knowledge-format standards provide transport or representation but not merge semantics. It performs gated merge-on-receive decisions through auditable Patches and binds them to publish/subscribe transport for coherent claim status, while explicitly not adjudicating truth.

  • Problem: Existing agent infrastructure standardizes tool access and knowledge representation, but provides no mechanism to reconcile claims that are equivalent, related, or contradictory.MCP exposes callable tools and resources, while Open Knowledge Format standardizes claim representation; neither specifies how a receiving brain should reconcile incoming knowledge.
  • Protocol: MELD is a state-synchronization protocol in which sovereign wiki brains merge knowledge on receipt rather than applying peer knowledge directly.Each brain runs a per-delta admission loop over claim-key identity, embedding similarity, and an inference verdict.
  • Auditable mutation: An authenticated, versioned Patch records the decision, target, emitted deltas, and fired gates; only the Patch mutates local state and can be published for auditability.The wire protocol uses PUBLISH for graph deltas, while status changes use append-only status links.
  • Admission procedure: Each incoming claim receives one of five outcomes—insert, same-enough, overlaps, conflicts, or reject—under context, authority, and freshness gates.The procedure first determines whether the incoming claim has any candidate, then records the admission result as a merge decision.
  • System scope and limits: MELD binds merge semantics to content-based publish/subscribe transport and preserves claim-status convergence across sovereign brains, but does not resolve truth or make the merge graph order-independent.The paper frames consistency as convergence on claim status, while truth adjudication remains outside the protocol.

2 Background

MELD assumes a versioned, typed-link agent-memory store and synchronizes each agent’s knowledge graph, or “wiki brain,” rather than flat documents. Because links are first-class and typed, reconciliation can remain explicit in the graph instead of overwriting one value.

  • 2.1 Substrate: MELD requires only a versioned, typed-link agent memory with content-addressed nodes, typed and versioned links, and per-node claims carrying status and validity intervals.The protocol is deliberately undemanding about the underlying store.
  • 2.2 Data model: Each agent’s knowledge is modeled as a versioned, typed-link knowledge graph called its wiki brain.The model is self-contained and describes the shape that existing stores approximate.
  • 2.2 Data model: A brain contains content-addressed nodes with ownership, provenance, authority, confidence, access-control, and retention metadata, plus authenticated, typed, versioned, weighted links.Examples of link types include association, entity coreference, supersession, partial overrule, grounding, and contradiction.
  • 2.2 Data model: The natural exchange unit is a graph delta containing versioned nodes, claims, and links, while reconciliation outcomes can be represented as association, coreference, or contradiction links.This preserves relationships in the graph rather than collapsing them into a single overwritten value.

3 The MELD protocol

MELD is a state-synchronization protocol for sovereign agent wiki brains built around one PUBLISH(graph-delta) operation. Incoming deltas are decomposed into typed objects, and only authenticated, auditable Patches mutate local state through five claim-admission outcomes.

  • Wire surface: MELD reduces transport to one PUBLISH(graph-delta) operation carrying graph deltas, delivered by content-based interest matching under an at-least-once, idempotent, eventually-complete contract.Subscribe and update are transport and state effects rather than separate wire verbs.
  • Delta processing: Incoming deltas are decomposed by type: claims run the merge procedure, status links enter an authenticated append-only CRDT, and other links follow store append rules.All local mutations occur through a Patch and nothing else.
  • Claim and mapping model: Claims are addressable assertions with canonical-content claim keys and discrete scope, making claim granularity—not whole-node granularity—the basis for deciding whether knowledge is same-enough.Mappings record cross-brain association or coreference when knowledge should relate rather than merge.
  • Typed objects: A Patch is MELD’s new wire object: an authenticated, versioned record whose decision is insert, merge, relate, conflict, or reject, with the affected target and fired gates.Recorded gates include claim-key match, embedding score, inference outcome, and freshness.
  • Patch semantics: The Patch is the only state-mutating object and is publishable, enabling federation-wide audit and replay of merge decisions.Replay uses the consumer’s current held state, so its result may differ while preserving the original decision and gates.

4 Merge semantics

MELD uses a gated, deterministic procedure to classify each incoming claim as insert, merge, relate, conflict, or reject. It preserves detected contradictions as auditable links and applies every decision through exactly one publishable Patch.

  • Decision procedure: MELD’s procedure returns one of five outcomes: insert, merge, relate, conflict, or reject.Pair adjudication distinguishes merge, relate, conflict, and no-relation, with no-relation mapping to insert at the protocol level.
  • Decision procedure: The decision combines scoped claim-key identity, embedding similarity, and natural-language-inference verdict under admission, context, freshness, authority, and contradiction gates.The signals are standard; MELD’s contribution is their safety-preserving combination in a decision procedure.
  • Identity and gates: Claim-key identity hashes canonical content with discrete scope, making byte-identical assertions in different jurisdictions distinct and preventing cross-boundary exact-key fusion.Validity interval and freshness remain in the Context gate rather than the key, preserving exact-key identity despite timestamp differences.
  • Conflict handling: Detected contradictions trigger a first-class contradiction link that preserves both claims and their contexts without selecting a winner.The conflict gate runs before context testing and can surface lexically divergent contradictions above the relatedness floor but below the merge threshold.
  • Mutation and audit: Every procedure run emits exactly one publishable Patch, the sole state mutation object, recording the decision, target, deltas, and fired gates.Because Patches are auditable and replayable, merge decisions can be inspected across the federation.

5 Consistency and trust

MELD achieves coordinator-free strong eventual consistency for per-claim status while deliberately leaving epistemic truth and contradictory-claim resolution outside the protocol. Its append-only, authenticated, replayable updates preserve CRDT premises across lossy transport and make errors correctable rather than destructive.

  • Status consistency: Per-claim status converges strongly eventually through a grow-only set of append-only status links merged by commutative, associative, and idempotent union.Brains receiving the same links hold identical status state regardless of delivery order, although merge-graph and retrieval-visible state may differ.
  • Status consistency: MELD converges whether claims are active, deprecated, or overruled, but preserves contradictory active claims and defers deciding which claim is true.The controlled variable is status; normative conflict resolution remains a world-model concern above MELD.
  • Transport discipline: Append-only wire updates, staleness and overrule gates, idempotent link identifiers, and anti-entropy preserve CRDT assumptions under at-least-once, eventually-complete delivery.Transport ordering and exactly-once delivery are unnecessary, but links never received remain missing state.
  • Authority and resolution: Authority-gated admission and an authority-first, recency-second, evidence-weight-third tie-break order structure deferred contradiction handling without claiming normative settlement.Canonical brains’ higher-authority claims can dominate peer claims, while automatic resolution remains deferred.
  • Trust and recoverability: 0.013 false-merge rate and 0/8 contradiction-miss rate are empirically bounded, while authenticated, replayable Patches make surfaced errors correctable without destructive deletion.MACs prevent transport forgery but do not provide individual sender attribution within a shared keyed group.

6 Implementation

MELD is implemented as a bounded merge engine and binding layer over mature agent-memory and publish/subscribe components. Its deployment separates harnesses, agents, and brains, while using a content-routed Kafka binding and calibrated operating thresholds.

  • Implementation scope: MELD adds a bounded protocol layer, merge engine, transport binding, and evaluation drivers while reusing mature transport, memory-store, and embedding infrastructure.The reused memory store supplies persistence, routing, retention, and access checks; MELD does not reinvent the data model or persistence.
  • Deployment model: A brain is a versioned, typed-link memory store that publishes graph deltas to interested brains, with the global brain serving as an aggregation role rather than centralized control.The global brain is created, merged, and tracked on demand under a trust hierarchy.
  • Transport binding: MELD binds PUBLISH(graph-delta) operations to content-based publish/subscribe events and turns arriving events into merge-on-receive calls, using Apache Kafka in deployment.The transport remains agnostic to the specific broker; the new contribution is mapping merge semantics onto the transport.
  • Reproducibility setup: The operating point uses 𝜃merge=0.90, 𝜎lo=0.12, and retention floor 𝑅min=0.10, with all-MiniLM-L6-v2 cosine similarity and cross-encoder/nli-deberta-v3-small NLI.Thresholds are calibrated rather than derived, and reported numbers come from seeded, deterministic runs.

7 Evaluation

MELD preserves recall relative to centralized memory while improving over naive union, and its coherence classifier combines key identity, embedding similarity, and NLI to detect mergeable, related, contradictory, and unrelated claims. Across routing and scaling tests, semantic synchronization remains selective, while candidate selection and sink throughput expose concrete deployment costs.

  • 7.1 Utility: 0.630 recall@5 for distributed merge versus 0.619 centralized was recall-non-inferior under the pre-specified Δ=0.05 equivalence margin, while merge exceeded naive union by +0.035.The difference versus centralized was +0.011, with 90% CI [−0.001, +0.024].
  • 7.3–7.8 Efficiency: 195 deltas/cell for semantic routing versus 585 for broadcast reduced synchronization traffic, while candidate selection cost 0.23 ms median and 0.30 ms at p95.Semantic routing delivered to only the approximately needed peer, and candidate selection scaled linearly at 3.8 ms per 1,000 active claims.
  • 7.1 Utility: 26% fewer live units accompanied recall@5 of 0.675 for distributed merge versus 0.575 centralized on LongMemEval, with merge matching or exceeding naive union.Exact-dedup tracked union, supporting semantic consolidation rather than store-size reduction; this was descriptive corroboration at n=40 without a powered equivalence test.
  • 7.2 Coherence classification: 0.845 macro-F1 and 0.013 false-merge rate were achieved at θ_merge=0.90 and σ_lo=0.12 using embedding similarity plus NLI signals.The false-merge rate was 1 of 78 non-mergeable pairs; per-class merge P/R/F1 was 0.95/0.77/0.85.
  • 7.2 Coherence classification: 0.96 conflict recall replaced 0.23 when conflict gating moved from θ_merge to σ_lo, raising macro-F1 from 0.69 to 0.845 without changing the 0.013 false-merge rate.The change rerouted divergent contradictions to conflict rather than no-relation or merge, surfacing them for authority adjudication.

8 Related work

MELD’s related-work distinction is compositional: existing protocols, replication systems, alignment methods, and memory stores provide adjacent capabilities but do not merge semantic knowledge across sovereign agent brains. MELD combines runtime semantic verdicts with per-claim convergence and publish/subscribe transport.

  • Agent communication and context protocols: Existing agent protocols expose ontologies, tools, resources, tasks, or capabilities, but none merges knowledge state.KQML and FIPA-ACL assumed a shared ontology, while Model Context Protocol and Agent2Agent are orthogonal in payload.
  • Conflict-free replication and eventual consistency: CRDTs provide deterministic convergence, but MELD adds a semantic verdict above its status CRDT because lattice rules do not identify meaning equivalence.The status CRDT is used only for per-claim convergence.
  • Ontology alignment, schema matching, entity resolution: Ontology alignment and entity-resolution methods produce offline, batch, pairwise correspondences, whereas MELD makes the verdict a runtime primitive over live, multi-owner state.The cited traditions include canonical alignment theory, benchmarks, record linkage, and an LLM-driven approach.
  • Sync transports: gossip and publish/subscribe: Publish/subscribe and gossip route bytes or events, but MELD turns publish/subscribe/merge into a protocol on a learned-semantic fabric.In conventional publish/subscribe, a subscription is a filter rather than a merge.
  • Agent-memory stores: Existing agent-memory stores make typed links first class within single stores, but define no merge protocol across sovereign stores; MELD synchronizes them.The passage names Zep/Graphiti, A-MEM, GraphRAG, HippoRAG, and Mem0 as related stores.

9 Discussion and limitations

MELD’s guarantees are topology-agnostic and hold across centralized, peer-to-peer, and hybrid deployments, but several evaluation and systems questions remain open. Its status convergence ensures agreement on claim status rather than truth, while confirmatory evaluations and unresolved scaling measurements limit the conclusions.

  • Interpretation and limitations: 30/30 partition-heal trials achieved status convergence versus 11/30 for last-writer-wins, but convergence does not adjudicate truth or validate an overrule.Distributed merge matches centralized memory and beats naive union, while routing demonstrates the transport binding without establishing optimality.
  • Evaluation gaps: LongMemEval answer-accuracy evaluation is confirmatory, while GAIA level-2 evaluation requires an out-of-scope tool-using agent loop.Open systems questions include absolute bytes synced under sustained load and latency beyond N≤4; contradiction-tuned inference could improve recall on lexically divergent contradictions.
  • Deployment scope: MELD’s topology-agnostic procedure and status CRDT support global-brain star, peer-to-peer mesh, and hybrid per-domain deployments; the global brain is optional.Hybrid deployments peer across boundaries under Context and authority gates.

10 Conclusion · A Convergence: partition-duration × reorder-rate sweep · B Convergence: reject-gate placement

MELD addresses unreconciled agent memories with an operational merge procedure, auditable Patches, and a status-CRDT-backed publish/subscribe binding. Its evaluation reports recall matching centralized storage, improved storage over naive union, robust partition healing, and fewer routed messages, while convergence studies test reordering and reject-gate placement.

  • 10 Conclusion: Tool-invocation protocols move capability but leave differently phrased shared facts unreconciled between agent memories.
  • 10 Conclusion: MELD combines an operational merge decision procedure, an auditable Patch, and a publish/subscribe binding coordinated by a per-claim status CRDT.
  • 10 Conclusion: Distributed merge matches a centralized store on recall and exceeds naive union at less live storage.
  • 10 Conclusion: 30/30 partition-heal trials reconverge with the status CRDT, compared with 11/30 for last-writer-wins.
  • 10 Conclusion: Semantic routing delivers ≈3× fewer messages at matched recall.
  • A Convergence: partition-duration × reorder-rate sweep: The convergence sweep varies queued status updates per claim before healing across {2, 4, 8, 16} and reorder rates across {0, 0.25, 0.5, 0.75, 1.0}.It uses 200 orderings per cell across six claims.
  • A Convergence: partition-duration × reorder-rate sweep: The status-CRDT holds modal agreement 1.000 in every one of the tested sweep conditions.
  • B Convergence: reject-gate placement: MELD admits every link unconditionally into a grow-only set and applies stale or overruled-delta gating during materialization-read.This avoids order-dependent admission that could make brains receiving identical links in different orders diverge.

C Additional ablations (constructed probes) · D Quantitative cross-tier partition-heal over the real Kafka WAN

Constructed-probe ablations isolate MELD’s contradiction, authority, and gate mechanisms as deterministic necessity checks rather than population error estimates. Real Kafka-WAN trials then show status reconvergence across laptop, CSC HPC, and 5GTN edge tiers, with measured heal latency.

  • C Additional ablations (constructed probes): Four ablations use deterministic, model-free checks on small constructed probes, so Table 2 figures demonstrate necessity and invariants rather than population error rates.The probes use a hashing encoder, lexical inference, and calibrated thresholds.
  • C Additional ablations (constructed probes): Gate-necessity probes drop the Context, inference, and staleness gates in turn, with each probe constructed so one gate blocks an otherwise high-similarity merge.These are distinct-key probes designed to isolate individual gate inputs.
  • C Additional ablations (constructed probes): MELD represents every injected contradiction as a CONTRADICTS edge, whereas an auto-merge baseline represents none.The ablation tests contradiction representation without silently merging conflicting claims.
  • C Additional ablations (constructed probes): The authority tie-break selects the canonical brain’s claim by construction, settling precedence rather than truth.It is correct exactly when the canonical brain holds ground truth and wrong when a peer does.
  • D Quantitative cross-tier partition-heal over the real Kafka WAN: The cross-tier experiment runs seeded partition-heal trials over a real Apache Kafka WAN linking a laptop hub, CSC HPC brain, and 5GTN edge brain.The laptop runs the Kafka broker in KRaft mode and a local brain; the other brains connect through ssh -R reverse tunnels.
  • D Quantitative cross-tier partition-heal over the real Kafka WAN: 1.000 (10/10) trials reconverged to a single status after initially diverging.The reported heal latency was p50 = 2990 ms, p95 = 3364 ms, and mean 2712 ms.
  • D Quantitative cross-tier partition-heal over the real Kafka WAN: Heal latency was dominated by WAN reconnection and missed-offset re-consumption rather than the merge step.The passage characterizes per-delta merge cost as tens of milliseconds.

E Second-substrate recall: LongMemEval … I Experiment inventory

Across LongMemEval and scaling experiments, MELD preserves recall while reducing semantic redundancy and keeping synchronization and sink state load bounded as the federation grows. The experiment inventory also covers latency across continuum hops and fan-outs, with per-cell results reported in the main evaluation and appendices.

  • E Second-substrate recall: LongMemEval: Distributed merge is recall-non-inferior to centralized on LongMemEval at every k and uses approximately 26% fewer live units than naive union.Exact deduplication tracks union, indicating that the storage reduction comes from semantic consolidation.
  • E Second-substrate recall: LongMemEval: 0.675 vs 0.575 at recall@5, 0.806 vs 0.731 at @10, and 0.881 vs 0.794 at @20: distributed merge exceeds centralized recall.At overlap 0.5, every cell remains within ≤0.013 of the overlap-0 result; recall is measured independently of an LLM.
  • F Node-scaling of sync overhead: 1.000 routing recall holds across N=2 through 128, while semantic deliveries remain 1.0 per claim and broadcast deliveries grow with N.The workload assigns each claim to exactly one needed brain, enabling direct measurement of delivery overhead.
  • F Node-scaling of sync overhead: 128× at N=128: broadcast-to-semantic overhead reaches a linear-in-N ratio, with 99.2% of broadcast deliveries wasted.MELD’s transport overhead per claim is constant in cluster size, so sink load depends on the rate of novel claims rather than the number of brains.
  • G Node-scaling of sink state-load: 26 live units persist for every N from 1 to 128, whereas naive union reaches 3328 units at N=128.Merge-on-receive consolidates repeated publication of a fixed 26-fact corpus, making sink state O(1) in cluster size.
  • H Sync-latency surface (exact values): Table 7 reports p50 publish-to-merge latency in milliseconds by added one-way RTT and fan-out N for each routing mode.The surface covers 0, 10, 25, and 50 ms continuum hops, with 15 seeds per cell, 360 cells, zero failures, and 95% bootstrap confidence intervals.
  • I Experiment inventory: The experiment inventory summarizes each main-paper experiment by question, dataset, infrastructure tier, and headline result.Detailed results are provided in the main evaluation and Appendices A–M.

J Completeness under lossy routing: the anti-entropy digest

The anti-entropy digest closes the completeness gap caused by lossy semantic routing by reconciling per-claim status-link sets without requiring a coordinator. In loss-injection trials, it restored federation-wide status agreement to 1.000 in one round, while full disconnection requires log re-consumption on reconnect.

  • Anti-entropy digest: Each brain serializes a canonical, order-independent per-claim digest of sorted link IDs and a 16-hex set-hash.The digest summarizes the grow-only status-link set as sorted-key JSON, enabling comparison across brains.
  • Loss-injection experiment: Without the digest, agreement degraded monotonically with independent delivery loss and the federation fragmented into up to 12 distinct status maps.The experiment delivered contested-lifecycle links to 12 brains with each delivery independently dropped.
  • Loss-injection experiment: 1.000 per-claim status agreement was restored at every tested loss rate, including the protocol’s ≈0.3% rate, in one round.The reconciliation exchanged ≈34 KB of digest data per round across 12 brains.
  • Scope and recovery: At loss rates ≤10% over 12 brains, each link survived somewhere with overwhelming probability, allowing one ring-gossip pass to reconcile the federation.A link lost by every brain is instead recovered through log re-consumption on reconnect.

L Merge-classifier robustness and signal generality

MELD’s merge-classification performance remains robust under degraded upstream signals and across encoder–NLI pairings. Encoder choice primarily governs discrimination, while the NLI signal primarily governs contradiction safety.

  • Robustness to degraded signals: 0.05: false-merge rate stays below 0.05 under heavy embedding noise and 50% NLI corruption, while macro-F1 declines from 0.845 to 0.684 and 0.653, respectively.The result indicates that safety persists under degraded inputs rather than depending on clean signals.
  • Signal generality (encoder × NLI sweep): 0.765–0.845 macro-F1 and 0.000–0.038 false-merge hold across three encoders and two NLI cross-encoders at the fixed operating point.The six pairings were all-MiniLM-L6-v2, all-MiniLM-L12-v2, all-mpnet-base-v2 with nli-deberta-v3-small or RoBERTa-MNLI.
  • Signal generality (encoder × NLI sweep): 0.061: encoder swaps change macro-F1 by up to 0.061, compared with 0.018–0.019 for NLI swaps at a fixed encoder.The reported comparison is 0.845 for MiniLM versus 0.784 for mpnet at a fixed NLI.

M Order-sensitivity of the merge graph

MELD’s per-claim status converges regardless of delivery order, but its merge graph is order-sensitive because decisions compare each claim with already-held state. In the gold-derived workload, this sensitivity changed surviving claims, statuses, links, and retrieval results across delivery orders.

  • Scope: Status converges regardless of delivery order, whereas the merge graph is not claimed order-independent.Status convergence follows a state-based CRDT join over a grow-only link set; graph construction depends on the per-pair decision procedure against already-held state.
  • Gold-derived workload: 177/200 (88.5%) of orderings produced a unique joint fingerprint, and 112/200 (56%) changed the live claim set.The status map also differed across 131/200 orderings, showing that delivery order changes store content and deprecation choices.
  • Retrieval impact: Every probe query showed retrieval disagreement across orderings under the same status-aware top-k evaluation.The disagreement was visible to callers rather than confined to internal graph bookkeeping.
  • Mechanism and cost: Median candidate-set size was 4 and 95th percentile 7, while scan latency was 0.23 ms median and 0.30 ms at the 95th percentile.These measurements came from 3,200 best_candidate calls with a warm embedding cache; the observed order-sensitivity is structural, not primarily computational.

N Architecture and control-loop reference

MELD adds a protocol layer over existing typed-link agent-memory and standard CRDT foundations, while separating harnesses, agents, and brains in a sovereign-peer deployment topology. Its control loop is self-managing rather than self-optimizing, with one authenticated Patch as the sole state mutation.

  • Layer stack: MELD adds a new protocol layer over public typed-link agent-memory substrates and standard CRDT foundations.The underlying substrates and convergence foundations are reused; only the protocol layer is new.
  • Layer stack: Harnesses handle execution, agents handle task logic, and brains handle knowledge as distinct layers.The architecture keeps these responsibilities separate.
  • Deployment topology: Many sovereign agent brains publish graph deltas through content-routed pub/sub into a global-brain aggregation role.The global brain is an aggregation role over sovereign peers rather than a replacement for them.
  • Control loop: One authenticated Patch is the only state mutation in MELD’s self-managing control loop.The system is self-managing, not self-optimizing, because thresholds are calibrated offline.
Loading 2608.16357v1…