Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

No annotations are provided, so the description carries full burden. It mentions the tool creates files and updates code, implying mutation, but lacks details on permissions needed, whether changes are reversible, error handling, or rate limits. For a tool that modifies project structure, this is a significant gap in behavioral disclosure.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is appropriately sized with two sentences: the first states the purpose and inputs, the second details the outputs. It is front-loaded with key information, though could be slightly more concise by merging sentences without losing clarity.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

Given the tool has an output schema (which handles return values), no annotations, and low schema coverage, the description is moderately complete. It covers purpose and basic usage but lacks behavioral details and full parameter semantics, making it adequate but with clear gaps for a tool that performs code generation and updates.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema description coverage is 0%, so the schema provides no parameter details. The description adds some meaning by explaining 'project_dir' as the directory of an existing scaffolded server and 'tool' as a JSON tool definition, but does not specify format, constraints, or examples. It partially compensates for the coverage gap but not fully.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Does the description clearly state what the tool does and how it differs from similar tools?

The description clearly states the specific action ('Add a new tool') and resource ('existing scaffolded MCP server'), with detailed scope ('Creates the tool module, service stub, test, and updates server.py'). It distinguishes from siblings like 'scaffold_server' (which creates a new server) and 'build_package' (which builds an existing one).

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Does the description explain when to use this tool, when not to, or what alternatives exist?

The description implies usage context ('existing scaffolded MCP server') and prerequisites (project directory and JSON tool definition), but does not explicitly state when not to use it or name alternatives. For example, it doesn't clarify if this is for initial setup vs. ongoing maintenance, or differentiate from 'update_creator_profile' for other modifications.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

No annotations are provided, so the description carries the full burden. It mentions the command 'uv build' but lacks details on behavioral traits like whether it's idempotent, what happens on failure, if it requires specific dependencies, or output behavior. This leaves gaps in understanding the tool's operation beyond the basic action.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is two sentences, front-loaded with the core action and followed by usage timing. Every word earns its place with no redundancy or fluff, making it highly efficient and easy to parse.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

Given the tool has an output schema (which covers return values), the description doesn't need to explain outputs. However, with no annotations and incomplete parameter semantics, it provides minimal context for a build operation. It's adequate for basic use but lacks depth on behavior and parameters.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

The input schema has 1 parameter with 0% description coverage, so the description must compensate. It doesn't mention the 'project_dir' parameter at all, failing to add meaning beyond the schema. However, with only one parameter, the baseline is higher, but the lack of any parameter info keeps it at an adequate minimum.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Does the description clearly state what the tool does and how it differs from similar tools?

The description clearly states the action ('Build') and the resource ('MCP server package'), specifying it uses 'uv build'. It distinguishes from siblings like 'publish_package' or 'scaffold_server' by focusing on compilation rather than distribution or setup. However, it doesn't explicitly differentiate from all siblings (e.g., 'check_setup' might be related), keeping it from a perfect score.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Does the description explain when to use this tool, when not to, or what alternatives exist?

The description provides clear context on when to use this tool ('after implementing your tools'), which helps guide timing. It doesn't specify when not to use it or name explicit alternatives among siblings, but the implied workflow is sufficient for effective usage without being misleading.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

With no annotations provided, the description carries the full burden of behavioral disclosure. It states the tool's purpose but doesn't describe what happens when a name is available vs. unavailable, whether there are rate limits, authentication requirements, or what the response format looks like. The description adds basic context but lacks operational details.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is perfectly concise with two clear sentences that each serve distinct purposes: stating the tool's function and providing usage guidance. There's zero wasted language, and the information is front-loaded with the core purpose.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

Given the tool's simple purpose (checking name availability), single parameter, and the presence of an output schema (which handles return values), the description provides adequate context. It covers the 'why' and 'when' effectively, though more behavioral details would be beneficial since annotations are absent.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

With 0% schema description coverage and only one parameter, the description adds meaningful context by specifying this checks 'package name' availability on PyPI. While it doesn't detail parameter constraints (like naming conventions or length limits), it provides essential semantic context beyond the bare schema.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Does the description clearly state what the tool does and how it differs from similar tools?

