purpose: Advanced context engineering and Agentic Horizon framework type: advanced-optimization domain: agentic-coding phase: elite-mastery audience: LLM-optimized last-updated: 2025-09-30 Elite Context Management represents the apex of agentic coding optimization. At this level, context is recognized as the most precious and constrained resource in agent systems. The Agentic Horizon framework provides systematic approaches for context engineering, focusing agents on high-value work while minimizing cognitive load. Context is the Most Precious Resource Claude: 200K tokens GPT-4: 128K tokens Gemini: 2M tokens (but processing cost scales) Agent performance degrades with context size Lost in the middle: Information in middle of large context often ignored More context ≠ better performance Cost scales with input tokens Wasted context = wasted money + wasted time Maximize signal-to-noise ratio in context provision. Provide exactly what agent needs, nothing more, nothing less. R&D Framework for Focused Agents The Agentic Horizon is the boundary of what an agent can effectively handle in a single session. Tasks within the horizon: high success rate. Tasks beyond: failure, hallucination, context overflow. Elite developers engineer contexts to keep work within horizon. Cognitive load of task Fix specific bug with known root cause Redesign entire authentication system Number of files/components affected Modify 3-5 related files Refactor 50+ files across multiple modules Information required for task understanding Single module with clear boundaries Entire codebase with complex dependencies Ambiguity in requirements or approach Well-defined task with established patterns Open-ended exploration with unclear requirements Break beyond-horizon tasks into within-horizon subtasks Beyond-horizon: "Migrate entire API to GraphQL" Decomposed: 1. Research GraphQL schema design for User model 2. Implement User queries (read operations) 3. Implement User mutations (write operations) 4. Add tests for User resolvers 5. Repeat for each model Each subtask is within horizon Maintain high success rate for complex initiatives Load context incrementally as needed High-level context: Project overview, architecture Module context: Specific subsystem details Implementation context: Exact files and functions Avoid overwhelming agent with irrelevant information Provide minimal core context, point to additional resources Core context: "We use JWT authentication (see auth/README.md for details)" Agent can read auth/README.md if needed, but not loaded by default Keep working context lean while maintaining access to details Use different agents for different subtasks Agent 1: Research best GraphQL patterns (sherlock) Agent 2: Implement User resolvers (jsmaster) Agent 3: Write tests (bugsy) Each agent sees only relevant context for their task No single agent overwhelmed by full project scope Hierarchical organization of information by relevance Task requirements (what to do) Constraints (what NOT to do) Success criteria (when done) Immediately relevant files (2-3 max) Beginning of prompt 20-30% of total context Related patterns/examples Adjacent code for consistency API documentation for dependencies Middle of prompt 40-50% of total context Broader architecture Historical decisions (ADRs) Edge cases and error handling End of prompt or linked documents 20-30% of total context Most important information first (attention is front-loaded) Maximize information density per token LLMs parse XML efficiently, provides structure Verbose: "This is the authentication module. It handles login and logout." Compressed: <module name="auth" purpose="login/logout"/> Code is denser than natural language descriptions Verbose: "The function takes a user ID and returns the user object from the database" Compressed: function getUser(userId: string): Promise<User> { return db.users.findById(userId); } Scannable structure, no filler words Verbose: "The authentication system is designed to handle user sessions. It uses JWT tokens for security and Redis for session storage." Compressed: - Auth: JWT tokens - Storage: Redis sessions Symbols convey meaning efficiently User → Profile → Orders → Items (relationship chain) ✓ Required field ✗ Forbidden operation Show only changes, not full files Instead of: Full 200-line file Provide: ```diff - const timeout = 5000; + const timeout = 10000; ``` Explicit boundaries on what agent should consider List exactly which files are relevant "For this task, ONLY consider: - auth/login.ts - auth/middleware.ts - models/user.ts All other files are out of scope." Focus on specific time period or version "Use patterns from code written in last 6 months (post-refactor), ignore legacy patterns" Limit to specific domain concepts "This task is authentication ONLY. Do not consider authorization, user profiles, or billing." Specify allowed dependencies "Use existing libraries only: express, bcrypt, jsonwebtoken. No new dependencies." Prevents context wandering and scope creep Reuse common context across multiple tasks CLAUDE.md provides persistent context - Project conventions - Architecture patterns - Common workflows - Tool preferences Avoid repeating project basics every session ken-you-remember stores reusable context store_fr3k: "Database: PostgreSQL 14, connection pooling via pg-pool" Later: recall_fr3k("database") retrieves this context Context persists across sessions automatically Reusable context templates for common scenarios Bug Fix Template: - Error logs: [paste here] - Relevant files: [list here] - Expected behavior: [describe here] - Constraints: No refactoring, minimal changes Standardized context provision Verify context quality before task execution Does agent have everything needed to complete task? Can task be done without asking clarifying questions? Is every piece of context necessary? Remove one piece - would agent still succeed? Is context unambiguous? Would different agents interpret this identically? Is context organized for easy parsing? Most important information first, logical grouping? 1. Provide context 2. Observe agent performance 3. Identify context gaps or bloat 4. Refine context provision 5. Repeat Replace large context with compact representations Full API documentation (1000+ lines) OpenAPI schema (structured, parseable) Detailed architecture explanation Diagram (ASCII or image) + brief legend Multiple similar examples One canonical example + "follow this pattern" Natural language requirements doc Structured checklist or acceptance criteria Leverage LLM's ability to parse structured formats efficiently Agent's working memory is context window. Optimize like RAM. Load context only when needed, not preemptively Task: Fix bug in checkout flow Initial context: Error logs + checkout.ts If agent needs payment integration: Then load payment.ts Don't load payment.ts upfront "just in case" Keeps working memory lean Remove irrelevant context as task progresses Phase 1: Research (load docs, examples) Phase 2: Implementation (keep docs link, focus on code) Phase 3: Testing (evict docs, focus on test output) Start new conversation for phase shifts Compress previous work into summaries Long conversation → store_fr3k("Implemented JWT refresh. Used 7-day expiry. Token in DB.") Next session → recall_fr3k retrieves summary, not full history Preserve decisions without full transcript Store context externally, reference as needed CLAUDE.md: Project conventions ken-you-remember: Decisions and patterns ADRs: Architectural rationale Code comments: Implementation details Agent reads when needed via Read tool Loading every potentially relevant file Working memory overwhelmed, performance degrades Assuming agent remembers from previous messages Agent loses critical context mid-task Repeating same information in multiple forms Wasted tokens, no additional value Minimal, precise context for well-defined tasks 1. Exact task (one sentence) 2. Exact file and location 3. Exact constraint 4. Exact success criterion "Add input validation to login endpoint. File: auth/login.ts, line 23-45 Validate: email format, password length (min 8 chars) Success: Invalid inputs return 400 with error message" Simple, isolated changes Layered context with progressive detail 1. High-level goal 2. Architecture overview 3. Specific implementation area 4. Detailed requirements 5. Examples and patterns Level 1: "Add real-time notifications to app" Level 2: "We use WebSockets (Socket.io), events are pub/sub via Redis" Level 3: "Notification service in services/notifications.ts" Level 4: "Add notifyUser(userId, message) function" Level 5: "Follow pattern in services/email.ts (similar pub/sub)" Complex features requiring context building Provide only differences from known baseline 1. Reference baseline ("like feature X") 2. List differences only 3. Constraints on what stays same "Add Order endpoints like User endpoints (user/routes.ts). Differences: - Orders have nested Items array - Orders require authentication (Users don't) - Orders have payment status enum Same: - CRUD structure - Validation pattern - Error handling" Similar to existing functionality Define success by what NOT to do 1. Task 2. List of forbidden actions 3. List of required patterns 4. Validation method "Refactor auth/login.ts for readability. DO NOT: - Change function signatures - Modify behavior (tests must pass unchanged) - Add dependencies DO: - Extract helper functions for validation - Add descriptive variable names - Add JSDoc comments Validate: All tests pass, no new dependencies" Refactoring, behavior-preserving changes % of provided context used in agent's solution Used Context Tokens / Total Context Tokens × 100 70-90% (higher = better targeting) Context bloat, agent overwhelmed Precisely targeted context May be missing helpful context % of tasks completed without requesting additional context 85%+ Better context anticipation, documentation Success rate per 1K tokens of context (Successful Tasks / Total Tasks) / (Average Context Size / 1000) Higher score = more efficient context usage % of context that comes from cached sources (CLAUDE.md, ken-you-remember) 40-60% (balance between reuse and task-specific) Faster context loading, consistency Pre-process codebase into agent-optimized summaries 1. Generate module summaries (purpose, key functions, dependencies) 2. Create API catalogs (all endpoints with signatures) 3. Build type indexes (all interfaces/types with purposes) 4. Store in structured docs 5. Agent reads relevant summaries, not full code Massive context window savings Custom scripts, aider, claude-code-helper Use embeddings to find relevant context automatically 1. Embed all docs, code files 2. Embed task description 3. Retrieve top-K most similar files/docs 4. Provide to agent as context Automatic context targeting LlamaIndex, LangChain, custom embedding pipelines Provide context in stages as agent requests 1. Agent starts with minimal context 2. Agent requests specific file/doc when needed 3. Human or tool provides requested context 4. Agent continues with new context Agent pulls exactly what it needs Conversational approach, agent uses Read tool autonomously Divide large context across specialized agents Task: Migrate monolith to microservices - Agent 1: Analyze dependencies (sees full codebase, produces dependency graph) - Agent 2: Design service boundaries (sees dependency graph only) - Agent 3: Implement User service (sees only User-related code) - Agent 4: Implement Order service (sees only Order-related code) No single agent overwhelmed Unlimited effective context (distributed) You can predict exact context needed before starting task Your agents rarely ask clarifying questions You track and optimize context utilization metrics You use context compression techniques automatically You know when to split tasks to fit within horizon First-attempt success rate exceeds 85% You spend more time on context engineering than writing prompts Context is not just information. It's the lens through which agents see reality. Bad context → agent is blind. Good context → agent is brilliant. Context engineering is the highest-leverage skill in agentic coding. Every wasted token is a missed opportunity for signal. The best context is invisible - agent doesn't notice, just succeeds. Measure baseline: Track context utilization and sufficiency Apply compression: XML tags, code over prose, bullets Implement layering: Essential → Supporting → Reference Deploy caching: CLAUDE.md, ken-you-remember for common context Optimize scoping: Explicit boundaries on every task Master horizon: Decompose beyond-horizon tasks systematically Achieve elite: Context engineering becomes subconscious Elite context management is the difference between good and great agentic developers. Beginners focus on prompts. Intermediates focus on tools. Experts focus on context. Master context engineering, and every other leverage point becomes exponentially more effective. This is the Agentic Horizon - the frontier where human expertise meets AI capability.