← Latest brief

Brief #173

16 articles analyzed

Practitioners are discovering that intelligence compounds through context preservation, not model capability—but achieving this requires granular state management and explicit documentation-as-context substrate rather than summarization or high-level orchestration.

◐

Context Collapse Kills Long-Running Agent Sessions

EXTENDS context-collapse — confirms existing concept but adds specific mitigation pattern (itemized vs summarized context)

Summarization-based context engineering causes information density to degrade across session updates. Practitioners are replacing summary patterns with itemized, surgically-updatable context structures that prevent collapse through caching and deduplication.

→ Replace context summarization with itemized structures. Track context efficiency as first-class metric in sessions >4 hours. Build explicit documentation layers for brownfield codebases before deploying agents.
Agentic Context Engineering (ACE) by SambaNova and Stanford

ACE research identifies 'context collapse' problem where summarization causes information loss. Grow-and-refine pattern with itemized structure prevents degradation.

72-hour Fable context accumulation experiment

Practitioner tracking shows context hits 42% plateau after 72 hours. RLMs required to prevent rot. Validates that summarization approaches fail for extended sessions.

Uncle Bob's brownfield agent implementation

Documentation-as-context (200-line Markdown + Gherkin specs) enabled agent independence. Explicit context prevented hallucination; implicit knowledge caused failure modes.

More signals

Model Capability Over-Provisioning Wastes Context Windows

EXTENDS model-selection-strategy — confirms concept but adds specific anti-pattern (over-provisioning) and economic framing

Teams defaulting to maximum-capability models (Fable for all planning, Opus for all coding) waste 30-50% of context on tasks requiring far less intelligence. Right-sizing model selection to actual task complexity preserves context for hard problems.

→ Audit multi-agent workflows for task-capability matching. Map subtask complexity before assigning models. Reserve high-capability models for legitimately hard reasoning; use mid-tier for routine orchestration.
Slate harness right-sized delegation

Practitioner identifies that planning doesn't always need Fable-level capability. Over-provisioning wastes resources; right-sizing requires understanding minimum sufficient intelligence per subtask.

◐

Persistent Shared State Enables Fleet Coordination

EXTENDS memory-persistence — confirms concept but adds specific implementation pattern (shared inbox, manager loop) for distributed systems

Distributed agent systems require explicit shared state mechanisms (inbox files, manager loops) to maintain coordination across 1000+ parallel instances. Without persistent state layer, context diverges and agents lose coherence.

→ Design explicit state persistence layer before scaling beyond 10 parallel agents. Implement manager-agent pattern for fleets. Use disk-based or database-backed shared state rather than in-memory coordination.
Cursor's 1000+ agent ML experiment fleet

Fleet Manager pattern: meta-agent monitors sub-agents via SSH, reads/writes shared inbox file. Persistent state enables distributed coordination without central orchestration complexity.

Agent Tool Outputs Must Be Agent-Optimized

EXTENDS tool-integration-patterns — confirms concept but adds specific requirement (agent-optimized vs human-optimized outputs)

Tools designed for human consumption (search returning links) fail when agents consume them. Agentic search requires pre-answered, structured outputs. Tool output format is a context engineering decision, not just a UX decision.

→ Audit existing tool integrations for agent-readiness. Convert human-facing outputs (links, summaries) to agent-facing formats (structured answers, typed parameters). Document tool semantics explicitly.
LangGraph agentic search design

Agentic search must return 'answers you can reference' not links. Function calling predictability enabled reliable tool use. Agents need differently structured information than humans.

Model Dependency Creates Strategic Vulnerability

Closed-source model availability, pricing, and capability are unstable. Production systems require architectural abstraction layers that isolate model-specific context from domain logic to enable portability across model switches.

→ Implement model abstraction layer separating prompts/token logic from domain code. Design context structures that work across model families. Test multi-model compatibility quarterly.
dbreunig on single-model dependency risk

Cannot rely on single model long-term. Architecture must support portability across models to mitigate availability/pricing risk.