Skip to main content
MICHIEL HORSTMAN
BOOK A CALL ↗

Model Merging for Dummies: Combine LLMs Without Training

Model MergingTIES-MergingDARESLERPTask VectorsAIMLLM
Model Merging for Dummies: Combine LLMs Without Training

Model Merging for Dummies: Combine LLMs Without Training

A practical guide to combining LLMs without retraining, covering SLERP, Task Vectors, Model Soups, and Activation-Informed Merging.

Model merging combines multiple fine-tuned LLMs into a single model without additional training. You have fine-tuned one LLM for code generation, another for summarization, and a third for math. What if you could combine them into one model without training anything from scratch?

That is what model merging does. It is like taking three different experts, averaging their knowledge, and getting someone who understands all three fields.

The approach is gaining traction. A March 2026 survey on arXiv shows model merging methods now apply to everything from large language models to multi-modal systems. Methods like TIES-Merging (Yadav et al. 2023) enable over 90% performance retention when merging models fine-tuned from the same base.

Let us walk through this step by step.

Why Merge Instead of Fine-Tuning?

Think of traditional fine-tuning like specialization. You train a general-purpose model to become an expert in one domain, but it forgets what it knew about everything else. This is catastrophic forgetting. If you are new to fine-tuning, read LoRA Fine-Tuning for Dummies for the foundations.

Model merging solves this by letting you:

  • Combine expertise from models fine-tuned for different tasks without retraining
  • Preserve generalization by keeping the base model's broad knowledge while adding specialized capabilities
  • Reduce computation by eliminating expensive full-model training
  • Enable rapid iteration by fine-tuning, merging, and testing in hours instead of weeks

Merging introduces its own challenges: interference between conflicting knowledge, degradation of nuanced capabilities, and the risk of creating a jack-of-all-trades that is master of none.

Model merging avoids catastrophic forgetting by combining specialized fine-tunes without retraining, preserving both breadth and depth.

What Are You Actually Combining When You Merge Models?

Before diving into techniques, understand what you are actually combining:

  • Weights: The numerical parameters that define model behavior
  • Embeddings: Vector representations of tokens that capture semantic meaning. For a deeper look, see Vector Databases for Dummies.
  • Activations: Internal representations the model computes during forward pass

Different merging techniques operate on different components. Some merge weights directly. Others combine embeddings. Recent approaches merge activation spaces.

The AIM paper (NeurIPS 2025) shows that considering activation-space information during merging provides substantial advantages, with experiments demonstrating up to 40% performance improvements over traditional weight-space methods.

Where in the representation space you merge matters as much as what the representation contains.

How Does SLERP Model Merging Work?

What it is: Take two models and average their weights: W_merged = 0.5 x W_model1 + 0.5 x W_model2. Spherical linear interpolation in high-dimensional space. Simple, fast, and surprisingly effective when models are closely related or fine-tuned from similar checkpoints.

When to use it:

  • Models fine-tuned from the same base model
  • Similar training objectives
  • Quick prototypes or experiments

Limitations:

  • Can degrade performance if models are too different
  • Simple averaging is not always optimal

A November 2025 study shows that SLERP merging consistently recovers base-model structure while retaining most task gains.

SLERP is often enough for simple use cases, but production systems usually need more sophistication.

What Is Model Soup Merging?

What it is: More sophisticated averaging that handles multiple models with different importance weights. Instead of equal 0.5/0.5 split, you learn optimal weights: W_merged = w1 x W_model1 + w2 x W_model2 + w3 x W_model3

When to use it:

  • Combining more than two models
  • Some models are more important than others
  • You want data-driven merging decisions

Limitations:

  • Requires validation set to determine optimal weights
  • Does not solve interference between conflicting knowledge
  • Computational overhead grows with number of models

Model soups extend linear interpolation with learnable weights, offering more flexibility at minimal additional complexity.

How Do Task Vectors Work for Model Merging?

What it is: Instead of merging weights directly, compute the difference between fine-tuned and base model (task vector), then add that to new base models.

How it works: Task_vector = W_finetuned - W_base. Then W_new = W_base + Task_vector

When to use it:

  • You want to apply the same task to different base models
  • Transfer learning scenarios
  • Rapid adaptation to new domains

