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

With no annotations, the description carries the full burden for behavioral disclosure, but it omits the critical dry_run default behavior and whether duplicates are ignored or rejected. It does state that existing entries are preserved, which is useful non-destructive context, but the dry_run semantics are a significant transparency gap for a mutating tool.

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, each earning its place: the core action, the necessary workflow condition, and the non-destructive guarantee. It is front-loaded and has 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?

Despite having an output schema, the tool has five parameters, zero schema description coverage, and no annotations, so the description needs to supply more operational context. The missing dry_run default behavior and lack of parameter-level guidance make it incomplete 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?

Schema description coverage is 0%, so the description must compensate, but it only implies the meaning of scope_id and entity_ids through the general 'activity or macro' and 'more entities' language. It does not explain host, scope, or dry_run parameters, leaving most parameter semantics to inference.

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: 'Allow an activity or macro to use more entities.' It clearly differentiates this from merely exposing an integration entity and gives workflow context ('it must also be added here before a button or page item can use it'). This is distinct enough from siblings like list_scope_entities and remove_scope_entities.

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 context for when to use this tool: after exposing an integration entity and before a button or page item can consume it. It does not explicitly name alternatives or when not to use it, but the workflow guidance is strong and prevents confusion with integration-level configuration.

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 disclosure burden. It clearly warns that a rejected step ends the flow and requires a restart, and it states that the tool returns the next screen. It does not mention permissions, idempotency, or partial-failure details, but the main behavioral risk is 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?

The description is two short sentences with the core action and outcome front-loaded. It contains no filler, though a slightly more explicit verb like 'submit answers' would improve clarity. Overall it is appropriately sized for the tool's simplicity.

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 covers the core form-answering behavior and the lifecycle consequence of rejection, and the output schema covers what is returned. However, it leaves parameter roles and the exact entry condition—how driver_id identifies the setup and what state must already exist—to inference.

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 driver_id, values, or host. The instruction to 'send every field the screen asks for' implicitly references the values object but does not clarify how driver_id selects the setup or what host/null means. The description fails to 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 states a concrete verb and object: it answers the current setup screen and returns the next one. This distinguishes it from related lifecycle tools like start_integration_setup, get_integration_setup, and confirm_integration_setup, though it never names them. The wording 'answer the current setup screen' is slightly jargon-heavy but still conveys the tool's function.

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 during an active multi-step setup by referring to the 'current setup screen' and instructing the agent to send every requested field. However, it does not explicitly state when to use this tool versus alternatives like get_integration_setup or confirm_integration_setup, nor does it give prerequisites or exclusion 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, description carries full burden. It discloses default file path, retention of last 50 backups, and timestamp naming. It does not mention if the operation is read-only or has side effects, but the term 'dump' implies non-destructive.

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. All information is front-loaded and directly relevant.

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 two optional parameters and an output schema (not shown), the description covers purpose, default behavior, and retention. Missing host parameter explanation and explicit return info, but overall adequate.

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

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

Schema coverage is 0%, yet description only explains the output_path default implicitly via the default path. The 'host' parameter is completely undocumented, leaving its purpose unclear.

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 clearly states the verb 'dump' and resource 'entire remote configuration', listing specific components (system, entities, etc.). This distinguishes it from sibling tools like restore_config or diff_config.

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?

Context is clear: use for full backups. No explicit when-not-to-use or alternatives, but the sibling list provides implicit differentiation.

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 provided, so description compensates well. It discloses that invalid activities are skipped (with reason), a backup is created before batch, and the default is dry_run=True. These behavioral traits are crucial for the agent.

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, very concise, front-loaded with the core action, then key details. No wasted words.

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 9 parameters and batch operation, description covers filtering, safety (backup, dry run), and error handling (skip invalid). It doesn't detail the output schema, but since one exists, the agent can infer return structure. Overall complete for the complexity.

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%, so description must add meaning. It explains activity_ids and name_contains as filters, button/command/entity_id as the binding, and dry_run. However, it does not describe host, params, or press (default is short_press), leaving gaps for secondary parameters.

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: 'Set the same button binding across many activities at once.' It provides an example (routing VOLUME_UP) and distinguishes from sibling set_button_mapping (single activity) through the 'bulk' aspect.

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

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

Explicitly mentions filtering options ('Filter with activity_ids and/or name_contains') and the behavior when no filter is applied ('all activities'). It also indicates dry_run default and how to apply. While it doesn't explicitly state when not to use, the sibling context (set_button_mapping for single) is implied.

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 burden, and 'changing nothing' is a meaningful non-mutation guarantee. This addresses the main behavioral risk for an agent considering whether the call has side effects.

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 eight words, front-loads the action, and tucks the key safety guarantee into an appositive. 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 two-parameter cancellation tool with an output schema, the description conveys the intent and safety profile in one sentence. It doesn't detail how driver_id selects the setup, but the schema and sibling structure make that inferable.

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 driver_id or host. The property names are somewhat self-explanatory, but the description adds no parameter-level meaning to compensate for the missing schema descriptions.

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

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

The description names a clear action ('Abandon') and a specific resource ('in-progress setup flow'), and adds the clarifying guarantee 'changing nothing'. This distinguishes it from sibling setup actions like answer_integration_setup and confirm_integration_setup.

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 states the clear context for use: an in-progress setup flow. It doesn't explicitly name alternatives or exclusions, but the domain of 'setup flow' makes the selection obvious among siblings.

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, 'Additive; removes nothing' is a meaningful side-effect guarantee that goes beyond the tool name and discloses non-destructive behavior. It does not mention the dry_run default or idempotence specifics, but the core behavioral trait is clearly stated.

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?

Three short sentences deliver purpose, side-effect guarantee, and setup caveat with no filler. The description is front-loaded with the action and 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?

