Architectural Paradigms in AI Model Merging: Foundations, Algorithmic Frameworks, and Systems Engineering

Full report

On this page

The development of modern foundation models is constrained by the extreme computational, financial, and environmental costs of training massive networks from scratch.1 To bypass these barriers, model merging has emerged as a major paradigm shift.4 Model merging combines the parameter weights of multiple pre-trained or fine-tuned neural networks into a single cohesive model without undergoing further gradient-based training or backpropagation.4 This paradigm capitalizes on the extensive open-source checkpoint ecosystem, establishing a highly cost-effective mechanism to compose specialized capabilities, improve multi-task generalizability, and mitigate catastrophic forgetting.4 To systematically categorize this rapidly evolving field, researchers have proposed the FUSE taxonomy, which organizes the domain into four interconnected dimensions 4:

• Foundations: The theoretical underpinnings, including loss landscape geometry, linear mode connectivity, and weight-space symmetries.4
• Unification Strategies: The algorithmic space spanning simple weight averaging, task vector arithmetic, sparsification-enhanced methods, mixture-of-experts architectures, and evolutionary optimization.4
• Scenarios: Downstream applications across multi-task learning, safety alignment preservation, domain specialization, and federated learning.4
• Ecosystem: The supporting infrastructure of specialized tools, deployment platforms, and evaluation benchmarks.4

Theoretical Underpinnings of Weight-Space Fusion

The functional coherence of a merged model depends on the structural topology of deep neural network loss landscapes and the geometric relationships between independently trained parameters.4

Model A (Optimized Basin) \\ \\ \<- Low-Loss Convex Path \\ Pretrained Base (θ0) ──── Merged Model (θ\_merged) / / \<- Linear Mode Connectivity / Model B (Optimized Basin)

Linear Mode Connectivity and Loss Landscapes

Linear Mode Connectivity (LMC) posits that if two neural networks share a common optimization trajectory—specifically, if they are fine-tuned from a shared pretrained initialization—they will reside within the same local loss basin.5 Under these conditions, the loss landscape behaves in an approximately convex manner along the linear interpolation path connecting the two models.5 Given two parameter sets [Figure omitted from source export] and [Figure omitted from source export] optimized from a shared parent checkpoint [Figure omitted from source export], any intermediate interpolation defined by: $$\\theta(\\lambda) \= (1 \- \\lambda)\\theta\_A \+ \\lambda\\theta\_B, \\quad \\lambda \\in $$ maintains a low loss value, effectively bypassing the high-loss barriers that typically degrade a model's functional output when merging independently initialized weights.5 This phenomenon underpins basic linear weight-averaging strategies and ensures that the model can integrate knowledge without undergoing representational collapse.4 This connectivity is highly evident in major open-weight families such as LLaMA, Mistral, Qwen, DeepSeek, Gemma, and CLIP, where fine-tuned variants tend to cluster within consistent geometric regions.5

Symmetries and Frank-Wolfe Optimization

When neural networks are trained from different random initializations, naive weight averaging fails, collapsing the network's output to random predictions.14 This collapse occurs due to the permutation invariance inherent in neural network architectures.14 Permuting the order of hidden units (neurons or attention heads) in a layer, while applying the corresponding inverse permutation to the adjacent weight matrix, preserves the model's overall mathematical mapping.12 However, this permutation symmetry creates a high-dimensional space of equivalent optima, meaning that independently initialized models converge to functionally similar but geometrically disjoint basins in weight space.11 To reconcile these structurally divergent models, alignment frameworks seek to canonicalize model parameters before merging.12 Traditional re-basining techniques align weights to a single, arbitrarily chosen reference model, introducing bias and sub-optimal alignment for multi-model merges.8 To address this, the [Figure omitted from source export] (cycle-consistent merging) algorithm employs Frank-Wolfe optimization to align collections of networks into a shared, reference-free parameter space.8 This approach establishes an unbiased, canonical aggregation point, making weight averaging meaningful without privileging any individual model as the anchor.8

Pre-Merging and Alignment Methodologies

The pre-merging phase focuses on establishing optimal structural and statistical conditions before parameter blending.18 This involves aligning coordinate spaces, performing architectural transformations, and mitigating statistical divergence.18

