AI Glossary: 100+ Terms Every Beginner Needs to Know

Artificial intelligence is the broad field of building computer systems that can do things normally associated with human thinking — recognizing what’s in a photo, understanding written language, holding a conversation, solving puzzles, or making decisions. The phrase is so broad it covers everything from spam filters in your email to ChatGPT.

When someone says “AI” in 2026, they usually mean a large language model like ChatGPT, Claude, or Gemini. But the term also includes image generators, voice assistants, recommendation systems on Netflix and Spotify, fraud-detection systems at your bank, and many things you’d never call “AI” out loud. The field is the umbrella; everything else in this glossary sits underneath it.

Machine learning is how computers learn to do something by looking at lots of examples instead of being told step-by-step what to do. You don’t write rules; you show the computer thousands or millions of examples and let it figure out the patterns on its own.

The classic illustration: to build a spam filter the old way, a programmer writes rules like “mark as spam if subject contains ‘free money’.” To build one with machine learning, you show the computer 100,000 emails labeled spam or not spam, and it works out the patterns itself. The result usually catches spam the rule-writer would have missed — including spam that uses words the rule-writer never thought of.

Machine learning is the foundation almost every modern AI tool sits on, including every large language model.

Deep learning is a kind of machine learning that uses a special structure called a neural network with many stacked layers — that’s the “deep” part. Each layer learns a slightly more complicated version of the patterns in the data.

Picture how you’d teach a child to recognize a cat. First they notice edges and shapes. Then they connect those shapes into ears, eyes, whiskers. Then they put it all together as “cat.” Deep learning works the same way: early layers spot simple things, middle layers spot parts, late layers spot the whole concept.

Almost every AI breakthrough of the last decade — image generation, large language models, voice cloning, protein folding — runs on deep learning.

A large language model is the AI behind ChatGPT, Claude, Gemini, and every other chatbot you’ve used in the last two years. It’s a program that was trained on huge amounts of writing — books, websites, articles, code — until it became extremely good at predicting what word comes next.

The “large” part is literal: today’s models have trillions of internal numbers (called parameters) and were trained on text equivalent to millions of books. The “language” part is also literal: the model learns the patterns of how humans actually use words.

You don’t need to know how an LLM works to use one. You type a question or a request, the model responds with text. That’s it. The depth shows up when you push it — the same model that writes a poem can also help debug code, draft a contract, or summarize a 200-page document.

A neural network is a kind of computer program inspired by — but very different from — how brains work. It’s a giant collection of simple math operations connected together in layers. Information flows in, each layer transforms it a little, and the answer comes out the other side.

Don’t get caught up in the “neural” word. The connection to biology is loose. What matters is that neural networks turned out to be very good at learning patterns from data — faces in photos, words in audio, the next word in a sentence. Every large language model is built from neural networks. So is every image generator, voice assistant, and most of the AI you actually use.

Training is how an AI model learns. You feed it huge amounts of data along with the answers (or let it work out the answers), and the model slowly adjusts its internal numbers until it gets things right more often than not.

For a large language model, training looks like this: take a sentence, hide the last word, ask the model to guess it. If it’s wrong, nudge the internal numbers a tiny bit toward the right answer. Now do that billions of times with different sentences. The result is a model that’s seen so much language it can write coherently about almost anything.

Training a frontier model in 2026 takes thousands of expensive GPUs running for weeks or months and costs tens to hundreds of millions of dollars. That’s why only a handful of companies (OpenAI, Anthropic, Google, Meta, xAI) train them.

Inference is what happens every time you actually use an AI model — you type a prompt, the model generates a response. It’s the opposite of training: training builds the model once; inference uses the trained model over and over.

When you ask ChatGPT a question, you’re triggering an inference run. The model takes your input, runs it through its neural network, and produces an output. Each inference is fast (often a second or two for short responses) but costs real money in computing power — especially at scale. That’s why ChatGPT free has usage limits and Pro doesn’t.

Parameters are the internal numbers a model uses to make predictions. They’re the “dials” that get tuned during training. A modern large language model has hundreds of billions to trillions of them.

Roughly speaking, more parameters means the model can capture more complicated patterns — but also costs more to train and run. GPT-3 had 175 billion parameters; current frontier models are believed to have many trillions. You’ll often see model names hint at this: Llama-3-70B has 70 billion parameters, Mistral-7B has 7 billion.

For users, parameter count is a rough size signal. Bigger isn’t always better — a well-trained smaller model often beats a poorly-trained larger one — but it correlates with capability.

