Brief #84
Context engineering is fracturing into two distinct practices: upstream clarity work (defining what problem agents solve) and downstream preservation work (maintaining context across executions). Practitioners are discovering that the bottleneck isn't model capability—it's organizational clarity about intent and architectural choices about what context to isolate vs. compound.
Progressive Disclosure Beats Verbose Documentation for Agent Skills
Practitioners are discovering that AI agents perform better with minimalist skill definitions plus explicit pointers to supplementary detail, rather than verbose human-style documentation. The pattern: tight scope in primary instruction, lazy-loaded references, and deterministic validation scripts—not LLM judgment.
Core practitioner insight: human documentation patterns are context-toxic for LLMs. Solution: numbered decision trees, third-person imperative voice, assets/ folder with templates, explicit lazy-loading directives like 'See references/xxx.md'
Validates tiered preservation strategy: offload redundant data first (cheap), summarize historical context second (lossy), maintain canonical record third (recovery). Supports progressive disclosure architecture pattern.
Production systems run 'tool search tool' at start—explicit skill filtering before planning. This IS progressive disclosure: load only relevant skills for THIS task rather than full inventory.
Observation Masking Outperforms AI Summarization for Agent Context
JetBrains research reveals that preserving raw observation logs with structure intact outperforms AI-summarized context for agent systems. The surprise: LLM summarization removes critical signal that agents need, while simple masking (hiding irrelevant observations) maintains performance.
JetBrains finding: masking vs LLM summarization for agents—summarization harms performance by removing critical signal. Raw observation logs with structure preserved outperform AI-summarized versions.
Vibe-Coded Systems Fail Because Context Isn't Encoded
Practitioner observation: AI-generated code that runs in production but lacks encoded reasoning about WHY decisions were made creates unmaintainable systems. The failure mode isn't capability—it's that agents solve problems without preserving the context/reasoning for future humans.
Core insight: when AI generates solutions without explicit context preservation, you get working code that's unmaintainable. Missing context: what problem the code solves, why specific design decisions were made, what constraints were considered.
Agent-Human Interfaces Must Surface Decision Context Not Just Status
Practitioners building agent interfaces are discovering that status indicators aren't enough—humans need visibility into the agent's reasoning context to collaborate effectively. The pattern: visual state signals PLUS explanation of why the agent made a decision.
Design pattern: blue glow status indicator + explanation sidebar showing agent's reasoning. Two pieces of context essential: immediate visual signal that agent needs attention, and explanation of the 'why' behind the state change.
Context Isolation Failures Break Agent Security Boundaries
Production MCP security vulnerabilities reveal that agents naively trust external content without isolation, and sandbox boundaries fail without explicit validation. The insight: context isolation isn't automatic—it requires defense-in-depth at multiple layers.
Three failure modes: (1) Agents trust external content without isolation—GitHub issue text injection, (2) Sandbox boundaries fail—symlink handling allows escape, (3) Permission granularity matters—overly broad agent access enables unintended tool use.
Hierarchical Delegation Compounds Intelligence Across Specialist Agents
Multi-agent drug discovery research reveals that structuring agents to mirror the epistemic structure of the problem domain enables intelligence compounding. Pattern: coordinator maintains problem-level context, delegates to domain specialists, then aggregates outputs—each specialist builds on previous work.
Hierarchical delegation pattern: coordinator agent maintains problem-level context and delegates to domain-specialized agents. Each specialist's context window is focused on its domain, but coordinator preserves cross-domain awareness. Integration step compounds intelligence by forcing explicit reasoning about specialist outputs.
Separated Context Architectures Preserve Knowledge Graph Integrity
Practitioners integrating AI into knowledge management are discovering that physical separation of AI-generated content from human-curated knowledge preserves graph quality. Pattern: dedicated Claude folder prevents knowledge graph dilution while enabling efficient context flows via MCPs.
Core pattern: Physical separation (dedicated Claude folder) prevents dilution of knowledge graph. Semantic separation distinguishes AI-generated from human-written notes. MCP integration enables efficient context flows. Repository-level organization (Zkills as company knowledge base) preserves intelligence across sessions.
Agents Excel at Iterative Work With Persistent State
Uncle Bob Martin's mutation testing experiment reveals that agents become viable for previously-unaffordable analysis tasks when they can maintain context across iterations. Pattern: break expensive problem into itemized queue → agent iterates with persistent state → cumulative improvements compound.
Mutation testing: theoretically valuable but practically unaffordable due to tedium. Agent made it viable by maintaining state across multiple mutations, understanding test failures, generating refactoring suggestions, and tracking coverage improvements. Context preservation across iterations is what made this work.