This skill is a provisional historical research snapshot of context-engineering practice as\npublished in 2024–2025. It is NOT normative. Do not apply it prescriptively to current frontier\nmodels without re-verification. On any conflict, OpenRig current skills, explicit user rulings,\nand directly measured OpenRig practice PREVAIL over this document. Treat these areas as\nparticularly suspect pending re-verification: compaction/summarization guidance, minimal-upfront\nversus broad orientation, just-in-time lookup assumptions, fixed context ceilings, and\nsingle-agent versus multi-agent advice.
\nCurated distillation of the best publicly available expertise on context engineering for coding\nagents, drawn from primary sources at Anthropic, OpenAI, and leading practitioners (Manus,\nCognition, Chroma, LangChain, Drew Breunig, and others). Load on the moments the description\nnames; it is deliberately not part of any base walk.
\nDefinition. Context engineering is \"the set of strategies for curating and maintaining the\noptimal set of tokens (information) during LLM inference\" — everything that lands in the window:\nsystem instructions, tool definitions, retrieved data, message history, and tool outputs, not\njust the prompt text (Anthropic, Effective context engineering for AI agents). Andrej\nKarpathy's framing, popularized via LangChain: \"the delicate art and science of filling the\ncontext window with just the right information for the next step\" — the LLM is a CPU and the\ncontext window is its RAM, and your job is deciding what gets loaded into RAM at each step\n(LangChain, Context Engineering for Agents).
\nWhy it superseded prompt engineering. A chatbot answers one question with whatever fits in\none turn. An agent runs in a loop, accumulating tool results, file contents, and history across\ndozens or hundreds of steps. The improvements stop coming from rewording instructions and start\ncoming from rewiring — what the agent retrieves, in what order, and what gets evicted when the\nwindow fills (Anthropic, ibid.). Philipp Schmid's formulation of the practical consequence:\n\"Agent failures aren't only model failures; they are context failures.\" Most of the time when a\ncapable model does something dumb, the context it was given made the dumb thing likely\n(Schmid, The New Skill in AI is Context Engineering).
\nThe physical constraint: attention is a budget, not a bucket. Three mechanisms make context\na scarce resource rather than free storage:
\nThe one-sentence discipline. From Anthropic: \"Find the smallest set of high-signal tokens\nthat maximize the likelihood of some desired outcome.\" Everything else in this pack is a\ntechnique in service of that sentence.
\nThe components you are engineering. Schmid's inventory is a useful checklist of what\nactually occupies the window: (1) system instructions, (2) the user's immediate request,\n(3) state/history of the current session, (4) long-term memory, (5) retrieved external\ninformation, (6) tool definitions, (7) output-format specifications (Schmid, ibid.). Each is a\nseparate dial. When an agent misbehaves, walk this list asking \"which of these is missing,\nstale, bloated, or contradictory?\"
\nP1 — Minimal ≠ short; curate for signal density. The goal is the smallest sufficient set\nof tokens, not the shortest prompt. A system prompt should fully outline expected behavior; the\nsin is low-signal filler, not length (Anthropic, Effective context engineering).
\nP2 — Engineer for the next step, not the whole task. Context is curated per inference step\n(Karpathy via LangChain). The question is never \"what might the agent ever need\" but \"what does\nthis step need to succeed.\" This is why loading everything upfront loses to just-in-time\nretrieval on long tasks.
\nP3 — Degradation precedes exhaustion. Budget context well below the marketed window.\nChroma showed serious degradation mid-window; Breunig collects the operational evidence: a\nGemini agent's planning quality collapsed beyond ~100K tokens [perishable snapshot, 2025–2026: model/vendor-specific — teach the mechanism, re-verify the number] into repeating past actions, and\nDatabricks found correctness falling around 32K for Llama 3.1 405B (Breunig, How Long Contexts\nFail). [perishable snapshot, 2025–2026: model/vendor-specific — teach the mechanism, re-verify the number] These specific ceilings are model- and time-specific — the durable lesson is that every\nmodel has one, and it is lower than the spec sheet.
\nP4 — Stability is money and latency: design append-only. Manus calls KV-cache hit rate \"the\nsingle most important metric for a production-stage AI agent\": cached input tokens can cost 10x\nless than uncached (their figure: $0.30 vs $3.00/MTok). [perishable snapshot, 2025–2026: model/vendor-specific — teach the mechanism, re-verify the number] One changed token invalidates the cache\nfor everything after it. Therefore: stable prompt prefixes (never embed a timestamp at the top),\nappend-only context (never rewrite history mid-session), deterministic serialization (Manus,\nContext Engineering for AI Agents). Anthropic's caching docs confirm the mechanics: exact\nprefix matching, cache reads at 0.1x base price, and a strict tools → system → messages\nhierarchy where a change at any level invalidates everything below it (Anthropic, prompt\ncaching docs).
\nP5 — Attention has a shape; place and refresh accordingly. Because of the U-curve (Liu et\nal.) and recency effects, put durable instructions at the start, and re-surface the current\nobjective near the end. Manus operationalizes this as recitation: the agent rewrites a\ntodo.md and appends it late in context on every step, \"reciting its objectives into the end of\nthe context\" to prevent goal drift across ~50-tool-call tasks (Manus, ibid.).
\nP6 — Failures are context, not garbage. Keep failed actions and stack traces in context;\nthe model updates its implicit beliefs and stops repeating the mistake (Manus, ibid.). The\n12-Factor Agents version: \"Compact Errors into Context Window\" — represent failures efficiently\nso they inform the next step rather than either vanishing or flooding the window (HumanLayer,\n12-Factor Agents, Factor 9).
\nP7 — Share decisions, not just facts. Cognition's two principles: \"Share context, and share\nfull agent traces, not just individual messages\" and \"Actions carry implicit decisions, and\nconflicting decisions carry bad results.\" Two workers given the same task summary but not each\nother's traces will make incompatible implicit choices (their example: subagents building\nvisually clashing pieces of the same game) (Cognition, Don't Build Multi-Agents). Any handoff\nor summary that transmits conclusions without the decisions behind them is lossy in the way that\nbreaks systems.
\nP8 — Calibrate instruction altitude. System prompts fail in two directions: hardcoded\nbrittle if-else logic (fragile, high-maintenance) and vague high-level guidance that \"falsely\nassumes shared context.\" Aim for \"specific enough to guide behavior effectively, yet flexible\nenough to provide strong heuristics.\" Start minimal with a capable model, then add instructions\ndriven by observed failure modes — not speculation (Anthropic, Effective context engineering).
\nP9 — Own the window; treat the agent as a function of its context. Deliberately control\nwhat the model receives rather than accepting framework defaults (\"Own your context window,\"\nFactor 3), and design the agent as \"a stateless reducer\" — output is a pure function of the\ncontext you assembled, which makes context bugs reproducible and testable (HumanLayer,\n12-Factor Agents, Factors 3 and 12).
\nLangChain's taxonomy organizes nearly everything into four moves: write (persist outside the\nwindow), select (pull the right things in), compress (shrink what's there), isolate\n(split across contexts) (LangChain, Context Engineering for Agents). The named techniques:
\nWhat: Structure knowledge in layers so the agent loads only what the current task needs.\nAnthropic's Agent Skills are the canonical design: Level 1 is name + description metadata\n(always in the system prompt — just enough to know when the skill applies), Level 2 is the\nSKILL.md body (loaded when relevant), Level 3+ is bundled files and scripts the agent navigates\n\"only as needed.\" Context becomes \"effectively unbounded\" because nothing loads until demanded\n(Anthropic, Equipping agents for the real world with Agent Skills).
\nWhy it works: It converts a token cost into a pointer cost. The analogy Anthropic uses is\n\"an onboarding guide for a new hire\" — compartmentalized knowledge absorbed progressively.
\nWhen: Any recurring domain knowledge, workflow, or reference material. The rule of thumb\nfrom Claude Code's docs: always-loaded files (CLAUDE.md) get only what applies broadly to every\nsession; anything situational belongs in an on-demand skill (Claude Code best practices).
\nWhat: The agent maintains lightweight identifiers — file paths, queries, URLs — and loads\ndata at runtime with tools, instead of receiving everything up front. This mirrors human\ncognition: we don't memorize corpora, we keep organization systems and retrieve on demand.\nMetadata itself (folder hierarchies, naming conventions, timestamps) is signal (Anthropic,\nEffective context engineering).
\nTrade-off: Runtime exploration is slower than pre-computed retrieval (embeddings/RAG). The\nproduction answer is usually hybrid: some context up front for speed, plus tools for\nautonomous exploration — Claude Code's CLAUDE.md-plus-grep pattern (Anthropic, ibid.). Classic\nRAG — \"selectively adding relevant information to help the LLM generate a better response\" —\nremains the right tool when the corpus is large and unindexed by structure (Breunig, How to\nFix Your Context).
\nWhen: Prefer just-in-time for coding agents in navigable environments (filesystems, git,\nAPIs); prefer indexed retrieval for large unstructured corpora; hybridize when latency matters.
\nWhat: When the window approaches its limit, summarize the trajectory, reinitialize with the\nsummary, and continue. Claude Code auto-compacts near the window limit (LangChain reports at\n~95%); the model distills decisions, code patterns, and open threads while discarding redundant\ntool outputs (Anthropic, Effective context engineering; LangChain, ibid.).
\nHow to tune it: \"Start by maximizing recall to ensure your compaction prompt captures every\nrelevant piece of information from the trace, then iterate to improve precision by eliminating\nsuperfluous content\" (Anthropic, ibid.). Good summarization prompts enforce temporal ordering,\nstructured sections (environment, steps tried, current status), and explicit \"UNVERIFIED\"\nmarking on uncertain facts — because \"if a bad fact enters the summary, it can poison future\nbehavior\" (OpenAI Cookbook, Session memory).
\nTrimming vs. summarizing (OpenAI Cookbook, ibid.): keep-last-N-turns trimming is\ndeterministic, zero-latency, easy to reason about — but loses old constraints abruptly. LLM\nsummarization preserves long-range decisions compactly — but adds latency spikes, drift risk,\nand observability burden. Trimming fits tool-heavy, independent tasks; summarization fits\nlong-horizon work where accumulated decisions matter.
\nCognition's caution: a dedicated compressor model that distills \"key details, events, and\ndecisions\" is their recommended path for long tasks — and they note it \"is hard to get right.\"\nGetting it right means capturing decisions and their rationale, not just facts (Cognition,\nibid.).
\nWhat: The lightest-touch compaction: automatically drop stale tool calls and results deep in\nhistory while preserving the conversational thread. Anthropic ships this as \"context editing\";\nmeasured effects: context editing alone gave 29% improvement on internal agentic-search evals,\ncombined with the memory tool 39%; on a 100-turn web-search eval it let agents complete\nworkflows that would otherwise die of context exhaustion while cutting token consumption 84%\n(Anthropic/Claude, Context management).
\nTension to know: this conflicts with P4 (append-only for cache) and P6 (keep errors). The\nreconciliation: clear bulky, stale, already-acted-upon tool outputs (a 30K-token file read\nfrom 40 turns ago), keep decisions and failures. Manus's version keeps information\nrestorable — drop a webpage's content but keep its URL, drop a document's body but keep its\npath (Manus, ibid.).
\nWhat: The agent writes notes to persistent storage outside the window — a NOTES.md, a\ntodo.md, a memory directory — and pulls them back when relevant. Persistent memory with minimal\ncontext overhead. Anthropic's example: Claude playing Pokémon \"maintains precise tallies across\nthousands of game steps,\" builds maps, and remembers strategies across multi-hour sessions\n(Anthropic, Effective context engineering). Anthropic's memory tool productizes this as\nfile-based CRUD in a client-side memory directory persisting across conversations\n(Anthropic/Claude, Context management).
\nThe general form — filesystem as ultimate context: Manus treats the filesystem as memory\nthat is \"unlimited in size, persistent by nature, and directly operable by the agent itself\"\n(Manus, ibid.). Breunig's name for the family is context offloading; even a simple\nscratchpad (\"think\" tool) produced up to 54% improvement on specialized-agent benchmarks\n(Breunig, How to Fix Your Context).
\nMemory layers in practice (synthesis of LangChain + Anthropic + OpenAI): (1) in-context\nworking memory — the current window; (2) session-scoped scratchpads/todo files; (3) persistent\ncross-session memory — files or stores, retrieved by relevance; (4) always-loaded curated core\n(CLAUDE.md-class files), kept ruthlessly small. Information should flow down this stack as it\nproves durable, and each layer buys persistence at the price of retrieval reliability.
\nWhat: Breunig's \"context quarantine\": isolate work in dedicated threads, each with its own\nwindow (Breunig, How to Fix Your Context). Anthropic's research system is the flagship: an\norchestrator spawns parallel subagents, each exploring one facet with a clean window, each\nreturning a condensed summary — typically 1,000–2,000 tokens — to the coordinator.\n\"Subagents facilitate compression by operating in parallel with their own context windows\"\n(Anthropic, Multi-agent research system). The multi-agent system beat single-agent Claude\nOpus 4 by 90.2% on their internal research eval, at the price of ~15x the tokens of a chat\n(Anthropic, ibid.).
\nWhen it wins: read-heavy, parallelizable, breadth-first work — research, codebase\ninvestigation, review — where workers' outputs are reports that the orchestrator integrates.\nClaude Code's guidance is exactly this: \"use subagents to investigate\" so exploration burns a\ndisposable context, not your main one; and use a fresh-context subagent for adversarial review,\nbecause \"a fresh context improves code review since Claude won't be biased toward code it just\nwrote\" (Claude Code best practices).
\nWhen it loses: write-heavy, coherence-critical work. Cognition's argument (P7): parallel\nworkers make conflicting implicit decisions and current models can't negotiate them away;\n\"running multiple agents in collaboration only results in fragile systems\" for building\nsoftware. Their prescription is a single agent with full traces plus a compressor (Cognition,\nibid.). OpenAI's builder guidance points the same direction: maximize a single agent's\ncapability first and reach for multi-agent orchestration only when single-agent complexity\ndemonstrably fails (OpenAI, A practical guide to building agents). See §6 for the\nreconciliation.
\nWhat: When context must cross an agent boundary, the transfer is an engineered artifact,\nnot a vibe. Anthropic's hard-won spec for what every delegated task must contain: an\nobjective, an output format, guidance on tools and sources, and clear task boundaries.\nWithout it, \"agents duplicate work, leave gaps, or fail to find necessary information\"\n(Anthropic, Multi-agent research system).
\nEffort scaling belongs in the contract: encode explicit rules — \"simple fact-finding\nrequires just 1 agent with 3–10 tool calls, direct comparisons might need 2–4 subagents with\n10–15 calls each\" — or orchestrators over-provision wildly (early versions spawned 50 subagents\nfor simple queries) (Anthropic, ibid.).
\nReturns are contracts too: the worker's report back is a compression step (1–2K tokens,\nper §3.6) and inherits every summarization risk in §3.3 — a handoff that reports conclusions\nwithout decisions violates P7. The spec-then-fresh-session pattern is the single-player\nversion: interview, write a self-contained SPEC.md (files, interfaces, out-of-scope,\nend-to-end verification step), then start a clean session to execute it (Claude Code best\npractices).
\nSelection: \"Every model performs worse when provided with more than one tool\" is the\nprovocative headline from Berkeley's function-calling data; a quantized Llama 3.1 8B failed\nwith 46 tools and succeeded with 19 (Breunig, How Long Contexts Fail). Dynamic tool\nselection — RAG over tool descriptions — improved Llama 3.1 8B performance 44% (Breunig, How\nto Fix Your Context); LangChain cites ~3x tool-selection accuracy from the same family of\ntechniques (LangChain, ibid.). Anthropic's design rule: tools must have minimal overlap — \"if a\nhuman engineer can't definitively say which tool should be used in a given situation, an agent\ncan't be expected to do better\" (Anthropic, Effective context engineering).
\nResponse design: tool outputs are context injections; engineer them. Paginate, filter, and\ntruncate with sensible defaults (Claude Code caps tool responses at 25,000 tokens [perishable snapshot, 2025–2026: model/vendor-specific — teach the mechanism, re-verify the number]); prefer\nsemantically meaningful names over UUIDs; offer a response_format: concise|detailed knob;\nconsolidate chains of granular calls into one higher-level tool (schedule_event, not\nlist_users + list_events + create_event); use error messages to steer the agent toward\nefficient strategies like \"many small targeted searches\" (Anthropic, Writing effective tools\nfor agents). CLI tools are often the most context-efficient integration surface of all\n(Claude Code best practices).
Masking over removal: dynamically removing tools mid-session invalidates the KV cache and\nconfuses the model about past references; prefer masking token logits to constrain choice\nwhile keeping definitions stable (Manus, ibid.).
\nWhat: Treat the window as a budgeted resource with an explicit spending plan: how much for\nsystem + tools, how much reserved for the task, at what fill level compaction triggers. Claude\nCode's docs are blunt: \"The context window is the most important resource to manage,\" and its\nUX (a /context inspector, status-line usage tracking, /clear, targeted /compact) is budget\ntooling (Claude Code best practices). Chroma's practical corollary: set working budgets far\nbelow the advertised window for high-accuracy work (Chroma, ibid.).
\nCaching discipline (the mechanics behind P4): structure prompts static-first (tools →\nsystem → messages); place cache breakpoints on the last stable block, never on content that\nchanges per request; verify with cache-read/cache-write token counts rather than assuming.\nA timestamp above the fold means you pay cache-write prices on every request forever\n(Anthropic, prompt caching docs; Manus, ibid.).
\nFew-shot rut: uniform repeated action-observation patterns in context cause the model to\nmimic rhythm over substance — \"drift, overgeneralization, or sometimes hallucination.\" Inject\nstructured variation in serialization and phrasing (Manus, ibid.).
\nBreunig's four-way taxonomy (How Long Contexts Fail) is the field's shared vocabulary; know\nthese by name:
\nAdd the operational failures from production systems:
\nThey measure token-shaped things. Anthropic found token usage alone explains 80% of\nperformance variance in their research eval (Anthropic, Multi-agent); Manus optimizes\nKV-cache hit rate as the top-line production metric (Manus). Elite teams instrument context —\nfill levels, cache hits, tokens per task — before theorizing.
\nThey iterate from observed failures, with the model in the loop. Anthropic's tool and skill\nguidance is evaluation-first: build representative tasks, watch real transcripts, let the model\ncritique its own failures, refine, re-run against held-out sets (Anthropic, Writing effective\ntools; Agent Skills). Prompts start minimal and grow only where failures demand (P8). And\nautomated evals aren't sufficient: human testers caught Anthropic's agents \"consistently\nchoosing SEO-optimized content farms over authoritative sources\" — a context-quality failure no\nprogrammatic eval flagged (Anthropic, Multi-agent).
\nThey keep the always-loaded core tiny and push everything else behind disclosure. Concise\nchecked-in CLAUDE.md-class files for what applies every session; skills for everything\nsituational; pruning as routine maintenance (\"treat CLAUDE.md like code\") (Claude Code best\npractices).
\nThey design the write path around verification and fresh contexts. Explore → plan →\nimplement → verify, with plan mode separating research from execution; a check the agent can\nrun (tests, build, screenshot diff) so the loop closes without a human; specs executed in fresh\nsessions; adversarial review in a fresh subagent context (Claude Code best practices).
\nThey engineer for the cache and the filesystem. Stable prefixes, append-only histories,\nmasked (not removed) tools, files as unlimited restorable memory, recitation for goal\nstability, errors left visible (Manus). These are production-economics practices as much as\nquality practices.
\nThey match architecture to task shape. Anthropic's own selection heuristic: compaction for\nlong conversational flows; note-taking for iterative work with milestones (coding fits here);\nmulti-agent for parallel-explorable research (Anthropic, Effective context engineering).
\n| Situation | \nReach for | \nSource | \n
|---|---|---|
| Recurring domain knowledge, sometimes needed | \nSkill w/ progressive disclosure | \nAnthropic Skills | \n
| Rules needed every session | \nTiny curated always-loaded file; prune ruthlessly | \nClaude Code docs | \n
| Large explorable environment (repo, filesystem) | \nJust-in-time retrieval via tools; hybrid if latency-bound | \nAnthropic CE | \n
| Large unstructured corpus | \nIndexed retrieval (RAG) | \nBreunig | \n
| Long task nearing window limit | \nCompaction (recall-first, then precision); or clear stale tool results | \nAnthropic CE / context mgmt | \n
| Long task with milestones | \nStructured notes + todo recitation | \nAnthropic CE, Manus | \n
| Cross-session persistence | \nFile-based memory outside the window | \nAnthropic context mgmt, Manus | \n
| Breadth-first research / investigation / review | \nParallel subagents, condensed returns, explicit delegation contract + effort scaling | \nAnthropic multi-agent | \n
| Coherent build/edit on one artifact | \nSingle agent, full traces, compressor for length — not parallel workers | \nCognition | \n
| Many tools available | \nLoadout selection; consolidate; namespace; no overlap | \nBreunig, Anthropic tools | \n
| Cost/latency pressure | \nStable prefix + append-only + cache breakpoints; mask don't remove | \nManus, Anthropic caching | \n
| Agent repeating itself / drifting | \nSuspect distraction: check fill level, compact or clear, recite goals | \nBreunig, Manus | \n
| Agent confidently wrong about earlier \"facts\" | \nSuspect poisoning: audit summaries and notes, restart from clean spec | \nBreunig, OpenAI Cookbook | \n