The description clearly states the specific action ('Check if a package name is available') and the target resource ('on PyPI'). It distinguishes from siblings by focusing on name availability verification rather than package creation, building, or publishing.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Does the description explain when to use this tool, when not to, or what alternatives exist?

The description explicitly states when to use this tool ('Call this first before scaffolding'), providing clear sequencing guidance. It implies an alternative workflow (using it before the 'scaffold_server' sibling tool) and establishes a prerequisite context for package creation.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

No annotations are provided, so the description carries the full burden of behavioral disclosure. It mentions that the tool checks for required tools, implying a read-only diagnostic operation, but doesn't detail what happens if tools are missing (e.g., error messages, suggestions) or any rate limits. The description adds some context but lacks comprehensive behavioral traits like response format or failure modes.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is concise and well-structured, consisting of two sentences that directly state the tool's purpose and usage guidelines. Every sentence adds value without redundancy, making it efficient and easy to parse for an AI agent.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

Given the tool's complexity is low (0 parameters, diagnostic function) and an output schema exists, the description is mostly complete. It explains when to call the tool and what it checks for, but could benefit from mentioning what the output might indicate (e.g., success/failure status). However, with an output schema, detailed return values aren't necessary, so it's largely adequate.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

The input schema has 0 parameters with 100% coverage, so no parameter information is needed. The description doesn't add any parameter details, which is appropriate here. Since there are no parameters, the baseline is 4, as the description doesn't need to compensate for schema gaps.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Does the description clearly state what the tool does and how it differs from similar tools?

The description clearly states the tool's purpose: checking the user's environment for required tools (uv, git, gh CLI, PyPI token). It specifies the verb ('check') and resource ('environment'), making it easy to understand what it does. However, it doesn't explicitly differentiate from sibling tools like 'scaffold_server' or 'setup_github', which might also involve setup-related tasks, so it misses full sibling distinction.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Does the description explain when to use this tool, when not to, or what alternatives exist?

The description provides explicit guidance on when to use this tool: after 'get_creator_profile' if 'setup_complete' is false. It also specifies when not to use it: if everything is set up, skip beginner instructions and go straight to building. This clearly outlines the context and alternatives, helping the agent make informed decisions.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

With no annotations provided, the description carries the full burden of behavioral disclosure. It helpfully mentions specific limits ('tagline max 100 chars, features max 30 items, tags max 30') which are valuable behavioral constraints not evident from the schema. However, it doesn't describe file creation behavior (overwrite vs. create new), error handling, or output format details beyond mentioning it creates a 'formatted file.'

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is extremely efficient - two sentences that convey purpose, outcome, and key constraints. Every word earns its place, with the first sentence stating what the tool does and the second providing critical behavioral limits. No wasted words or redundant information.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

Given the complexity (10 parameters, file generation tool) and the presence of an output schema (which means return values are documented elsewhere), the description provides adequate but incomplete context. It covers the core purpose and key constraints but leaves many parameter meanings unexplained. For a tool with 10 parameters and no annotations, more guidance on parameter usage would be beneficial.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

With 0% schema description coverage for 10 parameters, the description provides minimal parameter information. It only mentions three parameters indirectly through limits (tagline, features, tags) but doesn't explain what 'project_dir', 'package_name', 'category', 'tools_summary' or other parameters mean or how they should be formatted. The description doesn't adequately compensate for the complete lack of schema descriptions.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Does the description clearly state what the tool does and how it differs from similar tools?

The description clearly states the specific action ('Generate a LAUNCHGUIDE.md'), the resource ('for MCP Marketplace submission'), and the outcome ('Creates a formatted file ready to submit'). It distinguishes this tool from siblings like 'scaffold_server' or 'build_package' by focusing specifically on documentation generation for marketplace submission.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Does the description explain when to use this tool, when not to, or what alternatives exist?

The description provides clear context about when to use this tool ('for MCP Marketplace submission'), but doesn't explicitly state when NOT to use it or mention specific alternatives among the sibling tools. The context is sufficient to understand this is for preparing marketplace documentation, but lacks explicit comparison to other documentation or packaging tools.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

