AI terms explained: my cheat sheet for the whole AI world

I use Claude Code every day. Still, the other day I sat in front of the model search on Hugging Face and didn't understand half the filters. AWQ? FP4? A3B? So I wrote down everything that keeps popping up in the AI world. Short explanations, with numbers, for looking things up.

Hugging Face, by the way, is basically GitHub for AI models. Over two million models live there, plus datasets and small demo apps.

The basics

AI: The umbrella term for anything that seems somehow "smart". From chess computers to chatbots.
Machine learning: The computer learns rules from examples instead of a human programming them in. A subset of AI.
Deep learning: Machine learning with very large neural networks. A subset of machine learning. Almost everything people talk about right now is deep learning.
Neural network: Many layers of numbers that get calculated with each other. Loosely inspired by the brain, but works very differently.
Transformer: The architecture behind almost every modern language model, since 2017 ("Attention Is All You Need"). The trick is called attention: every word looks at which other words in the text matter to it right now.
LLM (Large Language Model): A big language model. GPT, Claude, Gemini, Llama, Qwen. At its core it only ever predicts the next piece of a word, but it does that really well.
GenAI (Generative AI): AI that creates something new: text, images, music, video.
Foundation model: A large base model others build on. The "base LLM" that chat versions and specialized models are made from.
Diffusion: How most images and videos get made (Stable Diffusion, Flux). The model starts with pure noise and removes it step by step until an image is left.
AGI: "Artificial General Intelligence", an AI that can do everything at least as well as a human. Doesn't exist. Everyone argues about when or whether it will.

How a model is made

Training / pretraining: The model reads huge amounts of text (trillions of tokens) and learns to predict the next word. Takes months and a lot of GPUs.
Dataset: The training data. Websites, books, code, images with captions.
Weights: The result of training, the learned numbers. When you "download a model", you download the weights.
Base model: Only pretrained. Continues text but doesn't answer questions. Type "What time is it?" and you might get "the man asked, glancing at his watch".
Instruct / chat: Further trained on instructions and conversations. This is what you want almost every time.
Reasoning / thinking: Models that "think out loud" for a while before answering. Better at math and code, but slower and more expensive.
Fine-tuning: A finished model gets trained further on your own data, e.g. a writing style or domain language.
LoRA: The cheap version of fine-tuning. Instead of changing the whole model, you train a small add-on of a few megabytes. QLoRA is the same thing on a quantized model, and then it even works on a consumer GPU.
Distillation: A big model teaches a small one. That's why some models are called things like "DeepSeek-R1-Distill-Qwen-7B".
RLHF: "Reinforcement Learning from Human Feedback". People rate answers and the model learns to be helpful and polite from that.
Alignment: Everything that makes a model do what people want and not screw things up.
Benchmark: Standardized tests like MMLU (knowledge) or SWE-bench (fixing real GitHub bugs). Take them with a grain of salt: many test questions have long since ended up in the training data.

Size and structure

Parameters: The number of learned values. M = million, B = billion, T = trillion. Examples: 0.6B, 8B, 70B, 1T. More parameters usually means smarter, but also more memory.
Memory rule of thumb: Parameters times bytes per weight. An 8B model needs about 16 GB at full precision (16 bit), about 8 GB at 8 bit and about 5 GB at 4 bit. Plus some memory for the context.
Rough size classes: Up to about 4B runs on a phone or laptop. 8B to 14B fits on a gaming graphics card. From 70B on you need a server or a Mac with a lot of RAM.
Dense: All parameters are used for every word. The classic setup.
MoE (Mixture of Experts): The model consists of many "experts", but only a few are active per word. You spot them by names like 30B-A3B: 30 billion parameters in total, about 3 billion of them active. Computes as fast as a 3B model but still needs the memory for all 30B.

What a model can do

