The AI Dictionary: Every Term You Need to Know, Explained Simply

If you have ever read an article about AI and felt lost by the third paragraph, you are not alone. The field moves fast, and the jargon piles up even faster. This glossary cuts through the noise. Every term is explained in plain language, organized from the basics up to the concepts that even practitioners sometimes struggle to articulate.

Bookmark this page. You will come back to it.

The Fundamentals

Artificial Intelligence (AI): A broad term for software that performs tasks usually requiring human thinking. Recognizing faces in photos, translating languages, recommending what to watch next. If a machine does something that looks like it requires intelligence, someone will call it AI.

Machine Learning (ML): A subset of AI where instead of writing exact rules, you feed data to an algorithm and let it figure out the patterns on its own. Think of it like teaching a child to recognize dogs. You do not describe every breed. You show them hundreds of pictures and they learn what a dog looks like.

Deep Learning: Machine learning using neural networks with many layers. "Deep" refers to the number of layers, not the depth of understanding. More layers allow the network to learn increasingly abstract patterns, from edges in an image to entire faces.

Neural Network: A system loosely inspired by the human brain. It consists of layers of connected nodes (neurons) that process information. Each connection has a weight that adjusts during training. Despite the name, it works nothing like an actual brain. It is math, not biology.

Model: The end product of training. When someone says "GPT-4o" or "Claude Fable 5," they are referring to a model: a file containing billions of learned parameters that can process input and generate output. Think of it as a finished recipe that took enormous resources to develop but can now be used repeatedly.

Parameter: A single tunable number inside a model. Modern large language models have billions of them. During training, each parameter adjusts slightly to reduce errors. The collection of all parameters is what gives a model its capabilities.

Training: The process of feeding data to a model and adjusting its parameters until it performs well. Training a large model can take weeks on thousands of GPUs and cost millions of dollars. Once trained, the model is fixed and ready to use.

Inference: Using a trained model to generate predictions or outputs. When you ask ChatGPT a question, that is inference. Training happens once (or periodically). Inference happens every time someone uses the model.

Dataset: The collection of data used to train a model. Quality matters more than quantity. A dataset full of errors or biases produces a model full of errors or biases. Garbage in, garbage out applies to AI as much as anything else.

GPU (Graphics Processing Unit): Originally designed to render video game graphics, GPUs turned out to be excellent at the parallel math that AI requires. Training and running AI models is overwhelmingly done on GPUs, primarily from NVIDIA.

TPU (Tensor Processing Unit): Google's custom chip designed specifically for AI workloads. Where GPUs are general-purpose parallel processors adapted for AI, TPUs are purpose-built from the ground up for tensor (matrix) operations.

Language Models and How They Work

Large Language Model (LLM): A model trained on massive amounts of text to understand and generate human language. "Large" refers to both the training data (often trillions of words) and the model size (billions of parameters). GPT-4, Claude, Gemini, and LLaMA are all LLMs.

Token: The basic unit an LLM works with. Not exactly a word. The sentence "I love AI" is three words but might be three or four tokens depending on the model's tokenizer. Roughly, one token is about three-quarters of a word in English. Models have token limits for both input and output. Want to see how text breaks into tokens? Try the Token Counter tool on this site.

Context Window: The maximum number of tokens a model can process at once, including both the input and the output. A 128K context window means the model can consider approximately 100,000 words at a time. Longer context windows allow the model to work with larger documents but require more memory and compute.

Prompt: The input you give to a model. This can be a question, an instruction, a document to summarize, or any combination. The quality of the output depends heavily on the quality of the prompt, which is why prompt engineering became its own discipline.

Prompt Engineering: The practice of crafting inputs to get better outputs from AI models. Techniques include providing examples (few-shot), asking the model to think step by step (chain-of-thought), and assigning the model a role. It is less engineering and more communication.

Hallucination: When a model generates confident-sounding but factually incorrect information. The model is not lying. It does not know what is true. It predicts what text should come next based on patterns, and sometimes those patterns produce plausible-sounding nonsense.

Temperature: A setting that controls randomness in the model's output. Low temperature (0.0-0.3) makes the model more deterministic and focused. High temperature (0.7-1.0) makes it more creative and varied. Think of it as a dial between "play it safe" and "take risks."

Transformer: The neural network architecture behind modern LLMs. Introduced in 2017 in the paper "Attention Is All You Need," transformers use an attention mechanism to weigh the importance of different words relative to each other. Nearly every major language model today is built on this architecture.

Attention Mechanism: The core innovation in transformers. It allows the model to look at all parts of the input simultaneously and decide which parts are most relevant to each other. When processing "The cat sat on the mat because it was tired," attention helps the model understand that "it" refers to "the cat."

Self-Attention: A specific type of attention where each token in a sequence looks at every other token to understand relationships. This is what makes transformers so powerful at understanding context. It is also what makes them computationally expensive, since the cost grows with the square of the sequence length.