With no annotations provided, the description carries full burden and effectively discloses key behaviors: it's a read operation ('Load'), has session initialization logic, and influences workflow decisions (onboarding skipping). It doesn't mention rate limits or error handling, but covers essential operational context.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Is the description appropriately sized, front-loaded, and free of redundancy?

Two sentences with zero waste: first states purpose and data scope, second provides critical usage instructions. Front-loaded with essential information, every sentence earns its place for a session initialization tool.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

Given 0 parameters, no annotations, but an output schema exists, the description is complete: it explains what the tool does, when to use it, and its behavioral impact. The output schema will handle return values, so the description appropriately focuses on operational context.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

The tool has 0 parameters with 100% schema description coverage, so the baseline is 4. The description appropriately doesn't discuss parameters, focusing instead on the tool's purpose and usage context, which adds value beyond the empty schema.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Does the description clearly state what the tool does and how it differs from similar tools?

The description clearly states the specific action ('Load') and resource ('creator's persistent profile'), listing exact data retrieved (setup status, GitHub/PyPI usernames, project history). It distinguishes from siblings like 'update_creator_profile' by focusing on retrieval rather than modification.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Does the description explain when to use this tool, when not to, or what alternatives exist?

Explicitly states when to use ('Call this FIRST in every session') and when not to use ('skip all onboarding if setup_complete=true'), providing clear context for session initialization versus alternatives like 'check_setup' or 'update_creator_profile'.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

With no annotations provided, the description carries the full burden. It discloses key behavioral traits: it's a write operation (publishing), requires authentication (PyPI token), and mentions environment variable alternatives. However, it lacks details on error handling, rate limits, or what happens during publishing (e.g., overwriting existing versions). The description adds value but doesn't fully cover behavioral aspects.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is efficiently structured in two sentences: the first states the purpose and method, the second covers authentication requirements. Every sentence adds essential information without redundancy, making it appropriately concise and front-loaded for quick understanding.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

Given the tool's complexity (publishing with authentication), no annotations, and an output schema (which reduces need to describe returns), the description is moderately complete. It covers the core action and auth needs but lacks details on prerequisites (e.g., built package), error cases, or side effects. It's adequate but has clear gaps for a mutation tool.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema description coverage is 0%, so the description must compensate. It explains the 'token' parameter's purpose (PyPI token) and alternatives (environment variable), adding meaning beyond the schema. However, it doesn't clarify 'project_dir' (e.g., what it should contain) or other implicit parameters. The description partially compensates but leaves gaps, aligning with the baseline expectation.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Does the description clearly state what the tool does and how it differs from similar tools?

The description clearly states the action ('Publish') and target ('built package to PyPI'), specifying the method ('using uv publish'). It distinguishes from siblings like 'build_package' or 'check_pypi_name' by focusing on the publishing step. However, it doesn't explicitly contrast with all siblings, keeping it at 4 rather than 5.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Does the description explain when to use this tool, when not to, or what alternatives exist?

The description provides clear context for when to use this tool: after building a package and when ready to publish to PyPI. It mentions the prerequisite of having a PyPI token. While it doesn't explicitly list when NOT to use it or name alternatives among siblings, the context is sufficiently clear for typical usage scenarios.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

With no annotations provided, the description carries the full burden and does well by disclosing key behavioral traits: the generated server 'runs immediately with stub implementations', mentions licensing gating via 'paid=true', and explains hosting options with defaults. It doesn't cover error conditions, performance, or security implications, but provides substantial operational context beyond basic functionality.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is efficiently structured with zero wasted words. It front-loads the core purpose, then details key parameters in a logical flow. Every sentence adds essential information about functionality or configuration options, making it dense yet highly readable.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

Given the tool's complexity (8 parameters, no annotations, but has output schema), the description provides substantial context about what the tool does and key configurations. The existence of an output schema means return values don't need explanation. However, it doesn't cover all parameters equally, leaving gaps for output_dir and env_vars.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema description coverage is 0%, so the description must compensate. It adds meaningful context for 5 parameters (package_name, description, tools, paid, paid_tools, hosting) by explaining their purpose and usage, but doesn't address output_dir or env_vars at all. With 8 total parameters and partial coverage, it provides moderate value beyond the bare schema.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Does the description clearly state what the tool does and how it differs from similar tools?

The description clearly states the specific action ('scaffold a complete, runnable MCP server project') and distinguishes it from siblings by focusing on initial project generation rather than incremental additions (like add_tool) or publishing operations. It specifies the verb 'scaffold' and resource 'MCP server project' with concrete details about what gets generated.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Does the description explain when to use this tool, when not to, or what alternatives exist?

The description provides clear context for when to use this tool (creating a new server project with specific configurations like paid features and hosting options). However, it doesn't explicitly state when NOT to use it or mention alternatives among the sibling tools (e.g., using add_tool for incremental additions instead). The guidance is practical but lacks explicit exclusions.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

No annotations are provided, so the description carries full burden. It discloses key behavioral traits: the tool performs write operations (initialize, create, push), requires external dependencies (gh CLI installed and authenticated), and has a specific workflow timing (after PyPI publishing). However, it doesn't mention potential side effects like overwriting existing git configurations or error handling.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Is the description appropriately sized, front-loaded, and free of redundancy?

Two sentences with zero waste. The first sentence states the purpose and prerequisites, the second provides usage timing. Every element earns its place, and the information is front-loaded with the core actions.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

Given the tool's complexity (multi-step GitHub setup), no annotations, and an output schema exists, the description is reasonably complete. It covers purpose, prerequisites, and timing, but lacks details on parameter usage or potential errors. The output schema likely handles return values, reducing the burden on the description.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema description coverage is 0%, so the description must compensate. It doesn't explicitly mention any parameters, though it implies 'project_dir' through 'Initialize git' and 'repo_name' through 'create a GitHub repo.' The description adds minimal semantic context beyond what the schema titles provide, resulting in a baseline score.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Does the description clearly state what the tool does and how it differs from similar tools?

The description clearly states the specific actions: 'Initialize git, create a GitHub repo, and push the project.' It distinguishes from siblings like 'scaffold_server' or 'publish_package' by focusing on GitHub repository setup and initial push operations, not package creation or publishing.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Does the description explain when to use this tool, when not to, or what alternatives exist?

Explicitly states when to use: 'Run this after publishing to PyPI so the repo URL can be included in the LAUNCHGUIDE.' It also specifies prerequisites: 'Requires the gh CLI to be installed and authenticated.' This provides clear context and timing guidance relative to other tools in the workflow.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

No annotations are provided, so the description carries full burden. It discloses key behavioral traits: the tool persists data across sessions and should be called after specific events. However, it doesn't mention authentication needs, error handling, rate limits, or what happens if parameters conflict. It adds useful context but lacks comprehensive behavioral details.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is appropriately sized with two sentences. The first sentence states the purpose and usage triggers, and the second explains persistence. It's front-loaded with essential information and avoids redundancy, though it could be slightly more structured.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

Given 5 parameters with 0% schema coverage, no annotations, but an output schema exists, the description is moderately complete. It covers usage context and persistence but lacks parameter explanations and behavioral details like error handling. The output schema mitigates some gaps, but more is needed for a mutation tool.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema description coverage is 0%, so the description must compensate. It mentions 'setup steps,' 'project creation,' 'GitHub/PyPI info,' and 'persists across sessions,' which loosely relate to parameters like setup_complete, github_username, pypi_username, and add_project. However, it doesn't explain parameter meanings, defaults, or interactions, leaving significant gaps.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Does the description clearly state what the tool does and how it differs from similar tools?

The description clearly states the tool's purpose: 'Update the creator's profile after setup steps or project creation.' It specifies the resource ('creator's profile') and the action ('update'), and distinguishes it from setup tools. However, it doesn't explicitly differentiate from sibling tools like 'get_creator_profile' beyond the update vs. get distinction.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Does the description explain when to use this tool, when not to, or what alternatives exist?

The description provides explicit usage guidelines: 'Call this after: setup completes, a project is published, or GitHub/PyPI info is learned.' It lists specific trigger conditions and mentions persistence across sessions, giving clear when-to-use guidance without alternatives needed.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.