Real Model Merge Lab

Merge actual HuggingFace models using any of 26 CRDT-verified strategies. 75+ models across 28 architecture families -- select a compatible family, then pick any two models to merge.

The merged model is downloadable as .npz (load with np.load() in any framework) with a full provenance audit trail and produced model card.

Download Merged Artifacts

Pick a strategy. Merge two models. See the mathematical proof that merge(A,B) == merge(B,A). Uses real prajjwal1/bert-tiny weights from HuggingFace Hub when available, otherwise synthetic tensors.

Note: Some strategies may produce similar or identical outputs with only 2 models at equal weights — this is mathematically expected. Differences become significant with 3+ models or real fine-tuned weights.

Every strategy tested live against all three CRDT laws — commutativity, associativity, idempotency. The two-layer OR-Set architecture makes any strategy CRDT-compliant without modifying the strategy itself.

The Mathematical Proof — Naive vs crdt-merge

The Mathematical Proof — Naive vs crdt-merge

Standard merge strategies fail associativity: merge(merge(A,B), C) ≠ merge(A, merge(B,C)). crdt-merge's OR-Set layer absorbs this — the gap drops to exactly 0.0 for every strategy.

How to read the proof table:

• Naive Assoc Gap ‖g₁−g₂‖: The L2 norm between two different groupings of a 3-way merge without crdt-merge. Non-zero values prove the raw strategy isn't associative.
• CRDT Gap ‖g₁−g₂‖: The same test with crdt-merge's OR-Set layer. 0.0 means the architecture makes the strategy fully associative.
• Bar Chart: Visual comparison — tall red bars (naive) vs flat green bars (crdt-merge). The bigger the red bar, the more the raw strategy violates associativity. Green bars at zero prove the fix.

Real benchmark results from NVIDIA A100-SXM4-40GB · v0.7.1 · Python 3.12. Polars engine peak: 38.8× speedup over Python at 500K rows. Streaming merge: O(1) memory verified — throughput dead-flat from 100K to 5M rows.

🏆 crdt-merge vs mergekit vs FedAvg — Live Benchmark

Live proof of order-independence. This benchmark merges 3 model weight tensors in all 6 possible orders using crdt-merge vs naive pairwise merging. crdt-merge produces identical results every time. Naive approaches (including FedAvg-style averaging) produce different results depending on merge order.

Click Run Live Benchmark to see the proof, or scroll down for the feature comparison.

📋 Feature Comparison — crdt-merge vs mergekit vs FedAvg

Explore the architecture layers, distributed protocols, and domain-specific merge capabilities.

Two-Layer Architecture — The Key Innovation

┌──────────────────────────────────────────────────────────────────────┐
│  LAYER 1 — OR-Set CRDT State (CRDTMergeState)                       │
│                                                                      │
│  Contributions arrive in ANY order from ANY node                     │
│  OR-Set union: commutative + associative + idempotent by definition  │
│  Every contribution: content-addressed (SHA-256 Merkle hash)         │
│  Version vectors for causal ordering                                  │
│  Tombstones for safe remove/replace operations                        │
│                                                                      │
│  merge(state_a, state_b) → set union  ← CRDT laws guaranteed here   │
└──────────────────────────────────────────────────────────────────────┘
                               │  resolve() — applied atomically
                               ▼
┌──────────────────────────────────────────────────────────────────────┐
│  LAYER 2 — Strategy Execution (pure function over sorted set)        │
│                                                                      │
│  Sees a SET — ordering non-determinism completely absorbed           │
│  26 strategies: weight_average, slerp, ties, dare, fisher, dual_     │
│    projection, evolutionary, negative, safe_merge, and 18 more ...   │
│  Same inputs → always same output (determinism via canonical sort)   │
│                                                                      │
│  f(sorted_set_of_contributions) → merged_tensor                     │
└──────────────────────────────────────────────────────────────────────┘

Why this works: Layer 1 guarantees all replicas converge to the same set of inputs. Layer 2 guarantees the same set → same output. Together: full CRDT convergence for any strategy.

Regulatory Compliance & Audit Trail Demonstration

crdt-merge is the only model merging library with built-in compliance capabilities for GDPR, HIPAA, SOX, and the EU AI Act. This tab demonstrates live compliance operations.

