← Latest brief

Brief #51

8 articles analyzed

The multi-agent transition is forcing practitioners to formalize context as infrastructure. Teams are moving from prompt engineering to context engineering—treating context as versioned, testable, and modular—because persistent agents expose problems that one-shot prompts could hide: context rot, version drift, and the need for autonomous context expansion.

◐

Structured Context Over Serialized Strings Becoming Protocol Standard

MCP's removal of batching in favor of structured tool output signals a fundamental shift: protocols are prioritizing semantic preservation over throughput efficiency. This means context engineering is maturing from 'pass more data' to 'preserve meaning across tool boundaries.'

→ If you're building MCP servers or agent integrations, prioritize structured output schemas over string concatenation. Design tool responses as typed objects with semantic fields, not flat text. This prevents information loss at boundaries and enables better context filtering downstream.
Key Changes - Model Context Protocol

MCP explicitly removed batching and added structured tool output—trading efficiency for semantic fidelity. OAuth Resource Server classification embeds authorization context into discovery, preventing token leakage.

Context Engineering Basics - Phoenix - Arize AI

ISTF framework decomposes context into orthogonal dimensions (Information, State, Tools, Format)—each requiring independent versioning. This matches MCP's move toward structured semantics rather than monolithic string passing.

Manage Context Window Size With Advanced AI Agents

Context rot (degraded recall at higher token counts) means the problem isn't just volume—it's preserving semantic integrity under load. Structured output addresses this by maintaining meaning rather than jamming more tokens.

More signals

Two-Phase Workflow: Agent Exploration Then Deterministic Formalization

Practitioners are using agents to discover the shape of problems before writing code—not replacing code with agents. The winning pattern is: let agents explore and document patterns (as SOPs/CLIs), then extract successful patterns into deterministic implementations.

→ Stop trying to make agents production-ready from day one. Instead: (1) Use agents to prototype workflows and capture results as SOPs or CLI scripts; (2) Run multiple iterations to identify consistent patterns; (3) Only then formalize into deterministic code. Treat agents as discovery tools, not production replacements.
@alexhillman: I use commands/agents/skills to create the first version with as little code

Explicitly describes using agents/commands to discover workflow shape, documenting as SOPs, then converting successful patterns into deterministic code after validation.

◐

Autonomous Context Expansion Outperforms Explicit Context Injection

AI systems that can independently identify, retrieve, and integrate missing context produce higher-quality outputs than systems waiting for explicit context provision. This shifts context engineering from 'what to include' to 'what tools enable self-directed discovery.'

→ Design your agent systems with search/retrieval tools from the start, not just knowledge injection. Give agents the ability to recognize context gaps and query for information (web search, vector DB, API calls). Measure whether autonomous retrieval improves output quality compared to pre-loaded context, then optimize tool design accordingly.
@steipete: Love how I ask codex to review and it just BY ITSELF googles for the upstream

Codex autonomously recognized it needed upstream repo context for better code review and retrieved it without explicit instruction—resulting in better analysis.

Multi-Pass Evaluation Chains Prevent Context Thrashing in Decision-Making

Effective AI-assisted decision-making requires chaining context across multiple passes with increasing specificity: (1) relevance filtering, (2) strategic fit assessment, (3) implementation planning. Single-pass evaluations cause either information overload or shallow analysis.

→ Stop asking AI for final decisions in one shot. Instead, design three-pass workflows: (1) Ask 'Is this relevant to our constraints?' (prune noise); (2) Ask 'What are the tradeoffs against our existing approach?' (strategic evaluation); (3) Ask 'How would we implement this?' (commitment planning). Each pass preserves context from the prior step.
@alexhillman: I do the same thing with screenshots, broad concepts, articles, research pape

Three-pass evaluation: (1) signal-to-noise filtering, (2) strategic fit + tradeoffs against existing patterns, (3) collaborative planning. Each pass narrows decision space while deepening analysis.

◐

Skill Modularity Enables Agent Composition Without Context Explosion

Breaking complex agent capabilities into reusable skills (43 skills across 6 subagents in one example) allows selective context loading rather than all-at-once context dumping. This is the multi-agent equivalent of microservices: bounded context per agent.

→ If building multi-agent systems, decompose capabilities into small, reusable skills with clear boundaries. Design a skill registry and task-based selection mechanism (e.g., 'for monitoring tasks, load only observability skills'). Measure context window utilization per task type and prune unused skills from agent context.
@dani_avila7: The Datadog CLI Skill looks interesting

6 subagents + 43 skills composed into a single template. Success implies aggressive skill modularity with selective loading based on task, avoiding loading all 43 skills simultaneously.