Concern: Context-mode may reduce AI capability when AI makes wrong tool choice

[bread22]

Summary

After reviewing the source code, I have a concern about context-mode's approach to context optimization.

The Concern

When using context-mode with hooks enabled:

1. Some tools are BLOCKED (curl, wget, WebFetch, inline HTTP) - these are completely redirected to sandbox tools

2. Some tools are PERSUADED (Read, Grep, Bash) - context-mode injects guidance but does NOT block

3. The critical issue: For file reading during debugging, the AI must decide whether to use:

   • Native Read -> gets FULL file content
   • ctx_execute_file -> gets only the summary AI prints

The Problem

In an agentic workflow, the AI decides which tool to use, not the user. When AI follows the rules and uses sandbox tools inappropriately:

• AI decides to use ctx_execute_file to analyze a log file
• AI writes code to process FILE_CONTENT
• Only AI printed summary enters context
• AI might miss important details it didnt know to look for

This is problematic because:

• Exploration phase: AI doesnt know yet whats relevant -> needs full context
• Analysis phase: AI knows what to look for -> summary is fine

Context-mode cant distinguish these phases automatically.

Evidence from Code

In hooks/core/routing.mjs:

• Lines 164-167: Read tool only gets guidance injected, NOT blocked
• Lines 120, 136, 175: Only curl/wget/WebFetch are blocked

Question

Is there a way for users to:

1. Force native tools for certain operations?
2. Configure when to use sandbox vs native?
3. Or is the expectation that AI will learn to choose correctly?

The benchmarks focus on command output (tests, logs, curl), which is where context-mode excels. But for code understanding and debugging, native tools may still be needed - and the user has no guarantee the AI will make the right choice.

---

This is not a criticism - context-mode is impressive engineering. Just want to discuss this trade-off.

[mksglu]

Great analysis — you clearly read the code carefully. Let me clarify the design intent and address each point.

The distinction is intentional

You correctly identified the two tiers:

• BLOCKED (exit code 2): curl, wget, WebFetch, inline HTTP — these always flood context with raw output that has zero analytical value in its raw form. There is no scenario where dumping 56KB of raw HTML into context is better than indexing it and searching.
• PERSUADED (exit code 0 + guidance): Read, Grep, Bash — the hook injects a nudge but does not block. The AI can and does ignore the guidance when native access is the right call.

This is the key point: Read is never blocked. The AI retains full access to native tools. The hook just reminds it that sandbox alternatives exist for analysis-heavy operations.

Your exploration vs analysis distinction

You are right that context-mode cannot distinguish phases automatically. But it does not need to — because it does not force the choice:

• When the AI needs to edit a file → it uses native Read (the hook says exactly this: "if you are reading to edit, Read is correct")
• When the AI needs to explore structure → it can use native Read or Grep freely
• When the AI needs to analyze a 2000-line log → the nudge toward ctx_execute_file saves context

The persuasion text is calibrated to make the AI choose correctly in ~90% of cases. The remaining 10% falls through to native tools — which is fine.

User control

To answer your specific questions:

1. Force native tools: Already the default. Persuaded tools are never blocked. The AI can always choose native Read/Grep/Bash.
2. Configure sandbox vs native: You can disable specific hooks by removing them from your hooks config (.claude/hooks.json). Removing the PreToolUse hook for Read stops all nudging.
3. AI learning: The routing instructions in CLAUDE.md give the AI clear heuristics (edit → native, analyze → sandbox). It is not guessing blindly.

The real-world impact

In practice, the failure mode you describe (AI misses details because it summarized too aggressively) is rare because:

• ctx_execute_file gives the AI the full file content inside the sandbox — it can run arbitrary analysis code against it
• The AI writes the analysis script, so it extracts what it needs
• If the first pass misses something, the AI runs a follow-up query (the file is already indexed)

The opposite failure mode (context window exhaustion from raw tool output) is far more common and far more destructive — a single unfiltered cat on a large file can consume 30-40% of the context window.

---

Appreciate the thoughtful writeup. The trade-off is real, but the design deliberately keeps native tools accessible for exactly the exploration scenarios you described.