How Foundation Models Actually Work

This handbook builds a clean mental model of modern foundation models without requiring advanced mathematics. It focuses on the concepts that matter for architecture, model selection, agent design, context engineering, and AI economics.

When the model is used inside an agentic system:

Training

Training is the process of creating the model's learned capability.

Training changes the model's parameters.

Inference

Inference happens after training, when the trained model is used.

Inference normally uses the existing learned weights rather than changing them.

Simple inference

Complex inference

Models do not directly process human language as sentences. Text is first converted into tokens.

Each token maps to a numerical token ID.

Tokenizer Design vs Tokenization Operation

The tokenizer vocabulary/mapping is effectively fixed for a trained model family. But tokenization itself happens every time the model is used:

The word “chunking” can create confusion.

A modern neural network contains a very large number of learnable numerical values. These are called parameters. A major subset of those parameters are weights.

w1 = 0.72
w2 = -1.14
w3 = 0.08

Real models contain billions or trillions of such values.

A neural network repeatedly performs mathematical transformations. Very simplified:

During training:

A larger parameter count gives a model more representational capacity, but more parameters do not automatically produce a better model.

A smaller but better-trained model can outperform a larger poorly trained one.

At generation time, learned weights transform the current representations into a probability distribution over possible next tokens.

Example

Training adjusts the weights so that good continuations become more probable across many examples.

The architecture is designed first. Parameters are learned within that architecture.

Useful analogy

Tokens are numerical IDs, but neural networks need continuous numerical representations. A token maps to a vector:

Example

The values are high-dimensional learned numbers.

A vector space is the high-dimensional geometry in which representations exist.

Instead:

Semantically related concepts can develop related representations.

A token's initial embedding is not its final meaning.

Example

The initial token representation enters the network, but contextual processing transforms it differently.

The Transformer architecture was a major breakthrough because it enabled models to process relationships across sequences efficiently and scale extremely well.

The key mechanism inside Transformers is attention.

Transformers enabled a combination of:

The capability leap came from the combination:

Example

When processing “he”, the model should strongly relate it to “Roy”, not “laptop”.

The intuitive mental model:

When processing “he”

Q("he") ≈ "Who does this pronoun refer to?"

Other tokens provide keys:

K("Roy")
K("laptop")
K("study")

The query is compared with keys. More relevant keys receive higher attention weight, and their values contribute more strongly to the updated representation.

Self-attention means tokens inside the same sequence attend to one another.

This helps capture:

• subject-object relationships;
• pronoun references;
• causality;
• grammar;
• semantic relationships;
• long-distance dependencies.

Models use multiple attention heads.

These roles are not manually assigned in a simple human-readable way; they emerge during training.

It is iterative across layers, but not a dynamic loop that runs until the model decides meaning is “finished”.

More accurately:

The number of Transformer layers is fixed by the model architecture.

Transformer depth

Within one forward pass:

Fixed by architecture.

Autoregressive generation

Continues until a stopping condition.

Reasoning / test-time compute

Some reasoning models use more computation for difficult tasks.

This is different from network depth.

Language models typically generate output one token at a time.

Stopping conditions may include:

• end-of-sequence token;
• max output length;
• tool call;
• runtime stop condition.

Context is the information actually available to the model during a particular inference. It may include:

The context window is the maximum working capacity available for the current inference.

Analogy

Everything actively needed for inference must fit on the desk.

A model may support a huge context window, but that does not mean every token is used equally well.

Very large context can increase:

• noise;
• cost;
• latency;
• attention dilution;
• retrieval difficulty.

A good system does not simply maximize context size.

This improves reliability and cost.

Long technical chats accumulate:

If everything is repeatedly carried forward:

This is why modular development and structured state matter.

Modularity is not only software hygiene. It is also context-efficiency architecture.

Then a validation task can receive only:

This reduces irrelevant context.

JSON is useful for:

• state;
• contracts;
• schemas;
• configuration;
• structured outputs;
• metadata.

{
  "module": "payroll_compute",
  "input_contract": "...",
  "output_contract": "...",
  "immutable_rules": [],
  "known_dependencies": []
}

It can be more efficient than reconstructing long conversational history.

Code should remain code. Narrative methodology can remain prose. JSON is best where explicit structure matters.

Max output is the maximum number of output tokens a model may generate in one response. This is separate from the context window.

