LLM, SLM, Foundation Model: Three Words for Three Different Questions

Sit through enough vendor calls and you start to hear LLM, SLM and foundation model used as if they were small, medium and large at a coffee counter. They are not sizes of one thing. Each term answers a different question, and once you separate the questions, a lot of architecture arguments get shorter.

A foundation model describes how something was trained and what you are allowed to expect from it. A large language model describes what it operates on. A small language model describes where it can run. Only the last one is really about size, and even then not in the way people assume.

Foundation model is a claim about training, not scale

The term came out of Stanford in 2021, in the report from what became the Center for Research on Foundation Models. The idea was to name a shift that had already happened: instead of training a model per task, you train one model on broad data at scale, usually with self-supervision, and then adapt it to many downstream tasks. The word foundation was chosen precisely because the thing is unfinished. It is what you build on.

Nothing in that definition mentions language. An image model, a speech model, a protein structure model and a weather model can all be foundation models. Nothing in it mentions size either, though in practice the broad-data-at-scale part rules out tiny models trained on one corpus.

Regulators mostly avoid the term. The EU AI Act talks about general-purpose AI models instead, and it is worth knowing where those lines fall even if you never ship in Europe, because they are the first widely adopted attempt to define this stuff in a way that carries consequences. The Commission’s guidance on general-purpose AI treats a model trained with more than 10^23 floating point operations that can generate language, images or video as presumptively general purpose, and treats anything above 10^25 FLOP as carrying systemic risk with heavier obligations attached. Those obligations started applying on August 2, 2025.

The part that catches engineers rather than lawyers is what happens when you fine tune. The Commission’s indicative line is that if the compute you spend modifying a model exceeds a third of the compute used to train the original, you have become the provider of a new general-purpose model, with the paperwork that implies. Almost nobody doing a LoRA on a weekend gets anywhere near that. It is still a line worth knowing exists before somebody in your company decides continued pretraining is a good idea.

Large language model is about modality, and the adjective is doing no work

An LLM is a foundation model whose input and output are language. That is the whole distinction. Large has never had a number attached to it in any specification, which is why the word has quietly stopped meaning anything.

Watch it fall apart in practice. GPT-2 was called large in 2019 at 1.5 billion parameters. Today a 3 billion parameter model ships inside a phone and nobody calls it large. Meanwhile the models people mean when they say LLM are increasingly mixture-of-experts systems where the total parameter count and the active parameter count differ by an order of magnitude, so even the number you would compare is ambiguous. Mistral Large 3, released in December 2025, is 675 billion total parameters with 41 billion active. Which of those is the size of the model? Both, depending on whether you are paying for memory or for compute.

The other thing to notice is that the pure language part is fading. Most models sold as LLMs today take images, many take audio, and the useful ones emit structured output rather than prose. Calling them language models is a habit left over from when they only did text.

Small language model is about the deployment envelope

SLM is the only one of the three that is genuinely about size, and the honest definition is circular in a useful way: a small language model is one small enough to run where you need it to run. The number moves with the hardware and the quantization, not with any taxonomy.

Apple’s on-device model is the clearest illustration. Apple’s own description of its foundation models puts the on-device model at roughly 3 billion parameters, quantized to 2 bits per weight with quantization-aware training, with 4 bits for embeddings and an 8-bit key-value cache. Those numbers are not vanity. They are what it takes to sit in a phone’s memory budget alongside everything else the phone is doing, and the framework exposing it to third party apps was announced in June 2025.

The open-weight side of this has gotten crowded in a good way. Google’s Gemma 3 line arrived in March 2025 at 1, 4, 12 and 27 billion parameters, with the 3n variants tuned for on-device use following in June. Mistral shipped Ministral 3 at 3, 8 and 14 billion under Apache 2.0. Microsoft’s Phi-4 sits at 14 billion and has spent a year being the model people point at when they argue that training data quality substitutes for parameters.

So when somebody says SLM, the question to ask back is which envelope: a phone NPU, a laptop with 16 GB of shared memory, a single A10 in your own VPC, or just anything cheaper per token than the frontier model you are currently using. Those are four different model choices and the word does not distinguish them.

Why the distinction earns its keep

The reason to keep these straight is that they push in different directions when you design a system.

If your problem is classification, extraction, routing, or turning a messy string into a known schema, the model size you need is almost certainly smaller than the one you are using. These tasks have narrow output spaces and tolerate fine tuning well, and that is where a small model on your own hardware stops being a compromise. NVIDIA’s research group made the strongest version of this argument in 2025 for agent systems specifically: most agent invocations are repetitive, narrow, and formatted, and paying frontier prices for them is a habit rather than a requirement. Their suggestion is heterogeneous systems where the big model handles the open-ended conversation and small models handle everything downstream of it.

If your problem is open-ended reasoning over unfamiliar material, you want the frontier model and the SLM discussion is a distraction. The gap is real and it shows up exactly where the task is least like your training data.

If your constraint is that data cannot leave the device or the account, then the deployment envelope decides everything and you work backwards from it. This is the case where I would take a meaningful capability hit without much argument, because a model running on the phone means a class of data handling problem simply does not exist.

The trap in all of this is benchmark shopping. A 4 billion parameter model that posts a competitive score on a public benchmark is telling you about that benchmark. Whether it can do the specific thing in your pipeline, at your prompt lengths, with your weird domain vocabulary, is a question only your own eval set answers, and building that eval set is the actual work. Quantization makes this sharper: the 2-bit version of a model is not the model, and the difference tends to show up in the long tail of your inputs rather than in the average case.

Pick by envelope and by task shape. The acronym is a label somebody in marketing applied afterwards.