5K

Tool Use Steering via Prompting

Tells the agent in the prompt which tool to use, how to learn a custom tool, and which shorthands map to tool sequences

best practice Updated 2026-10-13 By Nikola Balic (@nibzard) Based on Boris Cherny (via Claude Code examples)
View .md Edit on GitHub
Add to Pack
or

Saved locally in this browser for now.

Cite This Pattern
APA 
Nikola Balic (@nibzard) (2026). Tool Use Steering via Prompting. In *Awesome Agentic Patterns*. Retrieved October 14, 2026, from https://agentic-patterns.com/patterns/tool-use-steering-via-prompting
BibTeX 
@misc{agentic_patterns_tool-use-steering-via-prompting,
  title = {Tool Use Steering via Prompting},
  author = {Nikola Balic (@nibzard)},
  year = {2026},
  howpublished = {\url{https://agentic-patterns.com/patterns/tool-use-steering-via-prompting}},
  note = {Awesome Agentic Patterns}
}

Use when

  • Agent has custom or team-specific tools the base model does not know
  • Smaller models pick the wrong tools
  • Tool calls fail often without guidance

Avoid when

  • Agent has few tools and picks them correctly on its own
  • Tool interfaces change too often to keep prompts current

Problem

AI agents equipped with multiple tools (e.g., shell access, file system operations, web search, custom CLIs) need clear guidance on when, why, and how to use these tools effectively. Simply having tools available doesn't guarantee they will be used appropriately for the task at hand, especially for tools unfamiliar to the base model or specific to a team's workflow.

Solution

Guide the agent's tool selection and execution through explicit natural language instructions within the prompt. This includes:

  • Direct Tool Invocation: Telling the agent which tool to use for a specific part of a task (e.g., "Use the file search tool to find...", "Run a bash command to...").
  • Teaching Tool Usage: Instructing the agent on how to learn about or use a new or custom tool, including how to discover its options (e.g., "Use our barley CLI to check logs. You can use -h to see how to use it.").
  • Implicit Tool Suggestion: Using phrases or shorthands that the agent learns to associate with specific tool sequences (e.g., "commit, push, pr" for a Git workflow).
  • Encouraging Deeper Reasoning for Tool Use: Adding phrases like "think hard" to prompt more careful consideration before acting, potentially leading to better tool choices or sequences.

This pattern emphasizes the user's role in actively shaping the agent's behavior with respect to its available tools, rather than relying solely on autonomous tool selection.

The technique is grounded in research showing that interleaving reasoning traces with action execution—where the model explicitly thinks about which tool to use before acting—improves outcomes (Yao et al., 2022, ReAct).

Distinct from Patch Steering via Prompted Tool Selection, which applies the same steering idea specifically to choosing among patching or refactoring tools with per-tool usage rules and a fallback order.

Evidence

  • Evidence Grade: medium
  • ReAct (Yao et al., ICLR 2023): interleaving reasoning traces with actions beats imitation and reinforcement learning baselines by an absolute success rate of 34% on ALFWorld and 10% on WebShop
  • Practitioner report: Boris Cherny recommends teaching the agent your team's tools and steering tool choice in prompts (Claude Code interview, see References)
  • Community discussion: the technique is reported to work, and is debated as a named pattern: https://news.ycombinator.com/item?id=46491244

Example (tool guidance flow)

flowchart TD A[User Task] --> B[Available Tools] A --> C[Explicit Guidance] C --> D[Direct Tool Invocation] C --> E[Teaching Tool Usage] C --> F[Implicit Tool Suggestion] C --> G[Deeper Reasoning Prompts] B --> H[Agent Tool Selection] D --> H E --> H F --> H G --> H H --> I[Tool Execution] I --> J[Task Completion]

How to use it

  • Use when agent success depends on reliable tool invocation, especially with custom or team-specific tools the base model does not know
  • Structure guidance hierarchically: task categorization first, then tool selection rules
  • Include decision frameworks (e.g., "if modifying existing code, use Edit; if creating new file, use Write")
  • Add verification gates: always run build/test after code changes to prevent error cascades

Trade-offs

  • Pros: Improves execution success, reduces tool-call failures, and favors surgical edits over rewriting whole files, which keeps more of the conversation cacheable
  • Cons: Introduces integration coupling, requires prompt maintenance as tool interfaces evolve, and spends prompt tokens on guidance in every session

References