How it works: The OR-Set CRDT tracks every contribution by origin node. This enables complete audit trails, deterministic erasure (GDPR Art. 17), and field-level access control — all while maintaining mathematical convergence guarantees.

The Open Invitation: Let's Build What Nobody Else Can

crdt-merge is the first mathematically proven convergent merge system
for models, data, and agents. It exists. It works. The question is: who builds with it first?

Patent: UK Application No. GB 2607132.4, GB2608127.3 -- 26 Strategies -- 6-Layer Architecture -- 44,304 LOC -- E4 Trust-Delta -- Zero Coordinator

⭐ Star · 👁️ Watch · 💬 Start a Discussion · 📖 Read the Docs

The State of Play: A Problem Hiding in Plain Sight

Every major AI system today has the same dirty secret: merging is ad-hoc. Fine-tuned variants are averaged and hoped for the best. Federated models rely on central coordinators that become single points of failure. Agent memories are siloed. Data reconciliation is manual.

This isn't a minor inconvenience. It's the bottleneck between current AI and the decentralized, multi-agent, multi-model future everyone is racing toward.

crdt-merge solves it with mathematics — not heuristics, not hope.

The Competitive Landscape — And Where You Sit

The organizations that integrate convergent merging first will define the next era. The rest will license it from them.

The white space in this table is your opportunity. Or your competitor's.

The Researchers Who Laid the Groundwork — And What Comes Next

The science beneath crdt-merge didn't appear from nowhere. It stands on the shoulders of specific, brilliant work. We've built the bridge between these research threads — and we'd love the architects to walk across it.

Model Merging Pioneers

@prateeky2806 — Prateek Yadav · TIES-Merging (NeurIPS 2023) Your insight — trim, elect signs, merge — is one of our 26 strategies. But TIES without convergence guarantees means merge order matters. crdt-merge wraps TIES in CRDT semantics: same result regardless of merge order or network topology. Your method, now safe for production at any scale. We'd love to explore co-authoring the convergent extension.

@gabrilharco — Gabriel Ilharco · Task Arithmetic (ICLR 2023) Task vectors changed how people think about model editing. crdt-merge implements Task Arithmetic as a first-class strategy with base= model support and CRDT compliance. Imagine task vectors that compose across distributed teams with zero coordination. The math works. Let's publish it together.

@mitchellnw — Mitchell Wortsman · Model Soups (ICML 2022) Model Soups demonstrated that averaging fine-tuned models improves robustness. crdt-merge extends this to 26 soup recipes, all convergent. What would you discover with a convergent soup kitchen that works across institutional boundaries?

@cg123 — Charles Goddard · mergekit You built the definitive model merging toolkit. We built the convergence layer. mergekit + crdt-merge = mergekit-crdt — every merge strategy in mergekit, now with mathematical convergence guarantees. Your community wants this. So do we. Let's discuss an integration path.

@mlabonne — Maxime Labonne · LazyMergekit, NousResearch You've made model merging accessible to thousands. Your leaderboard experiments show the power of community-driven merging. crdt-merge adds the missing guarantee: no matter what order your community merges, the result converges. That's the difference between experimental and production-ready.

@rasbt — Sebastian Raschka · Machine Learning Q and AI Your educational work shapes how the next generation thinks about ML. crdt-merge introduces a concept that belongs in every ML curriculum: convergent model composition. We'd be honored to collaborate on educational content that introduces this primitive.

@TimDettmers — Tim Dettmers · QLoRA, bitsandbytes Quantization meets merging: what happens when you merge quantized models? crdt-merge preserves convergence through quantization boundaries. QLoRA adapters from different domains, merged convergently, quantized efficiently. The full stack, proven correct.

Federated Learning Architects

@AustinHenley · @mcmahan — H. Brendan McMahan · FedAvg Inventor (Google) You invented federated averaging — the foundation everything else builds on. FedAvg assumes a central coordinator. crdt-merge removes that assumption entirely. Same convergence, zero coordinator, pure peer-to-peer. We'd welcome your perspective on what this enables that FedAvg cannot.

@virginia-smith — Virginia Smith · CMU, Federated Optimization Your work on heterogeneous federated learning (MOCHA, FedProx) addresses the hard reality of non-IID data. crdt-merge complements this — convergent merging that tolerates arbitrary heterogeneity because the CRDT layer doesn't care about data distribution. Merge order invariance is stronger than convergence rate optimization.