Under the Hood

Embedding: A way to represent words, sentences, or concepts as lists of numbers (vectors) so that similar things end up close together in mathematical space. "Dog" and "puppy" would have similar embeddings. "Dog" and "democracy" would not. Embeddings are how models understand meaning.

Vector Database: A database optimized for storing and searching embeddings. Instead of searching by exact matches like a traditional database, it finds items that are semantically similar. Essential for RAG systems and recommendation engines.

Fine-Tuning: Taking a pre-trained model and training it further on a specific, smaller dataset to specialize it for a particular task. Like taking a general physician and putting them through a surgical residency. The broad knowledge remains, but the specialization improves.

RLHF (Reinforcement Learning from Human Feedback): A technique used to align a model's behavior with human preferences. Human evaluators rank the model's outputs, and the model learns to produce responses that humans rate highly. This is a major part of what makes models like Claude and ChatGPT helpful rather than just technically capable.

KV Cache (Key-Value Cache): When a language model generates text one token at a time, it needs to look back at everything it has already processed. Without caching, it would recalculate the attention for every previous token at each step. The KV cache stores these intermediate calculations (the "keys" and "values" from the attention mechanism) so they do not need to be recomputed. This makes inference dramatically faster but requires significant GPU memory, especially with long context windows.

Quantization: Reducing the precision of a model's numbers to make it smaller and faster. A parameter stored as a 32-bit number takes four times the memory of an 8-bit number. Quantizing from 32-bit to 8-bit (or even 4-bit) shrinks the model dramatically with surprisingly little quality loss. This is how large models run on consumer hardware.

Distillation: Training a smaller "student" model to mimic a larger "teacher" model. The student learns not just the correct answers but the teacher's confidence distribution across all possible answers. The result is a small model that punches above its weight because it learned from a larger one.

Mixture of Experts (MoE): An architecture where the model contains multiple specialized sub-networks (experts) and a router that decides which experts to activate for each input. Only a fraction of the model runs on any given input, making it possible to have a massive model that is efficient to run. Mixtral and some versions of GPT-4 use this approach.

Latency: The time between sending a request and receiving the first token of the response. In AI applications, latency matters enormously for user experience. Nobody wants to wait five seconds for a chatbot to start responding.

Throughput: The total number of tokens a system can generate per second across all users. High throughput means the system can serve many users simultaneously. Latency is about speed for one user. Throughput is about capacity for all users.

FLOPS (Floating Point Operations Per Second): A measure of how much math a processor can do per second. AI workloads are measured in petaFLOPS (quadrillions of operations per second). When NVIDIA announces a new GPU, the FLOPS number is the headline spec.

Retrieval, Agents, and Applications

RAG (Retrieval-Augmented Generation): A technique that gives a language model access to external knowledge by retrieving relevant documents before generating a response. Instead of relying solely on what it learned during training, the model can reference up-to-date or proprietary information. This reduces hallucinations and keeps responses current.

Agent: An AI system that can take actions, not just generate text. An agent might browse the web, write and execute code, manage files, or interact with APIs. The model decides what actions to take based on the goal it was given. Agents turn language models from advisors into workers.

Tool Use (Function Calling): The ability of a model to recognize when it needs an external tool and generate the correct call to use it. When you ask Claude to search the web or run a calculation, it is not doing those things itself. It is generating a structured request to a tool that performs the action.

Agentic Workflow: A multi-step process where an AI agent plans, executes, observes results, and adjusts its approach. Unlike a single prompt-response cycle, agentic workflows involve loops of reasoning and action. Think of the difference between asking someone a question and hiring someone to complete a project.

Multimodal: A model that can process multiple types of input: text, images, audio, video. GPT-4o, Claude, and Gemini are multimodal. They can look at a photo and describe it, or listen to audio and transcribe it, rather than being limited to text only.

API (Application Programming Interface): In the AI context, the interface that allows developers to send requests to a model and receive responses programmatically. Instead of using a chat interface, applications communicate with models through APIs to build products like customer service bots, coding assistants, or content generators.

Training Concepts

Epoch: One complete pass through the entire training dataset. Training typically involves multiple epochs. Too few epochs and the model has not learned enough. Too many and it starts memorizing the training data instead of learning general patterns.

Overfitting: When a model memorizes the training data instead of learning general patterns. An overfit model performs brilliantly on training data and poorly on anything new. It is like a student who memorizes test answers but cannot solve new problems.

Loss Function: A mathematical formula that measures how wrong the model's predictions are. During training, the goal is to minimize the loss. Think of it as a score where lower is better. The model adjusts its parameters to push this score down.

Gradient Descent: The optimization algorithm that adjusts model parameters to minimize the loss function. Imagine standing on a mountain in fog. You cannot see the bottom, but you can feel which direction slopes downward. You take a step downhill. Repeat. That is gradient descent.

