Context (topic)

Context is the information you give an AI model before it responds. Think of it like briefing a new employee: you tell them what projects matter and what your business does, and only then can they contribute meaningfully. Without that context, an AI is "just a smart intern who's guessing."

Context engineering (deciding what the model sees) is everything you put on top of the model itself: the knowledge you feed it, the way you prompt it, the instructions, and the systems you build around it. As one speaker puts it, it's "the way that you apply your own brain onto that powerful AI model."

Why does this matter for AI development? Because AI is only as smart as the context it receives. If it can't see the context it needs for a task, the entire rest of the flow is wasted. But more context isn't automatically better. If you give too little, the model guesses; if you give too much, it "drowns" and hallucinates. Formats matter too: large files like videos or big slide decks fill up the model's head quickly. You also want the right context, not just a pile of documents, because files that are two years old may hurt more than help.

Your context is often your unique advantage: it's your subject expertise, your IP, data that isn't publicly accessible. Since everyone uses the same underlying models, that private context is what makes your outputs distinct.

Context (everything the model can see at once) is the material your AI reasons from, and curating it well is called context engineering (selecting the right tokens for inference). A prompt is one instruction card, but context is the entire workbench — a good card cannot rescue missing evidence or distracting tools. Step one: start with the task, then wrap the context in XML tags (markup labels the model reads) so the model knows what material to use. If output requires judgment or style, add one-shot examples (a single sample passage and topic array); if passages vary widely, try multi-shot examples and let the evaluation decide whether the extra example earns its space.

Context is finite, and as tokens in the window grow, accurate recall of a given fact decreases — a problem called context rot. So when a chat gets overloaded, don't repeat messages or switch vendors: begin a fresh chat with a summary that preserves the goal while restoring clarity. For managing this across tools, use context files (markdown files that tell your AI what it needs) so you can switch tools anytime. You can also pull in granite or qwen (open models you run yourself), and with qwen 3.5 on Ollama you can increase the context window, often with a single command. Tools like ornith can serve as a context engine (a system that assembles relevant context), building a knowledge graph from your sources and vectorizing the data before answering. The finished habit is a prompt contract: task, tagged context, examples only when needed.

When you build with AI tools, the real challenge is not the prompt but the context (the full set of tokens a model sees at once). As one speaker puts it, context is the entire workbench while a prompt is just one instruction card. A good card cannot rescue missing evidence or distracting tools.

A common pitfall is context rot (declining recall as the window fills). As tokens grow, accurate recall of any given fact decreases. Tool calls make this worse: they gobble up context on both the edit side and the exploration side, and once context gets eaten, agents start to hallucinate (invent details that are not real) parts of a schema, leading to retries and errors.

Best practices start with separation. Put stable governance in the system instruction and the actual task, query, input data, and per-request examples in the user turn. Ask whether an instruction should persist across requests or change for this request. Long context has a reading order, so place documents and queries deliberately and select high-signal material instead of letting context become bloat.

When details get confused, do not treat context as unlimited. Begin a fresh chat with a concise summary that preserves the goal while restoring clarity. Context engineering is iterative, and memory and evaluation matter. Fix bad context early, because it compounds: find defects cheaply before you enter doom loops (repeated failing cycles).