@peterkairouz — Peter Kairouz · Google, Advances in Federated Learning Your survey defined the field. crdt-merge addresses the open problems you identified: communication efficiency (delta sync), privacy (field-level encryption), and heterogeneity (26 strategy options). The next edition of your survey might want a new category: coordinator-free convergent merging.

@danieljbeutel — Daniel J. Beutel · Flower Framework Flower made federated learning practical. crdt-merge makes it coordinator-free. Flower + crdt-merge = federated learning where the server is optional, not required. Your thousands of FL researchers get a new primitive. We see a flwr.strategy.CRDTStrategy in the future — shall we build it?

CRDT & Distributed Systems Theorists

@ept — Martin Kleppmann · Automerge, University of Cambridge Your work on CRDTs for collaborative editing is foundational. You proved CRDTs work for text. We proved they work for tensors, models, and agent state. The two-layer trick (OR-Set metadata + tensor merge) is, we believe, novel — and we'd value your formal analysis. Does this construction satisfy your definition of a Convergent Replicated Data Type?

Marc Shapiro · Sorbonne/INRIA, CRDT Co-inventor You defined the mathematics we build on. crdt-merge extends your framework to a domain you may not have envisioned: neural network weight spaces. We've proven commutativity, associativity, and idempotency for 26 strategies over continuous tensor fields. We'd be deeply honored by your review of the formal properties.

@nuno-preguica — Nuno Preguiça · NOVA University, CRDT Co-inventor Your work on optimistic replication and conflict resolution is the theoretical backbone. crdt-merge's conflict resolution across 26 strategies is, in some sense, a concrete instantiation of your theoretical framework in the ML domain. We'd love your assessment of our conflict rate metrics and resolution guarantees.

@dmonad — Kevin Jahns · Yjs Yjs proves CRDTs can be fast, practical, and widely adopted. crdt-merge aims to do the same for the AI domain. Your implementation insights on memory efficiency and encoding would be invaluable as we scale to billion-parameter models. We admire what you've built and see complementary paths.

Distributed Systems Pioneers

The mathematical foundations of consensus, consistency, and convergence — crdt-merge builds on your work and takes it to model merging.

AI Systems & Infrastructure Researchers

@mateiz — Matei Zaharia · Databricks, Apache Spark, MLflow You unified big data processing. crdt-merge unifies model merging. MLflow + crdt-merge = convergent model registry where merging is a first-class operation alongside training and deployment. Your platform serves thousands of ML teams — they all have the merge problem.

@ionstoica — Ion Stoica · UC Berkeley, Ray/Anyscale Ray distributes computation. crdt-merge distributes convergence. Ray Serve + crdt-merge = distributed model composition with mathematical guarantees. Every Ray user deploying model ensembles would benefit. We see ray.merge() as naturally as ray.remote().

@tridao — Tri Dao · FlashAttention, Princeton/Together AI FlashAttention made attention efficient. What makes merging efficient? crdt-merge's O(batch_size) memory and delta sync minimize the cost of convergence. Together AI's open model ecosystem + convergent merging = the platform where community models compose safely.

@chrisre — Chris Ré · Stanford, Hazy Research, Together AI Your data-centric AI work (Snorkel, Flash) showed that data quality matters more than model size. crdt-merge applies the same philosophy to merging: convergent composition quality matters more than merge speed. We'd love Hazy Research's perspective on data-aware merge strategies.

@percyliang — Percy Liang · Stanford HELM, CRFM HELM benchmarks models. Who benchmarks merges? crdt-merge's property verification (commutativity, associativity, idempotency) is a merge benchmark framework. We see a "HELM for Merges" — standardized evaluation of merge quality. Your framework could host it.

AI Safety & Alignment Researchers

@janleike — Jan Leike · Anthropic, Alignment When safety-trained models merge, do safety properties survive? crdt-merge's audit trail proves exactly what was merged, when, and how. Alignment verification for merged models — not hoped, but mathematically tracked.

@paulfchristiano — Paul Christiano · ARC, AI Alignment Alignment requires verifiable guarantees. crdt-merge provides verifiable merge guarantees. Different concern, same philosophy: if you can't prove it, you can't trust it.