A model can have a large context window while still imposing a much smaller maximum output length.

Memory is information intentionally preserved for future use.

Memory may include:

• durable preferences;
• long-lived decisions;
• recurring facts;
• stable operational information.

Relevant memory must be retrieved and injected into the current context.

Retrieval selects relevant stored information for the current task. Sources may include:

The goal is not to retrieve everything.

RAG stands for Retrieval-Augmented Generation. Typical pipeline:

RAG gives the model access to knowledge outside its learned weights.

Training changes the model. RAG changes the information available to the model at runtime.

The mechanisms may look similar technically, but their semantics differ.

Both can be retrieved into context, but they represent different categories of truth.

Embedding models are not primarily chat models. They transform input into vectors:

Used for:

• semantic search;
• similarity;
• clustering;
• retrieval.

They are central to many RAG systems.

A multimodal model can process more than one type of input or output modality.

A model does not “see” an image in the human sense.

Those representations become numerical vectors that can participate in attention and reasoning.

Multimodal systems must connect representations across modalities.

This lets the model connect a user's text request to visual regions in a screenshot.

Different modalities become representations that can participate in a shared reasoning process.

A multimodal system attempts to align related concepts across modalities.

The vectors do not need to be identical; they need enough alignment for cross-modal reasoning.

Attention is not limited to text. A multimodal system may need to decide:

• Which text matters?
• Which visual region matters?
• Which audio segment matters?
• How do they relate?

When structured data is available, structured access is usually preferable.

Multimodal reasoning is most valuable where the world is inherently unstructured.

Training gives a model general knowledge, but learned model knowledge may be:

• incomplete;
• outdated;
• probabilistic;
• difficult to trace;
• occasionally wrong.

Healthy architecture

A model is not an agent.

An agent system adds:

Most system builders do not modify frontier-model weights. They select the model that best fits the workload.

Practical questions become:

• Is the data clean?
• Is the context efficient?
• Is reasoning needed?
• Which model class is sufficient?
• How expensive is each inference?
• How many calls happen per task?
• Can deterministic code replace model work?

Ask instead:

• Reasoning quality?
• Instruction following?
• Tool discipline?
• Structured output reliability?
• Context performance?
• Coding?
• Vision?
• Latency?
• Cost?
• Stability?
• Hallucination rate?

A dense model activates most of its parameters for each token. A Mixture-of-Experts (MoE) model contains many expert blocks, but only some are activated for each token.

This matters for compute efficiency and model economics.

Trade-offs

Context is not free. In agent systems, one human request may create multiple model calls.

Example

Each model call may carry part of the context again.

Poor architecture

Better architecture

Economically

AI VALUE  ≈  Decision Quality × Reliability × Speed  ÷  Cost

Every concept in this handbook fits into one composite pipeline — the core generative path, surrounded by the systems that make it contextual, grounded, and multimodal.

Around that core

Keep this table mentally available.

You do not need to derive advanced Transformer mathematics to make strong architecture decisions.

You do not need to calculate attention equations manually.

You do not need to train a frontier foundation model.

What you do need is functional understanding of:

• what the model knows
• what the model does not know
• what context it receives
• how attention uses that context
• how retrieval changes that context
• what memory preserves
• what deterministic systems should handle
• when reasoning is needed
• how model calls create cost

The model is powerful because learned weights create a high-dimensional transformation system capable of extracting relationships from context.

These sources are useful for going deeper into the mechanisms summarized in this handbook:

• Attention Is All You Need (Transformer paper)https://arxiv.org/abs/1706.03762
• Anthropic — Model Context & Long Context Guidehttps://docs.claude.com/en/docs/build-with-claude/context-windows
• Anthropic — Prompt Engineering Overviewhttps://docs.claude.com/en/docs/build-with-claude/prompt-engineering/overview
• OpenAI — Tokenizerhttps://platform.openai.com/tokenizer
• Hugging Face — Transformers Documentationhttps://huggingface.co/docs/transformers/index
• Google — Mixture-of-Experts Explainerhttps://research.google/blog/mixture-of-experts-with-expert-choice-routing/
• Pinecone — Retrieval-Augmented Generation Guidehttps://www.pinecone.io/learn/retrieval-augmented-generation/
• Anthropic — Building Effective Agentshttps://www.anthropic.com/research/building-effective-agents