You cannot use, trust, or secure a thing you cannot name. This is a plain-language map of the whole GenAI vocabulary, built in the order the ideas actually depend on each other: from the smallest unit a model reads, up through memory and retrieval, to agents that act, and finally to the three jobs of the people who build with them. No term is skipped, and each one arrives only when you need it.
Every field hides behind its vocabulary, and this one moves fast enough that the words arrive faster than the understanding. The fix is not to memorize a glossary. It is to meet each term exactly when the idea before it makes it necessary, so the words hang on a structure instead of floating loose.
That structure is the plan of this guide. First the model itself, and how it is born. Then the memory we bolt on so it can know things. Then the loop that lets it act, and the ways many of them work together. And finally the three distinct jobs of building with all of it. Every term you have half-heard, embedding, RAG, agent, MCP, harness, lands in its place along the way.
A model cannot see letters or words the way you do. The first thing that happens to your text is that it gets chopped into tokens: chunks that are often a word, sometimes a piece of one, and each token is turned into a number the machine can work with. Hover the pieces to see how your sentence really looks to the model.
Those billions of numbers the model learned, the settings that turn an input token stream into a sensible output, have a name too: parameters, also called weights. When you hear a model is "70 billion parameters," that is the count of those dials. More dials can mean more capability, and always mean more cost to run.
Nearly every modern model is a transformer, and its breakthrough is a mechanism called attention. Instead of reading left to right one word at a time, it looks at every word at once and, for each one, weighs how much every other word matters to it. Scroll to watch attention resolve a word whose meaning depends on its neighbors.
"She sat by the bank and watched the river." Does "bank" mean money or riverside? The word alone cannot tell you.
To understand "bank," the model looks at all the other words at the same time, not just the ones nearby, and asks how relevant each is.
"river" lights up strongly; "watched" and "sat" a little; "she" barely at all. Those weights are the attention. The thicker the line, the more that word shapes the meaning of "bank."
Pulled toward "river," the model settles on riverside, not finance. It did this for every word at once, in parallel, which is why transformers are fast and good at long-range context.
Where does the skill come from? From pretraining: a single, staggeringly expensive pass where the model reads an enormous slice of the internet and books and code, learning only to predict the next token. Do that at scale and it absorbs grammar, facts, styles, and reasoning patterns as a side effect. The result is a foundation model: big, general, and adaptable to countless tasks.
Straight out of pretraining, it is a base model. A base model is a magnificent autocomplete: give it "The capital of France is" and it says "Paris," but ask it a question and it might just continue with more questions, because it learned to continue text, not to help you. It knows a great deal and takes no instruction.
To make the knowledgeable graduate genuinely helpful, it goes through RLHF, reinforcement learning from human feedback. People compare the model's answers and prefer the helpful, honest, harmless ones, and the model is nudged to produce more of those. The output is an instruct model or chat model: the same knowledge, now shaped to follow instructions and hold a conversation.
This is the thing you actually talk to. When people say LLM (large language model) they usually mean one of these chat models, and GPT (generative pre-trained transformer) is one famous family whose name became shorthand for the whole category. Base underneath, manners on top.
Actually using a trained model is called inference: text goes in, text comes out, once. The single most surprising fact for newcomers hides here. That call is stateless. The model remembers nothing between calls. Every message you send, it reads fresh, with no memory of the last one unless you resend it. The "conversation" you feel is an illusion the app maintains by resending the whole history each time.
Models also come in sizes, and the biggest, newest, most capable ones are called frontier models. Frontier is a moving line: whatever sits at the edge of capability today. Bigger is not automatically better to deploy, though, because of a trade-off worth naming.
Since the model forgets between calls, the only thing it knows in the moment is whatever you put in front of it: your question, the conversation so far, any documents you paste. That whole in-the-moment view has a name and a size limit, the context window. It is the model's short-term memory, its working desk, and it is finite. Fill it up and the oldest things fall off the edge.
Which raises the real question of memory. You cannot paste your whole company handbook onto the desk every time, and it would not fit. So how do you give the model the right knowledge, at the right moment, from a library far too big for the desk? The answer starts with turning meaning into numbers.
Here is the trick that makes searchable memory possible. Any piece of text can be turned into a list of numbers, an embedding, positioned so that things which mean similar things land near each other. "dog" and "puppy" get nearby numbers; "dog" and "invoice" get distant ones. Meaning becomes a location. Hover the coordinates of one word.
Store millions of these embeddings in a special database that can instantly find the nearest ones to any query, and you have a vector database. Ask it "anything about returns?" and it hands back the passages whose meaning sits closest, even if they never used the word "returns." It is a search that works by meaning, not by matching keywords.
Now assemble it. When you ask a question, the system finds the relevant passages and lays them on the desk before the model answers. That is RAG, retrieval-augmented generation, and it is how most real AI products know about your private, current, or specific data. Scroll the pipeline.
"What is our refund window for damaged items?" The model has never seen your policy; it was trained on the public internet, not your documents.
The question becomes a meaning-vector, the same kind of coordinates your documents were stored as. Now they can be compared.
The database returns the few passages whose meaning sits nearest the question. Your actual refund policy lights up, even if it never says "window."
Those passages are pasted into the context window alongside the question. The model now has the facts in front of it, for this one answer.
The model replies using the retrieved text, not its memory. The answer is current, specific, and traceable to your real document.
There is a cheaper cousin worth naming. If your knowledge is small and stable, you can skip the per-question search and just preload the whole thing into the context window once, then ask many questions against it. That is CAG, cache-augmented generation. RAG fetches the right pages on demand; CAG hands over the whole short book up front. Big or changing knowledge wants RAG; small and fixed wants CAG.
So far the model only answers. To make it do things, you wrap that stateless inference in a repeating loop. A model in such a loop is an agent, and the loop itself, often called ReAct, cycles through perceive, reason, act, observe. Scroll one turn of the wheel.
The agent reads the current state: the goal, what it has done so far, whatever came back from its last action. This is its input for this turn.
The model thinks about what to do next. "I need an open table Friday; I should check the booking system." A single inference produces this decision.
It takes an action in the world: calls a tool, searches, sends a request. This is the step that makes it an agent rather than a chatbot; it can reach outside itself.
It reads the result of the action. "The 8pm slot is free." That observation becomes part of what it perceives next turn.
Perceive, reason, act, observe, again and again, each turn a fresh stateless inference fed the growing history, until the goal is met. The loop is what turns a forgetful answer-machine into something that pursues a goal.
That notepad is not one thing. A capable agent juggles several kinds of memory, borrowed by name from how psychologists describe human memory. Hover each to see what it holds and where it lives.
The important thing is that only one of these, working memory, is the context window inside the model. Sensory, long-term, and collective memory all live outside the model, in databases and files that the surrounding code loads onto the desk when needed. The model stays amnesiac; the system around it remembers.
The "act" step needs things to act with. Those are tools: functions an agent can call to search, run code, query a database, send a message. The model does not run them; it asks, and the surrounding code runs them and hands back the result. Then come the standards that stop every tool and every agent from being a custom wiring job. Hover each to see what it is.
Here is the idea that ties the whole guide together. Everything in Part III, the loop, the tools, the memory stores, the permission checks, the code that assembles the prompt and runs the actions, is called the harness. And the fundamental equation of building with AI is simple: an agent is a model plus a harness.
This decomposition explains something that confuses everyone. Two products can use the exact same underlying model and behave completely differently, one careful and capable, one clumsy, because the harness around the model is different. The model supplies raw intelligence. The harness supplies memory, tools, guardrails, and the loop. Most of what makes an AI product good or bad, safe or dangerous, lives in the harness, not the model.
All the vocabulary finally resolves into the three distinct jobs of people who build with AI, and they nest inside each other like rings. Drag the scope from the smallest job to the largest, and watch what you are responsible for, and what the same model can do, grow with it.
That progression is the shape of the whole field. Prompt engineering is crafting one good instruction; your unit of work is a string. Context engineering is curating everything the model sees, the retrieved documents, the memory, the history; your unit is the whole context window. Agentic engineering is designing the harness itself, the loop, the tools, the protocols, the permissions; your unit is the entire system. Every term in this guide belongs to one of these rings.
A model reads tokens and weighs them with attention.
It learns by reading, then learns manners, then answers once and forgets.
We give it memory with embeddings and retrieval, and agency with a loop and tools.
Wrap a model in a harness and you have an agent. Name each piece, and none of it is magic.
Assemble everything you just named. Start with a bare model and add the parts, retrieval for knowledge, a loop for action, tools, memory, and watch what it can do, and what you now have to manage, both grow. The presets rebuild three real systems.
Seven rabbit holes the main path stepped around. Each stands alone.