What Is a Foundation Model? Explained for SMEs

A foundation model is a large AI model trained on huge amounts of unlabeled data (text, code, images, or a mix of these) that can later be adapted to perform a wide range of tasks. Instead of building a separate model for every application, a single foundation model serves as the starting point for many different AI tools at once. GPT (from OpenAI), Claude (from Anthropic), Gemini (from Google) and Llama (from Meta) are all examples of foundation models.

The name is deliberate. Stanford's Institute for Human-Centered Artificial Intelligence (HAI) coined the term in 2021 to describe how these models act as a foundation that other applications are built on top of, much like the foundation of a building.

How it works

A foundation model comes together in two stages.

Stage 1: Pretraining

In the first stage, the model is trained on a massive, broad dataset: chunks of the internet, books, code, and sometimes images or audio. This usually happens through self-supervised learning, where the model learns patterns, language structure and relationships in the data without humans having to label every example. Most modern foundation models use a transformer architecture, which is particularly good at recognizing connections between words or concepts across long stretches of text.

The result of this stage is a model with broad, general knowledge, but no specialization in any single task.

Stage 2: Fine-tuning and adaptation

After pretraining, the model is further adapted (fine-tuned) for specific purposes. This can be done with relatively little extra data, because the model already carries the heavy lifting of general knowledge. Examples include:

• Adapting a model to handle customer service conversations in a specific industry
• Training a model to summarize legal documents
• Instructing a model through prompts, without changing its underlying weights (this is called prompt engineering)

This two-stage setup means nobody has to start from scratch. That saves enormous amounts of compute, time and money compared to training an entirely new model for every task.

Why it matters for SMEs

The biggest advantage for small and medium businesses: you never have to train a foundation model yourself. Training a model like GPT-4 or Claude costs millions of euros in compute and requires datasets that only large tech companies can assemble. That is simply not an option for an SME, and it does not need to be.

Instead, you use a foundation model through an API from a provider such as OpenAI, Anthropic or Google. You pay per use (based on the amount of text processed, measured in tokens) and get access to a model that represents years of research and investment.

This lowers the barrier significantly:

For most SME use cases, the question is not 'which model should I train', but 'which existing foundation model fits my task best, and how do I build a usable application around it'.

A concrete example

Say a heating and installation company wants a chatbot on its website to answer customer questions about warranties, scheduling and quotes. The company does not train its own language model. Instead, it:

1. Picks an existing foundation model (for example via the Anthropic or OpenAI API) as the language engine.
2. Feeds the model its own business information: terms and conditions, frequently asked questions, pricing details. This often happens through a technique called retrieval augmented generation, where relevant company documents are supplied to the model alongside each question.
3. Lets the model answer questions in natural language, drawing on both its broad general knowledge and the specific company data.

The same approach works for document processing (automatically categorizing invoices), summarizing customer calls, or drafting marketing copy. The foundation model is always the engine, the application built around it determines what actually happens. Curious how this works in practice for your business, take a look at what AI agents could do for your processes.

When to use it, when not

A foundation model is a powerful tool, but not always the right choice.

Good fit when:

• The task involves natural language, text or unstructured data (answering questions, summarizing, writing, classifying)
• The input varies a lot (customers phrase questions in many different ways)
• Speed of implementation matters more than one hundred percent predictability

Not needed, or a poor fit, when:

• The problem can be solved with simple rules or a spreadsheet
• Full, guaranteed consistency is required (for example exact calculations or legally mandated checks)
• The available data or budget is too small to justify the added complexity

Not sure whether your process is a good fit for a foundation model? A free AI scan shows within minutes where AI does and does not make sense for your business.

Related concepts

• LLM (large language model): a foundation model specifically trained on text. All LLMs are foundation models, but not all foundation models are LLMs (some are trained on images or audio instead).
• Fine-tuning: further training a foundation model on a smaller, specific dataset to improve performance on a particular task.
• Prompt engineering: carefully wording instructions (prompts) to get a foundation model to produce the desired output, without changing the model itself.
• Inference: the moment a trained model actually generates a response to new input, as opposed to the training phase itself.
• Retrieval augmented generation (RAG): a technique where a foundation model consults a company's own documents while answering a question.

Foundation models have become the standard building block for nearly every serious AI application, from chatbots to document processing. For an SME, the real challenge is rarely the technology itself, it is translating that technology into a concrete, working process. That is where good AI consultancy helps: choosing a model based on what your business actually needs, not on hype.

Curious how a foundation model could be applied within your own processes? Start with an exploratory conversation, or test with a small real-world use case before scaling up.