A token is the smallest unit of text an AI model works with. It’s usually a chunk of a word — not a whole word, not a letter. The word “happening” might be one token; “sushi” might be two (“su” + “shi”); “antidisestablishmentarianism” might be a dozen.

You care about tokens because they’re how AI usage is priced and limited. ChatGPT’s context window is measured in tokens. The OpenAI and Anthropic APIs charge per million tokens. As a rough rule, 1,000 tokens is about 750 English words.

You don’t need to count tokens manually — the tools handle it. But knowing they exist explains why long documents fill up the context window and why some pricing is “per million tokens” instead of “per query.”

The context window is how much information an AI model can hold in mind at one time during a conversation. It includes your question, the model’s answer, everything you said earlier in the chat, any documents you uploaded, and any system instructions the developers set.

Context windows are measured in tokens. In 2026, common sizes range from 128,000 tokens (about 100,000 words — a long novel) to 2 million tokens (an entire book series). When you exceed the limit, the model starts to forget the earliest parts of the conversation.

For day-to-day use, this almost never matters. For long-document analysis, code review across many files, or extended multi-hour conversations, it matters a lot. Models from Gemini and Claude currently lead on context-window size.

Generative AI is the part of AI that creates new things — text, images, video, audio, code — instead of just classifying or analyzing existing data. Every popular AI tool you can name (ChatGPT, Claude, Midjourney, DALL-E, Suno, Sora) is generative AI.

The category exploded in late 2022 with ChatGPT and Stable Diffusion and has reshaped most knowledge work since. “Generative AI” is what most people mean when they say “AI” in casual conversation in 2026.

It’s distinct from older AI systems that classify (this email is spam) or predict numbers (the stock will go up tomorrow). Generative AI produces rather than judges.

A prompt is the text you type into an AI tool to tell it what you want. “Write a haiku about coffee” is a prompt. So is a 500-word brief telling the model exactly how to draft a contract. Anything you give the model is a prompt.

Prompts are the single biggest factor in whether an AI gives you something useful. Two people can use the same model with very different results, entirely because of how they wrote their prompt. The skill of writing better prompts is called prompt engineering.

Prompt engineering is the practice of writing prompts that reliably get useful results from AI models. It includes techniques like giving the model a clear role (“you are an editor”), showing examples of what good output looks like, telling it to think step by step, and being specific about the format you want.

You don’t need a technical background to do it. Most of prompt engineering is just being clearer about what you want than you’d be when asking a person. State the audience, the length, the tone, what to avoid, and what good looks like. The clearer the prompt, the better the result.

For beginners, learning the STACK framework (Situation, Task, Audience, Constraints, Format) covers about 80% of useful prompting.

Fine-tuning is when a company takes an already-trained AI model and trains it a little more on specialized data so it gets better at a specific task. It’s like hiring a professional editor and giving them your style guide.

You almost never fine-tune as an end user. It’s something AI labs and large companies do. For example, OpenAI starts with a base model and fine-tunes it to be helpful, harmless, and honest before releasing it as ChatGPT. A law firm might fine-tune a model on its own contracts to make it better at the firm’s specific style.

For most uses today, RAG (Retrieval-Augmented Generation) and good prompts work better than fine-tuning. Fine-tuning makes sense when you need consistent specialized behavior at scale.

RAG is a technique that lets an AI model answer questions using your specific documents instead of just its training data. Before answering, the system searches your files, pulls the most relevant snippets, and gives them to the model along with your question.

Without RAG, asking ChatGPT “what does our company policy say about remote work?” gets you a generic guess. With RAG, the system retrieves the actual policy document first and the model answers from it — usually with the right page reference.

RAG is what powers most company-specific AI tools: knowledge-base assistants, document Q&A, customer-support bots that know your products. Google’s NotebookLM is a consumer-friendly version of the same idea.

A hallucination is when an AI model confidently states something that isn’t true. The model didn’t “lie” — it just generated plausible-sounding text that turned out to be wrong. Made-up citations, invented dates, non-existent court cases, and wrong API documentation are all hallucinations.

Hallucinations happen because LLMs predict the next word based on patterns, not by checking facts. The same mechanism that helps them write fluently also generates confident-sounding falsehoods when they don’t actually know something.

Practical defense: don’t trust factual claims from any AI without verifying. For research, use tools that cite sources (Perplexity, NotebookLM, ChatGPT with web browsing). For anything you’d be embarrassed to be wrong about, double-check.

