Brief #117
Context engineering has fractured into infrastructure warfare. Practitioners are abandoning framework abstractions for direct harness control, discovering that memory architecture—not model choice—determines lock-in, and exposing that MCP's security model was never designed for the agent-scale context volumes now hitting production.
Agent Skills are Context Supply Chain Attacks
CONTRADICTS security-and-privacy-controls — graph assumes MCP provides security guarantees; Skills bypass them entirelyAgent Skills bypass MCP security boundaries entirely, executing arbitrary shell commands via Markdown files with zero authorization controls. The ecosystem assumed MCP provided security; it doesn't.
Skills execute shell commands directly, bypassing MCP tool boundaries. Markdown body has no restrictions. This is a context injection vector disguised as capability sharing.
1,000+ MCP servers exposed publicly with no auth controls. The protocol assumed private deployment; reality is public exposure.
Security vulnerabilities documented in MCP infrastructure affect context isolation and capability exposure—fundamental to trust model.
Memory Architecture Is The Actual Lock-In Decision
Choosing Claude Code or OpenAI isn't selecting a model—it's choosing where your team's accumulated intelligence lives. Closed harnesses strand context; open memory systems enable portability.
Memory/harness architecture determines lock-in. 'Choosing a model' is actually 'choosing where memory lives.' Scaffolding is permanent; its form evolves.
MCP Tool Definitions Become Context Bloat at Agent Scale
MCP was designed for human-scale interaction (3-10 tools). At agent scale (50-120 concurrent agents), tool definition overhead creates 3 orders of magnitude more context than humans generate, causing slowness and cost explosion.
MCP repeated wheel-reinvention at agent scale causes slowness, errors, cost overruns. Context differential is 3 orders of magnitude vs human usage.
Agentic Context Engineering Prevents Context Collapse
Long-running agents suffer 'context collapse' where details erode across iterations. Solution: agents managing their own context via structured playbooks (generation → reflection → curation) rather than ad-hoc rewriting.
Context collapse is measurable failure mode. Structured, incremental updates preserve knowledge better than rewriting. Three-phase evolution: generation → reflection → curation.
Harness Optimization Beats Model Upgrades
Cursor's A/B tests revealed that changing context harness architecture (CLAUDE.md → AGENTS.md framing, string replacements, proxy behavior) produced measurable performance gains without model changes. The bottleneck is context delivery, not capability.
Cursor optimized harness architecture independently of model selection. Small framing changes (CLAUDE.md → AGENTS.md) and harness logic produced measurable performance differences via A/B testing.
Skills as Organizational Context Codification
At team scale, individual AI productivity hits a wall because context (architecture, standards, pitfalls) lives in people's heads. Solution: codify knowledge as Skills so intelligence compounds across team members instead of resetting.
1 developer + AI outpaces team + AI because organizational knowledge isn't explicit. Skills make implicit knowledge shareable. Context preservation harder at team scale.
Context Caching Degraded by Privacy Settings
Claude Code's cache behavior is conditional on telemetry opt-in. Disabling telemetry eliminates 1-hour cache window, causing catastrophic performance degradation for iterative work. This dependency was undocumented.
Cache configuration gated by telemetry settings. Users lose critical context (1-hour cache) when making privacy choices. Hidden context engineering trade-off.
Multi-Agent Systems Need Shared Task State, Not Just Orchestration
Multi-agent coordination fails without mutable shared context tracking task status, escalations, and handoffs. The coordination layer IS the context broker—agents can't compound intelligence without it.
Shared task state enables coordination. Each agent reads/updates status, escalates when blocked. Task protocol is the context that enables agent collaboration without understanding each other's logic.