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

With no annotations provided, the description carries full burden for behavioral disclosure. While it mentions the action types and position parameter, it doesn't describe what 'control' entails (e.g., whether it's immediate, requires authentication, has rate limits, or what happens on failure). For a mutation tool with zero annotation coverage, this leaves significant behavioral 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 efficiently structured with a clear opening statement followed by well-organized Args and Returns sections. Every sentence earns its place by providing essential information without redundancy, making it easy to scan and understand.

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 moderate complexity (3 parameters, mutation operation) and the presence of an output schema (handling return values), the description is adequate but has gaps. It covers parameter semantics well but lacks behavioral context and usage guidelines, making it incomplete for optimal agent understanding despite the output schema assistance.

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 description adds substantial value beyond the input schema, which has 0% description coverage. It explains that device_id is a 'Bond shade device identifier', clarifies that action accepts 'open', 'close', or 'set_position', and specifies that position is a 'percentage (0-100)' for set_position actions. This compensates well for the schema's lack of 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 verb 'control' and resource 'motorized shades', making the purpose immediately understandable. However, it doesn't explicitly differentiate this tool from sibling tools like 'toggle_device_power' or 'send_custom_action' that might also affect shade devices, missing full sibling differentiation.

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 no guidance on when to use this tool versus alternatives. There's no mention of prerequisites (like needing device_id from list_devices), nor does it explain when to choose control_shades over send_custom_action for shade operations, leaving usage context unclear.

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 states the tool 'Get Bond Bridge information and status' and mentions return values, implying a read-only operation, but doesn't disclose behavioral traits like authentication needs, rate limits, or error handling. The description adds basic context but lacks depth for a tool with no annotation support.

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 core purpose in the first sentence, followed by a brief note on returns. Both sentences are necessary and add value, with no wasted words. It's appropriately sized for a simple tool with no parameters.

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 (0 parameters, no annotations, but with an output schema), the description is reasonably complete. It states the purpose and hints at return values, though it could benefit from more behavioral context. The output schema reduces the need to explain returns, but the lack of annotations means the description should do more to cover operational aspects.

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 documentation is needed. The description doesn't add parameter details, which is appropriate here. It mentions return values, but since an output schema exists, this isn't required. The baseline for 0 parameters is 4, as the description doesn't need to compensate for any 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: 'Get Bond Bridge information and status.' It specifies the verb ('Get') and resource ('Bond Bridge information and status'), making it easy to understand what the tool does. However, it doesn't explicitly differentiate from sibling tools like 'get_device_info' or 'get_device_state', which might also retrieve information about devices.

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 no guidance on when to use this tool versus alternatives. It doesn't mention sibling tools like 'get_device_info' or 'get_device_state', nor does it specify any context or prerequisites for usage. This leaves the agent without clear direction on tool selection.

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 states the tool retrieves 'detailed information' but doesn't specify whether this is a read-only operation (implied by 'Get'), what permissions are required, if there are rate limits, or the response format beyond 'including capabilities and properties'. For a tool with no annotation coverage, this leaves significant gaps in understanding its 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 appropriately sized and front-loaded, with the core purpose in the first sentence and additional details in a structured 'Args' and 'Returns' section. Every sentence adds value, but the 'Returns' section is somewhat redundant given the presence of an output schema, slightly reducing efficiency.

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 low complexity (1 parameter, no nested objects) and the presence of an output schema (which handles return values), the description is mostly complete. It covers the purpose and parameter semantics adequately. However, it lacks usage guidelines and behavioral details, which are minor gaps in this 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 description adds meaningful context beyond the input schema. The schema has 0% description coverage and only defines 'device_id' as a string, but the description specifies it as 'The Bond device identifier', clarifying its purpose and format. With 1 parameter and low schema coverage, this compensation is effective, though it could be more detailed (e.g., example format).

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 with a specific verb ('Get') and resource ('detailed information about a specific device'), distinguishing it from siblings like 'list_devices' (which likely lists multiple devices) and 'get_device_state' (which might focus on state rather than comprehensive information). However, it doesn't explicitly differentiate from 'get_bridge_info', which could be a similar info-retrieval tool for a different resource.

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 no guidance on when to use this tool versus alternatives. It doesn't mention prerequisites (e.g., needing a device_id from 'list_devices'), exclusions (e.g., not for bridges), or comparisons with siblings like 'get_device_state' (which might be for real-time state vs. static properties). The context is implied but not 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?

