A foundation model is a large neural network pre-trained on massive, broad datasets so it can be adapted to many different downstream tasks instead of being built from scratch for each one. Models like GPT-4, Claude, Gemini, and Stable Diffusion are foundation models that power chatbots, coding assistants, image generators, and search tools. The 'foundation' name reflects their role as a base layer you fine-tune, prompt, or extend with retrieval rather than a finished application.
Ask ten people what a foundation model is and you'll get ten different answers: "the thing behind ChatGPT," "a giant neural network," "the AI that everyone's talking about." All of these are pointing at something real, but the term itself has a precise origin and a specific meaning that matters if you're making decisions about which AI capabilities to buy, build, or adapt for your organization. This article walks through where the term comes from, how these models are actually constructed, the different flavors they come in, and what all of this means practically for anyone evaluating AI tools for enterprise use — including how foundation models relate to large language models, generative AI more broadly, and the newer wave of AI agents built on top of them.
What Is a Foundation Model, Exactly?
The term "foundation model" was coined in 2021 by researchers at Stanford's Center for Research on Foundation Models (part of Stanford HAI), specifically to name a shift that was already happening in AI but hadn't been given a clean label. Before that shift, machine learning was largely task-specific: you built a model to detect fraud, another to classify support tickets, another to translate French to English, each trained from scratch on data curated for that one job. A foundation model is different — it's trained once, on a broad swath of data, and then adapted to serve many downstream tasks it was never explicitly trained for.
The word "foundation" is doing metaphorical work here, and it's worth sitting with. Think of it as a base layer, like a building's foundation or an operating system: it's not the finished application, it's the substrate that many applications get built on top of. A single foundation model can power a customer service chatbot, a code assistant, a document summarizer, and a translation tool, without being retrained for any of them individually. That's the defining property — generality and reusability — as opposed to the older paradigm of one model, one job.
How Foundation Models Are Built
The construction process has a distinct two-phase shape: pre-training and adaptation.
Pre-training is where the heavy lifting happens. Engineers feed the model enormous quantities of data — text scraped from the web, books, code repositories, images, audio — and the model learns statistical patterns in that data using self-supervised learning. This means the model isn't given labeled examples ("this is a cat," "this is fraud"); instead, it's given a simpler, automatic task, like predicting the next word in a sentence or reconstructing a masked-out image patch, and it generates its own training signal from the raw data itself. This is what makes internet-scale training feasible: you don't need humans to label billions of examples, because the data labels itself through the prediction task.
Almost all modern foundation models use some variant of the transformer architecture, introduced in 2017, which processes input through an "attention" mechanism that lets the model weigh the relevance of every part of the input to every other part. This is what allows a model to track that "it" in sentence three refers to a company mentioned in sentence one, or that a pixel region in an image relates to an object described in a caption elsewhere.
What separates a foundation model from earlier neural networks is sheer scale — in data volume, parameter count, and compute spent on training. We're talking about training runs that cost tens of millions of dollars in compute, on datasets comprising hundreds of billions to trillions of tokens. This scale is not incidental; research has repeatedly shown that model capabilities improve in fairly predictable ways as you scale up data and compute, which is part of why labs kept building bigger models through the early 2020s.
Once pre-training is done, the model gets adapted for actual use. This happens through fine-tuning (further training on a narrower, task-specific dataset), prompting (giving the model instructions and examples at inference time without changing its weights at all), or retrieval-augmented generation, or RAG (connecting the model to an external knowledge source so it can pull in current or proprietary information it wasn't trained on). Each of these adaptation paths has different cost, speed, and control tradeoffs, which we cover in more depth in fine-tuning vs RAG vs prompting.
Master the right skills for your goal
Not sure which path fits? Get a free 1:1 consultation with our team.
Types of Foundation Models
"Foundation model" is an umbrella term covering several distinct categories, each suited to different kinds of input and output.
Large language models, or LLMs, are the most familiar category — trained primarily on text, they generate and reason over language. GPT-4, Claude, and Gemini's text capabilities all fall here. Multimodal models extend this further by handling vision and language together, letting you feed in an image and get a text description, or ask questions about a chart or photo — GPT-4V and Gemini's multimodal variants are examples. Image and diffusion models, like Stable Diffusion, Midjourney, and DALL-E, work in the opposite direction, generating images from text prompts by learning to reverse a noise-adding process during training. Audio and speech models handle transcription, voice synthesis, and music generation — Whisper and various text-to-speech foundation models fall in this bucket. Code models are LLMs specifically trained or fine-tuned on programming languages and repositories, powering tools like GitHub Copilot and Codex. And embedding models, though less visible to end users, convert text, images, or other data into numerical vectors that capture semantic meaning, which is the backbone of search, recommendation, and RAG systems. Most enterprise AI stacks end up combining several of these types rather than relying on just one.
Why Foundation Models Matter for Business
The practical significance of foundation models for business is a shift in the economics of building AI capability. Under the old task-specific paradigm, adding a new AI feature meant assembling a labeled dataset, training a model from scratch, and maintaining that model indefinitely — a process that could take months and required specialized ML engineering talent your organization may not have had. With foundation models, the same feature might be achievable by writing a good prompt against an existing API, or fine-tuning a pre-trained model on a comparatively small dataset. What used to be a multi-month ML project can become a multi-day integration project.
This cost and speed shift has opened entirely new product categories that weren't commercially viable before: AI copilots embedded in office software, on-demand image generation for marketing teams, code assistants that understand entire codebases, customer service agents that can handle open-ended conversation rather than rigid decision trees. None of these required a company to have its own AI research team — they required knowing how to adapt and integrate an existing foundation model well.
A foundation model is less like a finished employee you hire and more like a very well-read intern with no memory of your company — brilliant in general, useless on your specifics until you show them the filing cabinet.
That reframing matters because it clarifies what buying access to a foundation model actually gets you, and what work still remains on your side — namely, connecting it to your data, your workflows, and your governance requirements. Teams building this internal capability often benefit from structured learning; the Generative AI Training programme is built around exactly this gap between "the model is powerful" and "our team knows how to deploy it responsibly and effectively."
How Organizations Use Foundation Models in Practice
Most organizations don't train foundation models — that's the domain of a handful of well-resourced labs. Instead, adoption happens through a handful of well-worn paths, usually in combination.
API access is the most common entry point: you call a hosted model over the internet, pay per token or per request, and get output back without managing any infrastructure. This is how most teams first experiment with GPT-4, Claude, or Gemini. Prompting — crafting the instructions, context, and examples you send to the model — is often the highest-leverage skill in the early stages, since a well-designed prompt can dramatically improve output quality without any additional engineering. As needs mature, teams often add retrieval-augmented generation, connecting the model to internal documents, databases, or search indexes so it can answer questions using your organization's actual, current information rather than only what it learned during pre-training. Fine-tuning comes into play when you need the model to consistently follow a particular style, format, or specialized domain vocabulary that prompting alone can't reliably achieve.
A parallel decision runs alongside all of this: open-source versus proprietary models. Open-weight models like Llama or Mistral can be self-hosted, giving you full control over data residency, customization, and cost structure, at the price of needing infrastructure and expertise to run them. Proprietary models accessed via API, like GPT-4 or Claude, typically offer stronger out-of-box performance and zero infrastructure burden, but come with usage costs, less transparency into training data, and dependency on a vendor's roadmap and uptime.
Choosing a model for a specific use case usually comes down to matching capability to task: a customer-facing chatbot has different requirements — speed, cost per interaction, tone control — than a legal document analysis tool, which prioritizes accuracy and long-context reasoning over latency. Comparing options like Claude vs ChatGPT vs Gemini is often a useful starting point once you know which axis matters most for your use case. Organizations building this evaluation muscle across multiple teams often turn to structured enterprise AI training solutions rather than leaving model selection to ad hoc trial and error.
Foundation Models vs. Related Terms
These terms get used interchangeably in casual conversation, but they describe different things, and conflating them causes real confusion in planning conversations.
A foundation model is the broad category: any large, pre-trained model designed for general-purpose adaptation, regardless of modality. An LLM is a specific type of foundation model, one trained primarily on text and language. So every LLM is a foundation model, but not every foundation model is an LLM — a diffusion model trained purely on images is a foundation model with no language capability at all. Generative AI, meanwhile, refers to the broader class of AI systems that create new content — text, images, audio, video, code — and it describes a capability, not an architecture. Most generative AI tools today happen to be built on foundation models, but the terms aren't synonyms; you can read more on how this distinction plays out against older ML approaches in generative AI vs traditional AI. An AI agent is different again: it's a system that uses a foundation model as its reasoning engine but adds the ability to take actions, use tools, plan multi-step tasks, and interact with external systems autonomously. The foundation model is the brain; the agent is the whole operational entity built around that brain, complete with hands and a task list.
Risks, Limitations, and Common Misconceptions
Foundation models come with well-documented limitations that any deployment plan needs to account for. Hallucination — the tendency to generate fluent, confident-sounding output that is factually wrong — is inherent to how these models work, since they're predicting plausible continuations rather than looking up verified facts, and it doesn't fully disappear no matter how large or well-trained the model is. Bias is another persistent issue: because these models learn patterns from internet-scale data, they absorb and can amplify the biases present in that data, which shows up in everything from stereotyped language to skewed representation in generated images.
Data provenance and licensing raise separate, thornier concerns. Many foundation models were trained on scraped web data of uncertain copyright status, and this has triggered ongoing lawsuits and regulatory scrutiny that could affect which models remain available or how their outputs can legally be used commercially. Compute cost is a practical limitation too — running large models, especially at scale or with long context windows, is genuinely expensive, and that cost gets passed through to API pricing or infrastructure bills for self-hosted deployments.
One misconception worth retiring directly: bigger is not always better. Larger models cost more to run, respond more slowly, and in many practical business tasks — classification, extraction, simple summarization — a smaller, cheaper, fine-tuned model will match or beat a massive general-purpose one, at a fraction of the cost and latency. Model selection should be driven by the task's actual requirements, not by chasing the largest available parameter count.
Choosing and Evaluating a Foundation Model
When it's time to actually pick a model for a project, a handful of concrete criteria matter far more than marketing claims or leaderboard rankings alone.
- Context window: how much text (or other input) the model can consider at once — critical for tasks involving long documents or extended conversations.
- Cost per token: pricing varies significantly across providers and can dominate your operating costs at scale, especially for high-volume applications.
- Latency: how quickly the model responds, which matters enormously for real-time applications like chat but less for batch processing jobs run overnight.
- Modality support: whether you need text-only, or image, audio, and video input and output as well.
- Open versus closed weights: whether you can self-host and customize freely, or you're dependent on a vendor's API and terms of service.
- Benchmark performance: useful as a directional signal, but should be checked against tasks resembling your actual use case rather than taken at face value.
- Governance fit: data residency, audit logging, content filtering, and compliance requirements, which can rule out otherwise-strong models for regulated industries.
That last point deserves particular attention, since it's frequently the deciding factor in enterprise settings even when a model looks technically superior on paper. Understanding how model choice interacts with organizational policy, risk tolerance, and oversight requirements is covered in depth in AI governance in the enterprise, and it's worth reviewing before committing budget or engineering time to a particular vendor.
- A foundation model is pre-trained once on broad data and then adapted to many tasks, unlike traditional ML models built per-task.
- The category spans text, image, audio, code, and multimodal models — not just chatbots.
- Most organizations adapt existing foundation models via prompting, fine-tuning, or RAG rather than training their own.
- Foundation models carry real risks — hallucination, bias, and licensing exposure — that require governance, not just technical integration.
- Choosing a model is a fit exercise (cost, latency, context window, data handling) evaluated against your specific use case, not a single 'best' model.
Glossary
- Pre-training: The initial phase where a model learns general patterns from massive unlabeled datasets before any task-specific adaptation.
- Fine-tuning: Further training a pre-trained foundation model on a smaller, specific dataset to specialize its behavior for a task.
- Transformer: The neural network architecture using self-attention that underlies nearly all modern foundation models.
- Self-supervised learning: A training method where the model generates its own labels from raw data, e.g., predicting the next word in a sentence.
- Context window: The maximum amount of text (measured in tokens) a foundation model can process or 'remember' in a single interaction.
- Multimodal model: A foundation model that can process and generate more than one data type, such as text, images, and audio together.
Frequently asked questions
Is ChatGPT a foundation model?
ChatGPT is a product built on top of a foundation model (GPT-4 or GPT-4o) that has been fine-tuned for chat and wrapped in a user interface. The foundation model is the underlying pre-trained neural network; ChatGPT is one application of it.
Are foundation models the same as LLMs?
No — LLMs are a subset of foundation models focused on text. Foundation models also include image generators like Stable Diffusion, multimodal systems like GPT-4o, and audio models like Whisper, so 'foundation model' is the broader category.
Do I need to train my own foundation model?
Almost never. Training one from scratch requires hundreds of millions of dollars in compute and massive datasets, which is why most companies adapt an existing model via prompting, fine-tuning, or retrieval-augmented generation instead.
What's the difference between open-source and proprietary foundation models?
Open-source models like Llama or Mistral let you download and run the weights yourself, giving you control over data privacy and customization. Proprietary models like GPT-4 or Claude are accessed via API only, typically offer higher performance out of the box, but require sending data to the provider.
Can foundation models be wrong or biased?
Yes. They can hallucinate facts, reflect biases present in training data, and produce inconsistent outputs, since they generate statistically likely text rather than verified truth. This is why enterprise deployments pair them with retrieval, guardrails, and human review.
How do I pick a foundation model for a business use case?
Match the model to your requirements: context window and modality needs, cost per token at your expected volume, latency requirements, and whether data residency or IP terms rule out certain vendors. Benchmark on your actual tasks rather than relying solely on public leaderboard scores.
Ready to build this capability?
Browse our upcoming batches — live, instructor-led, delivered on Orbit.