Backpropagation: The method for calculating how much each parameter contributed to the error, working backward through the network. It answers the question: "Which parameters should change, and by how much, to reduce the error?" This is the core mechanism that makes training neural networks possible.

Batch Size: The number of training examples processed together before updating the model's parameters. Larger batches give more stable updates but require more memory. Smaller batches update more frequently but with more noise. Finding the right batch size is part of the art of training.

Learning Rate: How much the model adjusts its parameters with each update. Too high and the model overshoots optimal values and never converges. Too low and training takes forever or gets stuck. Most training runs adjust the learning rate over time, starting higher and gradually reducing it.

Safety and Alignment

Alignment: The challenge of ensuring AI systems do what humans actually want, not just what they were literally told. A model asked to "make users happy" might learn to tell people what they want to hear rather than what is true. Alignment research tackles these gaps between instruction and intent.

Guardrails: Safety measures built into AI systems to prevent harmful, inappropriate, or unreliable outputs. These can be rules, filters, additional models that evaluate outputs, or training techniques like RLHF. Guardrails are why models refuse certain requests.

Red Teaming: Deliberately trying to make an AI system fail or produce harmful outputs to discover vulnerabilities before deployment. Named after the military practice of having a team play the adversary. Red teaming is essential for understanding where guardrails break down.

Benchmark: A standardized test used to compare AI models. MMLU tests knowledge across dozens of subjects. HumanEval tests coding ability. Benchmarks provide a common measuring stick, though they can be gamed and do not always reflect real-world performance.

Deployment and Infrastructure

Edge Inference: Running AI models on devices close to the user (phones, laptops, IoT devices) rather than in the cloud. Edge inference reduces latency, works offline, and keeps data private. The trade-off is limited compute power, which is why quantization and distillation matter.

Model Serving: The infrastructure and software for running a trained model in production to handle user requests. This includes load balancing, batching requests, managing GPU memory, and scaling up or down based on demand. Frameworks like vLLM, TensorRT-LLM, and Triton handle this.

ONNX (Open Neural Network Exchange): A standard format for representing AI models that allows them to be moved between different frameworks and hardware. Train in PyTorch, export to ONNX, run on any hardware with an ONNX runtime. Portability for models.

Tensor: A multi-dimensional array of numbers. A scalar is a 0-dimensional tensor. A vector is 1-dimensional. A matrix is 2-dimensional. The higher-dimensional arrays that flow through neural networks are all tensors, which is why the math libraries are called TensorFlow and PyTorch.

CUDA: NVIDIA's programming platform that allows developers to use NVIDIA GPUs for general-purpose computing, including AI. CUDA's dominance in the AI ecosystem is a major reason NVIDIA GPUs are the default choice for AI workloads. Most AI frameworks are built on top of CUDA.

Emerging Concepts

Synthetic Data: Training data generated by AI models rather than collected from the real world. When real data is scarce, expensive, or privacy-sensitive, synthetic data can fill the gap. The risk is that training on AI-generated data can amplify errors and biases in a feedback loop.

Sparse Attention: A modification to the attention mechanism that only computes attention between select token pairs rather than all pairs. This reduces the computational cost from quadratic to roughly linear, enabling much longer context windows without proportional cost increases.

Constitutional AI: An alignment technique developed by Anthropic where the model is trained to follow a set of principles (a "constitution") rather than relying solely on human feedback. The model critiques and revises its own outputs based on these principles during training.

Speculative Decoding: A speed optimization where a smaller, faster "draft" model generates several tokens quickly, and the larger model verifies them in a single pass. If the draft tokens are acceptable, the system gains speed without sacrificing quality. When the draft is wrong, the large model corrects it. This works because verification is cheaper than generation.

The field continues to evolve, and new terms emerge regularly. But the fundamentals described here provide the foundation for understanding where AI is headed next. When you encounter a new concept, chances are it builds on something in this glossary.

Related Reading

• Why the Same Text Costs More on GPT Than on Gemini: How AI Tokenizers Actually Work
• How to Choose a Local LLM: Reading Ollama Model Tags (2026 Guide)
• Jev and the Rise of Decision Models: What Changes When AI Returns Probabilities Instead of Text

References

• Vaswani, A. et al. "Attention Is All You Need," 2017. arxiv.org/abs/1706.03762↗
• Anthropic. "Constitutional AI: Harmlessness from AI Feedback," 2022. arxiv.org/abs/2212.08073↗
• Meta AI. "LLaMA: Open and Efficient Foundation Language Models," 2023. arxiv.org/abs/2302.13971↗
• NVIDIA. "CUDA Toolkit Documentation." docs.nvidia.com/cuda↗
• Hugging Face. "Transformers Documentation." huggingface.co/docs/transformers↗