The description covers the core action and non-destructive guarantee, and an output schema exists for return values. However, it omits the practical implication of dry_run defaulting to true and does not state prerequisites like the integration needing to be installed or set up first.

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 only indirectly maps integration_id and entity_ids to 'entities from an integration.' It adds no meaning for host or dry_run, and dry_run's default of true is behaviorally important but left unexplained.

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 ('Expose') and resource ('entities from an integration') and states the purpose ('so activities and pages can use them'). This clearly differentiates it from installation, listing, enabling, or setup siblings.

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 note 'Setup finishing does not do this for you' gives the agent clear context that this is the necessary post-setup step for exposing entities. It does not explicitly name alternatives or exclusions, but the guidance is concrete enough for 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?

The description explains the expected behavior: answer the confirmation screen and return the next screen. However, with no annotations provided, it does not disclose side effects, reversibility, or whether confirming advances persistent setup state.

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 concise sentences with no filler. It front-loads the core behavior and then provides the key sibling differentiation.

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 is well differentiated from siblings, but the lack of parameter explanations and any side-effect disclosure makes it incomplete for reliable invocation. An agent would still need external knowledge or schema descriptions to know what driver_id, host, and confirm represent.

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 provides no meaning for the parameters host, confirm, or driver_id. The description does not compensate for the missing schema documentation, leaving agents without enough information to populate parameters correctly.

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: answering a confirmation screen and returning the next one. It also explicitly distinguishes this tool from answer_integration_setup, making the resource and behavior 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 an explicit routing rule: use answer_integration_setup for screens with fields, and use this tool for confirmation screens without fields. This leaves no ambiguity about when to choose this tool over its 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 carries the behavioral burden. It discloses side effects: the empty page is removed, and the result indicates whether the activity joined the default group and may control device power. It does not mention the dry_run default, but the schema exposes that parameter.

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 front-loaded: definition first, then construction modes, then side effects. Every sentence adds useful information with no redundancy or 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?

The description covers the main creation paths and a key side effect, and an output schema exists for return values. However, the critical dry_run default is unexplained, and there is no guidance for the optional host parameter, leaving an agent without full context for a 7-parameter tool.

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

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

Schema description coverage is 0%, so the description must compensate. It explains entity_ids, clone_from, and icon, but not host, description, or dry_run. The dry_run parameter is especially important because it defaults to true, yet the description is silent about its meaning.

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 a specific verb and resource: 'Create an activity' on the remote's home screen. It distinguishes the tool from siblings like list_activities and get_activity by making clear this is the creation 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?

It gives explicit construction guidance: use entity_ids for building from scratch, clone_from for copying, and not both. It lacks explicit comparison to alternative sibling tools, but the within-tool usage decision is clearly described.

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 does add useful details: pages are appended last, reordering is delegated to set_default_ui_page, and item commands are validated first. However, it fails to mention that dry_run defaults to true, meaning a default call may not persist the page at all, which is a critical behavioral omission for a creation tool.

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 at four sentences, front-loads the primary action, and every sentence adds necessary information. There is no filler or redundant repetition of the schema.

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 seven parameters, nested objects, and no annotations, the description is insufficient for safe invocation. It omits the dry_run default, the meaning of scope_id and name, the host field, and any prerequisites about the target activity or remote-entity. While an output schema exists and return-value details are not required, the missing behavioral and parameter context is significant.

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

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

Schema description coverage is 0%, so the description must compensate. It explains scope values, the grid shape, and that items match get_ui_page output, which is genuinely helpful. But it leaves required parameters like scope_id and name, plus optional host and dry_run, completely unexplained, so an agent cannot confidently populate all inputs.

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 a specific verb and resource: 'Add a new page to an activity or remote-entity.' It also clarifies the two valid scope values and distinguishes this operation from related siblings like update_ui_page, delete_ui_page, and set_default_ui_page. There is no ambiguity about what the 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 gives clear context for when to use the tool by stating the target types and scope values. It also directs the agent to set_default_ui_page for reordering, which is a useful alternative boundary. However, it does not explicitly say when not to use it or mention update/delete as alternatives for modifying existing pages.

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 of behavioral disclosure. It thoroughly explains the destructive scope: removing the driver, its instance, all entities, and stripping button mappings and page items. It also warns to read a preview, implying a dry-run or confirmation step. However, it does not explicitly mention permissions, reversibility, or the role of the dry_run parameter, which could be critical for safe use.

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

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

The description is two sentences with no filler. The primary action and full scope are front-loaded, and the safety instruction is concise. Every word adds value, and the structure is clear and scannable.

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 covers the main destructive behavior well and mentions a preview, but it omits key context such as the purpose of dry_run and host, and it does not describe the output format (though an output schema exists). Given the tool's complexity (cascading deletions) and the lack of annotations, the description is adequate but not comprehensive, leaving the agent to infer parameter roles and prerequisites.

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

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

Schema description coverage is 0%, so the description must compensate. It only implies that driver_id identifies the driver to remove, but does not explain the host or dry_run parameters. The mention of 'preview' hints at dry_run but does not clarify its default or behavior. Since two of three parameters are undocumented, the description adds minimal semantic value beyond 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 a specific action: removing a driver and all its associated entities, button mappings, and page items. It names the resource (driver) and the full scope, distinguishing it from similar tools like delete_integration_instance, which likely deletes only an instance. The verb 'Remove' is specific and the object is well-defined.

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 no explicit guidance on when to use this tool versus alternatives. It does not mention that delete_integration_instance exists for instance-only removal, nor does it provide conditions or exclusions. The only hint is 'Read the preview before applying,' which is a caution about the destructive nature, not about when to select this tool.

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 it does a good job: it discloses that entities, button mappings, and page items are removed, while the driver is preserved. It also hints at a preview step ('read the preview'). It stops short of discussing reversibility or permissions, but the main destructive scope 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?