@mmitchell-ai — Margaret Mitchell · AI Ethics, Model Cards Model Cards document individual models. Merge Cards should document merged models — provenance, strategies used, convergence verification, compliance status. crdt-merge generates this automatically. Let's define the standard together.

@stellaathena — Stella Biderman · EleutherAI EleutherAI democratized large language models. crdt-merge democratizes convergent model composition. Your community creates hundreds of fine-tunes — they deserve a merging system that guarantees correctness regardless of who merges what, in what order.

@sarahooker — Sara Hooker · Cohere For AI Your work on model compression and the "Lottery Ticket Hypothesis" explores what survives pruning. crdt-merge explores what survives merging — and proves the answer is "everything that matters," convergently. Cohere's Aya multilingual initiative + convergent merging = global language model assembly.

Foundation Model Labs — The Models Are Yours. The Merge Layer Is Missing.

@openai — @sama · @gdb · @maboroshi

Enterprise customers fine-tune GPT for legal, medical, finance. They ask: "Can we merge our domain models?" Today the answer is manual averaging. With crdt-merge: gpt.merge(legal_variant, medical_variant, strategy="dare_ties") — convergent, auditable, compliant. Your enterprise tier needs this. Your competitors will offer it if you don't build it first.

@anthropics — @darioamodei · @colah · @janleike

Constitutional AI's safety requirements demand verifiable merging. When Claude variants merge across safety research teams, the question isn't whether they converge — it's whether you can prove they converge. crdt-merge provides that proof. @colah's mechanistic interpretability + convergent merge auditing = the most trustworthy merge pipeline in AI.

@google-deepmind — @JeffDean · @demaboroshi

Gemini trains across Google's global fleet. @JeffDean pioneered distributed training — crdt-merge is the distributed merging complement. No coordinator. Pure peer-to-peer. Our gossip protocol converges on any topology, including your TPU pod mesh. Gemma's open ecosystem needs convergent community merging — the pieces fit.

@facebookresearch — @ylecun · @jpineau · @soumithchintala

Llama is open. crdt-merge is open. Together: community-driven model merging where convergence is guaranteed, not hoped. @ylecun's vision of self-supervised learning needs continuous model evolution — our ContinualMerge prevents catastrophic forgetting while maintaining convergence. PyTorch + crdt-merge — the obvious pairing.

@mistralai — @arthurmensch · @GuillaumeLample

Mixtral's Mixture-of-Experts architecture is designed for merging — specialized experts from different fine-tunes, composed into a unified model. crdt-merge handles this with routing-aware strategies. You're already thinking about this problem. We've solved the convergence part.

@cohere-ai — @aidangomez

Cohere serves enterprises across regulated industries. Every enterprise customer eventually asks: "How do we merge our department models while staying compliant?" crdt-merge is that answer — 5 regulatory frameworks, built-in audit trails, convergent by construction. The enterprise upsell writes itself.

@deepseek-ai

DeepSeek-V2's MoE architecture uses hundreds of expert modules. Community fine-tunes of DeepSeek-Coder, DeepSeek-Math, DeepSeek-Chat are begging for convergent composition. crdt-merge handles MoE expert merging with routing-aware strategies. The community is building. The merge layer is missing.

@StabilityAI — @emaboroshi

Stable Diffusion's community produces thousands of LoRA fine-tunes. crdt-merge enables convergent LoRA composition — merge artistic styles, character concepts, and aesthetic preferences with mathematical guarantees. CivitAI's model ecosystem + convergent merging = curated quality at scale.

@01-ai — Kai-Fu Lee

Yi's community is exploding with fine-tunes across languages and domains. crdt-merge enables permissionless model evolution where community contributions merge convergently. First-mover advantage in Chinese-language convergent merging.

@AlephAlpha — Jonas Andrulis

European AI sovereignty requires EU-hosted, convergent model merging with EU AI Act compliance. crdt-merge is the only system that offers this by default. Aleph Alpha + crdt-merge = the sovereign AI stack Europe is looking for.

Agent Framework Builders — Your Agents Have Amnesia. We Have the Cure.

Every agent framework today stores memory in isolated silos. When agents collaborate, they don't truly share knowledge — they pass messages. crdt-merge enables convergent shared memory: agents merge their learned state, observations, and beliefs with mathematical guarantees.

