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

The description discloses the read-modify-write flow and clamping behavior, which is valuable behavioral context beyond the schema. Since no annotations are present, this disclosure carries the full burden, though it does not cover error cases or clamp limits.

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 front-load the verb, resource, relative mode, and example, then add a single behavioral note. There is no filler or repetition.

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 simple three-parameter tool with no output schema, the description covers the core purpose, key parameter semantics, and the important read-then-write-clamped behavior. It could be more complete by explicitly pointing to set_fader for absolute adjustments and giving clamp ranges.

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 low at 33%, and the description helps by clarifying that delta_db is in dB and implying sign via the lowering example. However, index and index-specific range details are not enriched, and clamp boundaries for the final fader value are not specified.

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 adjusts a strip fader relatively by a dB delta, with a concrete example. This distinguishes it from set_fader, which would be used for absolute fader setting.

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 relative/dB-delta language and example make it clear when this tool should be used. It does not explicitly exclude or name set_fader as the absolute alternative, so it stops short of full when-not guidance.

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 reveals that search is across strip kinds, that matches have scores, and that ambiguity is possible. It does not disclose matching semantics, return format, pagination, or performance traits, which would be valuable for a search tool without annotations.

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 no fluff: first states the action and scope, second gives a critical safety caveat. The most important constraint is prominently placed and every word serves a 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?

For a simple search tool, the key ambiguity caveat is present. However, with no output schema and no annotations, the description leaves out what the response contains, how 'top score' is determined, and how max_results affects results. This is enough for basic use but not fully complete for an agent to predict behavior confidently.

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 only 33% with descriptions limited to kinds. The description clarifies that the query relates to scribble-strip names and that kinds can scope the search, but it leaves max_results semantics and query matching details (e.g., partial, exact, case sensitivity) unstated. The description adds some meaning but does not fully compensate for the 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 states a specific action ('Search scribble-strip names') and a clear resource ('across strip kinds'), making the tool's purpose understandable. It does not explicitly contrast with sibling tools like list_strips, but the function is easy to distinguish from mutating 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?

The description gives useful post-search guidance: when multiple matches share the top score, use an explicit kind or index before writing. However, it does not explain when to use this tool versus alternatives such as list_strips, or what prerequisites or limitations apply.

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 transparency burden, and 'Read' clearly signals a non-destructive operation. It also adds useful detail like fader in dB. It does not describe error behavior or output formatting, but those are minor for a simple getter.

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?

One front-loaded sentence with no filler. It names the action, the target, the returned fields, and units efficiently, making it easy for an agent to parse quickly.

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 low-complexity read tool with only two parameters and no output schema, the description adequately lists the returned fields and confirms the single-strip scope. It is slightly incomplete around valid index ranges per strip type and failure behavior, but the kind enum descriptions cover much of that 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 schema fully documents 'kind' with enum meanings, but 'index' only has min/max constraints and no semantic description. The tool description says 'one strip' but does not clarify how index relates to kind or what valid index ranges are, so the 50% schema coverage gap is not compensated.

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 action ('Read'), a precise resource ('one strip'), and the specific fields returned (name, fader in dB, mute, pan). This cleanly distinguishes it from sibling set_* tools and from list_strips.

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 use for reading a single strip's status, and 'one strip' contrasts with list_strips. However, it does not explicitly state when to choose this tool over alternatives like find_strip_by_name or osc_get, nor does it mention any exclusion cases.

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 explicitly says 'Read', indicating a non-mutating operation, and adds behavioral detail about liveness ('live') and compactness ('compact'). It also describes the effect of include_status. It doesn't fully describe return format or pagination, but for a read-only listing tool it discloses the essential traits.

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, front-loaded with the primary purpose, and a single follow-up for the optional flag. Every word earns its place; no fluff.

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 no output schema, the description explains what is returned — strip IDs and scribble-strip names, plus optionally fader, mute, pan. It implies the filterable kinds via schema but doesn't restate. There are no obvious missing inputs or side effects for a read-only list operation, though a note on output shape would make it 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 coverage is 50%: kinds is well described in the schema, but include_status is only a bare boolean. The description compensates by saying 'Set include_status to also read fader, mute, and pan,' giving meaning to an otherwise opaque parameter. It does not need to restate kinds because the schema already does.

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 specific verb and resource: 'Read a compact live list of strip IDs and scribble-strip names.' It clearly distinguishes itself from the mutation-oriented siblings like set_fader and adjust_fader by framing this as a read-only listing operation, and it enumerates what is returned.

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 clear usage context: it is a read-only listing tool, and it tells the agent when to include status via the include_status parameter. It does not explicitly name alternatives such as get_strip_status or find_strip_by_name or state when not to use them, but the intended usage is clear.

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 behavioral disclosure burden. 'Read' communicates that the operation is non-mutating, which is helpful. However, it does not explain what happens for invalid or nonexistent addresses, whether any address is truly accepted, or what the response payload looks like, so some transparency is missing.

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, no filler, and the core behavior is front-loaded. The usage constraint is stated in the second sentence, making the description easy to scan.

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 low-complexity one-parameter getter, the description covers what the tool does, how the address is formatted, and when to choose it. The only notable gap is the lack of an output schema or an explicit statement of return semantics, but this does not seriously block 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?