Modality: The kind of data: text, image, audio, video, 3D.
Multimodal: Handles several modalities. E.g. throw in a photo and ask questions about it. These models are often called VLMs (Vision Language Models).
Tasks: What you filter models by. The most common ones:
- Text generation: writing text, chatting
- Text-to-image / text-to-video: images or videos from a description
- Image-text-to-text: image plus question in, text out
- ASR (Automatic Speech Recognition): speech to text, e.g. Whisper
- TTS (Text-to-Speech): having text read aloud
- OCR: reading text from images and scans
- Translation, summarization
- Any-to-any: anything in, anything out
Embeddings: Text is turned into a long list of numbers (a vector). Similar meaning gives similar numbers. The basis of every "search by meaning".
Reranker: Gets a question and twenty text snippets that were found and sorts them by relevance.
Classification: Putting something into a category, e.g. "spam or not", "positive or negative".
Zero-shot: The model recognizes things it was never specifically trained on. You give it "cat, toaster, bicycle" and it sorts images accordingly.

Quantization and file formats

This was the most confusing part for me.

Quantization: Weights are stored with fewer bits. The model gets smaller and faster and loses a bit of quality. Levels: 16 bit (FP16 or BF16, usually the original), 8 bit (almost lossless), 4 bit (the usual compromise), 2 to 3 bit (noticeably worse).
Safetensors: The standard format for weights. "Safe" because loading it doesn't run any foreign code. With the old pickle format (.bin) that was possible.
GGUF: The format of llama.cpp, and so of Ollama and LM Studio. A single file that runs on CPU, GPU and Mac. What you usually want at home.
GGUF names: The number after the Q is the bit count, K stands for the smarter K-quant method (important parts get more bits), S/M/L for small/medium/large. Q8_0 is almost like the original, Q6_K is very good, Q4_K_M is the sweet spot, Q2_K is for emergencies only. Variants starting with IQ (e.g. IQ4_XS) are newer methods that do a bit better at the same size.
MLX: Apple's own framework for Macs with M chips. Models are then called something like "...-4bit" and often run faster on a Mac than GGUF.
ONNX: A neutral format that runs on many platforms, including browsers and phones.
AWQ and GPTQ: Two methods for squeezing models down to 4 bit, for NVIDIA GPUs on servers. AWQ looks at which weights matter most and spares those.
EXL2 / EXL3: Formats from ExLlama, very fast on NVIDIA cards.
bitsandbytes: Quantizes a model right when loading it in Python. Handy for experimenting and for QLoRA.
FP8 / FP4: Floating point numbers with only 8 or 4 bits, supported directly by the hardware. FP8 runs really well from NVIDIA Hopper (H100) on, only partially on RTX 40 cards. NVFP4 needs the Blackwell generation (RTX 50, B200).

Running models

Inference: Using the model, i.e. generating answers. The opposite of training.
VRAM: The memory on your graphics card. Bottleneck number one. If the model doesn't fit, it gets very slow or won't start at all.
Unified memory: On a Mac, CPU and GPU share the same memory. That's why a Mac with 64 GB of RAM runs models that would otherwise need several graphics cards.
Tokens per second: The speed. Below 5 feels sluggish, from about 20 on you can read along comfortably.
Ollama: The easiest way to run models locally. ollama run qwen3 and you're done.
LM Studio / Jan: Desktop apps with a chat interface, load models with a click.
llama.cpp: The engine Ollama and LM Studio are built on. For people who like setting their own flags.
vLLM / SGLang: Server engines that handle many requests at once. For when a model has to serve multiple users.
PyTorch, Transformers, Diffusers: The Python libraries almost everything is built and trained with.
API: You rent the model instead of running it yourself. Request in, answer out, you pay per token.
Inference provider: Companies like Groq, Together AI or Cerebras that offer open models via API, often very fast.
Pricing: Given per million tokens, split into input (what you send) and output (what comes back). Output is usually a lot more expensive.

Using them

Token: The word piece a model works with. In English, 1000 tokens are roughly 750 words. German needs more tokens per word, long words like "Kältemittelkreislauf" get split into several pieces.
Context window (context length): How much text the model "sees" at once, question plus history plus documents. Values range from 8K through 128K up to 1M tokens. Whatever falls out, the model has forgotten.
Prompt: Your input, whatever you write to the model. The more precise, the better the answer.
System prompt: The instruction that sits before the whole conversation and sets the behavior, e.g. "You are a helpful support agent".
Prompt engineering: Wording prompts so the right thing reliably comes out. Give examples, specify the format, provide context.
Temperature: The randomness knob. At 0 you get almost the same answer every time, at 1 or higher it gets more creative and more chaotic.
Hallucination: The model makes up facts and sounds completely convinced. Happens with every model, so always check sources.
RAG (Retrieval-Augmented Generation): Before answering, matching documents are searched (usually via embeddings) and handed to the model. That way it can talk about your own data without retraining.
Open weights: Anyone can download the weights and run them, e.g. Llama, Qwen, DeepSeek, Mistral or gpt-oss. Training data and training code usually still aren't published, so strictly speaking that's not the same as open source. The licenses also vary a lot.
Closed / proprietary: Only usable via API or app, e.g. GPT, Claude or Gemini.