Limitations:

  • Assumes linearity of task changes
  • Does not always transfer well across very different architectures
  • Sensitive to base model choice

Task vectors let you extract the "difference" a fine-tune makes and apply it to any compatible base model.

What Is Task Arithmetic in Model Merging?

What it is: Add or subtract task vectors to combine or remove capabilities.

How it works: W_math = W_base + Task_vector_coding + Task_vector_reasoning

When to use it:

  • Combining multiple distinct capabilities
  • Removing unwanted behaviors (negative task vectors)
  • Complex multi-skill models

Limitations:

  • Assumes task vectors are independent (they are often not)
  • Interference between tasks can cause degradation
  • Requires careful balancing of vector magnitudes

Task arithmetic opens interesting possibilities, but interference between task vectors makes this more challenging than theory suggests.

What Is Frankenstein Model Merging?

What it is: Combine different layers from different models — take encoder from one, decoder from another, middle layers from a third.

How it works: Carefully match layer dimensions and architectures, then stitch components together.

When to use it:

  • Models have compatible architectures
  • Each component is clearly superior in one area
  • You want architectural innovation through combination

Limitations:

  • Extremely brittle — small mismatches cause failures
  • Requires deep understanding of model architecture
  • Hard to maintain performance consistency

Frankenstein merging is where most teams fail. The engineering complexity often overwhelms any theoretical benefits.

What Is Activation-Informed Merging (AIM)?

What it is: The NeurIPS 2025 breakthrough that considers activation-space information during merging to improve performance and robustness.

How it works: AIM integrates information from the activation space of LLMs into the merging process, using a task-agnostic calibration set to selectively prioritize essential weights.

When to use it:

  • Production systems where performance matters
  • Models trained on different domains
  • When traditional merging methods show inconsistent results

Benefits:

  • Significantly enhances performance over weight-space methods
  • More robust to distribution shifts
  • Flexible — applicable to any existing merging algorithm

The AIM paper demonstrates consistent improvements across multiple benchmarks, with up to 40% performance gains in certain settings.

AIM considers activation-space information during merging, delivering up to 40% performance improvements over traditional weight-space methods.

When Should You Use Model Merging?

Great for:

  • Combining models fine-tuned from the same base
  • Multi-task systems where tasks are related
  • Rapid prototyping and experimentation
  • Domain adaptation without full retraining

Challenging for:

  • Models with fundamentally different architectures
  • Conflicting knowledge bases
  • Tasks requiring nuanced, subtle understanding
  • Safety-critical applications where reliability is paramount

Merging works well for combining coding and reasoning capabilities. It struggles with nuanced domains where subtle differences matter. For complementary reading, see Advanced RAG for Dummies.

Model merging excels at combining related capabilities but struggles with conflicting knowledge and safety-critical applications.

My Take

Model merging is one of the highest-leverage techniques in AI right now — no training required, no GPU hours, just smart averaging of existing work. The field is moving fast enough that the question is not whether you should merge, but which technique fits your use case first.


Full code examples and implementation details are available on GitHub.

Image Suggestions

  1. Model merging architecture diagram — A flowchart showing multiple fine-tuned models feeding into a merging algorithm that produces a single merged model. Alt text: "Diagram showing how model merging combines multiple fine-tuned LLMs into one unified model without additional training."

  2. Technique comparison table — A visual comparison of SLERP, Model Soups, Task Vectors, Task Arithmetic, Frankenstein, and AIM across complexity, data requirements, and performance. Alt text: "Comparison chart of six model merging techniques showing tradeoffs between complexity, data requirements, and performance gains."

  3. Task vector visualization — A 2D illustration showing task vectors as arrows from base model to fine-tuned models, with merged results as vector sums. Alt text: "Visualization of task vectors showing how fine-tuned model weights are subtracted from base model weights and added to new base models for transfer learning."

SEO Metadata

SEO Title: Model Merging for Dummies: Combine LLMs Without Training Meta Description: Combine multiple fine-tuned LLMs into one model without retraining. A practical guide to SLERP, Task Vectors, Model Soups, and AIM merging techniques. Primary Keyword: model merging Secondary Keywords: LLM merging techniques, SLERP model merging, task vectors, model soups, activation-informed merging

Back to all posts

Surface. Thanks for diving.

Shark model by alextkd2003, CC BY, converted to ASCII.