Base Models vs Instruct Models vs Chat Models

“The model” usually names one of three different things. They share an architecture and most of their weights, and they behave so differently that swapping one for another without changing your prompt format will produce output that looks like a bug.

Three stages, three artefacts

Training runs in stages, and a checkpoint can be published after any of them.

The distinction is not a marketing gradient. Each stage changes what the same prompt does.

What a base model does

Give a base model “What is the capital of France?” and a plausible continuation is another question, because in the training corpus a question is very often followed by more questions — it is a quiz page, an interview transcript, an exam paper. The model is not failing. It is doing exactly the job in the definition: continuing the text.

What base models are good at is completion in the literal sense. Code autocomplete in an editor, filling a templated document, continuing a style from a long example, computing perplexity over candidate text. They also respond well to few-shot prompting formatted as pure pattern — three input/output pairs and then a fourth input with nothing after it, which the model completes because completion is all it does.

They are also the starting point if you intend to teach behaviour yourself. Fine-tuning an already-chat-tuned model means fighting the preferences it was given; training from a base checkpoint means the only behaviour it has is the behaviour you supply.

Instruct: supervised fine-tuning

Supervised fine-tuning shows the model many examples of an instruction followed by a good response, and continues next-token training on them. The knowledge does not change materially. What changes is the distribution over formats: after SFT, the highest-probability continuation of a question is an answer rather than another question.

It is worth being clear about how small the change is in one sense and how large in another. SFT typically touches a tiny fraction of the tokens the base model saw, and it is enough to make the model usable — which tells you that the capability was already there and that instruction tuning is mostly about eliciting it in the right shape. The same observation is why fine-tuning teaches format far more readily than knowledge. The system prompt is an artefact of this stage too: a base model has no concept of a privileged instruction that outranks the rest of the text. The notion that one span of the sequence governs the others is taught, first by the examples in supervised fine-tuning and then by the preference stage. That is worth holding on to when reasoning about system prompts — their authority is a trained tendency rather than an architectural guarantee, which is exactly why sufficiently determined input can argue it away .

Chat: preferences and a template

The third stage optimises against human preference rather than against a demonstration. InstructGPT (Ouyang et al., 2022) is the reference description of the pipeline: collect comparisons between candidate responses, train a reward model, then optimise the policy against it. Direct preference optimisation (Rafailov et al., 2023) reaches a similar objective without a separate reward model, which is why much of the open ecosystem uses it.

The same paper is the origin of the “alignment tax” observation: the authors reported regressions on some standard NLP benchmarks after preference tuning, and mitigated them by mixing pretraining gradients back into the update. The general lesson holds — a preference-tuned model is not uniformly better than the instruct model it came from, it is better at being an assistant.

Chat models also come with a chat template: a specific string format with role markers and special tokens that the model was trained to see. This is the part that bites hardest, because it is invisible when you use a hosted API and mandatory when you do not. Feed a chat model raw text with no template and it may answer anyway, badly; feed a base model a chat template full of special tokens it never saw in training and the output degrades sharply. The mechanics are in chat templates.

Telling them apart, and choosing

• Check for a template. The reliable test on an open checkpoint is whether the tokenizer configuration ships a chat template. If it does, it is meant to be spoken to in turns. Suffixes like -base, -instruct, -it and -chat are conventions, not standards, and vendors use them inconsistently.
• Ask it a question with no framing. A base model continues; an instruct model answers. This takes one call.
• Assume hosted means chat. Hosted APIs almost never expose base checkpoints, so if you are calling a chat completions endpoint you have a chat model and the template is being applied for you.

Choosing is then simple. Base for training your own behaviour and for literal completion. Instruct for single-turn task execution where you supply all the framing. Chat for anything conversational, anything multi-turn, and anything where you want the safety behaviour that the preference stage installed. The only expensive mistake is using a base model with chat-shaped prompts and concluding the model is weak.

That mistake is worth recognising by its symptoms, because it does not look like a configuration error. Output that starts plausibly and drifts, answers that restate the question, special-token strings leaking into the text, or a model that will not stop at the end of its turn are all consistent with a template mismatch, and all routinely misdiagnosed as poor model quality. The check costs one call: render the exact string you are about to send, read it, and confirm it matches the format the checkpoint was trained on.