No annotations are provided, so the description carries the full burden of behavioral disclosure. It states this is a 'Get' operation, implying read-only behavior, but doesn't mention permissions, rate limits, error conditions, or whether it's idempotent. For a tool with zero annotation coverage, this leaves significant gaps in understanding its 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 well-structured with a clear purpose statement, an 'Args' section, and a 'Returns' section, making it easy to parse. It's appropriately sized for a simple tool, though the 'Returns' part could be slightly more detailed to enhance clarity without adding bulk.

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 low complexity (one parameter) and the presence of an output schema, the description is adequate but minimal. It covers the basics but lacks depth in usage guidelines and behavioral context, which are important for an agent to operate effectively without annotations.

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 description adds meaningful context beyond the input schema: it explains that 'device_id' is a 'Bond device identifier,' which clarifies the parameter's purpose. With 0% schema description coverage and only one parameter, this compensation is effective, though it could specify format or constraints.

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 verb 'Get' and resource 'current state of a Bond device', making the purpose specific and understandable. However, it doesn't explicitly differentiate from sibling tools like 'get_device_info' or 'list_devices', which prevents 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 no guidance on when to use this tool versus alternatives. With siblings like 'get_device_info' and 'list_devices', there's no indication of how this tool differs in usage context, leaving the agent without direction on tool selection.

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 discloses that the tool returns a dictionary with basic information, which is useful behavioral context. However, it doesn't mention potential limitations like rate limits, authentication needs, or whether the list is real-time or cached. The description doesn't contradict any annotations (since none exist), but it lacks depth for a tool that might have operational constraints.

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 concise with only two sentences, front-loading the core purpose ('List all Bond devices connected to the bridge') and following with return details. Every sentence earns its place by clarifying the action and output, with zero wasted words. This is a model of efficiency for a simple 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 the tool's low complexity (0 parameters, simple listing operation), the description is reasonably complete. It states what the tool does and what it returns. With an output schema available, the description doesn't need to detail return values extensively. However, for a tool with no annotations, it could benefit from more behavioral context (e.g., permissions or performance hints) to fully guide an agent.

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 parameters need documentation. The description doesn't add parameter details, which is appropriate here. It does mention the return type ('Dictionary containing all devices with their basic information'), which provides semantic value beyond the schema, though an output schema exists to cover this 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 verb ('List') and resource ('Bond devices connected to the bridge'), making the purpose immediately understandable. It distinguishes this from siblings like 'get_device_info' (single device) and 'get_device_state' (state rather than listing), though it doesn't explicitly mention these distinctions. The description avoids tautology by not just repeating the tool name.

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 by specifying 'all Bond devices connected to the bridge,' suggesting this is for inventory purposes. However, it doesn't provide explicit guidance on when to use this versus alternatives like 'get_device_info' (for single device details) or 'get_bridge_info' (for bridge metadata). No exclusions or prerequisites are mentioned.

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 states this sends an action but doesn't disclose behavioral traits such as whether this is a read/write operation, potential side effects (e.g., device state changes), authentication needs, rate limits, or error handling. This is a significant gap for a tool that likely performs mutations.

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 and front-loaded with the core purpose, followed by structured sections for Args and Returns. Each sentence earns its place, but the Returns section is redundant given the presence of an output schema, slightly reducing efficiency.

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 moderate complexity (3 parameters, no annotations, but with an output schema), the description is partially complete. It covers parameters well but lacks behavioral context (e.g., mutation effects, error cases). The output schema reduces the need to explain return values, but overall, it's adequate with clear gaps in usage and transparency.

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%, but the description compensates by explaining all three parameters: 'device_id' as the Bond device identifier, 'action' as the Bond action name with examples, and 'argument' as optional with its type. This adds meaningful context beyond the bare schema, though it could specify format constraints (e.g., action naming conventions).

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 verb ('Send') and resource ('custom action to a Bond device'), making the purpose understandable. However, it doesn't explicitly differentiate from sibling tools like 'toggle_device_power' or 'set_fan_speed', which also control devices but through specific actions rather than custom ones.

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 'toggle_device_power' or 'set_fan_speed'. The description mentions it's for custom actions but doesn't clarify scenarios where this is preferred over the more specific sibling tools, leaving usage context implied at best.

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 for behavioral disclosure. While 'Set' implies a mutation operation, it doesn't specify whether this requires authentication, what happens on failure, if changes are immediate or reversible, or any rate limits. The return statement is vague about what 'Result' actually contains.

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 a clear purpose statement followed by organized Args and Returns sections. Every sentence serves a distinct purpose with zero wasted words, making it easy to parse and understand 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 mutation tool with no annotations and an output schema (though not shown), the description covers basic purpose and parameters adequately but lacks important behavioral context about permissions, side effects, and error handling. The presence of an output schema reduces the need to describe return values, but more operational guidance 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, the description provides essential parameter context: device_id is identified as 'Bond fan device identifier' and direction is clarified to accept 'forward' or 'reverse' values. This adds meaningful semantics beyond the bare schema, though it doesn't explain format requirements for device_id.

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 ('Set fan direction') and target resource ('for a ceiling fan device'), distinguishing it from sibling tools like set_fan_speed or toggle_device_power. It precisely communicates the tool's function without ambiguity.

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 for controlling ceiling fan direction, but provides no explicit guidance on when to use this versus alternatives like set_fan_speed or toggle_device_power. It doesn't mention prerequisites, error conditions, or specific scenarios where this tool is appropriate.

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 for behavioral disclosure. While it implies a mutation operation ('Set'), it doesn't disclose whether this requires authentication, has side effects, is idempotent, has rate limits, or what happens with invalid inputs. The return statement is vague about what 'Result' contains.

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 clear sections (purpose, args, returns). The first sentence states the core purpose, and subsequent sections add necessary detail. While efficient, the 'Returns' section could be more specific about what 'Result' entails.

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 but with an output schema, the description provides adequate basic information about purpose and parameters. However, it lacks important behavioral context about side effects, error handling, and authentication requirements that would be expected for a device control operation.

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, the description fully compensates by providing complete semantic information for both parameters. It explains device_id is a 'Bond fan device identifier' and speed is a 'Fan speed level (0-8, where 0 is off)', adding crucial context beyond the bare schema types.

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 ('Set fan speed') and target resource ('for a ceiling fan device'), distinguishing it from sibling tools like set_fan_direction or set_light_brightness. It provides a complete verb+resource+scope statement that leaves no ambiguity about what this tool does.

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 no guidance on when to use this tool versus alternatives like toggle_device_power or set_fan_direction. It doesn't mention prerequisites, error conditions, or contextual constraints, leaving the agent with no usage differentiation from 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 provided, the description carries the full burden of behavioral disclosure. It implies a mutation operation ('Set brightness') and specifies the brightness range (0-100), but lacks details on permissions, rate limits, or side effects. It adds some context but falls short of fully describing behavioral 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?

