How Top AI Companies Handle Context Engineering

The framework

Core problem: context windows are finite while agents generate tokens exponentially (a Manus task ~50 tool calls); smarter context management beats bigger windows.

MANUS (Context Engineering for AI Agents, Jul 2025): six principles — 1) KV-cache is sacred: keep prompt prefix stable, logs append-only, even reordered JSON keys invalidate cache (cached $0.30 vs $3/MTok). 2) Logit masking over tool removal: all tools stay in context, availability controlled at decoding time. 3) File system as extended memory: large observations to files, only references in context; compression must be reversible. 4) Attention manipulation via recitation: a living todo.md re-read each step keeps objectives in the high-attention end of context. 5) Preserve errors, don't clean them. 6) Structured variation against fixation (vary serialization/phrasing).

CURSOR (Dynamic Context Discovery, Jan 2026): five techniques — files as tool-output interface (read via tail/grep); chat-history files making lossy summarization lossless; skills as discoverable files found via search, not pre-loaded; lazy MCP tool loading (only names upfront, definitions on demand — 46.9% token reduction in A/B tests); terminal sessions saved as greppable files. Premise: models are now good enough to pull the context they need.

ANTHROPIC (Effective Context Engineering for AI Agents, Sep 2025; Effective Harnesses for Long-Running Agents, Jan 2026; code execution with MCP, Nov 2025): attention budget framing; Goldilocks system prompts (clear sections/XML headers, canonical examples, don't hard-code edge cases — avoids over-engineered 2K-word if-else prompts and vague 'be helpful'); just-in-time retrieval over pre-inference RAG; lean, non-overlapping tools; auto-compaction at 95% window capacity, initializer agent writes persistent requirements file; code execution over direct MCP tool calls; failure patterns = one-shotting complex projects and imperfect compaction transfer, fixed with structured planning files.

OPENAI (Agents SDK cookbooks: session memory Sep 2025, context personalization Dec 2025): trimming (keep last N — causes amnesia), compression (summarize with separate call — risk of summary drift), state-based long-term memory (profile + notes with precedence: latest input → session → global). Key distinction: state-based memory supports belief updates over fact accumulation; more deterministic than retrieval-based memory.

GOOGLE DEEPMIND (ReadAgent paper 2024 + Gemini long-context docs): 'just put it all in' — abundance bet with up to 2M tokens (research to 10M); evidence: Gemini learned to translate Kalamang (<200 speakers) from in-context materials alone; context caching up to 75% cost reduction; progressive truncation; ReadAgent gist memory (20x effective context); many-shot in-context learning. Tension: still 15–47% performance drops as context grows.

LANGCHAIN (Context Engineering for Agents; The Rise of Context Engineering; Deep Agents): the write-select-compress-isolate taxonomy — Write (scratchpads, persistent state, filesystem); Select (RAG, grep/glob — retrieving the RIGHT context, not just most similar); Compress (measured 115K → 60K tokens via end-to-end summarization); Isolate (multi-agent, own windows, prevent context pollution); no-op tools as context engineering (Claude Code's todo tool is purely a planning strategy).

Industry consensus: file system as extended memory, dynamic retrieval, persistent plan files, keep error traces. Active disagreements: logit masking (Manus) vs lazy loading (Cursor) for tool overload; long vs lean context (Google vs everyone); frameworks vs raw primitives. Unsolved: session memory (no two companies alike) and context-engineering evaluation (no standard benchmarks).

What it's for

• Design memory and context compaction architectures for long-running autonomous agents
• Optimize prompt caching and KV-cache hit rates to reduce agent operational costs
• Implement file-system-based memory patterns to prevent context window bloat
• Evaluate trade-offs between lazy tool loading, logit masking, and traditional RAG

Key points

• Manus framework: KV-cache preservation, logit masking, and attention manipulation via persistent todo lists
• Cursor architecture: Filesystem tool outputs, greppable chat logs, and lazy MCP tool definition loading
• Anthropic patterns: Attention budgeting, Goldilocks system prompts, and auto-compaction triggers
• OpenAI memory models: State-based memory precedence and belief updating versus simple fact accumulation
• DeepMind context philosophy: Massive context window utilization, gist memory, and many-shot in-context learning
• LangChain taxonomy: Core write-select-compress-isolate framework for agent context boundaries
• Industry consensus analysis: Synthesis of converged patterns and unresolved agent evaluation benchmarks

Pricing

Free

Details

Type

Framework

Category

AI

Topic

Agent Architecture

Open source

No

Platforms

Web

For

AI engineers and system architects building autonomous agent systems

Tags

context engineering, ai agents, llm architecture, prompt caching, mcp

Why it was saved

• @himanshutwtxs, 15 February 2026: A single researched comparison of the industry's context-engineering strategies, with the exact source posts, papers and cookbooks named for each company.

Related

• Agent Harness is the Real Product↗

  Architectural breakdown of AI agent harnesses, scaffolds, and context management patterns.

• ai-engineering-hub↗

  Open-source tutorials and project templates for LLMs, RAG, and AI agents.

• Inspo↗

  Design inspiration MCP server and archive for AI coding agents.

• Agent Reach↗

  Open-source capability layer giving AI agents access to browse and scrape platforms

• awesome-claude-skills↗

  Curated collection of skills, tools, and plugins for Claude workflows

• Monid↗

  Pay-per-call tool discovery and API integration platform for AI agents