Three short sentences deliver the core action, the use context, and the important side effects without redundancy. The most important scoping information ('keeping the driver') is front-loaded, and 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?

The description covers the main action and side effects well, and an output schema exists to document return values. However, with no annotations and no parameter-level guidance, the agent is left to guess at the meaning of dry_run and host, which matters for a deletion tool. This prevents the definition from being 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%, and the description mentions none of the parameters (integration_id, host, dry_run). The agent must infer integration_id from the tool name and cannot learn from the description what dry_run or host do. The description does not compensate for the schema's lack of parameter 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-resource pair ('Remove one configured instance and its entities') and immediately distinguishes this tool from delete_integration by stating 'keeping the driver.' It also identifies the niche purpose ('teardown for firmware-shipped drivers'), making its role unmistakable among many sibling 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 explicit context for when this tool is appropriate: 'The teardown for firmware-shipped drivers.' It does not explicitly say when not to use it or name an alternative like delete_integration, but the 'keeping the driver' contrast strongly implies the intended boundary.

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?

Discloses key behaviors: irrevocable deletion, auto-backup before write, and dry-run default showing content to be lost. No annotations provided, so description fully covers behavioral traits relevant for a delete 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?

Two sentences, front-loaded with key action and resource, no redundant words. Every sentence adds essential 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?

Has output schema (not shown) so return values are covered. Description covers purpose, scope, dry-run, and irreversibility. Lacks details about restoration process from backup, but that is acceptable for a delete 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 coverage is 0%, so description must compensate. It explains scope types and dry_run behavior (shows full content), but does not describe the 'host' parameter. Partially adds value beyond 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?

Clearly states 'Delete a UI page' with specific resource (UI page) and scope types ('activity' or 'remote'), distinguishing it from sibling tools like update_ui_page or get_ui_page.

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?

Provides clear guidance on irreversible nature and dry-run default, telling users to preview before deletion. Does not explicitly list alternatives but the dry-run option serves as cautious usage advice.

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 full burden. Explicitly states read-only behavior and outlines output contents (operations a restore would perform plus non-restorable differences). Lacks details on permissions or error handling but sufficient for basic understanding.

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 wasted words. Front-loaded with the core purpose, then adds specific output detail. Efficiently communicates essential 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?

Has output schema so return values are covered elsewhere. Still lacks parameter details and usage context relative to siblings. Adequate but incomplete for fully autonomous agent use.

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 description must compensate. It does not explain any parameters (against_path, host). Leaves agent to infer meaning from parameter names alone, which is insufficient.

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?

Clearly states it shows differences between live config and a backup file, specifying it is read-only. Distinguishes from siblings like backup_config and restore_config by focusing on diff rather than create/restore.

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?

Implies usage for previewing restore operations and identifying unrecoverable differences, but does not explicitly state when to use vs alternatives like restore_config or provide when-not-to-use 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?

No annotations are provided, so the description carries full burden. It states the scanning mechanism and return list, but does not disclose the timeout behavior, potential duration, or network prerequisites. Adequate but not thorough.

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 concise sentences with no wasted words. The first sentence states the action, the second explains the return value. Excellent structure.

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 is simple with one optional parameter and documented output. The missing parameter description is a gap, but overall the description is nearly complete for this simple 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 mention the 'timeout_s' parameter at all. It fails to add meaning beyond the schema, leaving the agent without guidance on how to use this 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 clearly states 'Scan the LAN via mDNS for UC remotes' with a specific verb and resource, and the return structure is explicitly listed. It distinguishes itself from sibling tools as the only discovery-oriented 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?

No explicit when-to-use or alternatives are mentioned. The usage is implied from the action, but no exclusions or prerequisites are provided. For a simple tool, this is adequate but not exemplary.

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 should disclose behavioral traits. It is likely read-only (get operation), but the description does not explicitly state that, nor does it mention permission requirements, side effects, or rate limits. The response format is also not described, though an output schema exists.

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 of 14 words with no wasted words. However, it is overly minimal and lacks structure—no bullet points or front-loading of key information. It earns its place but barely adds value.

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?

Despite having an output schema (which covers return values), the description does not explain the meaning of 'activity_id' or how to obtain it. Given the number of sibling tools, the description should help differentiate, but it leaves ambiguity about what constitutes an 'activity' and when to use this 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 adds no meaning to the parameters (host and activity_id). It does not explain their roles, valid values, or where to obtain activity_id. The description only describes the output, not the input.

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 it returns 'Full activity config' and lists specific components (included entities, sequences, button overrides, UI pages). It distinguishes from sibling tools like get_button_mapping and get_ui_page by indicating a broader scope. However, 'activity' is not defined and could be ambiguous without domain context.

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 on when to use this tool versus alternatives such as list_activities or get_remote_info. The description does not mention prerequisites, context, or exclusions, leaving the agent to infer usage.

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 device scope returns all bindings across activities and remotes for the target device, which adds useful behavioral context. However, it does not mention response format, empty results, or other potential behaviors.

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 that packs essential information without redundancy. It is front-loaded with the core purpose and uses parentheses to add detail efficiently.

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 simplicity and the presence of an output schema, the description sufficiently covers parameter behavior and scope differentiation. No missing information is critical for correct usage.

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 must compensate. It explains the semantics of 'scope' and 'scope_id' well, but the 'host' parameter (optional, default null) is not mentioned at all, leaving a gap.

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 retrieves bindings between physical buttons and commands, and distinguishes three scope types (activity, remote, device) with specific requirements. This makes the purpose explicit and distinguishes it from sibling tools like set_button_mapping.

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

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

