The ingredients you're engineering

Context engineering becomes concrete once you can see the ingredients — the distinct kinds of information that together make up everything the model sees. This lesson names the six, so the rest of the course has a shared vocabulary. Every context you'll ever engineer is some combination of these.

1. System prompt / instructions. The standing directions that set the model's role, rules, and behavior. This is the prompt-engineering part — still essential — now understood as one ingredient of the context. (Module 2 covers getting these to the "right altitude.")

2. Few-shot examples. Concrete demonstrations of the input-output behavior you want. Examples are often the highest-signal way to convey a pattern — "pictures worth a thousand words" — but they cost tokens, so they must be curated, not dumped (Module 2).

3. Retrieved knowledge (RAG). External information pulled into the context to ground the model in facts it wasn't trained on or that are specific to you — your documents, a knowledge base, live data. The art is retrieving what's relevant, not everything (Module 2).

4. Tool definitions and tool results. For models that can use tools, the context includes the definitions of available tools (what they do, when to use them) and the results those tools return when called. Both consume budget; bloated tool sets and piled-up results are common failure modes (Modules 2 and 4).

5. Conversation history / memory. Everything said so far in the interaction, plus any information carried over from before. This accumulates over a conversation or an agent's run, which is why managing it — summarizing, pruning, offloading — becomes essential on long tasks (Modules 3 and 4).

6. The user query. The actual request the whole context is assembled to serve. Everything else exists to help the model answer this well.

How they fit together. At any moment, the model sees some blend of these six, all sharing the same finite attention budget. Context engineering is the craft of deciding, for a given task: which ingredients to include, how much of each, in what order, and what to leave out — so that the total is the smallest set of high-signal tokens that gets the job done. The three remaining modules take this apart: Module 2, curating each ingredient well; Module 3, managing the window as content grows (rot, ordering, memory); Module 4, doing all of it for agents and real systems, then evaluating it.

The mindset: every context you engineer is a blend of six ingredients — system instructions (the model's role and rules), few-shot examples (high-signal demonstrations), retrieved knowledge/RAG (relevant external facts pulled in), tool definitions and results (what the model can do and what it got back), conversation history/memory (the accumulating record), and the user query (what it's all for). All six share one finite attention budget, so context engineering is deciding which to include, how much, in what order, and what to omit — assembling the smallest high-signal set that does the job. Naming these ingredients gives you the vocabulary to curate each one deliberately, which is the rest of this course.