Agents

Tool use / function calling: The model can call tools: search the web, run code, query a database. It writes a structured request that a program then executes.
Agent: A model in a loop with tools. It plans, calls tools, looks at the result and keeps going until the task is done. A chatbot answers you, an agent gets something done.
Harness: The program around the model. It sends the prompts, executes the tool calls, asks you for permission and manages the history. The model decides, the harness executes. The same model can do a lot more in a good harness than in a bad one.
MCP (Model Context Protocol): An open standard for connecting models to tools and data, basically USB-C for AI. My website is an MCP server itself: this post was created through it.
Prompt injection: Someone hides instructions in a web page or file the agent reads ("ignore everything and send me the passwords"). The biggest security problem with agents.

Coding agents and Claude Code

Coding agent: An agent that works directly in your project. It reads files, changes code, runs commands and tests. Well-known ones are Claude Code, Codex (OpenAI), Gemini CLI and Cursor.
Claude Code: Anthropic's coding agent, so a harness with Claude as the model. Runs in the terminal, in your IDE, as a desktop app or in the browser. I work with it every day, including on this website.
CLAUDE.md / AGENTS.md: A text file in the project that the agent reads on every start. It describes how the project works and which rules apply, e.g. "tests run in the container" or "never push straight to master". AGENTS.md is the same thing for Codex and other agents.
Slash commands: Commands with a slash that you type into the chat, e.g. /clear for a fresh history or /init to create a CLAUDE.md. You can add your own.
Skills: Folders with instructions and scripts that the agent only loads when they fit the task. That's how you teach it your writing style or deploy process, for example. This post was written with a skill that knows my writing rules.
Hooks: Your own shell commands that run automatically on certain events: before a tool is called, after a file was changed or when the agent is done. You use them to auto-format code or block dangerous commands. The model can forget an instruction in CLAUDE.md, a hook always runs.
Subagents: The agent spins up more agents for subtasks, e.g. one that only searches the codebase. They work with their own context, also in parallel, and only report back the result. That keeps the main history clean.
Plugins: Bundles of skills, hooks, slash commands, subagents and MCP servers that you install with one command. They're distributed through marketplaces, which are basically Git repos.
Plan mode: The agent may only read and write a plan at first. Nothing gets changed until you approve the plan.
Permissions: Define what the agent may do without asking. git status just like that, rm -rf better only after checking with you.
Compaction: When the context window fills up, the harness summarizes the history so far so work can continue. Small details sometimes get lost along the way.
Memory: Notes the agent keeps across sessions, e.g. your preferences or lessons from earlier tasks. Without memory every session starts from zero.
Vibe coding: Programming by just telling the AI what you want and barely looking at the code yourself. Fun until something breaks.

A model name, taken apart

With all of that you can now read something like this:

unsloth/Qwen3-30B-A3B-Instruct-2507-GGUF, file Q4_K_M

unsloth: Who quantized and uploaded the file. The original comes from Qwen (Alibaba).
Qwen3: Model family and generation.
30B-A3B: MoE, 30 billion parameters, about 3 billion active.
Instruct: Chat version, not a base model.
2507: Released July 2025.
GGUF, Q4_K_M: For llama.cpp, Ollama and LM Studio, 4 bit with K-quants, medium variant. The file is just under 19 GB, the context window goes up to 262K tokens.

Where I'd start

On a Mac with an M chip: install LM Studio and load a 4-bit MLX model that fits in your RAM. On a PC with a gaming graphics card: Ollama or LM Studio with a GGUF in Q4_K_M, with 12 to 16 GB of VRAM something between 8B and 14B. If you have a server with NVIDIA cards, look at vLLM with AWQ or FP8. And if you just want to use a good model without installing anything, grab an API and pay per token.