@langchain-ai · @hwchase17 — LangChain / LangSmith

LangChain orchestrates agents. crdt-merge gives them shared, convergent memory. ConversationCRDTMemory replaces ConversationBufferMemory — multi-agent state merges automatically, correctly, without a central memory server. Your 100K+ developers need this for production multi-agent systems. LangSmith can track merge provenance alongside chain traces.

@run-llama · @jerryjliu — LlamaIndex

LlamaIndex connects LLMs to data. crdt-merge connects LLMs to each other's knowledge — convergently. Index merging across distributed RAG pipelines with mathematical correctness. Your users building multi-source RAG are merging indices manually. We automate it with guarantees.

@cpacker · @letta-ai — MemGPT / Letta

You solved agent long-term memory. crdt-merge solves agent shared memory. MemGPT's archival memory + CRDT convergence = agents that remember collectively, not just individually. The next Letta feature: SharedArchivalMemory(merge_strategy="ties").

@mem0ai — Mem0

Memory layer for AI. crdt-merge is the convergence layer for memory. When multiple agents write to Mem0, who wins? With CRDT merging: everyone wins, convergently. No conflicts. No overwrites. No data loss.

@crewAIInc · @joaomdmoura — CrewAI

Crews of agents collaborate. crdt-merge makes their collaboration mathematically sound. Crew members merge their findings, observations, and learned patterns — convergently. The difference between a crew and a swarm is guaranteed convergence.

@microsoft · @sonichi — AutoGen

Multi-agent conversations are powerful. Multi-agent convergent state is transformational. AutoGen agents that share merged world models, not just chat messages. Microsoft's enterprise customers need this for production agent deployments.

@stanfordnlp · @okhat — DSPy

DSPy optimizes prompts and weights programmatically. crdt-merge optimizes how optimized models compose. When multiple DSPy-optimized modules need to merge, convergence guarantees matter. The missing dspy.Merge() primitive.

️ MLOps & Infrastructure — The Merge Primitive Belongs in Your Stack

@huggingface · @julien-c · @Narsil · @claboroshi

The Hub hosts 500K+ models. Thousands are fine-tune variants of the same base. "Merge these two models" should be a Hub button, not a manual process. huggingface_hub.merge(model_a, model_b, strategy="slerp", verify_convergence=True). You're already the home of model merging culture (Open LLM Leaderboard). crdt-merge makes it production-grade.

@Lightning-AI · @williamFalcon

PyTorch Lightning → LitServe → LitData. Add LitMerge? MergeCallback(strategy="dare_ties", gossip=True) — merge distributed training runs on completion. Your researchers train in parallel. They should merge convergently.

@mlflow · @mateiz — Databricks

MLflow Model Registry tracks model versions. crdt-merge adds convergent model composition as a registry operation. mlflow.merge(run_a, run_b, strategy="ties") — logged, versioned, auditable. Your 30K+ enterprise customers do this manually. Automate it.

@ray-project · @anyscale — Ray / Anyscale

Ray distributes compute. crdt-merge distributes convergence. ray.merge() as naturally as ray.remote() — distributed model composition with mathematical guarantees. Every Ray Serve ensemble deployment would benefit.

@modal-labs · @erikbern — Modal

Serverless compute + convergent merging = ephemeral merge workers that spin up, merge, and vanish. Modal's cold-start speed + crdt-merge's sub-second merge = instant model composition as a service.

@replicate · @bfirsh — Replicate

Push-button model deployment. Why not push-button model merging? replicate.merge("stability/sdxl", "custom/sdxl-anime", strategy="slerp") — one API call to a convergent merge. Your model marketplace becomes a model composition marketplace.

@vllm-project · @WoosukKwon — vLLM

PagedAttention revolutionized inference. crdt-merge revolutionizes what you serve. Dynamically merged models served via vLLM — speculative composition + speculative decoding. The inference stack for the merge era.

@ggerganov — llama.cpp / GGUF

llama.cpp runs on everything. crdt-merge + GGUF = merge, quantize, deploy anywhere. crdt_merge → GGUF → llama.cpp — the edge deployment pipeline with convergence guarantees. Your community merges models daily. They deserve correctness.

@iterative — DVC

