purpose: Deep dive into Core Four In-Agent Leverage Points (1-4) type: technical-reference domain: agentic-coding category: in-agent-leverage audience: LLM-optimized last-updated: 2025-09-30 The Core Four In-Agent Leverage Points represent direct control mechanisms within the agent's operational environment. These are the highest-leverage, most immediate interventions available to developers in Phase 2 SDLC. Mastery of these four points is prerequisite for effective agentic coding. CONTEXT: What can your agent see? critical 10/10 Context encompasses all information available to the agent during task execution: conversation history, files read, documentation provided, environment details, and prior decisions. Agent performance is directly proportional to context quality and relevance. Agents cannot see files unless explicitly shown via Read tool Conversation history has token limits (context window) No persistent memory across sessions without explicit storage Cannot infer project structure without exploration Provide relevant files before agent requests them Bad: "Fix the authentication bug" Good: "Fix the authentication bug. Here's auth.js, user.model.js, and the error logs." Reduces back-and-forth by 70% Start broad, then narrow focus based on task Project overview (README, architecture) Relevant subsystem (module docs, related files) Specific implementation (exact file, function, tests) "We're building an e-commerce platform [layer 1]. The checkout system handles payments via Stripe [layer 2]. The bug is in checkout/payment.ts line 47 where token validation fails [layer 3]." Use ken-you-remember (store_fr3k) to preserve decisions across sessions 1. Make important decision 2. store_fr3k: "Decided to use Redis for session storage due to scale requirements" 3. Later session: recall_fr3k retrieves this context automatically Eliminates re-explaining architecture every conversation UFC system for domain-specific knowledge ~/.claude/context/ ├── tools/ # Tool capabilities ├── patterns/ # Coding patterns ├── architecture/ # System design └── domain/ # Business logic Agent loads only relevant context files per task Maximize information density within token limits XML tags for structure (LLMs parse efficiently) Code snippets over full files when possible Summaries with "see file X for details" pointers Remove boilerplate/comments in context sharing Providing every file in codebase Overwhelms context window, dilutes signal Curate relevant subset only "You should know this from earlier" Agent has no memory unless explicitly provided Always re-establish context or use recall_fr3k "The user authentication stuff" Agent must guess which files/logic Specific file paths and function names Context Hit Rate: % of needed info provided upfront Context Waste: % of provided info not used in solution Clarification Rounds: # of back-and-forth exchanges 90%+ hit rate, <10% waste, <2 clarifications MODEL: Which LLM powers your agent? high 8/10 The underlying Large Language Model determines reasoning capability, token limits, tool use proficiency, and task-specific strengths. Model selection is not one-size-fits-all; optimal choice depends on task complexity, cost constraints, and latency requirements. Superior reasoning for complex architecture decisions Best-in-class tool use (file operations, shell commands) Large context window (200K tokens) Excellent code generation quality Higher cost per token Slightly slower response time Complex refactoring requiring deep codebase understanding Architectural decisions with multiple tradeoffs Tasks requiring extensive file operations Fast response times Good general-purpose coding Strong API/library knowledge 128K token limit (half of Claude) Less sophisticated tool use Quick bug fixes and simple features API integration tasks Documentation generation Fastest response times Lower cost Good for iterative tasks Less reasoning depth More prone to hallucination Repetitive code generation (CRUD, boilerplate) Simple test writing Code formatting/linting 2M token context window (10x Claude) Excellent for document-heavy tasks Less mature tool ecosystem Variable reasoning quality Analyzing large codebases or documentation sets Migration tasks requiring full codebase context Select model based on task complexity Complex reasoning required? Claude Sonnet 4.5 Continue... Need massive context? Gemini 1.5 Pro Continue... Speed critical? GPT-4o GPT-4 Turbo (balanced) Use cheaper models first, escalate if needed 1. GPT-4o attempts simple implementation 2. If output quality insufficient, escalate to GPT-4 Turbo 3. If still insufficient, escalate to Claude Sonnet 4.5 Optimizes cost while maintaining quality floor Different models for different task types All models hallucinate - validation required regardless Context window limits are hard constraints Model knowledge cutoff dates vary (affects recent APIs/libraries) Tool use capability varies dramatically between models PROMPT: How are you communicating? critical 10/10 The prompt is your communication interface with the agent. Quality of prompt directly determines quality of output. Effective prompts provide clear intent, constraints, examples, and success criteria. Poor prompts generate irrelevant, incomplete, or hallucinated responses. What you want the agent to do Bad: "Fix the auth" Good: "Modify the authentication middleware to add JWT token refresh logic" Boundaries and requirements "Must maintain backward compatibility with existing tokens. Must not modify user.model.js. Must add tests for refresh flow." Background information "Current implementation uses 15-minute access tokens. Users are being logged out too frequently. We want to add 7-day refresh tokens." Show desired output format "Similar to how password reset tokens work in auth/reset.ts: - Store refresh token in database with expiry - Validate on refresh endpoint - Rotate token after use" How to know task is complete "Success means: 1. Refresh token endpoint returns new access token 2. Expired refresh tokens are rejected 3. All auth tests pass 4. Manual testing shows users stay logged in for 7 days" Use direct commands, not questions Could you maybe look at fixing the authentication issue? Fix the JWT token expiration bug in auth/middleware.ts Explicit boundaries prevent scope creep "ONLY modify auth/middleware.ts. DO NOT change database schema. DO NOT refactor existing functions. ADD new refresh logic only." Prevents agent from over-engineering Specify desired format "Provide your solution in this format: 1. Code changes (with file paths) 2. Test additions 3. Migration steps (if any) 4. Breaking changes (if any)" Show 2-3 examples of desired behavior "Write error handling similar to these examples: Example 1 (validation): if (!userId) throw new ValidationError('userId required') Example 2 (not found): if (!user) throw new NotFoundError('User not found') Example 3 (auth): if (!token) throw new UnauthorizedError('Token missing')" Request reasoning before output "Before implementing, explain: 1. Your understanding of the requirement 2. Your proposed approach 3. Potential edge cases Then implement the solution." Catches misunderstandings early "Make it better" Agent guesses at intent, likely misses target Specific, measurable improvement criteria "Use the standard pattern" Agent's "standard" may differ from yours Explicitly reference or show the pattern "Fix auth and also refactor database and add tests" Agent prioritizes poorly or does partial work One clear primary intent per prompt, secondary tasks listed explicitly "If you don't mind, could you possibly..." Wastes tokens, no benefit Direct imperatives: "Implement...", "Fix...", "Add..." Persistent instructions across conversation (CLAUDE.md, UFC) "For this project: - Always use TypeScript strict mode - Write tests using Vitest - Follow DDD architecture patterns - Store decisions in ken-you-remember" Have agent generate its own task breakdown "Create a TodoWrite list for implementing this feature, then execute each step." Agent generates, then critiques its own output "Generate solution. Then critique it for edge cases, security issues, and performance. Revise based on critique." TOOLS: What can your agent execute? high 9/10 Tools are executable capabilities available to the agent: file operations (Read/Write/Edit), shell commands (Bash), search (Grep/Glob), web access (WebFetch/WebSearch), task management (TodoWrite), and memory (ken-you-remember). Tool proficiency is the difference between theoretical agents and practical agents. View file contents Essential - agents must see code to modify it Always read before editing, even if "agent should know" file_path: Absolute path required offset: Starting line (optional) limit: Number of lines (optional) Create new file or overwrite existing High - but prefer Edit for existing files Must Read file first if it exists (enforced) Overwrites entire file, no undo Surgical modification of existing files Essential - safer than Write for changes Use exact string matching, include context for uniqueness file_path: Target file old_string: Exact text to replace new_string: Replacement text replace_all: Replace all occurrences (optional) Execute shell commands Critical - testing, building, git operations Chain related commands with && for atomicity Run tests: npm test, pytest Build: npm run build, cargo build Git: git status, git diff, git commit Install: npm install, pip install Can modify system, no undo - use carefully Search file contents with regex High - finding code patterns, references pattern: Regex to search path: Directory or file to search type: File type filter (js, py, ts, etc.) output_mode: content (lines) | files_with_matches | count Find files by pattern Medium - discovering relevant files Glob("**/*.test.ts") finds all TypeScript test files Task tracking and planning High - prevents agent hallucination and lost context Create todos with content and activeForm Mark one todo in_progress before starting Complete immediately after finishing Update with new todos as discovered Persistent memory across sessions Critical - prevents re-learning same lessons store_fr3k: "Database uses PostgreSQL 14, not MySQL" recall_fr3k: "database setup" retrieves PostgreSQL info Max 500 chars per memory, max 5 retrieval results Model Context Protocol servers for specialized capabilities mcp__grep__searchGitHub: Search public repos for code patterns mcp__snap-happy: Screenshot capabilities mcp__hey-daddy: Task management with validation workflow Execute custom workflows (debugging, deployment, refactoring) /debug: Fast problem identification workflow /check: Quality verification and test running /api: Complete API development with testing and docs Combine tools for complex workflows 1. Glob: Find all test files 2. Grep: Search for specific test pattern 3. Read: Load relevant test file 4. Edit: Modify test 5. Bash: Run test suite 6. TodoWrite: Mark complete Agent can call multiple independent tools simultaneously Call Read on 3 files + Grep for pattern + Bash git status in single response 5x faster than sequential tool use Use tools to verify other tool outputs 1. Edit: Modify code 2. Bash: Run linter to verify syntax 3. Bash: Run tests to verify logic 4. store_fr3k: Record success pattern Use right tool for each job Find filesGlob (not Bash find) Search contentGrep (not Bash grep) Read filesRead (not Bash cat) Modify codeEdit (not Bash sed) Using bash for tasks with dedicated tools Bad: Bash: cat file.txt Good: Read: file.txt Less reliable, harder to parse output Overwriting entire file for small change Risk of losing other changes, merge conflicts Use Edit for surgical modifications Not using TodoWrite or ken-you-remember Agent loses track, repeats work, hallucinates Use planning/memory tools proactively The Core Four work together as a system. Optimize one, benefit from all. Debugging complex issue CONTEXT: Provide error logs, relevant files, stack trace MODEL: Use Claude Sonnet 4.5 for reasoning depth PROMPT: "Analyze error, explain root cause, propose fix with reasoning" TOOLS: Read source files, Grep for references, Edit fix, Bash run tests Root cause identified and fixed in single iteration Implementing new feature CONTEXT: Load architecture docs, similar features, requirements MODEL: GPT-4 Turbo for balanced speed/quality PROMPT: "Implement [feature] following [pattern]. Add tests. No refactoring." TOOLS: TodoWrite plan, Edit implementation, Bash test, store_fr3k decisions Feature complete with tests in one pass CONTEXT + PROMPT: Highest immediate impact TOOLS: Enable agent action capabilities MODEL: Fine-tune for task complexity Can you articulate what context your agent needs before asking? Do you proactively load relevant files? Can you match task complexity to appropriate model? Do you know when to escalate to stronger model? Are your prompts specific, constrained, and measurable? Do you provide examples and success criteria? Do you use the right tool for each job? Do you leverage TodoWrite and ken-you-remember consistently? Practice Context loading: Before next task, list needed files Audit Prompts: Rewrite last 3 prompts with constraints + examples Tool proficiency: Use Edit instead of Write, Grep instead of Bash grep Study Through-Agent points for long-term infrastructure