Schema coverage is 0%, but the description compensates reasonably for the single address parameter by labeling it a raw OSC address and giving '/ch/3/eq/on' as an example. This adds practical format context beyond the schema's pattern constraint of starting with a slash.

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 concrete action ('Read any raw OSC address'), a specific resource ('from the WING'), and gives an illustrative example. It also distinguishes itself from the sibling typed tools by positioning this as the fallback for parameters not covered by them.

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 explicitly tells the agent when to use this tool: for parameters not covered by typed tools. This implies that covered parameters should go through typed tools like set_fader or set_mute, which is clear usage guidance even without naming a single sibling.

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 takes on the burden and does well: it reveals value type coercion (float/int/string based on form), the force_type override mechanism, and the dangerous 'can change anything on a live console' side effect. It does not cover response behavior or error cases, but the core risk is clearly disclosed.

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 no filler. The core action is front-loaded, the type behavior is stated in one clause, and the caution is compact yet impactful. 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?

For a destructive raw-write tool, the description conveys what it does, how values are typed, how to override typing, and the risk. It lacks explicit return/output information, but this is acceptable given no output schema and the nature of a raw OSC write command. Sibling context further reinforces its purpose.

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 meaningfully explains value ('sent as float/int/string based on its form'), force_type (override), and the nature of address ('raw OSC address'). The address pattern and required-ness remain only in the schema, so this isn't a perfect five, but it is far above baseline.

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?

Description states a specific verb ('Write'), resource ('raw OSC address on the WING'), and scope ('any'), clearly distinguishing it from sibling tools like set_fader or set_mute that target specific parameters. The word 'raw' signals this is a low-level universal tool.

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 is for arbitrary addresses that specific sibling tools don't cover, but never explicitly says 'use this when no dedicated tool exists' or mentions alternatives. The CAUTION warning gives context about appropriate care but not about selection criteria.

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 primary operation and optional enable/disable, but does not disclose side effects, whether existing send settings are overwritten, what 'enabled' defaults to, or any persistence 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?

Two sentences with no filler. The core operation is front-loaded, and the optional enable/disable clause is a meaningful addition rather than repetition.

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 mutation tool with no annotations and no output schema, the description is too thin. It omits important context such as validation limits already present in the schema, what happens when the send is disabled, whether the send is created if missing, and any behavioral consequences beyond setting a value.

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 only 20%, so the description must compensate. It adds meaning for 'db' as a level in dB and for 'enabled' as the send on/off toggle, and hints that 'bus' is the destination. However, it does not clarify source_index semantics, output behavior, or the relationship between the parameters beyond the source/destination framing.

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: setting a send level from a source (channel, aux, or bus) to a bus destination, expressed in dB, with optional enable/disable. This distinguishes it from sibling tools that address faders, mutes, pan, naming, and OSC operations.

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 explicit guidance is given about when to use this tool versus alternatives like set_fader or adjust_fader. The usage context is only implied by the description's reference to bus sends, with no exclusions or decision criteria.

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 usefully clarifies that -144 is equivalent to -inf and implies a mutation. However, it does not disclose whether the set is absolute, whether it overrides current levels, what side effects occur, or how out-of-range values are handled.

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 states the operation, object, and range without any redundant or filler content. 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?

For a tool with three required parameters, no annotations, and no output schema, the description is too sparse. It omits usage guidance relative to adjust_fader, leaves index semantics and valid ranges undocumented, and fails to describe behavioral outcomes, making it incomplete for safe and 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?