An embedding is the AI version of a fingerprint for a piece of text. The model converts a sentence, paragraph, or whole document into a long list of numbers (typically 1,000 to 4,000 of them) that captures its meaning in a way computers can compare.

You don’t see embeddings as an end user. But they power a lot of what you do see: similar-document search, “you might also like” recommendations, semantic search that finds “dog photos” even when the file is named IMG_4521.jpg, and the retrieval step in RAG.

The key property: two things with similar meaning have similar embeddings, even if they share no words. “Car” and “automobile” end up close together; “car” and “cardinal” end up far apart.

Temperature is a setting that controls how predictable or creative an AI model’s responses are. Low temperature (close to 0) makes the model deterministic and conservative — it’ll pick the most likely next word every time. High temperature (1 or above) makes it more random and creative — it’ll sometimes pick less obvious words.

You don’t usually see temperature when chatting with ChatGPT or Claude — it’s set to a sensible default. It shows up when you use the API or developer tools. For factual Q&A you want low temperature (0.0–0.3). For brainstorming or creative writing you want higher (0.7–1.0).

Zero-shot means asking an AI to do a task without giving it any examples first. You just describe the task and the model figures it out from its general training. “Classify this email as spam or not spam” with no examples is a zero-shot prompt.

Modern LLMs are remarkably good at zero-shot tasks they were never specifically trained for — that’s one of the things that makes them useful. But for tricky or specialized tasks, giving the model a few examples (called few-shot) often produces better results.

Few-shot means giving an AI two to five examples of what good output looks like before asking it to do the same on a new input. It’s one of the highest-leverage prompting techniques.

Instead of saying “summarize this article in my voice,” you’d paste three articles you’d already written summaries for — showing what your voice and structure look like — then paste the new article. The model copies the pattern. Few-shot dramatically improves output for anything where consistency matters: writing style, output format, classification, structured extraction.

Multimodal AI is a single model that can handle more than one kind of input or output — text, images, audio, video — not just one. Gemini can look at a photo and answer questions about it. ChatGPT‘s voice mode listens to you talk and talks back. Claude can read a PDF, look at a chart, and write the analysis in one conversation.

In 2026 most major AI assistants are multimodal by default. The shift from text-only to multimodal happened roughly between 2023 and 2025 and is one of the biggest practical upgrades the field has had — you can now point your phone at something and ask “what is this and how do I fix it?”

An AI agent is an AI system that doesn’t just answer your question — it takes actions to accomplish a goal. You tell it “book me a flight to Lisbon next Tuesday under $700,” and the agent opens a browser, searches multiple airlines, compares results, and reports back (or actually books, if you let it).

Agents are LLMs hooked up to tools: a web browser, your calendar, your email, a code interpreter, your file system. The model decides what tool to use, uses it, looks at the result, and decides what to do next. The loop is what makes it an agent rather than a chatbot.

2025-2026 has been the year agents went from research demos to actual products: OpenAI’s ChatGPT agent mode, Anthropic’s Claude with computer use, Google’s Project Mariner. They’re still imperfect — long workflows go off the rails — but the trajectory is clear.

Tool use is what lets an AI model do things beyond generating text — search the web, do precise math, run code, query a database, send an email, or move files. The model decides when to reach for a tool, calls it, and uses the result.

Without tool use, asking an LLM “what’s the current price of Bitcoin?” gets you a guess based on training data. With tool use, the model calls a web-search tool, reads the live price, and gives you the right answer with a source. Tool use is what turns a chatbot into something genuinely useful for real-world tasks.

Tool use is also the foundation of AI agents — agents are LLMs with access to many tools, deciding which to call in what order.

Function calling is the technical pattern that makes tool use work. Developers register a list of functions the AI can call (each with a name, description, and inputs); the model, when relevant, generates a structured request to call one; the developer’s code runs the function and returns the result; the model continues.

As an end user you mostly experience the results. But if you’re building anything with the OpenAI or Anthropic API, function calling is the mechanism. It’s how a customer-support bot looks up a real order, how a research assistant pulls from a database, how an agent buys you a flight.

A base model is the raw output of pretraining — the model fresh out of seeing trillions of words of internet text, before anyone has shaped it to be helpful or harmless. Base models are good at completing text but lousy at following instructions. Ask a base model “what’s the capital of France?” and it might continue with “What’s the capital of Germany? What’s the capital of Spain?” instead of just answering.

