HAAW — What IS the LLM?

Start With the Question

When someone says, “the LLM answered the question,” what exactly is the LLM?

An LLM is a trained mathematical model.

At rest, it is represented principally by stored numerical parameters—its learned weights—together with information defining the model architecture and how those numbers are to be used.

To produce an answer, software must load that model and execute its mathematical operations on computing hardware.

LLM Means Large Language Model

Large

The model contains a very large number of learned parameters and requires substantial computation and storage compared with small models.

Language

It is trained to operate on tokenized language and related sequences, learning statistical structure that supports language generation and other tasks.

Model

It is a learned mathematical system whose behavior is determined by its architecture and trained parameter values.

Powered Off: Where Is the LLM?

Return to our original HAAW machine and shut it down.

The GPU is no longer computing. VRAM is no longer holding the active model state. The inference process is gone from RAM.

But the model files remain on persistent storage.

MOTHERBOARD
├── CPU
├── RAM [volatile — inactive when powered off]
├── PCIe → GPU card → VRAM [volatile — inactive]
└── PCIe → NVMe SSD
└── LLM model files remain stored here

At rest, the LLM does not “think.”

Its learned parameter values are stored data. Computation begins only when software and hardware execute the model.

PCIe: The Shared Highway

Both a modern NVMe SSD and a discrete GPU commonly communicate through PCI Express connections, but they are different devices serving different jobs.

CPU / PLATFORM
│
├── PCIe lanes ──→ NVMe SSD persistent storage
│
└── PCIe lanes ──→ GPU CARD
├── GPU processor
└── VRAM

The GPU is therefore not normally plugged into the NVMe drive. They are separate PCIe-connected participants in the larger computer system.

Power On: The Model Becomes Executable

Now replay the path we already know.

Linux boots

↓

GPU driver becomes available

↓

AI runtime / inference software starts

↓

Model files are read from persistent storage

↓

Weights and required model data become available in working memory

↓

GPU / CPU executes model operations

↓

The LLM is now being used for inference

NVMe, RAM and VRAM Have Different Jobs

NVMe / SSD

Persistent storage. Model files can remain here while the machine is powered off.

System RAM

CPU-accessible working memory. Runtime software, model data, buffers, and other process state may occupy RAM.

GPU VRAM

Accelerator working memory. Model weights, activations, KV cache, and working buffers may be placed here so GPU computation can access them at high bandwidth.

Exact placement varies. Large models can be split across several GPUs, partially kept in system memory, or managed with other loading and offloading strategies.

The GPU Is Not the LLM

This distinction is fundamental.

A GPU is computing hardware. An LLM is the trained model being executed.

The same GPU can execute different models. The same model can, within practical and software constraints, be executed on different compatible hardware.

The GPU provides enormous parallel mathematical capability. The model's learned weights determine the particular trained transformations being performed.

Now Attach the Other Words

Several AI terms that can sound like separate mysterious objects now have places in our machine.

LLM

The trained language model: architecture plus learned parameters and associated model information required to execute it.

Runtime

Software that loads and executes the model using available CPU/GPU hardware and supporting libraries.

Inference

The act of using the trained model to process supplied input and produce output. Our “Why is the sky blue?” journey was inference.

Interface

The boundary through which a human or another program submits a request and receives results—for example a web UI, application, or API.

Put the Whole Stack Together

HUMAN / APPLICATION
    │
    ▼
INTERFACE — accepts request / presents result
    │
    ▼
INFERENCE SERVICE / RUNTIME — manages execution
    │
    ▼
LLM — trained model being executed
    │
    ▼
Linux + drivers + libraries
    │
    ▼
CPU + RAM + GPU + VRAM + NVMe + PCIe
    │
    ▼
PHYSICAL HARDWARE

Where Is the Intelligence?

This question needs careful wording.

The learned behavior we associate with the model is encoded across its trained parameter values and architecture. But those stored values alone perform no computation.

Useful behavior appears when the model is executed: input is transformed through the architecture using those learned weights, producing the token-by-token inference process we already followed.

Stored model + execution machinery + input → observable model behavior.

The Acronym Has a Physical Address Now

When the machine is off, we can point toward persistent storage and say: the files representing the trained LLM are there.

When the machine is running, we can follow those model parameters into working memory and watch hardware execute the operations they define.

And when a user asks a question, we can identify inference as the running process that uses that LLM to produce the answer.

The LLM is no longer a magic box floating somewhere behind the chat window.

HAAW Checkpoint

LLM: A trained language model defined by architecture and learned parameters, represented persistently by model data/files when not executing.
NVMe / SSD: Persistent storage where model files may reside.
RAM / VRAM: Working memory used while software and model computations are active.
GPU: Accelerator hardware that executes large amounts of the model's mathematical computation; it is not itself the LLM.
Runtime: Software machinery that loads and executes the model.
Inference: Using the trained model to process input and generate output.
Interface: The boundary through which users or other software communicate with the AI service.

Next HAAW Page: Inside the GPU — Where the Math Runs