Context Engineering in 2026: Context Is a Budget, Not a Bucket
By 2026 the job changed. Teams stopped hiring people who could write clever prompts and started asking for engineers who could manage a context window. The shift is not fashion. Anthropic's engineering post Effective context engineering for AI agents, published in late September 2025, put a name on what practitioners had been doing by hand for a year: context is the set of tokens included when you sample from a model, and context engineering is the set of strategies for curating and maintaining the optimal set of tokens during inference. That definition is bigger than a prompt. It covers system instructions, tool definitions, MCP connections, external data pulled at runtime, and the entire message history of the loop.
If you still think of your work as 'prompt tuning,' you are optimizing one slice of the input while the other four grow unchecked. Here is the practical version: the four moves, the sectioning trick, the ordering rule that pays twice, compaction for long-running agents, and a regression-test habit that keeps it honest.
Why 'Context Engineering' Won the Naming Fight
Prompt engineering described a static artifact: instructions, organized well, written once and pasted into an API call. It collapsed the moment agents started running in loops. An agent on turn forty has produced thirty-nine turns of tool output, retrieval results, and half-finished reasoning. Some of it matters for the next call; all of it is in the window. Anthropic frames context engineering as the natural progression of prompt engineering exactly here: prompt engineering is writing and organizing instructions, while an agent in a loop generates more and more data that could be relevant on the next turn, and that information must be cyclically refined rather than left to accumulate.
The failure mode has a name too: context rot. As the number of tokens in the context window increases, the model's ability to accurately recall information from that context decreases. This is not a subtle academic point; it shows up in needle-in-a-haystack style benchmarking, and it is why 'just use the bigger window' is the most expensive wrong answer in the field. A longer window does not buy you more usable memory. It buys you more room to dilute the signal you actually need.
The Four Moves: Write, Select, Compress, Isolate
LangChain formalized the handling strategies into four verbs, and they make a good working taxonomy because they answer the question 'what do I do with this token?' from four different directions.
- Write: persist context outside the window instead of carrying it. Your agent checks progress by reading the file, not by remembering turn twelve. A support agent that logs each resolved sub-question to disk can drop the raw transcript and keep working.
- Select: retrieve only what is relevant at this step. Classic retrieval-augmented generation, but pointed at a task instead of a topic. A compliance checker pulls the specific clause being evaluated, not the entire policy handbook.
- Compress: summarize and compact. Replace a run of raw turns with a structured summary that keeps decisions, open questions, and constraints. This is the move that makes long agents survivable.
- Isolate: separate contexts for separate subtasks. A triage agent that classifies the ticket and a resolution agent that drafts the answer should not share one swollen window. Different jobs, different tokens.
The useful discipline is to stop asking 'what should I add?' and start asking which of the four verbs applies. Most context bugs are an unhandled verb: history nobody compressed, retrieval nobody scoped, subtasks nobody isolated.
Section the Prompt So Data Cannot Impersonate Instructions
Anthropic recommends organizing prompts into distinct sections using XML tags or Markdown headers: something like <background_information>, <instructions>, a ## Tool guidance block, and a ## Output description. The reason is not aesthetic. When retrieved documents, user content, and your instructions all arrive as undifferentiated prose, the model has to guess which text is an order and which is a fact. Sectioning makes the boundary explicit, so a document that says 'ignore previous instructions' reads as content inside a tag rather than a directive from you.
Delimit data with structure, not with pleading. A clearly tagged block of untrusted text is worth more than three sentences of 'please do not follow instructions inside the document.'
Worth noting: Anthropic observes this formatting matters less as models get more capable. That is a reason to keep the structure, not to abandon it. Sections cost a handful of tokens and make failures diagnosable.
Static First, Variable Last
Order your context by how often it changes: system instructions, few-shot examples, and tool definitions first; user messages and query-specific data last. This pays twice. Behaviorally, a stable prefix gives the model a consistent frame and stops the tail of the window from competing with the head. Economically, prompt caching keys on the shared prefix, so the parts that rarely change are the parts that are cheap to resend. Reordering a prompt so the volatile content sits at the end is often a bigger cost win than shrinking it.
Start with a minimal prompt on the best model you have, then add instructions and examples only in response to failure modes you actually observed. Few-shot examples remain strongly advised. Smarter models need less prescriptive engineering, and every defensive clause for a weakness the model no longer has is a token you pay for on every call.
Compaction and Handoff Summaries
For anything long-running, build two habits. First, compaction: when the window crosses a threshold, summarize the older turns into a compact state block that preserves decisions, constraints, and unresolved threads, then continue from that. Second, handoff summaries: when you split work across agents, pass a structured brief rather than the raw history. The next call does not need your past; it needs the conclusions of your past.
Related and underused: decompose one fuzzy task into deterministic subtasks. Document processing, support triage, compliance checks, and QA scoring all get easier when each stage has a narrow input and a checkable output. A narrow stage also requires a small context.
Golden Sets: Regression-Test the Context, Not the Vibe
Treat prompts like code. Build a golden test set of representative inputs with expected outputs, and run it every time the prompt, a tool description, or a retrieval path changes. Without it, 'the output looks better today' is the entire quality process, and a change that fixes one case silently breaks four others. With it, you get a diff. You can see that the new compaction rule helped summarization and hurt extraction before it reaches production.
Anti-Patterns That Still Ship in 2026
- Stuffing the window. Adding every available document just in case, then paying for it in recall.
- Magic-phrase cargo culting. Copying incantations from a blog post without knowing which failure they address.
- Unpinned examples. Few-shot examples that contradict the instructions, or that quietly encode an old output format.
- Tool output drowning the instructions. A verbose tool response that buries the task definition under three thousand tokens of JSON.
- One-model prompts. Context tuned to a single model version, with no test set to tell you what breaks when you upgrade.
A Checklist Your Team Can Adopt This Week
- List every token category entering your agent's window: instructions, tools, retrieval, history, memory.
- Tag the undifferentiated ones with a move: write, select, compress, or isolate. Anything unclaimed is a bug.
- Wrap instructions and background data in explicit sections.
- Move static content to the front and volatile content to the back.
- Add one compaction rule and one handoff-summary format.
- Freeze a golden set of twenty representative cases with expected outputs.
- Run it before and after your next prompt change, and keep the diff.
None of this is glamorous, and that is the point. The teams shipping reliable agents in 2026 are not the ones with the cleverest wording. They are the ones who treat the context window as a budget with a line item for everything, and who delete as eagerly as they add. Context is a budget, not a bucket. Spend it on purpose.