You don’t interact with base models directly — they’re a stepping stone. The version you actually use (ChatGPT, Claude, Gemini) has been through additional training (see instruction-tuned model and RLHF) to make it conversational and useful.

An instruction-tuned model is a base model that’s been trained additionally to follow instructions. Instead of just continuing text, it understands “summarize this,” “translate that,” or “rewrite in a friendlier tone” and does the thing.

Almost every consumer AI assistant is instruction-tuned. The training process involves showing the model thousands of example (instruction, good response) pairs so it learns the pattern of helpful responses. After instruction tuning, models usually go through RLHF to refine helpfulness further.

An API (Application Programming Interface) is how one piece of software talks to another. The OpenAI API lets developers integrate ChatGPT into their own apps. The Anthropic API does the same for Claude.

For most users, the API never matters directly — you just use the web app or mobile app. But it explains why every AI tool you encounter (a chatbot inside a website, an AI writing feature in Notion, a customer-service agent) might be calling the same underlying model. The API is the plumbing.

The transformer is the specific kind of neural network design behind every modern large language model. It was introduced in a 2017 paper by Google researchers titled “Attention Is All You Need.” The architecture turned out to scale up extraordinarily well, and the resulting flood of models eventually produced ChatGPT.

You don’t need to know how transformers work to use AI. But if you’ve ever wondered why so many model names end in “T” (GPT, BERT, T5), that’s why — it stands for “Transformer.”

A vector database is a specialized database for storing embeddings — the long lists of numbers that represent the meaning of text. It’s optimized to answer “find me the things most similar to this” quickly across millions of entries.

Vector databases power most RAG systems. When a user asks a question, the question gets converted to an embedding, the vector database returns the most similar stored embeddings (and the original text they came from), and that text gets fed into the LLM as context.

You’ll only deal with vector databases if you’re building AI tools. As an end user, they’re behind-the-scenes plumbing.

An agentic workflow is a multi-step task an AI agent handles autonomously — researching across multiple sources, then writing a summary, then emailing it; or planning a trip by checking flights, hotels, and your calendar in sequence. The agent decides what step to take next based on what it found in the previous step.

Agentic workflows are what make agents useful in practice. A single AI action is rarely interesting; a chain of actions ending in a real outcome (a draft, a booking, a fix) is. The downside: long chains accumulate errors. The agent might be right on each step but wrong about the whole picture — one wrong assumption early on cascades.

Best practice in 2026: agentic workflows for research, comparison shopping, and structured data extraction work well. For anything with real money or legal consequences, keep a human in the approval loop.

RLHF is one of the steps that turns a raw language model into something genuinely helpful. After basic training, the model goes through a process where humans rate its outputs — this answer is better than that one — and the model gradually learns to produce the kinds of answers humans rate highly.

It’s why modern LLMs are friendlier, more polite, and more aligned with what users actually want than the same models would be straight out of pretraining. RLHF was first popularized by OpenAI’s work on InstructGPT (the model behind early ChatGPT) and is now standard across the industry.

It has limits — RLHF teaches models to produce responses humans rate well, which isn’t always the same as responses that are correct or wise. But it’s the difference between a model that’s useful in daily life and one that isn’t.

AI safety is the field focused on making sure AI systems do what we actually want them to do, and don’t cause harm — especially as they become more capable and more autonomous. Concerns range from immediate ones (a model giving dangerous medical advice, a chatbot generating phishing emails) to long-term ones (highly capable agents pursuing goals that don’t match human values).

Practical AI safety work in 2026 includes red-teaming (deliberately trying to make models fail), building filters against harmful outputs, testing how models behave in unusual situations, and watching for unexpected behavior at scale. Anthropic, OpenAI, Google DeepMind, and a growing list of universities all have dedicated safety teams.

For end users, AI safety mostly shows up as the model declining certain requests — refusing to write malware, refusing to give medical dosing advice, etc. Those refusals exist because of safety research.

AI alignment is the part of AI safety focused on the harder problem: making sure an AI’s goals actually match human values — not just in the cases the developers tested, but in novel situations the developers never imagined. A perfectly aligned AI does what you meant, not just what you said.

The problem is harder than it sounds because human values are messy, contradictory, and hard to write down precisely. Worse, a sufficiently capable AI might find clever ways to satisfy the letter of an instruction while missing the spirit of it.

Anthropic, the company behind Claude, was founded explicitly around this problem. You’ll see alignment come up whenever people debate whether more capable AI systems should be paused, regulated, or built differently. It’s a real open research problem, not a solved one.