DVC versions data and models. crdt-merge adds convergent branching and merging for models — dvc merge model-branch-a model-branch-b --strategy=ties. Git branching semantics, but for neural networks. Your "git for ML" vision, completed.

@wandb · @Borgosworth — Weights & Biases

W&B tracks experiments. crdt-merge tracks convergent merges. Every merge logged as a W&B run — strategy, convergence verification, property checks, before/after comparisons. The merge dashboard your platform is missing.

Distributed Systems & Databases — Convergence Is Your Missing Primitive

You've solved consensus. You've solved replication. You've solved sharding. But you haven't solved model merging across distributed nodes. Every database that replicates data could replicate trained models. Every conflict resolution system could resolve parameter conflicts. crdt-merge is the bridge between your infrastructure and the AI era.

Distributed Databases — Your Replication Layer Needs a Merge Brain

CRDT-Native Systems — We Speak Your Language

Message Brokers & Streaming — The Merge Happens in the Stream

Orchestration & Distributed Compute — Convergence as a Workflow Step

Edge CDN & Serverless — Convergence at the Edge

Service Mesh & Infrastructure — The Invisible Convergence Layer

Edge, On-Device & Hardware — Convergence Without Connectivity

@qualcomm · Cristiano Amon

3B+ Snapdragon devices running on-device AI. Models fine-tune locally for personalization. crdt-merge enables peer-to-peer model sync between devices — convergent personalization without cloud dependency. WiFi Direct, Bluetooth mesh, or intermittent connectivity — the math works on any transport.

@samsung — Galaxy AI

Galaxy S series on-device models across 100M+ devices. crdt-merge's delta sync minimizes bandwidth — only changed weights transfer. Galaxy devices that learn locally and converge globally. Samsung's privacy-first AI vision, enabled.

@apple — Core ML / Apple Intelligence

On-device models across 2B+ Apple devices. When iPhone models fine-tune locally with differential privacy, they need to merge back without a central server. crdt-merge's gossip protocol works on-device. Federated Apple Intelligence, no coordinator required.

@NVIDIA · Jensen Huang · @jrhuntsman

You build the hardware. We build the convergence layer. NVIDIA NIM + crdt-merge = convergent model composition as a microservice. Every DGX cluster running distributed training should offer distributed convergent merging. TensorRT optimization + convergent merge = production-grade composed models. The merge SDK for CUDA.

@AMD · Lisa Su

ROCm + crdt-merge = vendor-agnostic convergent merging. Every AMD MI300X customer running distributed workloads needs the same merge guarantees NVIDIA users get. First-mover advantage in the convergent merging ecosystem on AMD silicon.

@intel — Intel Gaudi / OpenVINO

Gaudi accelerators + OpenVINO deployment + crdt-merge convergence. The full Intel AI stack, merge-complete. Edge AI on Intel hardware with convergent model sync across the fleet.

@ARM-software — ARM · Rene Haas

ARM's AI ecosystem spans phones to servers. crdt-merge optimized for NEON/SVE = convergent merging at every scale, from Cortex-M microcontrollers to Neoverse server clusters. The universal merge layer for the universal compute architecture.

Autonomous Systems & Robotics — Safety-Critical Convergence

Tesla · @karpathy · Elon Musk

Millions of vehicles learning from different driving conditions. crdt-merge enables fleet learning without a central server — vehicles merge driving models peer-to-peer at charging stations. Convergence guaranteed. Audit trail for NHTSA. The FSD training pipeline that doesn't need Dojo as a single point of failure.

@waymo-research — Waymo · Dmitri Dolgov

Multi-city autonomous driving. Phoenix model + SF model + Austin model converge regardless of merge order. Safety-critical audit trail included. When regulators ask "how was this model built?", you have the mathematically verified answer.

@BostonDynamics · @figure-ai · @1x-technologies

Robots learning in diverse environments. Each robot learns different manipulation skills. crdt-merge enables skill merging across the fleet — every robot gains every other robot's skills, convergently. The backbone of scalable embodied intelligence.

@chelseafinlab — Chelsea Finn · Stanford, Meta-Learning

MAML and meta-learning create models that adapt quickly. crdt-merge enables convergent meta-model composition — meta-learners from different task distributions merge their adaptation capabilities. Meta-learning at fleet scale.

@sergey-levine — Sergey Levine · UC Berkeley, Robot Learning

