Model Merging Applications › Limitations and Practical Considerations

Model merging is a powerful technique with real limitations that deserve serious attention before you commit to a merging strategy for production use.

The most fundamental limitation is that merging cannot recover capabilities that were lost during fine-tuning. When a model is fine-tuned aggressively on a narrow task, the base model's general capabilities can degrade significantly, a phenomenon called catastrophic forgetting that was discussed in the fine-tuning fundamentals chapters. Merging the fine-tuned model back with the base model can restore some of those capabilities, because the base model's weights still contain the general representations. But this only works if the fine-tuned model still contains the relevant intermediate representations, which is not guaranteed when fine-tuning has been severe. A heavily fine-tuned model may have restructured its internal representations so thoroughly that simple interpolation with the base cannot reconstruct the original general-purpose behavior.

The compatibility requirement is strict. All models being merged must share the same architecture and tokenizer. You cannot merge models of different sizes (a 7B model and a 13B model), different attention head configurations (different numbers of heads per layer), or models trained with different tokenizers. The tokenizer constraint is particularly important: even if two models share the same architecture but were trained with different vocabularies, their embedding matrices are not aligned, and merging embedding layers across incompatible vocabularies produces nonsense. This limits merging to the growing but still bounded ecosystem of publicly available fine-tunes of specific popular base models. LLaMA 3, Mistral, and Gemma have the richest merging ecosystems, with hundreds of community fine-tunes available on Hugging Face that can theoretically be combined.

The strict architecture compatibility requirement also means that model merging cannot be used to combine proprietary closed-source models with open fine-tunes. You need access to the raw weight tensors, which closed API-only models do not provide. This positions merging as fundamentally an open-source model technique, at least for now.

Evaluation is hard in a way that training is not. During fine-tuning, loss curves provide continuous feedback about whether the model is improving. During a merging sweep, you get one data point per configuration, and that data point may not reveal all relevant failure modes. Merged models can perform well on standard benchmarks while failing in unexpected ways on production traffic, particularly when the fine-tunes being merged represent somewhat different domains than the evaluation benchmarks. A merged model that scores well on MMLU and HellaSwag may still generate inconsistent outputs on edge-case prompts that activate conflicting representations from the two source models.

Another limitation that is often overlooked is the sensitivity of merging to the fine-tuning hyperparameters of the source models. Two fine-tunes of the same base on the same data with different learning rates will produce task vectors of very different magnitudes. When you merge these, the higher-magnitude task vector will dominate even if you set equal $\lambda$ values, because it contributes larger absolute updates to each parameter. Normalizing task vectors by their L2 norm before merging can mitigate this, but it introduces a new hyperparameter choice and can cause its own artifacts.

Finally, merging is not a substitute for domain-specific fine-tuning when the target task requires knowledge or reasoning patterns absent from all available fine-tunes. Merging recombines what exists in the source models. It does not generate new capabilities from nothing. If no available fine-tune contains examples of reasoning about a specific technical domain, merging fine-tunes from adjacent domains may provide a useful starting point, but it will not achieve the performance that direct fine-tuning on domain-specific data would provide.

Despite these constraints, the practical value of merging is significant. It offers a route to multi-capability models that would cost substantial GPU-hours to train, using only inference-time compute for the merge operation itself. A multi-task merge that combines three fine-tunes into a single model using task arithmetic takes seconds on a standard GPU, while training an equivalent multitask model from scratch might require days. As the ecosystem of fine-tuned models continues to grow, the space of useful merges will expand correspondingly, and the techniques for diagnosing and resolving interference will improve.

Model merging methods continue to change. Recent work has explored learned merging coefficients (where a small optimization loop automatically finds the best $\lambda$ values using a few gradient steps on validation data), structured sparsification approaches that go beyond TIES and DARE, and methods that merge only specific components (attention heads versus feed-forward blocks) rather than all parameters uniformly. These extensions have not yet reached the maturity of the core task arithmetic and TIES approaches, but they represent directions where the field is heading.

Looking ahead, the techniques covered in this chapter and the preceding model compression chapters represent the current state of post-training model manipulation. The next section of the book turns to reasoning: how models can be prompted or trained to exhibit structured, multi-step reasoning, and what the limits of that reasoning are.