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

There are no annotations, so the description carries the behavioral burden. It strongly implies a read-only informational call through the phrase 'what this server is running on' and the listed status fields, but it does not explicitly state side effects, permissions, or caching behavior.

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 a single sentence that packs the essential status categories into a concise, scannable list. There is no filler 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?

With zero parameters and an output schema available, the description covers the key semantic categories: artifact, build time, seasons, progress, and definition health. An agent has enough context to invoke and understand the tool correctly.

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 zero parameters, so the schema trivially covers everything. The description adds meaningful context about the actual status fields returned, which helps an agent interpret the output without needing parameter guidance.

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 explains what build_status provides: database artifact, build time, seasons, progress state, and definition counts. It is specific enough to distinguish it from sibling tools like coverage or describe_schema, though it lacks a direct verb phrase.

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 this tool is for inspecting server build/status information, but it does not explicitly state when to use it instead of alternatives such as coverage or describe_schema. No exclusions or alternative routing are provided.

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, the description carries the full behavioral disclosure burden. It reveals that the tool accepts three ref formats and ties the coverage window to query refusal, which is useful context. However, it does not describe what the tool returns, whether it is read-only, or what happens on invalid references, leaving meaningful gaps.

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 compact and each sentence contributes: the core concept, accepted input forms, and a usage directive. The first sentence is slightly cryptic, but the overall structure is efficient and free of filler.

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?

For a single-parameter tool, the description covers the accepted ref formats and the key use case of checking coverage before promising a range. An output schema is present, so the lack of return-value details in the description is acceptable, though a short example would make it even more complete.

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 only provides the parameter name 'ref' with no description, so the description adds essential meaning by specifying that ref can be a table.column, entity.attribute, or definition name. This is strong value beyond the sparse schema, though it stops short of giving concrete examples or formatting rules.

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 defines coverage as 'the seasons a thing can answer for' and lists accepted reference forms, which conveys that the tool returns or checks time coverage. However, it never uses an explicit verb like 'returns' or 'checks,' and the metaphorical 'seasons' language is vaguer than needed to distinguish the tool's exact function clearly.

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 gives concrete usage guidance: 'check here before promising a range' and explains that queries are refused when they fall outside the coverage window. It clearly communicates when the tool should be called, even though it does not explicitly name alternative tools for other 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 present, the description carries the full burden of disclosing behavior. It does so meaningfully: it states that deletion is recoverable because the previous version is kept in history, and it warns that dependent artifacts become broken until replaced. This goes well beyond a generic 'deletes a definition' statement.

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 short sentences with no filler. The core action is front-loaded, and the second sentence adds valuable consequence information that earns its place.

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 that this is a destructive tool with no annotations, the description covers the two most important contextual aspects: recoverability and downstream breakage. The output schema exists so return-value details are not required. It is slightly incomplete in not framing when to prefer this over alternatives, but it is otherwise sufficient for a single-parameter deletion 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%, and the description does not explain the 'name' parameter beyond what the schema already shows. The parameter is simple and self-descriptive to some degree, but the description adds no clarification about what name refers to or any format/constraints, leaving the full burden on a schema that contains no 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 names a specific verb ('Delete') and resource ('a definition'), making the tool's purpose immediately clear. It also distinguishes this from sibling tools like save_definition, get_definition, and list_definitions by stating it is the removal operation.

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 gives helpful context about the consequences of deleting, but it does not explicitly state when to use this tool versus alternatives or when not to use it. Usage is implied by the tool name and the CRUD-style sibling set, but no direct routing or exclusions are provided.

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 a good job: it states what the tool returns—entities, namespaces, attributes, and coverage windows—and reveals a key domain rule that attributes are the only raw fields a plan may reference. It does not explicitly discuss output format or side effects, but 'Describe' and the output schema make the read-only nature sufficiently clear.

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 dense, purposeful sentences with no filler. The main capability is front-loaded, and the second sentence adds a crucial caveat with concrete sibling pointers. Every sentence earns its place.

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 that an output schema exists and this is a read-only descriptive tool, the description sufficiently covers what the agent learns and when to route to definition tools instead. The only meaningful gap is the undocumented include_play_columns parameter, but the overall guidance is strong enough for correct invocation.

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% description coverage, so the description must compensate. It does provide the valid domain for the entity parameter by listing the six entity names, but it says nothing about include_play_columns, its default behavior, or how filtering by entity affects the result. One parameter remains essentially undocumented.

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 uses the specific verb 'Describe' and identifies a precise resource: what can be queried, including the six entities, their namespaces, and every attribute with its coverage window. This immediately distinguishes it from definition-related tools like list_definitions and propose_definition.

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 gives a clear decision rule: raw fields belong to this schema, while concepts such as 'star' or 'injury' must be terms looked up via list_definitions and propose_definition. It does not cover all sibling alternatives, but the most important schema-vs-definition distinction is explicit.

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 behavioral burden. 'Dry run' and 'before running' strongly communicate that this tool does not execute the query, and the description details the informational output it produces. It could be more explicit about side-effect-free behavior, but the dry-run framing is sufficient.

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 short sentences with no filler. The first sentence front-loads the core behavior, and the second adds a concrete usage scenario. Every word earns its place.

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?