Schema description coverage is only 33% (kind only), so the description must compensate for the undocumented db and index parameters. It adds no per-parameter meaning beyond the unit dB, which is already implied by the parameter name, and does not explain how to choose a valid index or which strip ranges apply.

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 a specific verb ('Set') and resource ('fader level in dB on the WING console'), and includes the acceptable dB range. However, it does not explicitly differentiate this tool from the sibling adjust_fader, e.g., by noting that set_fader sets an absolute level rather than a relative adjustment.

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 about when to use set_fader versus adjust_fader or other siblings. The description does not state whether this is for absolute level setting or how it differs from adjust_fader, leaving the agent to infer the usage solely from the tool name.

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 present, so the description carries the full burden of behavioral disclosure. It only states the operation and does not explain whether the muted value is an absolute state or toggle, whether changes persist, what happens on invalid indices, or what the tool returns.

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 efficient sentence that gets straight to the point. There is no redundant wording, and the main action 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?

For a simple three-parameter boolean setter, the description plus the input schema is minimally viable to form a correct call. But there are no annotations and no output schema, and the description does not explain response behavior, error conditions, or whether the operation is absolute or toggling, leaving meaningful gaps.

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 only 33%, and the description does not compensate by explaining index or the muted boolean. The kind parameter is well described in the schema, but index and muted semantics are left implicit; the 'Mute or unmute' wording weakly hints at the muted boolean but adds little concrete value.

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 ('Mute or unmute') and a specific resource ('a strip on the WING console'), clearly distinguishing it from sibling tools like set_fader, set_pan, or set_name. Even without the schema, an agent can tell this tool is for mute state control.

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?

Usage is implied by the action itself: use this tool when you need to mute or unmute a strip. However, there is no explicit guidance about when not to use it or how it compares to siblings, so it relies on inference.

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 present, so the description carries the full burden for behavioral disclosure. It only states that the tool sets a name; it does not mention whether existing names are overwritten, what happens on invalid indexes, permission requirements, side effects, or error 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 concise sentence with no filler or repetition. It is front-loaded and every word contributes to the core action, though its brevity contributes to the lack of behavioral and parameter detail.

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 enum-based kind parameter, an undocumented index parameter, sparse schema coverage, no annotations, and no output schema, the description is not complete enough to guarantee a correct call. It needs more detail about index semantics, valid strip kinds, and overwrite behavior.

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 only 33%, with only the kind parameter described. The description ties 'name' to the scribble strip but does not clarify the meaning or range of index, nor the name constraints. It only partially compensates for the sparse schema 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 uses a specific verb and resource: 'Set the scribble strip name of a channel/bus/dca.' This makes the action unambiguous and distinguishes it from sibling set_* tools. It loses a point because it omits aux, main, and mtx strip kinds that the schema explicitly allows.

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 intended usage is implied: use this tool to change a strip's scribble strip name. However, there is no explicit guidance about when to use it versus alternatives, no prerequisites, and no exclusions. Sibling names are distinct enough that the context is inferable rather than fully stated.

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 available, so the description carries the full disclosure burden. It does reveal the pan value range and what values mean, which is useful behavioral context. But it fails to disclose whether the operation overwrites existing state, whether some strip kinds support pan, how invalid or out-of-range values are handled, or what the response is. For a mutation tool with zero annotations, this is insufficient.

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 short sentences carry all the information. The action is front-loaded, and the range mapping is compact and easy to parse. There is no filler or redundancy.

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 3 required parameters, no output schema, and no annotations, the description is under-specified. It doesn't explain what 'index' represents, what valid indices are for each kind, or how the operation behaves under edge conditions. The agent would need to infer or probe too much to call the tool confidently.

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 schema only documents the 'kind' parameter (33% coverage), leaving 'pan' and 'index' with only type constraints. The description adds important semantics for pan (-100 left, 0 center, +100 right), which is genuinely helpful. However, 'index' remains unexplained—the agent only knows it is an integer ≥1 and doesn't learn what it refers to or its bounds per strip type.

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 starts with a specific verb and resource: 'Set pan position of a strip', which clearly identifies the tool's function. The value mapping for pan (-100 to +100) further clarifies the domain. However, it doesn't explicitly distinguish from sibling set tools like set_fader or set_mute, though the resource itself is fairly specific.

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?

There is no guidance on when to use this tool versus alternatives such as set_fader or adjust_fader. It also doesn't state any context, prerequisites, or conditions that would make this tool the right choice. The only additional content is a parameter value explanation, which is not usage guidance.

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