The description provides explicit instructions on how to use each scope type and what scope_id is required, but does not explicitly state when not to use the tool or mention alternatives, though the context 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?

No annotations are present, so the description carries the full burden. It describes what the tool returns (features, commands, attributes, options) but does not disclose whether it is read-only, requires special permissions, or has any side effects. The description is moderately transparent but lacks behavioral details.

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

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

The description is a single, clear sentence that efficiently conveys the tool's purpose. However, it could be slightly more structured by separating the parameter details or adding usage notes.

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 an output schema, so return values are partially covered. However, the description lacks any context about authentication, prerequisites, or the scope of the returned config (e.g., includes all options or only a subset). It is adequate 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%, and the description provides no elaboration on the 'device_id' or 'host' parameters. The agent must infer meaning solely from parameter names, which is insufficient for a tool with two parameters.

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 it retrieves the full configuration for one device, listing the specific components (features, commands, attributes, options). This differentiates it from sibling tools like list_devices (which lists all devices) and other get_* tools (which target different entities).

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 on when to use this tool versus alternatives. It does not mention prerequisites, edge cases, or when to avoid using it. The agent must rely on the name and description alone to infer 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, the description carries the full burden of behavioral disclosure. It implies a read operation (get) and mentions the return content, but it does not explicitly state that it is read-only, does not modify anything, or describe any side effects. It also lacks details on error behavior or required permissions. The description is adequate for a simple retrieval but not rich.

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, succinct sentence that front-loads the core purpose. There is no wasted wording, and it achieves clarity without unnecessary elaboration.

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

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

Given the tool has two parameters, one required, and the description does not explain the optional host parameter, the description is incomplete. While an output schema exists (which covers return structure), the description fails to clarify the meaning of host or any limitations (e.g., if the integration must exist). This leaves an agent uncertain about parameter usage.

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 has zero description coverage for its two parameters (integration_id and host). The description mentions neither parameter, leaving their purpose and format entirely to inference. This is a critical gap; the description should at least clarify that integration_id is the identifier and explain what host modifies, but it does not.

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 returns 'One integration instance in full, including the entities it has configured.' This specifies the verb (get), the resource (integration instance), and the scope (full details plus entities). It distinguishes from siblings like list_integrations (which lists many) and list_integration_entities (which lists entities separately) by emphasizing it's a single full instance.

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 explicit guidance on when to use this tool versus alternatives. It does not mention that it should be used for detailed single-integration retrieval, nor does it reference siblings or exclusion conditions. The intended usage is only implied by the phrase 'one integration instance in full,' which is insufficient.

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 disclosure burden. It discloses one important behavior: a 404 response means no setup flow is in progress. It does not explicitly confirm the operation is non-mutating or mention any side effects, though the read-only nature is strongly implied by 'current screen' and the get prefix.

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 very short, front-loaded, and contains no filler words. However, it is so sparse that it omits parameter semantics and contextual routing; this reads as under-specification rather than deliberate conciseness.

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 output schema covers return values, and the 404 behavior adds useful state-related context. Still, the description leaves key gaps: it does not explain driver_id or host, nor does it orient the agent relative to the setup-flow siblings. For a simple two-parameter getter this is minimally viable, but not 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%, and the description does not mention driver_id or host at all. The required driver_id and nullable host with a default of null remain unexplained, so the description provides no compensation for the completely undocumented 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 identifies the resource as the current screen of an integration setup flow and adds the 404 meaning, which distinguishes it from state-changing sibling setup tools like start_integration_setup and confirm_integration_setup. It is a noun phrase rather than an explicit verb, but the tool name and 'current screen' make the retrieval intent 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 implies this is used to inspect the current step of an active setup flow, and the 404 note defines the 'no flow in progress' condition. It does not explicitly state when to call this versus sibling tools such as get_integration or when to start a new setup flow on 404, so guidance remains implicit.

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?

Discloses default behavior (first configured remote if host not specified) and output fields. No annotations, but description covers key behavioral aspects for a read-only tool.

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 concise sentences, front-loaded with return values; no 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?

Given low complexity, one optional parameter, and an existing output schema, the description fully covers needed 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?