The description adequately explains what the tool does, what it returns, and when to use it, and an output schema exists so return-value details are less critical. However, because the plan parameter is a complex nested object with no schema descriptions, the description leaves the main invocation detail under-specified.

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 only parameter, plan, is an object with additionalProperties allowed and 0% schema description coverage. The description repeatedly references 'the plan' and implies it is a query plan, but it provides no structural guidance about what fields the plan object should contain or how to construct it.

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 uses a specific verb and resource: it 'Shows the English reading of the plan' and lists the concrete contents shown (definitions, seasons, warnings, SQL). It also distinguishes itself from executing siblings like query and raw_sql by explicitly labeling the operation a 'Dry run', making its non-execution role clear.

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 gives explicit usage context: 'Use it to confirm your interpretation with the user before running an expensive or ambiguous query.' This clearly tells an agent when to invoke it, though it does not name alternatives or explicitly say when not to use it.

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 transparency burden and does a solid job by disclosing the specific components of the result: spec, nested English explanation of dependencies, evidence attributes, coverage, and previous versions. It does not discuss failure modes or read-only guarantees, but 'get' plus the enumerated return content makes the behavior clear for a retrieval operation.

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 a single front-loaded sentence that conveys the tool's full scope via a colon-separated list. Every listed item earns its place, and there is no filler.

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?

For a one-parameter read operation with an output schema, the description is nearly sufficient. It names the major result categories and implies the domain. It misses only a small amount of context, such as explicitly linking the `name` parameter to the definition identifier, so it is not a 5.

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%, and the description does not explicitly explain that the required `name` parameter is the identifier of the definition to retrieve or what format/valid values it accepts. The tool name and 'one definition' provide weak inference, but the description does not compensate for the schema's lack of documentation.

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 identifies the resource (one definition) and enumerates the content areas returned: spec, nested English explanation, evidence attributes, coverage, and previous versions. It stops short of a 5 because it lacks an explicit verb like 'retrieves' or 'returns' and does not directly distinguish itself from the coverage or list_definitions siblings beyond the 'one definition' scope.

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 a clear use case: when an agent needs comprehensive details about a single definition. It does not explicitly name alternatives or exclusions, but the 'everything about one definition' framing distinguishes it from list-oriented siblings such as list_definitions.

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, and the description does not state whether this operation is read-only or has side effects. It does not disclose any behavioral details beyond listing definitions and noting broken ones.

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 relatively short but includes extraneous phrasing (e.g., 'Every term used in a query must be here') that does not directly explain the tool's function. It is not overly verbose, but it could be more streamlined and front-loaded.

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?

The description does not explain what the tool returns, how the parameters affect results, or the context of use relative to the other tools. Given the simplicity of the schema, the lack of detail leaves significant gaps for an agent trying to invoke it correctly.

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 includes 'family' and 'include_broken', but the description provides no explanation of these parameters or their impact. The schema itself has no descriptions, so the meaning of the parameters is completely undocumented.

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 implies listing definitions ('Broken definitions ... are listed') and mentions the vocabulary concept, but it does not explicitly state a clear verb like 'list' or 'retrieve'. It is not a tautology, but it is somewhat indirect and could be clearer.

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?

No guidance is provided on when to use this tool versus alternatives like get_definition, query, or delete_definition. The statement about every term being in the vocabulary hints at a use case but does not explicitly contrast with sibling 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, the description carries the full burden, and it is mostly strong: it discloses that candidates are grounded in computable data, include explanations/coverage, and must not be selected silently. It doesn't explicitly state that nothing is saved yet, though 'ready-to-save' and 'present to the user' strongly imply it.

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 front-loaded with the usage trigger and is only three sentences. The first sentence is long and list-heavy, but every part adds useful guidance.

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?