Offline RL and real-world robot learning produce models across diverse environments. crdt-merge enables convergent policy merging — robots share learned policies without centralized replay buffers.

Telecommunications — Edge AI at Network Scale

Ericsson · @Ericsson · Nokia · @nokia · Vodafone · @Vodafone

5G edge nodes running AI workloads. crdt-merge enables convergent model sync across cell towers — each tower's model learns local traffic patterns, converges network-wide via gossip. No central orchestrator. The self-organizing network, realized. Vodafone's pan-European operations get GDPR-compliant convergent merging across national boundaries — models merge, data stays sovereign.

️ Defense & Sovereign AI — Convergence in Contested Environments

DARPA · NATO ACT · Five Eyes Alliance

Tactical edge AI with classification constraints. crdt-merge enables convergent model merging across security boundaries — field-level encryption ensures need-to-know. Models converge, secrets don't leak. In contested environments, no coordinator means no single point of failure to target. Coalition AI interoperability with per-nation data sovereignty. crdt-merge's cryptographic remove() and audit trails satisfy the most demanding operational requirements.

Industry Verticals — Every Sector. Every Use Case. One Primitive.

If your industry uses AI models, your industry has the merge problem. The only question is whether you solve it with mathematics or with hope.

Healthcare & Life Sciences

Financial Services

Energy & Climate

Manufacturing & Industry 4.0

Retail & E-commerce

Gaming & Entertainment

️ Legal & Professional Services

Education

Cybersecurity

International AI Initiatives — Sovereign Convergence

The Arithmetic

The Invitation

🚀 Start a Conversation

💬 GitHub Discussions — Open a thread, tag us, propose an integration

📧 chi@optitransfer.ch — Direct line for partnership discussions

⭐ Star the Repo — Signal interest. We notice every star.

👁️ Watch for Updates — First to know when integrations ship

📖 Read the Full Documentation — 25+ guides, architecture deep dives, formal proofs

300+ organizations. 150+ individuals. 18 verticals. 7 distributed systems categories. One unsolved problem. One mathematical solution.

The merge problem is universal. The solution is convergent. The question is: who builds with it first?

Patent: UK Application No. GB 2607132.4, GB2608127.3 · © 2024 Optitransfer · Built in Switzerland

⭐ Star · 👁️ Watch · 💬 Discuss · 📖 Docs · 📐 Architecture · 🚀 Demo

E4 Recursive Trust-Delta Protocol

Trust as a first-class CRDT dimension. Every merge carries cryptographic proof of provenance. E4 activates transparently on import crdt_merge (v0.9.5+).

Why crdt-merge Is Novel & Disruptive

crdt-merge is the first library to apply formal CRDT mathematics to ML model merging, data integration, and multi-agent AI — simultaneously.

No other framework provides all three of these guarantees:

What makes this disruptive:

1. No Parameter Server — Federated model merging without a central coordinator. Teams merge fine-tuned models peer-to-peer with mathematically guaranteed convergence.
2. 26 Merge Strategies — From simple weighted average to DARE-TIES, Fisher-weighted, and novel spectral methods like STAR and SVD Knot Tying — all wrapped in CRDT-compliant OR-Set semantics.
3. Cross-Domain Unification — The same merge() primitive works for DataFrames, ML tensors, agent memory, and knowledge graphs. One theory, one API.
4. Provenance & Compliance Built In — Every merge is auditable, reversible (via CRDT remove()), and GDPR/HIPAA/SOX/EU AI Act compliant by default.
5. Patent (UK Application No. GB 2607132.4, GB2608127.3) -- The mathematical framework for deterministic model merging via CRDTs is a genuine invention, not incremental improvement.

AI & ML Model Merging

Merge fine-tuned models from independent teams — no central server, guaranteed convergence.

Data & Records

Merge distributed DataFrames, resolve conflicts deterministically, query merged data with SQL.

Transport & Sync

Move states between nodes efficiently — gossip, delta sync, Merkle verification.

Agentic & Context

Multi-agent AI systems with convergent shared memory — no message ordering required.

Privacy, Provenance & Compliance

Every merge is auditable, reversible, and regulation-compliant.

️ Architecture & Research

Learning Path

Troubleshooting Guide — common errors and fixes when working with crdt-merge.