The description is appropriately sized and front-loaded, with a clear purpose statement followed by structured Arg and Return sections. Every sentence adds value without redundancy, making it 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's moderate complexity (2 parameters, mutation operation) and the presence of an output schema (which handles return values), the description is largely complete. It covers purpose and parameter semantics well but could improve by adding usage guidelines and more behavioral context, especially 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?

The description adds significant meaning beyond the input schema, which has 0% description coverage. It explains that device_id is a 'Bond light device identifier' and brightness is a 'percentage (0-100, where 0 is off)', clarifying semantics and constraints not present in the 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 ('Set brightness') and target resource ('dimmable light device'), distinguishing it from sibling tools like set_fan_speed or toggle_device_power. It precisely defines what the tool does without being vague or tautological.

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 no guidance on when to use this tool versus alternatives like toggle_device_power or send_custom_action. It doesn't mention prerequisites, such as needing the device to be a dimmable light, or exclusions, leaving the agent to infer usage context.

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 toggles power (implying a mutation) but doesn't describe side effects (e.g., device response time, error conditions like offline devices), authentication needs, or rate limits. The mention of 'Result of the toggle operation' hints at output but lacks detail, leaving behavioral traits unclear.

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 and front-loaded, with the core purpose stated first. The 'Args' and 'Returns' sections add structure, but the 'Returns' sentence is vague and could be more informative. Overall, it's efficient with little waste, though minor improvements in clarity could enhance it.

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 moderate complexity (mutation with one parameter) and no annotations, the description is somewhat complete but has gaps. It covers the basic action and parameter, and an output schema exists (so return values needn't be detailed). However, it lacks usage context, behavioral details, and parameter constraints, making it adequate but not fully helpful for an agent.

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 description adds minimal meaning beyond the input schema. It defines 'device_id' as 'The Bond device identifier', which is basic but helpful given 0% schema description coverage. However, it doesn't explain format (e.g., string pattern, where to find it) or constraints, so 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 tool's purpose with a specific verb ('Toggle') and resource ('power state of a Bond device'), making it immediately understandable. It distinguishes from siblings like 'control_shades' or 'set_fan_speed' by focusing on power state. However, it doesn't explicitly differentiate from 'get_device_state' which reads rather than toggles power.

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 no guidance on when to use this tool versus alternatives. It doesn't mention prerequisites (e.g., device must be online), exclusions (e.g., not for devices without power control), or comparisons to siblings like 'get_device_state' for checking power or 'send_custom_action' for other operations. Usage is implied but not specified.

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