When a model merge beats a fine-tune — and how to know which problem you actually have

The problem arrived as a deployment cost complaint, which is usually how the interesting architectural problems arrive. An enterprise finance team had two fine-tuned models in production — one trained on earnings transcripts and financial covenants, one trained on client communication and investor-facing language. Both were good at their jobs. Neither could do the other's. An analyst needed to draft a client memo explaining a DCF analysis, which requires quantitative precision and readable prose in the same output — the kind of thing that feels natural when a skilled analyst writes it and falls apart when piped through two models, because the comms model receives a text string and never sees the intermediate reasoning that produced the numbers. The boundary between the two models destroys exactly the thing the output needed most.

The obvious fix was fine-tuning a single model on both domains — weeks of work and thousands of dollars in GPU compute, for a problem where both required capabilities already existed, in trained form, in two models sharing the same base architecture. That's when merging became worth examining.

Model merging combines the weights of two or more fine-tuned models into a single model — no training, no labelled data, no gradient updates. The intuition starts with task vectors: fine-tuning changes weights relative to the base model, and that difference encodes everything the fine-tuning taught it. Two models fine-tuned from the same base can each be represented as base-plus-task-vector; adding the vectors together and applying the sum produces a model that, in principle, inherits both. In practice it's more complicated — task vectors interfere when two models disagree on the sign of a weight update for the same parameter, and naive averaging cancels the disagreement out, preserving neither specialisation. Mid-to-late transformer layers, where domain-specific representations concentrate, show the highest conflict rates.

Three techniques address the interference problem with increasing sophistication. SLERP interpolates between models geometrically with no explicit interference handling — the simplest merge, and the quality floor. TIES-Merging adds sign conflict resolution, trimming low-magnitude parameters and electing a consensus sign before merging. DARE adds a sparsification step first, zeroing out a fraction of each model's delta parameters before TIES resolves what's left. DARE-TIES, the combination, consistently outperforms either technique alone on domains with significant inter-model interference.

Merging isn't a universal substitute for fine-tuning. It works under four conditions, and the decision to merge should be an explicit check against all of them, not a default.

Shared base architecture. Source models must derive from the same base — same architecture, tokenizer, weight tensor shapes. Hard requirement, not a guideline. Models fine-tuned from different checkpoints can't be merged; they can be fine-tuned jointly or run as a pipeline.

Capabilities that already exist in trained form. Merging combines what exists. It cannot add a capability neither source model has. The merged model's quality ceiling in any domain is bounded by the best source model in that domain — you cannot merge your way above the quality that already exists in your sources.

Domains that are meaningfully orthogonal. Merging works best when specialisations don't compete for the same weight space. Quantitative financial reasoning and client communication prose are genuinely different representations — evidenced by near-zero correlation between their task vectors across transformer blocks. Two models trained on similar domains fight for the same space, and the interference problem gets worse, not better.

The finance team's case satisfied all three: same base checkpoint, both capabilities already existed in trained form, and the domains were orthogonal enough that DARE-TIES preserved both specialisations in a single merged model — at a fraction of the cost and time a joint fine-tune would have required. The decision wasn't "merging is better than fine-tuning." It was recognising which of the two problems was actually in front of us.

Further reading: Yadav, P. et al. (2023). TIES-Merging. NeurIPS. arXiv:2306.01708. · Yu, L. et al. (2023). Language Models are Super Mario (DARE). arXiv:2311.03099. · Ilharco, G. et al. (2023). Editing Models with Task Arithmetic. ICLR. arXiv:2212.04089. · Goddard, C. et al. (2024). Arcee's MergeKit. EMNLP Industry Track. arXiv:2403.13257.