Context Engineering for AI Agents

For two years the advice was the same: learn prompt engineering. Craft the perfect instruction and the model does what you want. That advice was never wrong — but at production scale it quietly stopped being the bottleneck.

The models got bigger context windows and better instruction-following, and the hard part moved. When an agent fails in production today, it's almost never because someone chose the wrong adjective in a prompt. It fails because the *context*

was wrong: the retrieved documents were stale, the memory was truncated at the worst possible moment, the tool definitions were ambiguous, or the window was so stuffed with low-signal tokens that the model lost the plot.

Deciding what goes into the context window — in what order, at what cost, on every single turn — is now the central engineering discipline of building with LLMs. It has a name: context engineering. And unlike prompt engineering, it's a real

engineering problem: retrieval systems, memory stores, compression under a token budget, caching, measurement, and cost/latency trade-offs.

This book teaches it the way technical skills should be taught: by building. Across 16 chapters you construct ctxkit, a small but real Python context engine that grows one chapter at a time — retrieval, agentic multi-hop search, layered

memory, budget-aware assembly and compression, structured tool context, evals for context quality, and caching. By the end you've built the thing, not just read about it, and you recognize the same patterns inside every serious agent

framework.

What you'll build, chapter by chapter:

- The context window itself: tokens, budgets, and why position matters

- Retrieval done right: chunking, embeddings, a vector index, and agentic multi-hop search

- Memory systems: short-term, long-term, and episodic — with summary, vector, and knowledge-graph backends

- Assembly and compression that keep the highest-value context under a hard token budget

- Tool definitions and structured context that models actually parse reliably

- Long-horizon sessions that don't drift or forget

- Evals, cost accounting, and prompt caching to ship it for real

Who it's for: engineers building with LLMs — AI engineers, backend and platform engineers, anyone who has shipped a prompt to production and watched it behave nothing like the demo. You should be comfortable reading Python and have called an

LLM API before. No machine-learning background required; we treat the model as a component with a context window, a cost, and a latency budget, and engineer around it.

Prompt engineering got you a demo. Context engineering ships it.