The discipline that took over from prompt engineering.

From prompt engineering to context engineering.

Prompt engineering: craft the perfect instruction. Context engineering: optimize everything the model sees on every turn. The field shifted because long-running agents stress the second much more than the first.

The Anthropic line: “Find the smallest set of high-signal tokens that maximize the likelihood of your desired outcome.”

The window, anatomy.

Five slots, each one paid for in tokens, each one the responsibility of a different layer of the harness.

Context rot & context clash.

Two failure modes most teams haven’t named. Once you have names, you can diagnose them.

The Galileo blog formalized these terms; Anthropic's posts validate them. The fix is the four moves in the next unit.

The four moves.

Good context engineering comes down to four moves. Every advanced technique is one of these four.

Offload to external memory.

Anthropic calls it “structured note-taking.” The agent writes notes to disk (or to a database) and retrieves them on demand — instead of keeping everything in the window.

Concrete implementations:

• NOTES.md file — simplest. The agent reads/writes a markdown file. Used by Claude Code subagents.
• The LLM Wiki pattern — structured pages with cross-links. Used by Practice 05 (NanoClaw).
• A SQLite / Postgres database — when notes need queries, joins, indexes.

Retrieve, don’t front-load.

If you have a wiki of 800 pages, don’t paste 800 pages into the prompt “just in case.” Give the agent a search tool. Let it pull what it needs, when it needs it.

Implementation note: pair retrieval with the wiki pattern. The agent calls search_wiki(query); the tool reads index.md first to pick which page, then reads that page. Two-stage retrieval saves you from vector-DB infrastructure for most personal-scale projects.

Isolate via sub-agents.

Specialized agents handle focused tasks and return condensed summaries (typically 1,000-2,000 tokens) to a coordinating agent. The parent never sees the detail.

Reduce via compaction.

When the window fills, summarize the past. The advice that pays off: “Maximize recall to ensure your compaction prompt captures every relevant piece of information from the trace.”

The trigger

Watch a context-utilization metric. When you cross ~70% of the cap, compact. Don’t wait for 100% — you need headroom to write the new response.

The prompt

CopyYou are about to summarize the conversation trace below.

Preserve everything that future turns might need:
- All facts and decisions
- All commitments by either side
- Any user preferences expressed
- Any open questions

Drop everything else: pleasantries, false starts, repeated explanations.

Output: a single message under 500 tokens, structured as
<summary>facts and decisions</summary>
<commitments>...</commitments>
<preferences>...</preferences>
<open>...</open>

The trace:
[paste trace]

The safeguard

Before the harness compacts, fire a PreCompact hook that persists everything to disk. If the summary loses a fact, you can retrieve it. Compaction is irreversible in context; not on disk.

Tiered memory architecture.

Production agents combine all four moves into a single memory architecture with multiple tiers. Each tier has a different cost, latency, and capacity profile.

Prompt caching for cost.

The single most under-used feature for production agents. Mark the system prompt and tool defs as cached; subsequent calls pay 10% of the cost on the cached prefix.

Validated against official Claude API docs: prompt caching references `tools`, `system`, and `messages` in that order; 5-minute cache writes are 1.25x base input and cache reads are 0.1x. Source: Prompt caching.

Copyclient.messages.create(
    model="claude-sonnet-4-6",
    system=[{
        "type": "text",
        "text": LARGE_STABLE_SYSTEM_PROMPT,
        "cache_control": {"type": "ephemeral"}   # ← cache this part
    }],
    tools=tools,                                  # also cached automatically when stable
    messages=messages,
)

Measuring context efficiency.

You can’t improve what you don’t measure. Four numbers worth tracking per agent.

These plug into the eval harness from Practice 04 Unit 02 — the shipped eval_harness.py already reads input_tokens / output_tokens per run and prints cost, latency, and pass-rate. Add the four numbers above as columns on the dashboard.

The closing maxim.

When an agent “hallucinates” or “forgets”, nine times out of ten the failure is in the context window assembly, not in the model itself.

Master this and your agents will outperform agents twice their size. Skip it and bigger models won’t save you.

The four moves on one page.

Run this checklist on every new agent BEFORE writing prompts. Most context bloat is preventable upstream — by the time you're token-pruning, you've already designed yourself into a corner. This audit catches that.

Copy# CONTEXT BUDGET AUDIT — run before building any agent

## 1. OFFLOAD — what lives outside the context window?
- [ ] Long documents → file system, not the prompt
- [ ] Historical conversations → external memory store
- [ ] Reference data → DB / search, looked up only when needed
- [ ] Code / config → repo files Claude reads with the file tool
- [ ] User profile / preferences → CLAUDE.md, not every prompt

## 2. RETRIEVE — what loads only when relevant?
- [ ] RAG over docs: which retrieval, which embed model, top-K
- [ ] Tools that fetch: lookup, search, query — not paste-in-bulk
- [ ] Conditional context loading by user intent
- [ ] Slow-changing reference data: cached, not re-loaded

## 3. ISOLATE — which steps run in fresh sub-agent contexts?
- [ ] Long-running tasks split into sub-agents (each fresh)
- [ ] Read-heavy steps separated from synthesis steps
- [ ] Tool-calling loops bounded — sub-agent per N calls
- [ ] Each sub-agent gets ONLY the context it needs, nothing else

## 4. REDUCE — what gets compacted when context fills?
- [ ] Compaction prompt written + tested before you need it
- [ ] Trigger: at 70% capacity, not 95%
- [ ] What to keep: decisions, open questions, the spine
- [ ] What to drop: tool-call logs, scratch reasoning, fixed bugs

## RED FLAGS
- Prompt > 4k tokens before any tool call → you skipped offload
- Same data appears in multiple sub-agent contexts → fix isolation
- Context fills before the task completes → compaction missing
- Agent forgets the goal mid-task → ISOLATE step lost the spine

## OUTPUT
After running this audit, write 2 sentences:
1. The biggest move you'll make (OFFLOAD/RETRIEVE/ISOLATE/REDUCE)
2. The token budget you're targeting per typical run