Coordinate Space Alignment and PLeaS

While re-basining algorithms function effectively when merging models of identical widths, they struggle when practitioners attempt to merge models of varying sizes or those fine-tuned from different base checkpoints.20 The PLeaS (Permutations and Least Squares) algorithm relaxes these structural constraints through a two-stage alignment pipeline.20 In the first stage, PLeaS utilizes the permutation symmetries of the networks to partially match nodes in each layer, maximizing feature alignment and identifying similar representations.20 In the second stage, the algorithm solves a layer-wise Least Squares optimization problem, forcing each layer of the merged model to mimic the permuted ensemble of features from the corresponding layers of the original models.20 This approach provides the flexibility to merge models trained on different initializations and allows the resulting merged model to have a customized width tailored to specific hardware resource constraints.20

Activation Variance Collapse

Even when coordinate spaces are aligned, deeper architectures frequently suffer from variance collapse when weight-averaged.14 Because weights are averaged, the variance of the pre-activations in the merged model's intermediate layers drops significantly compared to the parent models.14 In deep networks, this reduction in variance accumulates multiplicatively across layers, rendering the activations in the final layers nearly constant and stripping the network of its discriminative capacity.14 The REPAIR (REnormalizing Permuted Activations for Interpolation Repair) method resolves this issue by introducing post-merging normalization.14 REPAIR calculates the empirical activation statistics (mean and variance) of the original models on a small forward-pass calibration dataset and rescales the weight matrices or inserts batch normalization layers to restore variance to its optimal level.14 This modification successfully compresses the interpolation loss barrier, enabling successful merging across models initialized from different starting points.14

Parameter-Space Unification Strategies

During the merging phase, parameter updates are synthesized using algebraic, geometric, or sparsification techniques designed to resolve representation conflicts.18

Spherical Linear Interpolation

Linear interpolation (LERP) draws a straight line between two parameter vectors.25 In high-dimensional deep learning weight spaces, this straight path often cuts through regions of high loss, distorting the magnitude and directional composition of the parameters.23 Spherical Linear Interpolation (SLERP) mitigates this by interpolating along the geodesic curve of a spherical manifold, thereby preserving the geometric properties and norm distribution of the individual models.23 Given two normalized weight vectors [Figure omitted from source export] and [Figure omitted from source export] and an interpolation factor $t \\in $: First, the initial angle [Figure omitted from source export] between the vectors is computed using their dot product: [Figure omitted from source export] The angle at a given timestep [Figure omitted from source export] is defined as: [Figure omitted from source export] The scale factors [Figure omitted from source export] and [Figure omitted from source export] are then calculated: [Figure omitted from source export] Finally, the interpolated parameter vector is obtained by combining the scaled vectors: [Figure omitted from source export] If the vectors are nearly collinear ([Figure omitted from source export]), the algorithm defaults to standard LERP to bypass numerical instability.23

Task Arithmetic

Task Arithmetic treats fine-tuned weights as directional updates relative to their base model.17 By defining a "task vector" [Figure omitted from source export] as the parameter delta between the fine-tuned model [Figure omitted from source export] and the shared pre-trained base model [Figure omitted from source export] 17: [Figure omitted from source export] capabilities can be composed linearly in weight space.17 The merged model is constructed by scaling and adding these vectors back to the base architecture 23: [Figure omitted from source export] where [Figure omitted from source export] represents a scaling term controlling the strength of the injected task vector.23 This framework also allows for negation: subtracting a task vector (e.g., [Figure omitted from source export]) can actively purge unwanted behaviors or domain knowledge from the network.23 Under standard optimization assumptions, task vectors behave as approximate gradients, explaining both their effectiveness and their limitations when scaling to many distinct tasks.8

TIES-Merging (Trim, Elect Sign, and Merge)

As the number of combined task vectors scales, direct summation leads to significant parameter interference.25 Conflicting updates (e.g., one model increases a weight parameter while another decreases it) zero out functional updates, causing severe degradation in performance.25 TIES-Merging addresses this via a three-stage pipeline 24:

[Figure omitted from source export]

1. Trim: Identifies and retains only the top\-[Figure omitted from source export] most significant changes (by absolute magnitude) in each task vector [Figure omitted from source export], resetting the bottom [Figure omitted from source export] changes to zero to discard redundant parameter updates.24
2. Elect Sign: Resolves direction conflicts across different task vectors.24 It computes a unified sign vector [Figure omitted from source export] based on the dominant direction of change. For each parameter position [Figure omitted from source export], the algorithm calculates the sum of positive and negative updates across all models, selecting the sign with the greater cumulative magnitude 24:
3. Disjoint Merge: Computes the arithmetic mean of only those non-zero parameter updates that align with the elected sign [Figure omitted from source export], completely ignoring opposing values to eliminate destructive interference.24

DARE (Drop and Rescale)

DARE is an advanced sparsification technique that can act as a standalone merging strategy or as a pre-processing module (e.g., paired with TIES' sign election as dare\_ties).23 DARE stems from the observation that the vast majority of fine-tuned weight updates are highly redundant and can be aggressively pruned without affecting downstream performance.23 Given a drop rate $p \\in $ (often exceeding [Figure omitted from source export] or even [Figure omitted from source export]), DARE processes the delta parameter vectors [Figure omitted from source export] through two operations 23: First, a random Bernoulli mask is applied to set a proportion [Figure omitted from source export] of the weight updates to zero, effectively reverting them to the base model's values 23: [Figure omitted from source export] [Figure omitted from source export] Second, the remaining active delta values are rescaled by a factor of [Figure omitted from source export] to ensure the expected output of the neural network layers remains mathematically consistent with the original unpruned models 23: [Figure omitted from source export] These rescaled delta parameters are subsequently aggregated and added back to the pre-trained weights.23 DARE's implementation also supports magnitude-based pruning (MAGPRUNE), where the drop probability [Figure omitted from source export] is inversely proportional to parameter magnitude, ensuring that the most influential updates are preserved.26

Advanced Adaptive and Evolutionary Orchestration

To move beyond the constraints of static, human-engineered merging heuristics, recent architectures integrate dynamic low-rank routing and gradient-free evolutionary algorithms.2

Task Singular Vectors

Because task vectors behave as approximate gradients, and gradients are known to exhibit low-rank properties, task vectors inherit this low-rank structure.8 Task Singular Vectors (TSV) formalize this property by applying singular value decomposition (SVD) directly to the task-specific weight updates.8 By decomposing the delta weight matrix into its principal singular components: [Figure omitted from source export] TSV-Merge stores only the most salient singular components for each task.8 This mathematical representation enables both extreme model compression and significant interference reduction, establishing a cleaner, coordinate-aligned subspace for multi-task blending.8

Input-Adaptive Subspace Selection

A key limitation of standard merging methods is that their aggregation step is strictly static: the final merged parameters are fixed at compile time, regardless of the input encountered during inference.32 MASS (MoErging through Adaptive Subspace Selection) resolves this limitation by coupling model merging with the dynamic routing capabilities of Mixture-of-Experts (MoE) architectures.31

Input Tokens (x) ────\> First-Pass Forward Run (Extract intermediate features) │ ▼ Non-Parametric Router (Space Projection) │ ▼ Dynamic Activation of Low-Rank Task Subspaces │ ▼ Second-Pass Forward Run (Inference)

At test time, MASS performs input-adaptive merging using a projection-based, data-free router.32 The router projects intermediate activation features onto the subspaces defined by each task's TSV, identifying which combination of task subspaces best explains the current input without requiring task-specific data or additional fine-tuning.32 A thresholded gating function [Figure omitted from source export] then dynamically integrates the selected task-specific components.32 This procedure is training-free, introduces only a two-pass inference overhead, and requires a minimal [Figure omitted from source export] storage footprint relative to a single model, yet recovers up to [Figure omitted from source export] of the average accuracy of separate, fully ensembled expert models.31

Evolutionary Optimization and M2N2

Evolutionary Model Merging automates the search for optimal merge recipes by treating layers and parameters as genetic material.2 This framework optimizes merges across two distinct spaces:

• Data Flow Space (DFS): Learns how to stack, repeat, or skip layers from different parent models to create new macro-architectures.30 To prevent variance mismatch when stacking non-adjacent layers, input activations are multiplied by scale parameters [Figure omitted from source export] optimized via evolutionary paths.30
• Parameter Space (PS): Blends the weight matrices of parent models layer-by-layer using continuous coefficients optimized via CMA-ES.30

While traditional evolutionary merging is used to combine existing pre-trained checkpoints, the M2N2 (Model Merging Neural Network) framework demonstrates that evolutionary merging can evolve highly capable networks entirely from scratch.1 M2N2 automates and optimizes the parameter partitioning process during evolution, offering a gradient-free approach that avoids catastrophic forgetting and remains compatible across models trained on completely different objectives.1 To drastically reduce the evaluation cost of evolutionary searches, the [Figure omitted from source export] framework integrates Item Response Theory (IRT).8 By modeling the difficulty of test questions and the latent ability of candidate models, IRT enables the evolutionary search to evaluate candidate merges on highly representative subsets of benchmarks, slashing evaluation costs by up to [Figure omitted from source export] while preserving the quality of the final solution.8

Systems Engineering and Resource Optimization

The practical execution of complex, multi-model merges requires robust hardware planning and memory management.27 The library mergekit serves as the industry-standard toolkit, utilizing an out-of-core architecture to stream and process models tensor-by-tensor under extreme hardware constraints.27

Out-of-Core Architecture and Memory Management

mergekit handles resource-constrained situations by building an execution plan graph (graph.py) that processes models tensor-by-tensor rather than loading entire architectures into memory.38 By combining \--lazy-unpickle with \--allow-crimes, practitioners can execute elaborate merges on highly consumer-grade hardware.24 Additionally, mergekit performs automated "tokenizer surgery" to reconcile mismatched vocabularies.38 When a tokenizer source is configured (e.g., a union of all vocabularies), the embedding matrix of each input model is adjusted to match the output vocabulary before parameter blending.38 Missing token embeddings are imputed using a hierarchical fallback heuristic:

Does the base model have the token? ├── Yes ──\> Use base model's embedding └── No │ Does only one model have the token? ├── Yes ──\> Use that model's embedding └── No ──\> Use average of all available embeddings

The merge method (SLERP, TIES, etc.) then combines these aligned embedding matrices to produce the final, vocabulary-consistent output.38

Empirical Realities, Vulnerability Vectors, and Defenses

Despite the theoretical promise of model merging, systematic empirical evaluations have uncovered critical performance gaps, security vulnerabilities, and licensing conflicts.7

The "In-the-Wild" Performance Gap

A large-scale, systematic evaluation conducted on open-weight LLMs (including Llama2, Gemma2, and Mistral) across sixteen standard benchmarks investigated the viability of "in-the-wild" model merging.13 This setup evaluated merging heterogeneous expert models that were not designed to harmonize, often possessing overlapping or conflicting objectives.13 The study revealed a critical performance gap: sophisticated, interference-aware, and subspace-based merging methods (such as TIES and DARE) typically fail to produce notable improvements over the base model, frequently resulting in significant performance drops.13 Among all six evaluated merging methods, Task Arithmetic was the only approach that reliably and consistently yielded performance gains and constructive interference on LLMs.13 This occurs because modern, highly overparameterized LLMs construct diffuse, highly coupled representations.13 Forcing hard parameter pruning or rigid sign consensus (as in TIES or DARE) disrupts these delicate, distributed pathways.13 Task Arithmetic, by preserving the raw, unpruned weight updates, behaves as a smoother gradient approximation, proving far more robust to unaligned, real-world model distributions.13

Security Vectors and Proactive Weight Protection

Because model merging synthesizes parameters directly in weight space without data validation, it exposes a critical supply-chain and intellectual property attack surface 7:

• Model Merging Stealing: Free-riders can download fine-tuned models released under restrictive, non-commercial licenses (e.g., CC BY-NC-ND 4.0) and merge them to create multi-capability models for commercial redistribution.42 Because parameter blending conceals the provenance of individual weights, traditional watermarking and fingerprinting techniques are easily rendered ineffective.42
• Trojan and Poisoning Exploits: Attackers can construct targeted backdoor perturbations that preserve source model safety through directional consistency constraints.46 When merged with other models, these dormant task vectors constructively align to form pre-computed activation paths, triggering catastrophic safety degradation (e.g., increasing harmful response rates from [Figure omitted from source export] to [Figure omitted from source export]) in the final merged model.46
• Proactive Weight Protection (MergeGuard & MergeBarrier): To defend model ownership, researchers have developed proactive defense frameworks that preprocess parameters to disrupt merging compatibility while maintaining task fidelity.42 MergeBarrier actively eliminates the linear mode connectivity between a protected model and its homologous counterparts, preventing the establishment of a low-loss interpolation path.42 MergeGuard employs PaRaMS (Parameter Rearrangement and Multi-head Scaling), which reorders MLP parameters and randomly scales attention heads.45 This maintains functional equivalence in the target model but pushes it completely out of the shared parameter basin with other models, causing the accuracy of any subsequently merged model to immediately degrade to single digits.45

Licensing and Regulatory Compatibility

The legal feasibility of model merging depends on license compatibility—the feasibility of combining code or weights from multiple programs such that the resulting work fulfills the terms of every original license without violation.48 The software and machine learning ecosystem commonly mixes highly permissive licenses (such as MIT, Apache 2.0, or BSD) with copyleft-style licenses (such as GPL) and Responsible AI Licenses (RAILs), which impose explicit down-stream usage restrictions.48 Because RAILs include usage constraints, they are fundamentally incompatible with GPL or copyleft licenses, which strictly forbid the imposition of any additional restrictions.48 Merging models with incompatible licenses risks severe copyright and intellectual property violations, mimicking the legal complexities found in traditional software integration.42 To avoid compounding these legal hurdles, major tooling providers have actively streamlined their software compliance.50 For example, Arcee.ai returned the mergekit library to the highly permissive GNU Lesser General Public License v3 (LGPL v3) after briefly experimenting with the restrictive Business Source License (BSL).50 This transition eliminated licensing friction, allowing developers to freely integrate the merging pipeline into commercial and proprietary applications.50

Conclusions

Model merging represents a powerful, training-free paradigm for composing specialized capabilities directly in the weight space of deep neural networks.4 Its theoretical foundations—grounded in linear mode connectivity, loss landscape geometry, and permutation symmetries—explain its capacity to combine knowledge without the massive overhead of retraining or joint fine-tuning.4 However, systematic empirical evidence demonstrates that sophisticated, static sparsification techniques often fail when applied to complex, heterogeneous LLMs in the wild, leaving the simpler Task Arithmetic as the most reliable baseline for weight-space fusion.13 As the field matures, the architectural focus is shifting toward dynamic, input-adaptive routing mechanisms like MASS, which bridge the gap to full ensembling, alongside proactive protection frameworks like MergeGuard to secure intellectual property in an increasingly open-source landscape.31

Works cited

1. Competition and Attraction Improve Model Fusion \- arXiv, accessed June 25, 2026, https://arxiv.org/html/2508.16204v1
2. Evolutionary Model Merging Explained: Automating AI Development | Hassan Almalki, accessed June 25, 2026, https://almalki.sa/en/articles/evolutionary-model-merging
3. Arcee's MergeKit: A Toolkit for Merging Large Language Models \- arXiv, accessed June 25, 2026, https://arxiv.org/html/2403.13257v3
4. \[2603.09938\] Model Merging in the Era of Large Language Models: Methods, Applications, and Future Directions \- arXiv, accessed June 25, 2026, https://arxiv.org/abs/2603.09938
5. Model Merging in the Era of Large Language Models: Methods, Applications, and Future Directions \- arXiv, accessed June 25, 2026, https://arxiv.org/html/2603.09938v1
6. Model Merging in the Era of Large Language Models: Methods, Applications, and Future Directions \- arXiv, accessed June 25, 2026, https://arxiv.org/pdf/2603.09938
7. fineset-io/model-merging-papers · Datasets at Hugging Face, accessed June 25, 2026, https://huggingface.co/datasets/fineset-io/model-merging-papers/viewer
8. DONATO CRISOSTOMI | INFORMATICA \- SAPIENZA, accessed June 25, 2026, https://phd.uniroma1.it/web/DONATO-CRISOSTOMI\_nT1754001\_IT.aspx
9. Model Merging in the Era of Large Language Models Methods, Applications, and Future Directions \- arXiv, accessed June 25, 2026, https://arxiv.org/html/2603.09938v2
10. Daily Papers \- Hugging Face, accessed June 25, 2026, https://huggingface.co/papers?q=merging%20coefficient%20tuning
11. Git Re-Basin: Merging Models modulo Permutation Symmetries \- GitHub, accessed June 25, 2026, https://github.com/samuela/git-re-basin
12. GIT RE-BASIN: MERGING MODELS MODULO PERMU- TATION SYMMETRIES, accessed June 25, 2026, https://personalrobotics.cs.washington.edu/publications/ainsworth2023gitrebasin.pdf
13. A Systematic Study of In-the-Wild Model Merging for Large Language Models \- arXiv, accessed June 25, 2026, https://arxiv.org/html/2511.21437v2
14. Vanishing Feature: Diagnosing Model Merging and Beyond \- GitHub, accessed June 25, 2026, https://raw.githubusercontent.com/mlresearch/v280/main/assets/qu25a/qu25a.pdf
15. Vanishing Feature: Diagnosing Model Merging and Beyond \- arXiv, accessed June 25, 2026, https://arxiv.org/html/2402.05966v3
16. Git Re-Basin: Canonical Model & Code Merging \- Emergent Mind, accessed June 25, 2026, https://www.emergentmind.com/topics/git-re-basin
17. \[2605.01580\] Model Merging: Foundations and Algorithms \- arXiv, accessed June 25, 2026, https://arxiv.org/abs/2605.01580
18. Model Merging in LLMs, MLLMs, and Beyond: Methods, Theories, Applications and Opportunities \- arXiv, accessed June 25, 2026, https://arxiv.org/html/2408.07666v5
19. \[PDF\] Git Re-Basin: Merging Models modulo Permutation Symmetries | Semantic Scholar, accessed June 25, 2026, https://www.semanticscholar.org/paper/Git-Re-Basin%3A-Merging-Models-modulo-Permutation-Ainsworth-Hayase/a9e20180153f6c139a4b6f2791b535fa6ffc3959
20. CVPR Poster PLeaS \- Merging Models with Permutations and Least Squares, accessed June 25, 2026, https://cvpr.thecvf.com/virtual/2025/poster/33794
21. Beyond Fine-Tuning: Merging Specialized LLMs Without the Data Burden \- Medium, accessed June 25, 2026, https://medium.com/data-science/beyond-fine-tuning-merging-specialized-llms-without-the-data-burden-1c449c2060c4
22. REnormalizing Permuted Activations for Interpolation Repair \- OpenReview, accessed June 25, 2026, https://openreview.net/forum?id=gU5sJ6ZggcX¬eId=f\_X0OhkwCQ
23. An Introduction to Model Merging for LLMs | NVIDIA Technical Blog, accessed June 25, 2026, https://developer.nvidia.com/blog/an-introduction-to-model-merging-for-llms/
24. Merge Large Language Models with mergekit \- Hugging Face, accessed June 25, 2026, https://huggingface.co/blog/mlabonne/merge-models
25. A brief analysis of automerger data, feat. SLERP and DARE-TIES LLM merging, accessed June 25, 2026, https://huggingface.co/blog/kgourgou/a-first-look-at-automerger-data
26. Papers Explained Review 13: Model Merging | by Ritvik Rastogi \- Medium, accessed June 25, 2026, https://ritvik19.medium.com/papers-explained-review-13-model-merging-d0db49797b90
27. Mergekit Model Merging | Guides \- Clore.ai, accessed June 25, 2026, https://docs.clore.ai/guides/training/mergekit
28. TIES-Merging: Resolving Interference When Merging Models \- arXiv, accessed June 25, 2026, https://arxiv.org/pdf/2306.01708
29. Paper Review TIES-MERGING: Resolving Interference When Merging Models \- Medium, accessed June 25, 2026, https://medium.com/@kimseongu15/paper-review-ties-merging-resolving-interference-when-merging-models-88581ee56557
30. Understanding Sakana.ai's Evolutionary Model Merging | Paper Notes, accessed June 25, 2026, https://en.bioerrorlog.work/entry/sakana-ai-model-merging-paper
31. MASS: MoErging through Adaptive Subspace Selection \- NeurIPS 2026, accessed June 25, 2026, https://neurips.cc/virtual/2025/127204
32. MASS: MoErging through Adaptive Subspace Selection \- arXiv, accessed June 25, 2026, https://arxiv.org/html/2504.05342v1
33. \[2504.05342\] MASS: MoErging through Adaptive Subspace Selection \- arXiv, accessed June 25, 2026, https://arxiv.org/abs/2504.05342
34. Publications of the month \- April 2026 \- 3IA Côte d'Azur \- Interdisciplinary Institute for Artificial Intelligence, accessed June 25, 2026, https://3ia.univ-cotedazur.eu/publications-of-the-month-april-2026
35. Evolutionary Model Merging: How Sakana AI is Changing AI Development \- Feed | Aipo, accessed June 25, 2026, https://www.spaces.aiponetwork.com/c/machine-deeplearning/evolutionary-model-merging-how-sakana-ai-is-changing-ai-development
36. Evolutionary Optimization of Model Merging Recipes \- arXiv, accessed June 25, 2026, https://arxiv.org/html/2403.13187v1
37. Sakana AI Evolutionary Model Merging Guide \- AI Understanding, accessed June 25, 2026, https://aiunderstanding.org/ig/learn/sakana-ai-evolutionary-model-merging
38. arcee-ai/mergekit: Tools for merging pretrained large language models. \- GitHub, accessed June 25, 2026, https://github.com/arcee-ai/mergekit
39. \[2403.13257\] Arcee's MergeKit: A Toolkit for Merging Large Language Models \- arXiv, accessed June 25, 2026, https://arxiv.org/abs/2403.13257
40. Arcee's MergeKit: A Toolkit for Merging Large Language Models \- arXiv, accessed June 25, 2026, https://arxiv.org/html/2403.13257v2
41. \[2511.21437\] A Systematic Study of In-the-Wild Model Merging for Large Language Models, accessed June 25, 2026, https://arxiv.org/abs/2511.21437
42. Do Not Merge My Model\! Safeguarding Open-Source LLMs Against Unauthorized Model Merging, accessed June 25, 2026, https://ojs.aaai.org/index.php/AAAI/article/view/40433/44394
43. A Systematic Study of In-the-Wild Model Merging for Large Language Models \- MCML, accessed June 25, 2026, https://mcml.ai/publications/hga26/
44. A Systematic Study of Model Merging Techniques in Large Language Models \- arXiv, accessed June 25, 2026, https://arxiv.org/html/2511.21437v1
45. Defending Unauthorized Model Merging via Dual-Stage Weight Protection \- CVF Open Access, accessed June 25, 2026, https://openaccess.thecvf.com/content/CVPR2026/papers/Chen\_Defending\_Unauthorized\_Model\_Merging\_via\_Dual-Stage\_Weight\_Protection\_CVPR\_2026\_paper.pdf
46. When Safe Models Merge into Danger: Exploiting Latent Vulnerabilities in LLM Fusion, accessed June 25, 2026, https://arxiv.org/html/2604.00627v1
47. Defending Unauthorized Model Merging via Dual-Stage Weight Protection \- arXiv, accessed June 25, 2026, https://arxiv.org/html/2511.11851v3
48. License compatibility \- Grokipedia, accessed June 25, 2026, https://grokipedia.com/page/License\_compatibility
49. License compatibility \- Wikipedia, accessed June 25, 2026, https://en.wikipedia.org/wiki/License\_compatibility
50. Mergekit Returns To Its Roots \- Arcee AI, accessed June 25, 2026, https://www.arcee.ai/blog/mergekit-returns-to-its-roots