conflict-preserving replication

This work addresses the limitations of existing memory layers in multi-agent systems, which often obscure observation conflicts through overwriting, thereby hindering auditability and correction. The authors propose a conflict-aware replicated memory contract grounded in standard OpSet/CRDT merging semantics. Without introducing new merge algebras, their approach leverages immutable history, explicit conflict objects, semantic handles via claim_id/claim_ref, deterministic predicate contracts, and resolution-at-projection mechanisms to ensure conflict visibility, safe abstention, and auditable corrections. Experimental evaluation on MemoryAgentBench demonstrates that the method maintains accuracy comparable to existing approaches while significantly enhancing contradiction retention. Notably, when precise identifiers are unavailable, the semantic handles prove essential for reliable correction.

This work proposes a semantic-dependency-based conflict resolution model to address the challenge of explicitly and decentrally handling concurrent operation conflicts in distributed collaborative editing. By introducing semantic dependencies into the Conflict-Free Replicated Data Type (CRDT) framework for the first time, the approach integrates three-way merging with operational rebasing to enable explicit conflict identification and resolution without centralized coordination, all within a local-first architecture. Operation histories are maintained via replicated logs, supporting a semi-automatic coordination mechanism that remains interpretable to users. Experimental results demonstrate the model’s effectiveness in collaborative register scenarios, where it not only explicitly captures Last-Writer-Wins semantics but also extends naturally to multi-register entities, thereby enhancing the transparency and controllability of conflict resolution.

Strict memory consistency models (e.g., Sequential Consistency, SC) overly constrain compiler and hardware optimizations, preventing certain safety-preserving transformations. Method: We establish a formal link between memory semantics and optimization safety by modeling program optimizations as transitions over execution trace effects, and introduce “completeness”—a novel compositional property that precisely characterizes how memory model evolution ensures optimization safety. Contribution/Results: We prove, for the first time, that the transition from SC to the weaker SC_RR model is complete—demonstrating that weakening consistency does not necessarily increase optimization freedom. This work provides the first verifiable methodology for optimization-driven memory model design, bridging formal semantics with practical compilation.

To address build failures caused by method deletions and other structural changes during code branch merging, this paper proposes BUCOR, an automated conflict resolution technique that synergistically integrates example-driven learning with rule-driven reasoning. BUCOR performs three-way diff analysis, static semantic understanding, and change-history mining to automatically identify recurring conflict patterns and generalize reusable program transformation rules. Crucially, it is the first approach to combine context-aware example learning with structured rule-based inference for build conflict repair. BUCOR extracts, abstracts, and applies repair patterns directly from real-world projects. Evaluated on 88 real-world build conflicts, it produces at least one valid fix for 65 cases, with 43 achieving fully correct repairs. This demonstrates substantial improvements in integration efficiency and software quality.

Static synchronization mechanisms in distributed systems impose severe scalability bottlenecks by enforcing strong consistency even in the absence of actual conflicts. This work introduces the “dynamic concurrency” paradigm—the first approach to perform fine-grained, runtime state–aware conflict detection: synchronization is triggered only when concurrent operations induce genuine dependency conflicts under the current data state. Methodologically, we design a state-aware, generic conflict predicate that integrates dynamic conflict detection with lightweight synchronization arbitration. Experimental evaluation shows that our approach significantly reduces redundant synchronization overhead, achieving 32%–68% higher throughput and 41% lower latency under typical distributed workloads, while preserving linearizability. The core contribution lies in elevating conflict detection from static, operation-level reasoning to dynamic, state-level reasoning—establishing a novel, efficient foundation for concurrency control in high-concurrency distributed systems.

This work addresses the challenge of maintaining consistent persistent memory in large language model (LLM) agents under frequent belief updates, where existing conflict-resolution heuristics lack formal isolation guarantees. The authors model this problem as write-time concurrency control and introduce TOKI, a bitemporal operational algebra that unifies four classes of heuristic strategies while ensuring semantic consistency through isolation preconditions and provenance annotations. They establish the first formal correctness contract for LLM memory conflicts, encompassing isolation, schema, and provenance properties, and prove its scalability over operation pipelines and n-ary conflict sets. Experiments on the LoCoMo natural workload demonstrate that TOKI is the only approach that simultaneously avoids three classes of write anomalies while preserving the LLM’s adjudication capability; its audit-row mechanism improves accuracy by 0.86, whereas removing the typed memory layer reduces accuracy by 0.49 across 1,444 problems.

Traditional reader-writer locks suffer from coarse-grained contention, making them ill-suited for concurrent data structures involving long-running operations. This work proposes SemanticLock, a synchronization mechanism that generalizes read-write semantics to arbitrary semantic conflict relationships among operations. By constructing an operation conflict graph, SemanticLock enables fine-grained concurrency control while allowing flexible specification of operation semantics. The approach has been integrated into array-based structures supporting both point and range queries, as well as an enhanced ConcurrentHashMap. Experimental results demonstrate that SemanticLock substantially improves concurrency performance under complex, long-duration operations.

Existing multi-agent large language model systems lack a persistent mechanism for handling contradictory claims at write time, making it difficult to track the adoption status, disputes, and update rationale of statements. This work proposes a conflict-aware structured memory mechanism that detects contradictions during the write phase via lightweight symbolic checks and invokes the large language model for coordination only when semantic conflicts are irreconcilable—enabling write-time conflict resolution in multi-agent systems for the first time. By integrating symbolic verification with semantic coordination, the approach supports traceable and updatable memory management. On the source-agnostic ConflictBank benchmark, it achieves an accuracy of 0.97, substantially outperforming the strongest baseline (0.61, p<10⁻⁶); ablation studies confirm that removing either component causes a 12–14 percentage point performance drop.

This study addresses four critical failure modes in shared memory systems for multi-agent large language model (LLM) fleets: unauthorized leakage, information staleness, persistent contradictions, and provenance breakdown. To tackle these challenges, the work formally introduces the “fleet memory” problem and proposes a governed shared memory mechanism grounded in system-level primitives—scoped retrieval, temporal coverage, provenance tracing, and policy-based control. Implemented via MemClaw, a multi-tenant memory service, and evaluated using ArgusFleet, a reproducible testing framework, the system enables fine-grained scope enforcement, asynchronous contradiction detection, and synchronized write-gating coordination. Experiments demonstrate that the approach achieves 100% accurate reconstruction of four-layer-deep provenance chains within sub-second latency, ensures zero cross-fleet leakage, and guarantees immediate write visibility in strong-write mode with a single round-trip search.

This work addresses the challenge of knowledge updating in large language models, which typically necessitates costly retraining. Building upon the Compositional Multi-layer Memory (CMM) architecture, the authors propose a version-aware operational layer that compiles high-level semantic edits into ordered, composable memory primitive transactions. By introducing versioned CMM and transactional CMM, knowledge modifications are modeled as reversible and reusable structured transactions, enabling fine-grained replacement, rollback, historical tracing, and localized updates. This approach substantially reduces reliance on full model retraining while ensuring editing efficiency and traceability.