Base, instruct, and reasoning models

Open any model catalogue and everything in it is called a model. Three of the things in that list are different kinds of product, and mixing them up is a cheap way to waste an afternoon or a month of budget. This lesson separates them, and you can reproduce the first one on a laptop.

1.A base model completes text, it does not take orders

A base model is the raw output of pre-training. Its one skill is continuing whatever text you hand it.

Here is the failure case. I gave a small open base model the line Summarise this article in one line. and asked for eight tokens, greedy. It printed The first thing to do is. It did not refuse and it is not broken. It read your line as the opening of a how-to page and carried on. You are not talking to it; you are giving it a prefix and asking what usually comes next.

So you steer a base model by shaping the prefix until the thing you want is the natural continuation. To label a review, you do not ask for a label. You show two labelled reviews, then write a third and stop at the word the label would follow.

Review: The food was cold and slow.
Sentiment: negative
Review: Lovely staff, great pizza.
Sentiment: positive
1Review: The room was filthy.2
Sentiment:3

from transformers import pipeline

# A small open-weight BASE model. Apache-2.0 as of Oct 2026; read the model card.
gen = pipeline("text-generation", model="HuggingFaceTB/SmolLM2-135M")

def complete(text):
    out = gen(text, max_new_tokens=8, do_sample=False, return_full_text=False)
    return out[0]["generated_text"]

# 1. An instruction. A base model treats it as the start of a document.
print(repr(complete("Summarise this article in one line.")))

# 2. A prefix whose natural continuation is the answer.
prefix = (
    "Review: The food was cold and slow.\nSentiment: negative\n"
    "Review: Lovely staff, great pizza.\nSentiment: positive\n"
    "Review: The room was filthy.\nSentiment:"
)
raw = complete(prefix)
print(repr(raw))

# 3. A base model does not reliably stop by itself, so you cut it where the pattern repeats.
print(raw.split("\n")[0].strip())

I ran this with transformers 5.20.1 and torch 2.14.1 on a laptop CPU. The first download is a few hundred megabytes. The three lines printed were '\n\nThe first thing to do is', then ' negative\nReview: The food was cold', then negative. Look at the middle one. The label is right, and then the model starts inventing the next review, because it has no idea it was meant to stop. Cutting at the first newline is your job.

Two honest limits. I tried a translation pair first, and this tiny model only repeated the pattern, so I picked a task it can do. And a model of 135 million parameters copies a shape far more readily than it judges anything, so treat the output as a demonstration of the interface, not a verdict on base models.

Where you meet base models: open-weight releases, where the base and instruct versions ship side by side; as the starting point for your own fine-tune; and in research that wants no instruction tuning. Names do not tell you which you have, since the repo above carries no -base suffix at all, so read the model card. For a hosted API, check the model's page for what kind it is. I did not check every provider's catalogue, so I make no claim about who does or does not sell base models.

2.An instruct model was taught to follow, and that teaching is post-training

Take the base model and run it through post-training and you get the thing most docs mean by the model.

Two stages do the work. Supervised fine-tuning shows it many written examples of a request and a good answer, so continuing the text and doing what was asked start to coincide. Then preference tuning shows it pairs of candidate answers with a judgement about which is better, and pushes the weights toward the preferred one. The best-known paper for the whole recipe is InstructGPT. Its authors report that human raters preferred a tuned model with 100 times fewer parameters over the 175-billion-parameter GPT-3. The second stage goes by several names: RLHF (reinforcement learning from human feedback), DPO (direct preference optimisation), or AI-feedback methods where a model applies written rules instead of a person rating every pair.

What you get is a model that follows a request, holds a role and a format across a conversation, stops when the answer is finished, and can use tools. What you also get is a house style and a set of refusal habits that someone else chose, and that can change between versions of the same model. Treat both as things to test, not constants.

This is the default, and it should be yours. Everything else in this lesson is a deviation from it that you should have to justify.

3.A reasoning model buys accuracy with tokens

Same machinery again, trained further to produce a long run of intermediate working before it commits to an answer. Providers call this thinking, extended thinking or reasoning tokens. One published account, the DeepSeek-R1 paper, says reasoning can be "incentivized through pure reinforcement learning" on tasks whose answers can be checked, for example maths and coding. I could not confirm how any closed lab trains its own reasoning models.

The part that matters for your bill is the same everywhere I checked. As of Oct 2026, Anthropic's docs say thinking tokens are billed as output tokens even when the text is not returned to you, and that they count toward max_tokens. OpenAI's reasoning guide says, as of Oct 2026, that its reasoning tokens are not visible through the API, are billed as output, and still occupy space in the context window. What you actually pay for covers the rest of the price list. To see your own number, Anthropic reports it in usage.output_tokens_details.thinking_tokens.

What that buys, and only this: problems where getting step three wrong ruins the answer, and where checking your own work partway through helps. Multi-step maths, planning against rules that interact, debugging from indirect evidence, careful analysis of a document whose clauses qualify each other. What it costs is extra output tokens and extra seconds, both of which you can measure and neither of which I will put a number on, because they depend on the task.

A base model continues your text. An instruct model does what you asked. A reasoning model thinks first, and bills you for the thinking.

Now the second failure case. You turn thinking on, keep the max_tokens you used for plain answers, and replies start arriving cut off or empty. Thinking is output, so it spends the limit first. As of Oct 2026, Anthropic's steering page describes this as stop_reason: "max_tokens" and says to raise the cap or lower the effort. As of Oct 2026, OpenAI's guide warns that a response can end incomplete with no visible output, and suggests reserving at least 25,000 tokens when you start. Check stop_reason before you trust a short answer.

When this does not apply: a classifier running a million times a day almost never needs thinking, and a request with no steps gains nothing from it. The three-way split also describes behaviour, not product names. One hosted model can act as both instruct and reasoning depending on a setting, and as of Oct 2026 some Anthropic models cannot have thinking switched off at all. If the model's page does not settle it, test: send the same ticket both ways and compare the output tokens and the labels.

How you turn thinking up or down differs by provider and by model, and the old fixed token budget is rejected by newer Anthropic models as of Oct 2026. That is its own lesson, Thinking and effort, model by model. For now the working rule is short. Start at the cheapest setting your task tolerates, collect the failures, move up one step, and keep the step only if a test set shows it changed the answer.