Aug 20, 2026· 6 min read

Context Engineering in August 2026: What the Big Players Learned

Research synthesis from Anthropic, OpenAI, Google, Meta, and IBM on context engineering best practices for AI agents.

TL;DR: Anthropic, OpenAI, Google, Meta, and IBM all converged on the same conclusion — dynamic, evolving context systems outperform static context files by a wide margin. Here's what their research revealed and how to apply it.

Why Context Engineering Matters Now

Large language models are only as good as the context they receive. Feed them irrelevant information and they hallucinate. Starve them of critical data and they fail simple tasks. The discipline of context engineering — designing systems that give models the right information at the right time — has become the difference between agents that ship and agents that burn tokens.

This isn't theoretical. Meta's research shows that engineered context achieves 89.1% on SWE-bench versus 70.7% for hand-crafted approaches. That's a 26% relative improvement from context alone.

We tracked the major research published this month. Here's what each player contributed.

Anthropic: Hybrid Retrieval + Compaction

Source: Effective Context Engineering for AI Agents

Anthropic's approach centers on one principle: "The smallest possible set of high-signal tokens that maximize the likelihood of some desired outcome."

Hybrid Retrieval

Production agents should combine two strategies:

Prefetch critical info — Load essential context upfront (CLAUDE.md files, project structure, key constraints)
JIT exploration — Let the agent pull additional context on-demand via tools like glob and grep

Their internal testing shows 49% reduction in retrieval failures with hybrid search, and 67% when combined with reranking.

Compaction

When conversations approach context limits, summarize rather than truncate:

Preserve architectural decisions and unresolved issues
Discard redundant outputs and completed steps
Use the Compaction API (compact-2026-01-12) for production workloads

Key insight: Combine compaction with Git commits as checkpoints and progress files. The agent can then understand what was completed, what's in progress, and what's blocked — without holding it all in active context.

Sub-Agent Summaries

Specialized sub-agents handle focused tasks and return condensed summaries — typically 1,000-2,000 tokens — to a coordinating agent. This keeps the orchestrator's context lean while still benefiting from deep specialist work.

OpenAI: Retained Reasoning

Source: GPT-5.6 Builder's Guide

GPT-5.6 introduced persisted reasoning — the model reuses reasoning items across turns instead of re-deriving them.

Performance Impact

On ARC-AGI-3 benchmarks:

Without retained reasoning: 13.3%
With retained reasoning + compaction: 38.3%
Output tokens: 6× reduction

This isn't just caching. The model actively maintains reasoning state, making multi-turn agent loops significantly more efficient.

New Capabilities

Programmatic Tool Calling — Explicit control over tool selection
Max Reasoning Effort — Budget reasoning tokens per request
Prompt Cache Retention — Now defaults to 24 hours (previously in-memory only)
Multi-Agent Orchestration — Beta support in Responses API

Google/DeepMind: Query-Focused Reranking

Sources: Gemini Embedding 2, MLOps Community Benchmark (May 2026)

Google's contribution focuses on what happens after retrieval.

Reranking Beats Raw Similarity

Standard semantic search returns what's similar. But agents need what's relevant to the current task. Cross-encoder reranking adds 5-15 points of MRR on difficult retrieval sets.

The key: Score retrieved content against the agent's current plan, not just the original query.

Agentic RAG Architecture

Move retrieval inside the agent loop (Self-RAG, FLARE patterns):

The model can request more evidence mid-task
Queries get rewritten based on intermediate findings
Retrieval stops early when sufficient evidence exists

Production impact: Agentic RAG with knowledge graphs reduced hallucinations by 62% across 47 deployments (MLOps Community benchmark, May 2026). Trade-off: Higher latency and orchestration complexity.

Meta AI: Skill Evolution

Source: Meta Context Engineering via Agentic Skill Evolution (Ye et al.)

Meta treats context assembly as an optimization problem, not a static configuration.

Bi-Level Framework

Meta-level agent — Continuously refines context engineering skills
Base-level agent — Executes tasks and optimizes context as flexible files

The system learns through agentic crossover — a deliberative search over the history of skills, their executions, and evaluations.

Results

5.6–53.8% relative improvement over state-of-the-art agentic CE methods
Mean improvement: 16.9%
Tested across 5 domains (offline and online settings)

Core insight: Hand-engineered context rules can't adapt. Evolved skills can.

IBM: Agent Control Plane

Source: IBM Think 2026

IBM's focus: Governance and observability at scale.

Control Plane vs. MCP

Layer	Scope
MCP	How context, tools, and data flow into a single model request
Control Plane	How agents are deployed, monitored, and governed across an organization

watsonx.data 2.3.2

IBM shipped a managed MCP server that exposes data platform capabilities as discoverable tools. Agents can dynamically interact with data while actions remain governed under enterprise security controls.

Governance Graph

watsonx.governance maps:

AI assets and their dependencies
Policies and compliance requirements
Risks and audit trails

This becomes critical when agents make decisions that require explainability.

TokenPilot: Cache-Efficient Eviction

Source: TokenPilot (arXiv:2606.17016)

A research contribution worth noting: TokenPilot addresses the tension between text reduction and prompt cache alignment.

Two-Level Architecture

Global Ingestion-Aware Compaction — Stabilizes prefixes by substituting volatile runtime markers with static placeholders
Local Lifecycle-Aware Eviction — Tracks context through three states: active → completed → evictable

Benchmarks

Mode	PinchBench	Claw-Eval
Isolated	61% cost reduction	56% cost reduction
Continuous	61% cost reduction	87% cost reduction

State estimator overhead: < $0.03 for full benchmark evaluation.

The Consensus

Every major player arrived at the same conclusions:

Principle	Evidence
Filter aggressively	Less, targeted context beats comprehensive dumps
Dynamic over static	Evolved context systems outperform hand-engineered rules
Hybrid retrieval	Prefetch essentials + JIT exploration
Lifecycle-aware eviction	Don't just truncate — track what's still relevant
Sub-agent isolation	Specialists return summaries, not full context

What to avoid:

LLM-generated context files (Gloaguen et al. found they reduce success by ~3%)
Dumping everything into context "just in case"
Static documentation without runtime adaptation

Applying This in Practice

If you're building AI agents today:

Audit your context pipeline — What's prefetched vs. retrieved on-demand? Is the split optimal?
Implement compaction — Don't wait for context overflow. Summarize proactively and checkpoint state.
Add reranking — Raw embeddings aren't enough. Score against the agent's current task, not just the original query.
Track context lifecycle — Know what's active, what's completed, and what can be evicted.
Measure — Context engineering without metrics is guesswork. Track retrieval precision, cache hit rates, and task success by context configuration.

We apply these principles in our own AI agent infrastructure — hybrid retrieval with JIT exploration, sub-agent summaries, and lifecycle-aware context management. The difference between a €2 task and a €20 task is often context engineering, not model capability.

Building AI agents and need help with context architecture? Contact us — we've shipped production agent systems and can help you avoid the expensive lessons.

Sources

Published: August 2026 | tokenwise.sk