It covers the main workflow and output well, and an output schema exists, but it omits the optional parameters and does not clarify follow-up tool calls such as save_definition after user approval. This is acceptable for a tool with only one required parameter but not fully complete.

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 should compensate by explaining the parameters. It only implicitly covers term; entity and context are completely unexplained, leaving the agent to guess whether or when to populate them.

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 opens with an explicit trigger: call when a concept lacks a definition or when query returns unresolved_term. It also names the concrete outputs (near-matches, candidate definitions, coverage, related attributes) and makes the tool's role clear relative to plain query or lookup tools.

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?

It tells exactly when to call the tool and instructs the agent to present candidates to the user rather than choosing silently. It does not explicitly name alternatives like get_definition or save_definition, but the no-definition/unresolved-term condition implicitly separates it from those.

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, the description carries the full behavioral burden. It discloses the unresolved_term return, the instruction not to work around it, the result contents (definitions_used, seasons covered, sample, SQL), the caveat that the number is not meaningful without definitions/coverage, and the meaning of warnings.

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 dense but every sentence adds necessary operational detail. Inline code keeps the plan and where syntax scannable, and the warnings/error-handling instructions are placed where they matter.

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?

For a complex query tool with one unstructured parameter, the description provides solid coverage of plan structure, error handling, result contents, and warning interpretation. It remains slightly vague about allowed operator values for op and the exact semantics of each metric/grouping field, though an output schema may fill that gap.

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 coverage is 0%, but the description fully compensates by enumerating every plan field and explaining where-clause syntax for concepts, raw fields, and boolean combinators. Without this, the single opaque plan object would be unusable.

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 runs a structured query and explains the plan object, so the agent knows its core function. It does not explicitly contrast itself with sibling tools like raw_sql or explain_query, but the structured query framing distinguishes it reasonably.

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 gives concrete guidance: every fuzzy word must be a term, and on unresolved_term the agent should call propose_definition and ask the user rather than substituting an attribute rule. It does not explicitly state when to choose query over raw_sql or explain_query, but the error-handling guidance is strong.

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, the description carries the full behavioral burden and does so thoroughly. It discloses read-only access, no file or network access, single SELECT/WITH statements, row caps, timeouts, lack of definitions in results, and logging behavior—far beyond what the schema alone provides.

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 dense but every sentence earns its place: purpose, constraints, alternative tool guidance, and operational side effects are all packed into a highly readable format. The most important distinguishing information is front-loaded.

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 and the presence of an output schema, the description is fully sufficient. It covers scope, safety, usage boundaries, logging, and fallback behavior without needing to describe return values, which the output schema already handles.

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 for missing parameter documentation. It adds meaning by specifying that `sql` must be a single SELECT or WITH statement and implying `limit` through the row-cap constraint, though it does not explicitly name the limit parameter.

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 opens with 'Escape hatch: read-only SQL over every raw and derived table,' which clearly states the tool's function, scope, and constraints. It also distinguishes itself from `query` by noting that raw SQL results carry no definitions and that `query` should be preferred for concept-based work.

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 tells the agent when to use this tool versus `query`, directing concept-related queries to `query` and raw/derived table access here. It also provides practical guidance such as telling the user when a number came from raw SQL and noting that recurring raw queries drive attribute prioritization.

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, the description carries the responsibility for behavior. It usefully discloses that saving is versioned and previous versions are kept, and that the returned explanation is meant for telling the user what was saved in plain English. It does not cover permissions or the exact effect of overwrite, but what it does disclose is substantive.

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 three sentences with no filler, covering the core action, a key parameter, versioning, and user-facing output in a compact structure. It is front-loaded with the main purpose and remains 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?

The tool has nine parameters and no annotations, and the output schema only covers the return shape. The description addresses only a small fraction of the parameter space, leaving most inputs ambiguous. An agent could handle the simplest save but would be under-equipped for complex definitions or overwrite semantics.

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 needs to compensate, but it only explains `copy_of`. The other eight parameters, including basis, entity, params, signal, aliases, overwrite, and description, remain unexplained. This leaves the agent guessing about most of the input semantics.

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 states a clear verb, 'save', and resource, 'definition', and specifies it saves the definition the user has chosen. It also distinguishes the copy_of sub-behavior with a concrete example. This clearly separates it from sibling tools like list_definitions or delete_definition.

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 when the user has chosen a definition to save, but provides no explicit when-to-use or when-to-avoid guidance. It does not mention alternatives such as propose_definition, nor does it clarify when to use copy_of versus a fresh save beyond one line.

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