For a single parameter with 0% schema coverage, description adds value by clarifying default behavior (uses first configured remote if host 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 explicitly states it returns model, firmware, battery level/status, and active activities, which distinguishes it from siblings like get_activity (single activity) and get_device (device info).

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?

Implied usage: when you need general remote info. No explicit when-not-to-use or alternative tool guidance, but siblings are listed; minimal help for 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 full burden. It states the output content but omits behavioral details such as safety (read-only), error behavior, permissions, or rate limits. Minimal disclosure beyond what 'get' implies.

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 concise sentences with no fluff. First sentence front-loads the main purpose; second sentence explains identification. Every sentence is informative.

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?

Sufficient for a simple read tool with output schema. Explains output and input mapping. Missing details on the 'host' parameter and error cases, but overall complete for successful use.

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%; the description adds meaning for three parameters (scope, scope_id, page_id) by explaining their roles and allowed values. However, the 'host' parameter is not mentioned, leaving a gap.

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 it retrieves items on one UI page (grid size, position, type, command) and identifies the page by scope, scope_id, and page_id. This distinguishes it from sibling tools like list_ui_pages (which lists pages) and delete_ui_page, update_ui_page.

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 implies usage after list_ui_pages by referencing page_id from that tool. It specifies the scope values ('activity'/'remote') but does not explicitly state when not to use or name alternatives.

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 burden. It discloses key behaviors: no in-place update (must delete), and restart requirement. This is critical for a mutation tool. It doesn't cover permissions or side effects, but it's substantial.

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 purpose, then caveats. No waste; every clause adds essential 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?

The description covers the main operation and critical prerequisites but lacks explanation of host and dry_run. With an output schema present, return values are covered, but parameter semantics remain incomplete, making it only partially 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 must explain parameters. It implies file_path (the archive), but host and dry_run are entirely unexplained. This is a significant gap for an agent trying to invoke correctly.

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 (install), a specific resource (custom driver from .tar.gz), and a location (this machine). It clearly distinguishes from siblings like delete_integration or restart_integration by focusing on installation.

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 provides crucial context: no in-place update, delete old driver first, and restart required. This implicitly guides when to use (fresh installs) and the necessary steps. It doesn't explicitly name alternative tools but gives clear operational instructions.

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 provided, so description must carry full burden. It implies a read operation but does not disclose any side effects, permission requirements, or how the optional 'host' parameter affects behavior. The behavior is partially clear but lacks depth.

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?

Single sentence, no wasted words. However, it could be structured to front-load the parameter nuance. Still efficient.

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 an output schema present (though not shown), the description still omits the crucial parameter 'host' and does not relate to siblings. No annotations exist to fill gaps. Incomplete for a simple list 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%. The description does not mention the 'host' parameter at all, providing no meaning beyond what the schema offers. With 0% coverage, the description fails to compensate.

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 explicitly states the verb 'list', the resource 'activities', and the returned fields: id, name, state, description, and included entities. This clearly differentiates from siblings like get_activity (single item) and other CRUD 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?

No guidance on when to use this tool vs alternatives such as get_activity for a single activity or list_devices for other resources. No exclusions or prerequisites 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?

With no annotations, the description carries full burden. It discloses the return structure ({features, simple_commands}) and that it lists commands, but omits details about potential errors, permissions, or side effects. Adequate but not thorough.

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 exceptionally concise: two sentences with no redundant information. Every word serves a purpose, defining the action and the output structure.

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 existence of an output schema, the return value description is partially redundant but helpful. However, the complete lack of parameter documentation leaves the tool inadequately specified for an agent. Moderate completeness.

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 adds no meaning to the parameters 'device_id' or 'host'. The agent receives no guidance on what values are valid or how the parameters affect behavior.

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: listing commands that a device exposes, specifically for button mapping. It distinguishes itself from sibling tools like 'send_command' by focusing on listing rather than executing.

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 context on when to use ('for picking when mapping buttons'), implying a preparatory step before setting mappings. However, it does not explicitly state when not to use or list alternatives among siblings.

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 full burden. It transparently explains that a physical device may appear as several entities (behavioral nuance) and lists return fields. Does not address rate limits or side effects, but for a read-only list tool, this is adequate.

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?

Three sentences: purpose, nuance, filter/returns. No redundant information. Every sentence adds value. Front-loaded with core action.

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?

Describes filtering, entity relationship, and return fields (though output schema exists). Missing explanation of the host parameter and any pagination or limits. Overall fairly complete for a list tool.

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

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

Schema description coverage is 0%, so description must add meaning. It adds value for entity_type by listing example values. However, the host parameter is entirely undocumented in the description, leaving its purpose unclear.

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?

Clearly states the tool lists all configured devices, explains that physical devices may appear as multiple entities, and specifies optional filtering by entity_type with examples. Distinguishes itself from sibling tools like get_device (single device) and list_activities.

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?

Implied usage: use when you need to list all devices or filter by entity type. No explicit comparison to alternatives like get_device for retrieving a single device, nor guidance on when not to use this tool.

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 disclosure burden. It does add behavioral value by stating that only_new 're-polls the integration' (network/refresh behavior) and 'lists what is not exposed yet' (filter semantics). But it doesn't disclose read-only nature, pagination, rate limits, or failure behavior. The re-poll disclosure is genuinely useful, but incomplete for a no-annotation tool.

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 at two sentences with no wasted words. However, the opening sentence 'Entities an integration offers' is a grammatically incomplete fragment and isn't ideally front-loaded with the action or the key differentiator. The only_new explanation is appropriately placed second.

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 output schema exists, which relieves the description of explaining return format. Core purpose is stated and one usage context (device pairing) is given. But with 3 parameters, 0% schema coverage, and no annotations, the description leaves integration_id and host unexplained, and lacks exclusions or alternatives. It's adequate but not complete for an integration tool with sibling overlap.

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 explain all parameters. It explains only_new in some detail ('re-polls the integration and lists what is not exposed yet') but says nothing about integration_id (the required parameter) or host. With one of three parameters covered, the description fails to compensate for the total lack of schema descriptions.

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

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

The description states the resource ('entities an integration offers') and the verb is implied by the name 'list'. It's reasonably clear what the tool does, and it distinguishes from list_integrations (which lists integrations, not entities). However, it's a sentence fragment, not a complete statement of purpose, and doesn't distinguish from list_scope_entities which also lists entities.

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 one concrete usage scenario: 'required after pairing a new device' for the only_new mode. This is a useful when-to-use hint. However, it doesn't name alternatives or explain when NOT to use this tool versus similar siblings like list_scope_entities or get_integration.

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?

The description adds a valuable behavioral warning: 'device_state is not a health signal: an instance reports CONNECTED while its entities are stale. Check the entities too.' This goes beyond a simple listing description and warns about a misleading field, which is critical for correct interpretation. With no annotations provided, the description carries the full burden, and it does a good job of disclosing this caveat.

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

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

The description is two sentences: the first states the purpose, the second delivers a critical caveat. Every sentence earns its place, and the warning is front-loaded after the purpose. No wasted words.

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 an output schema (not shown in detail) and a single optional parameter. The description covers the core purpose and a key behavioral caveat. It doesn't explain the 'host' parameter, but with an output schema present and a simple optional filter, the description is largely complete. The warning about device_state adds important context that an agent needs to interpret results 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?

Schema description coverage is 0%, so the description must compensate. The description doesn't explain the 'host' parameter at all. However, the parameter is optional, has a default of null, and its name is fairly self-explanatory (likely filters by host). The description adds no meaning beyond the schema, so a baseline 3 is appropriate given the single optional 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 states a specific verb and resource: 'Installed integration drivers and their configured instances.' This clearly identifies what the tool lists. It doesn't explicitly differentiate from siblings like list_integration_entities or list_scope_entities, but the resource is distinct enough that an agent can infer the purpose.

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: call this to see installed integration drivers and their instances. It doesn't explicitly state when to use this vs alternatives like get_integration or list_integration_entities, but the context of listing installed drivers is reasonably clear. 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 must disclose behavior. It explains a domain rule ('a command naming an entity outside it is rejected') but does not describe the tool's own behavior: that it lists entities, is read-only, or the nature of its return. The read-only nature is only implied by the name, not stated.

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 short but poorly structured: it begins with a noun ('Entities') rather than a verb, making the purpose less immediate. The two sentences contain relevant information but could be rephrased for clarity. It is not overly verbose, but the format is suboptimal.

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 (3 parameters, including one required), the description is incomplete. It does not explain what the tool returns, although the output schema exists, but it also fails to clarify parameter usage or selection context. The description leaves an agent guessing about basic invocation requirements.

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%. The description gives a hint about the 'scope' parameter by stating scope is 'activity' or 'macro', but does not explicitly map it to the parameter. The required scope_id and the host parameter are entirely unexplained, leaving the agent without guidance on what values to provide.

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 the resource ('entities an activity or macro is currently allowed to use') but lacks an explicit verb like 'list' or 'retrieve'. It does distinguish from add_scope_entities and remove_scope_entities by focusing on what is 'currently allowed', but the fragment structure leaves ambiguity about the action.

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 given on when to use this tool versus the add/remove siblings. The description mentions that 'both keep their own list', but does not explain that this tool is the read-only counterpart or when to select it over others.

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 provided, so description must disclose behavior. It states the return includes page ids, names, grids, and item counts, but does not mention if the operation is read-only, has side effects, or requires authentication. Adequate but leaves 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?

Two efficient sentences with no wasted words. Front-loads the action and resource, then details parameters and return fields.

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 output schema exists, return value details are less critical. The description includes return fields. However, without annotations, some behavioral context (e.g., read-only nature) is missing. Still fairly complete for a list 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 coverage is 0%, so description must explain parameters. It explains 'scope' (values 'activity' or 'remote') and 'scope_id' (the entity's id), but does not mention the optional 'host' parameter. Covers required fields well.

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 the resource 'UI pages', and specifies the scope ('activity' or 'remote'). This distinguishes it from sibling tools like 'get_ui_page' (single page) and 'update_ui_page' (mutation).

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?

Provides clear context: use for listing pages of a given scope and scope_id. It does not explicitly state when not to use or list alternatives, but the scope clarification inherently differentiates from other 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 burden of disclosing side effects, and it does warn that button mappings and page items referencing the entities are also removed and that a preview should be read first. However, it does not state whether the action is reversible, what permissions are needed, or what 'stop an activity or macro' concretely entails.

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 efficient sentences: the first states the core action, the second surfaces the most important side effect and a practical caution. There is no filler or redundant repetition of schema field names.

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 five parameters, no annotations, and a relatively complex destructive behavior, yet the description addresses none of the parameters and leaves the preview/dry-run workflow unexplained. The output schema exists, so return values are covered, but an agent still lacks enough context to invoke this tool safely and 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?

Schema description coverage is 0%, so the description must compensate, but it only vaguely implies that entity_ids are the entities being removed. It does not explain scope_id, host, scope, or dry_run, even though dry_run is critical to the preview-and-apply workflow hinted at in the text.

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 operation as stopping an activity or macro by removing its entities, and it states the cascading removal of dependent button mappings and page items. It distinguishes itself from sibling tools like add_scope_entities or list_scope_entities through the explicit 'remove' semantics and destructive side effects, though it does not name those siblings.

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 no guidance on when to choose this tool over alternatives, such as add_scope_entities or delete_integration. It offers a caution about reading the preview but does not explain prerequisites, exclusions, or how to select between this and related scope-entity 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?

The main behavior is disclosed plainly ('Disable and re-enable'), which is more than a tautological restart statement. There are no annotations to cover safety, and the description does not mention side effects such as temporary interruption of connected devices, whether settings are preserved, or failure modes.

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

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

Two sentences, front-loaded with the action, and the use-case context follows immediately. 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?

Although an output schema exists, correct invocation still depends on understanding the dry_run default and optional host, which are not addressed. The description gives a good usage signal but leaves an agent vulnerable to silently running a no-op or targeting the wrong host.

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 compensate by explaining integration_id, dry_run, or host. This is especially problematic because dry_run defaults to true, meaning a call without it would not actually perform the described disable/re-enable cycle.

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 phrase ('Disable and re-enable') and names the resource ('an integration'), then gives the concrete symptom that calls for it. This separates it from siblings like set_integration_enabled, which toggles state, and restart_remote, which acts on 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?

It clearly tells an agent when to use the tool: 'when devices stop responding but the integration still claims to be connected.' It does not, however, state when not to use it or name alternative tools, so it stops short of full routing 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?

Since no annotations are provided, the description carries the burden of behavioral disclosure. It states that the tool sends no device commands and changes no configuration, mitigating safety concerns. However, it does not mention the dry_run default or potential service disruption during restart, leaving some behavioral context unspecified.

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, each serving a purpose: what the tool does, what it does not do, and when the two targets are needed. It is front-loaded and avoids 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?

The tool is simple, with optional parameters and an output schema, so the description doesn't need to explain return values. However, it omits the crucial dry_run semantics, which could cause an agent to believe a restart occurred when the tool only echoed the action. This gap makes the description incomplete for safe autonomous 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%, so the description must compensate. It defines the valid values for target and hints at their purposes, but it fails to explain the host and dry_run parameters, especially dry_run's default true, which is critical for the tool to actually perform a restart.

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 (Restart), a resource (the remote), and the valid targets ('ui', 'core', 'system'). It differentiates itself from sibling tools like restart_integration by focusing on the remote-level restart and explicitly disclaiming device commands or configuration changes.

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 explains when to use each target: ui for repainting configuration changes and system after driver installation. It implicitly distinguishes this from send_command or configuration tools by stating it changes no configuration, but it does not explicitly name alternatives or conditions for choosing this tool over restart_integration.

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 bears full responsibility. It discloses the two-phase commit (dry run then apply), the requirement for a confirmation_token, and the auto-backup before applying. Minor gap: does not mention what happens on failure or invalid input.

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 long, each serving a distinct purpose: state the action, explain the two-step process, and note the auto-backup. No redundant or irrelevant information; it is front-loaded and efficiently conveys the key behavior.

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?

Despite the presence of an output schema (reducing the need to describe return values), the description covers the main workflow, safety mechanisms, and token-based confirmation. Missing details: error handling, file format expectations, and the 'host' parameter. Sibling differentiation is adequate but not explicit.

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 compensates for dry_run (implies default true), confirmation_token (explained as token from first call), and input_path (implied as backup file). However, the 'host' parameter is not mentioned at all, leaving its purpose unclear.

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 tool's action ('Restore activities/remotes customization from a backup file') and specifies the resource scope (activities, remotes, UI pages, etc.). The two-step process distinguishes it from siblings like backup_config and diff_config.

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 outlines the required process (first call with dry_run=true, second with dry_run=false and confirmation_token) but does not explicitly state when to choose this tool over alternatives like backup_config or diff_config. Usage is implied but not compared to siblings.

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. It discloses that the command is transient (does not change saved config) but still affects the device. It also clearly explains the default dry_run behavior and how to override it, providing essential behavioral context for a potentially destructive action.

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

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

The description is only three sentences, each adding value. The first sentence states the purpose, the second provides behavioral guidance, and the third gives the HTTP method and body structure. No unnecessary words.

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, the description does not need to explain return values. It covers the key aspects: one-off nature, transience, dry_run default, and the API call. However, it fails to mention the 'host' parameter, which is a minor gap. Overall, it is sufficiently complete for a command-sending tool.

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

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

Schema description coverage is 0%, so the description must compensate. It mentions the device, command, params, and dry_run parameters, and adds context about the API endpoint (PUT /entities/{id}/command). However, it does not describe the 'host' parameter at all, leaving one parameter 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 'Fire' and identifies the resource as 'a device (entity)'. It clearly states the action as sending a one-off command, which distinguishes it from sibling tools like 'list_device_commands' that only list commands. The purpose is unambiguous.

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 explains that the tool defaults to dry_run=true for safety and instructs to set dry_run=false to actually send. This provides clear guidance on when to use the dry run vs. actual execution. However, it does not explicitly state when not to use the tool or mention alternatives.

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?

Without annotations, the description carries the full burden. It discloses that dry_run defaults to true (shows before/after) and that auto-backup occurs before any real write. This gives the agent awareness of safety mechanisms. Missing details on authentication or rate limits, but adequate for a mutation tool.

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 well-structured sentences, no filler. Every sentence adds value: first defines the operation and key parameter condition, second describes safety defaults. Front-loaded with the core purpose.

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

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

Given 9 parameters (4 required) and an output schema (not shown), the description covers the key behavioral aspects and the most critical parameter conditions. However, it omits explanations for many scalar parameters (host, press, params). Moderate completeness.

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

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

Schema description coverage is 0%, so the description must compensate. It explains the conditional meaning of 'entity_id' and the purpose of 'dry_run'. However, it does not explain 7 other parameters (host, press, params, etc.), leaving significant gaps for an agent.

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

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

The description clearly states the action ('Set'), the resource ('physical-button -> command binding'), and the scope ('activity' or 'remote'). It distinguishes from sibling tools like 'bulk_set_button_mapping' (bulk) and 'get_button_mapping' (read).

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

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

The description provides explicit usage context: entity_id is required for activities and ignored for remotes. It also mentions the default dry_run=true for preview, which guides safe usage. However, it does not explicitly state when to avoid this tool in favor of alternatives.

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?

The description reveals that the tool implements a page reorder (not an explicit default property) and defaults to dry_run=True. However, with no annotations, it omits details on side effects, authorization, or reversibility.

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

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

The description is concise, with two sentences that front-load the core functionality. No unnecessary words 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?

The description is incomplete for a 5-parameter tool with no schema descriptions. It lacks explanations for host and scope_id, and provides no guidance on output or errors. The output schema partially compensates for return values, but parameter gaps remain.

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 coverage, the description should explain all parameters. It clarifies scope, page_id, and dry_run but does not define host or scope_id, leaving a significant gap.

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: to make a page the default/first page of an activity or remote UI. It also explains the mechanism (page reorder) and distinguishes it from siblings like update_ui_page or delete_ui_page.

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 the correct tool for setting a default page, but does not explicitly state when to use it over alternatives. It mentions dry_run default but lacks guidance on prerequisites or exclusions.

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

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

With no annotations, the description must disclose behavioral traits. It only says 'Enable or disable' without mentioning side effects, reversibility, permission requirements, or the role of dry_run (which defaults to true, implying the action is a dry run unless explicitly overridden). This critical behavior is undocumented.

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 short sentence, which is concise but under-specified. It front-loads the action but omits essential details, so the brevity is not a virtue here.

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 four parameters, no annotations, and an output schema that is not described, the description is grossly incomplete. It fails to explain dry_run behavior, the host parameter, or what the output contains, making it difficult for an agent to use 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?

Schema description coverage is 0% and the description adds no meaning to parameters like host or dry_run. The schema provides types and defaults but no explanations. The description does not compensate at all, leaving agents to guess what each parameter affects.

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

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

The description clearly states the action ('Enable or disable') and the resource ('an integration instance'), which is a specific and distinct purpose. However, it does not explicitly differentiate from sibling tools like restart_integration or install_integration, though the resource and action are clear enough.

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 such as configure_integration_entities or restart_integration. There are no exclusions, prerequisites, or context about integration lifecycle. The agent is left to infer when this 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?

No annotations are provided, so the description carries full burden. It discloses authentication and config saving, but fails to mention potential side effects like overwriting existing config, idempotency, or error conditions (e.g., if already set up).

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 very concise with two sentences, delivering key information without waste. It could be slightly more structured but remains effective.

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 presence of an output schema, the description does not mention what is returned. It also lacks detail on parameter semantics and behavioral constraints. For a first-run setup tool with 4 parameters and many siblings, the description is insufficiently 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%. The description mentions 'admin PIN' and 'save config', hinting at the pin and host parameters, but does not describe name or port parameters. It adds minimal meaning beyond the schema's field names.

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 'First-run setup. Authenticate with admin PIN, create a long-lived API key, and save config. Only needed once per remote.' It clearly identifies the tool's purpose: performing initial setup on a remote device, with specific actions and constraints.

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 notes 'Only needed once per remote', providing clear guidance on when to use (first-run) and implying not to use for subsequent operations. However, it does not mention alternatives or when not to use, but the context of sibling tools suggests this is a one-time initialization.

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

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

With no annotations provided, the description carries the full burden. It discloses that the tool returns the first screen, that some drivers require setup_data up front, that a 400 error indicates missing setup data, and that a 503 means the driver process is not running yet. This is meaningful behavioral context beyond the schema, though it doesn't describe side effects or state changes in detail.

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 front-loaded with the core purpose, then adds two sentences of practical troubleshooting. Every sentence earns its place, though the 503 guidance could be seen as slightly tangential to the core purpose. Overall it's well-structured and not bloated.

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

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

Given the tool has an output schema and 4 parameters, the description covers the key behavioral nuances (setup_data, 400, 503) that an agent needs to call it correctly. It doesn't explain host or reconfigure, but those are optional and likely self-explanatory. The description is complete enough for a setup-initiating tool with an output schema.

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

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

Schema description coverage is 0%, so the description must compensate. It explains setup_data semantics in detail (pass it up front to avoid 400 errors) and mentions driver_id implicitly as the integration being set up. It doesn't explain host or reconfigure, but the setup_data guidance is the most critical parameter behavior. The description adds value beyond the bare schema.

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

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

The description states a specific verb and resource: 'Begin an integration's setup and return its first screen.' This clearly distinguishes it from sibling tools like get_integration_setup, answer_integration_setup, and confirm_integration_setup, though it doesn't explicitly name them. The purpose is clear and actionable.

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 practical guidance on when to pass setup_data up front and how to interpret 503 errors, which helps an agent decide how to invoke the tool. It doesn't explicitly contrast with sibling tools like get_integration_setup or answer_integration_setup, but the context of starting setup is clear. The guidance about 503 and restarting the system is a strong usage hint.

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. It discloses key behaviors: validation against activity entities, dry_run default, and auto-backup before writes. It does not detail error handling, but the presence of an output schema reduces the need for return value explanation.

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 four sentences, front-loading the main action. Every sentence adds unique information: purpose, sequence format, validation, and safety defaults. No unnecessary words.

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 (modifying sequences with validation and safety features) and the absence of annotations, the description covers the main behaviors: sequence format, validation, dry run, and backup. It does not address errors or success output, but the output schema exists. Minor gaps prevent a perfect score.

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%, so the description must compensate. It explains the sequence format (on_sequence, off_sequence) and dry_run default, but does not describe the 'host' parameter at all. Activity_id is implied but not explicitly described. Partial compensation, but a gap remains.

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: 'Replace an activity's on and/or off power sequence.' It uses a specific verb ('Replace') and resource ('activity's power sequence'), and the format description distinguishes it from siblings like 'send_command' which sends single commands.

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 context on usage: it explains that omitted sequences remain unchanged and empty lists clear them, and that dry_run defaults to true with auto-backup. However, it does not explicitly compare to alternative tools or state 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, the description carries full burden and provides notable transparency: omitted fields stay unchanged, empty items list clears the page, item commands are validated, defaults to dry_run=True, and auto-backup before real write. It does not cover permissions or failure behavior, but still offers substantial insight.

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

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

The description is concise, using four sentences to convey the main action and key behaviors. It is front-loaded with the core purpose and avoids 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?

For a tool with 8 parameters and no annotations, the description provides good context for the core functionality. The existence of an output schema likely covers return values, but the 'host' parameter remains unexplained, and the 'auto-backup' detail lacks elaboration.

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 explains the behavior of 'name', 'grid', 'items', and 'dry_run' parameters, but the 'host' parameter is not mentioned, and 'scope', 'scope_id', 'page_id' are only implied. Given 0% schema coverage, the description partially compensates but leaves some parameters unexplained.

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 'update' and the resource 'UI page', and specifies the scope ('on an activity or remote'). It distinguishes from sibling tools like delete_ui_page, get_ui_page, and list_ui_pages by focusing on modification.

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

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

The description implies usage for modifying existing UI pages but does not explicitly state when to use this tool versus alternatives like create or delete. No prerequisites or exclusions are mentioned, leaving some ambiguity.

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