In 2024 the bottleneck of an LLM application was the model. By mid-2026 it is almost always the context — what goes in the window and in what order. The teams shipping reliable agents have stopped writing prompts and started engineering context: prompt-cache hygiene, just-in-time tool injection, compaction, sub-agent isolation, and aggressive measurement of context-rot. If you cannot speak about KV cache reuse, lost-in-the-middle, and compaction strategies, you are still in the prompt-engineer chair while your peers have moved into the context-engineer chair.
Analogy first. Imagine briefing a brilliant but amnesiac contractor every morning. She forgets everything overnight. Each day you choose what folders to put on her desk, in what order, with what sticky notes on top — and after eight hours her desk is full and she stops being effective. Prompt engineering is the sticky note. Context engineering is the whole desk: what is on it, how it’s arranged, what gets cleared away mid-day, what gets summarised onto a fresh sheet so the project keeps moving. Karpathy’s phrasing on X (June 25, 2025) is the cleanest one-liner: context engineering is “the delicate art and science of filling the context window with just the right information for the next step.”
Mechanism. An LLM call is a stateless function: tokens in, tokens out. Every input token costs latency, money, and (worse) attention dilution — with each extra token, the share of attention any single token can claim shrinks. Empirically (Liu et al. 2023, Hsieh et al. 2024) accuracy degrades non-linearly with input length and is especially bad for information buried in the middle of a long context. The context engineer’s job is therefore to maximise signal-per-token, exploit cache hits on the static prefix, and choose when to compact, when to fetch just-in-time, and when to spawn a sub-agent with a fresh window.
The four pillars an engineer must distinguish:
The three timescales of context. A useful 2026 vocabulary: turn-level context (the system prompt and current message), session-level context (the running conversation, tool traces, and scratchpads), and persistent context (long-term memory, codebase, RAG corpora). Each scale has its own engineering: turn-level is about ordering and caching; session-level is about compaction and sub-agents; persistent is about retrieval and storage hierarchies. Mixing them up — e.g. dumping persistent memory into turn-level context — is the most common rookie mistake and the one that turns a working demo into a $40K/month invoice.
core/context directory before designing your own.cache_control markers on any block, 5-minute and 1-hour TTLs, ~10× cheaper on cache hits. Claude Code (the CLI) ships compaction as a default behaviour: at ~75–85% window fill it summarises the conversation and reseeds. The Claude Agent SDK exposes sub-agents as a primitive — a parent can delegate to a child with its own clean window. Tool-clearing (drop a tool from the schema mid-conversation) is also exposed. The cookbook’s tool-use-context-engineering notebook is the canonical reference.The platform tell. If you want to know how seriously a platform takes context engineering, look at three signals: (1) does it expose an explicit cache control? (2) does it expose compaction or sub-agents as primitives? (3) does its docs mention “just-in-time” context? Anthropic scores 3/3, OpenAI 1/3, Google 1.5/3 (caching, no compaction), and the open-source stack is now catching up via LMCache + LangGraph + sub-agent patterns.
load_skill(‘contracts’), and only then does the 4K-token contract template enter context.”If a tutoring agent makes 8–15 model calls per student session and the static prefix (system prompt, pedagogy guide, current chapter) is identical across calls, then a properly-cached architecture is 5–10× cheaper than a naive one. The savings show up immediately in COGS — usually a 30–60% gross-margin improvement on the inference line. This is not optimisation theatre; it is the difference between a unit-economics-positive product and a slow bleed.
Concrete action: get your engineering team to instrument cache hit rate on every model call and report it in the weekly metrics review next to latency and cost. If the number is below 70%, there is a context-ordering bug. If it is above 90%, you’re probably over-caching stale content. The healthy range is 75–90%.
botlearn.ai’s competitive moat is the curriculum. In a context-engineering frame, that moat is concretely “a static, cacheable prefix that encodes how we teach” — concept maps, common-misconception traps, our scaffolding ladder. Competitors with bigger compute can’t shortcut this because it’s domain knowledge, not engineering. The same pedagogy delivered as cached context buys: cheaper inference, faster TTFT (a measurable UX gain on student attention), and consistency across teachers. Three product wins from one architectural choice.
Concrete action: make “cacheable pedagogy package” a first-class artifact of the curriculum team, version-controlled like code. Each subject (algebra, biology, etc.) gets a stable cached prefix that the agent inherits at session start. The curriculum lead becomes, structurally, a context engineer.
When a buyer asks “does your tutor handle a full course?” the honest answer is about effective context, not advertised window. RULER scores beat marketing claims. botlearn.ai can ship a number that is empirically true for tutoring tasks — e.g. “effective at 128K on our tutoring RULER, against Gemini’s 1M-advertised which degrades at 256K.” That is a defensible technical claim, and it is the kind of credibility that lets a non-technical CGO win an evaluation against a technically-confident incumbent.
Concrete action: commission a botlearn-tutor-RULER — a custom benchmark of 50–100 tutoring tasks at varying lengths. Publish it. The marketing-defensible number isn’t “1M context”, it’s “90% accuracy at 128K of real curricula”.
Bonus arc continues. The original 17 mapped what an agent is; the bonus arc maps how it is actually built. Day 21 was the training layer. Day 22 is the runtime layer — the place where, on every single inference call, you either save or burn 30% of your unit economics.