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 implies a read-only browsing operation, but does not disclose what is returned, whether the operation is non-mutating, how pagination behaves, or what happens for invalid paths. With no output schema, this leaves important behavior 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 a single, front-loaded sentence with no filler or redundancy. Every phrase adds meaning and the length is appropriate for the simplicity of the operation.

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 core operation and required parameter are clear, and the schema covers the pagination parameters. However, with no annotations and no output schema, the description omits the return shape and any context about how this browse operation relates to file restore lifecycle tools.

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

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

The input schema already describes all four parameters with 100% coverage, so the baseline is 3. The description adds little beyond the schema, only reinforcing that path is optional and defaults to root.

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 ('Browse') and a specific resource ('files and folders exposed by a file restore'), and mentions the optional path. This makes the tool's purpose clear, though it does not explicitly differentiate it from sibling tools by name.

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

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

The description gives no guidance on when to use this tool versus related tools like slide_list_file_restores, slide_get_file_restore, or slide_browse_image_export. The intended use case is implied by the name, but not explicitly stated.

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

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

No annotations are provided, so the description carries full responsibility for behavioral disclosure. 'Browse the files and folders' suggests a read-only listing, but it does not indicate what the response looks like, whether pagination behavior is expected, or any permissions or side effects. This is thin coverage for a tool with no annotation support.

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

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

The description is a single concise sentence that states the core action and resource without wasted words. It is front-loaded with the verb and clearly scopes the operation.

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?

This is a relatively simple browse operation with one required parameter, and the schema is fully documented. However, there is no output schema and no behavioral details about the returned listing, so the description is minimally workable 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 100%, with all three parameters already documented in the input schema. The description does not add any parameter-level meaning beyond what the schema provides, which corresponds to the baseline score of 3.

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 ('Browse') and a concrete resource ('files and folders exposed by an image export'), making the tool's purpose immediately clear. It is distinguishable from sibling tools like slide_get_image_export and slide_list_image_exports, though it does not explicitly name those alternatives.

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 purpose implies that this tool is for navigating the contents of an image export, which provides some usage context. However, it does not explicitly state when to prefer this over sibling tools such as slide_list_image_exports or slide_get_image_export, nor does it mention any exclusions or prerequisites.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It only says 'Get', which implies a read operation, but doesn't disclose return format, error behavior, or any side effects. For a simple read tool this is a modest gap, but with zero annotation coverage the description should say more.

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

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

One short sentence that is front-loaded with the verb and resource. 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?

For a simple single-parameter read tool, the description is mostly adequate. However, with no output schema and no annotations, an agent might benefit from knowing what the response contains or whether the account is a client, user, or billing account. The sibling list shows many account-related tools, so a bit more context would help.

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 100% and the only parameter, account_id, is described as 'Account ID.' The description adds no additional meaning beyond the schema, so the baseline 3 applies.

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 ('Get') and resource ('a single Slide account by ID'), which clearly distinguishes it from list operations like slide_list_accounts. It doesn't explicitly name a sibling, but the resource and scope are 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 implies usage: use this when you need a single account by ID, versus slide_list_accounts for multiple accounts. However, it doesn't explicitly state when not to use it or mention alternatives, leaving the agent to infer from the sibling names.

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 discloses the important behavioral trait of redacting passphrase values (only names/IDs returned), which is critical for security and not shown in annotations. It also lists the scope of returned data. No annotations exist to contradict, so the description carries the behavioral burden and does so effectively.

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 one sentence covering purpose and returned data, and a second sentence adding the security caveat. It is front-loaded with purpose before the caveat, 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?

Given the tool has only one parameter and no output schema, the description provides adequate context for correct invocation. It lists what data to expect and the passphrase redaction behavior, making it complete enough for an agent.

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

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

Schema coverage is 100% with agent_id described as 'Agent ID.' The description does not add extra meaning to the parameter, but baseline 3 is appropriate since the schema fully defines it. No need for additional compensation.

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 get a single agent by ID and lists the specific data returned including backup schedule, retention policy, volumes, alert configs, and connection info, making it distinct from list_agents and other get_* siblings. The tool name and description align well with the action and resource.

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

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

The description implies this is for retrieving detailed single-agent info, and the sibling list_agents suggests when to use a list instead. However, it does not explicitly state when not to use this tool or mention alternatives like slide_list_agents for bulk retrieval.

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. 'Get' conveys a read-only operation, and 'snapshot versions available' indicates the kind of data returned. However, it says nothing about pagination behavior, output shape, or error conditions, leaving some behavioral ambiguity 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 a single front-loaded sentence with no filler. Every word contributes to identifying the tool's purpose and scope.

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 read-only getter with a fully documented schema, the statement is minimally adequate. But with no output schema and no annotation, it doesn't describe return values, pagination, or how this differs from sibling tools, so the context is 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 100%, so the schema already documents all six parameters. The description only reinforces the roles of agent_id and path by mentioning 'specific file path on an agent'; it adds no meaning beyond the schema, which earns the baseline 3.

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 precise verb ('Get'), a specific resource ('snapshot versions'), and a clear scope ('for a specific file path on an agent'). This distinguishes it from sibling getters like slide_get_snapshot or slide_search_agent_files even without naming them.

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

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

The description gives no explicit guidance about when to prefer this tool over related siblings, and it does not mention exclusions or prerequisites. The only implied use is 'when you need snapshot versions,' which is not enough to route an agent reliably among the many file/snapshot tools in the sibling list.

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 clearly indicates a read-only list operation ('Get') and scopes the result to 'backed-up services ... detected on an agent.' It does not mention authentication or edge cases, but for a simple list tool this is adequate transparency.

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 one front-loaded sentence with no filler. The parenthetical examples are valuable because they disambiguate what counts as a 'service,' making every word earn 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 tool has only one required parameter and no output schema or annotations, so the description does not need extensive caveats. It conveys both the input (agent_id) and the return subject (list of backed-up services). A minor gap is the lack of explicit return format details, but this is not critical for a simple list operation.

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

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

The schema already documents agent_id as 'Agent ID.' with 100% coverage, so the baseline applies. The description reinforces that agent_id is the agent whose services are listed, but it adds no additional format, validation, or behavioral detail 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 uses a specific verb-resource pair: 'Get the list of backed-up services' and clarifies with concrete examples ('installed applications, database engines'). The scope is clearly tied to a single agent, which distinguishes it from sibling tools like slide_get_agent or slide_get_agent_file_versions.

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 the intended use: call this when you need the backed-up services detected on a specific agent. However, it does not explicitly state when not to use it or mention any alternative tools, so guidance is implied rather than fully articulated.

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

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

With no annotations provided, the description carries full responsibility for behavioral disclosure. It states 'Get' which implies a read-only operation, but it does not mention return format, potential errors (e.g., not found), or any permissions required. The description adds no context beyond the action itself.

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

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

The description is a single concise sentence with no redundancy, front-loading the core purpose. However, it is slightly under-specified in terms of context, though it remains efficient and to the point.

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

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

For a simple getter with one parameter, the description is functionally complete: it specifies the action and the identifier needed. The absence of an output schema and the low complexity mean that no additional context is essential for correct invocation, though a note on error behavior would enhance 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 100% (alert_id with 'Alert ID.'), so the schema already documents the parameter. The description does not add any additional meaning, such as format, constraints, or how the ID is used. Baseline 3 is appropriate given the high schema coverage.

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 'Get a single alert by ID' clearly states a specific verb (Get) and resource (alert) with a method of identification (by ID). It inherently distinguishes from the sibling slide_list_alerts, which retrieves multiple alerts, making the purpose 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 gives no explicit guidance on when to use this tool versus alternatives like slide_list_alerts, nor does it mention any preconditions such as needing a valid alert ID or whether the alert must exist. Usage is only implied by the phrase 'by ID'.

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 for behavioral disclosure. 'Get' implies a read operation, but the description does not mention error behavior (e.g., not-found), response content, or any permissions; however, for a seemingly immutable audit-log lookup, the risk is modest.

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?

A single, front-loaded sentence with no filler or repetition. Every word earns its place, and the structure makes the tool's function instantly 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?

For a simple get-by-ID tool with one parameter and no output schema, this description covers the essential calling context. It could be enriched with return/error details, but none of those are necessary to invoke the tool correctly.

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

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

Schema description coverage is 100%, and the only parameter audit_id is already described as 'Audit log ID.' The tool description adds no semantic detail beyond the schema, so the baseline of 3 is appropriate.

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 ('Get'), resource ('audit log entry'), and scope ('single ... by ID'), which makes the purpose unambiguous. It does not explicitly name sibling list_audit_logs, but 'single' and 'by ID' implicitly distinguish this from a list 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?

There is no guidance on when to use this tool rather than list_audit_logs or the other audit-related siblings. It is implied that one should use this when the audit_id is already known, but the description never states that or any 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 carries the full burden of behavioral disclosure. It adds useful information that the result and error details are included for failed attempts, but it does not mention read-only side effects, not-found behavior, authentication, or rate limits. This is adequate for a simple getter 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, focused sentence with no filler. The core action and the key output detail are front-loaded, making it easy for an agent to parse quickly.

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

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

For a single-parameter getter with no output schema, the description is mostly complete: it states the resource, the lookup key, and the response contents. It does not specify behavior when the ID is not found, but this is a minor gap for such a 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 100%, and the description adds no extra meaning to backup_id beyond what the schema already states. This matches the baseline expectation when the schema fully documents the 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 uses a specific verb ('Get') and resource ('a single backup attempt by ID'), which clearly distinguishes it from sibling tools like slide_list_backups that return multiple items. It also identifies what the response includes: result and error details if failed.

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

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

The description implies this tool is for fetching one backup attempt by ID, likely after listing backups, but it does not explicitly state when to use it versus slide_list_backups or other backup-related tools. 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?

No annotations are provided, so the description carries the burden. 'Get' implies a read-only operation with no side effects, and the scope is clear. However, it does not disclose behavior around missing IDs, errors, or response format, which would add useful transparency for an unannotated 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 a single, front-loaded sentence with no filler. Every word earns its place and directly supports tool selection and invocation.

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

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

For a one-parameter retrievable resource with no output schema, this description is largely complete: it names the resource, the scope, and the required lookup key. It could be slightly stronger with mention of not-found behavior or response shape, but nothing essential to invoking the tool correctly is missing.

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 100% and the only parameter, client_id, is clearly documented in the schema. The description's 'by ID' adds marginal reinforcement but no new semantic detail 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?

Description uses a specific verb and resource: 'Get a single client by ID'. It clearly differentiates itself from list-style siblings like slide_list_clients and other resource-specific getters by scoping to one client.

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 'by ID' phrasing clearly signals this tool is for retrieving one known client, implying it should be used instead of slide_list_clients when a specific client_id is already available. It does not explicitly state when not to use it or mention alternatives, but context is clear for a simple single-entity getter.

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 burden of behavioral disclosure. It goes beyond the schema by naming the returned content categories, making the read-only nature of the operation clear through 'Get.' It does not mention error behavior or auth, but for a simple getter this is a reasonable disclosure.

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

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

The description is a single dense sentence that front-loads the action and resource, then lists the return value categories. There is no filler, repetition, or unnecessary detail.

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

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

For a single-parameter getter with no output schema, the description adequately tells an agent what the call will return. The main omissions are error/not-found semantics and explicit guidance about alternative getters, but these are minor for a tool this simple.

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 100% and device_id is already described as 'Device ID.' The description only restates 'by ID' and adds no extra format, constraints, or usage context, so the schema is doing the work.

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

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

The description names a specific action ('Get') and resource ('a single device by ID') and lists the key data categories returned: hardware/service model, storage usage, warranty, and service status. This clearly distinguishes it from broader list tools and other device-related getters.

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 'by ID' phrasing implies the intended use case: fetch one known device. However, it does not explicitly contrast this tool with sibling tools such as slide_get_device_network or slide_list_devices, so guidance is implicit rather than explicit.

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

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

No annotations are provided, so the description carries the full burden. It states what the tool returns (network configuration fields) but does not disclose whether the device must be online, whether this is a read-only operation, whether it can fail for offline devices, or any rate-limit/auth considerations. For a getter, the read-only nature is implied but not explicit, and there is no mention of error behavior.

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

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

A single, front-loaded sentence that names the resource and the specific fields returned. Zero waste; every word earns its place.

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

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

For a simple one-parameter getter with no output schema, the description is mostly complete: it tells the agent what it returns. However, with no annotations and no output schema, it could add a bit more context about return shape or failure conditions. Still, the tool is simple enough that the description is 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 description coverage is 100%: the only parameter, device_id, is described as 'Device ID.' The description adds context about what the device_id is used for (fetching network config) but does not add format, validation, or source details. Baseline 3 is appropriate since the schema already documents the parameter adequately.

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

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

The description clearly states the verb 'Get' and the resource 'a device's network configuration', and specifies the content (DNS servers, network mode, gateway/address). It is distinguishable from siblings like slide_get_device (which likely returns general device info) and slide_get_network (which likely returns network-level info), though it doesn't explicitly name those alternatives.

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 when you need a device's network configuration details. However, it does not explicitly state when to use this over slide_get_device or slide_get_network, nor does it mention any prerequisites or context. The context is clear enough for a simple getter, but no exclusions or alternatives are given.

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 burdenebb; 'Get' communicates a read-only, non-destructive operation. It does not mention error behavior, authorization needs, or the shape of the returned interface, but for a simple getter the core behavioral trait 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 a single, front-loaded sentence with no wasted words. It immediately states the action and resource, making it easy for an agent to parse at a glance.

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 getter with no output schema and no annotations, the description is adequate for basic invocation but omits return format and explicit usage guidance. Since there is no output schema to carry the response contract, some completeness gap remains.

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 100%, so the parameters are already individually documented. The description adds only that the operation targets a single VLAN interface by ID, providing minimal extra meaning beyond the schema's 'VLAN ID' and 'Device ID' descriptions.

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

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

The description clearly names the operation ('Get'), the resource ('single VLAN interface'), and the required scoping context ('on a device by ID'). This distinguishes it from list-style siblings like slide_list_device_vlans and makes the tool's purpose immediately obvious.

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 phrase 'single ... on a device by ID' implies this tool is for retrieving one specific VLAN interface by known identifiers, as opposed to listing all VLANs. However, it does not explicitly name alternatives or state when not to use this tool, leaving the guidance implicit rather than explicit.

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

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

With no annotations, the description carries the burden of explaining behavior. 'Get' reasonably signals a read-only retrieval, and the single-resource scope is clear, but the description does not mention response contents, error behavior, or permissions. It is adequate for a simple fetch operation but leaves some behavioral details implicit.

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

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

The description is a single, front-loaded sentence with no filler. Every word contributes to identifying the action, the object, and the lookup key, making it 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?

For a one-parameter get-by-ID tool with no output schema, the description provides the essential invocation knowledge: what action is taken and which identifier is required. It lacks explicit return-shape or not-found behavior, but those are minor for such a straightforward operation.

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

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

The input schema covers 100% of the single parameter with the description 'File restore ID.' The description's phrase 'by ID' reinforces this, but it does not add meaning beyond what the schema already provides. Baseline of 3 is appropriate because the schema does the heavy lifting.

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 ('Get') and resource ('file restore') and clearly scopes the operation to a single item by ID. This distinguishes it from sibling tools such as slide_list_file_restores and slide_browse_file_restore, which imply bulk or browsing operations.

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

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

The 'by ID' phrasing implies this tool is for fetching one known restore when the ID is available, but it does not explicitly discuss when to choose it over list or browse alternatives. Usage context is only implied rather than directly stated.

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

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

With no annotations and no output schema, the description carries the full burden, and it clearly communicates a read-only status lookup. However, it does not disclose what statuses may be returned, whether the operation can be polled, or any error/edge-case behavior, so it is only minimally transparent.

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, well-structured sentence with no filler or redundancy. It front-loads the action and resource, making it immediately scannable for an agent.

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

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

For a simple two-parameter get-status tool, the description covers the core purpose and the schema covers all parameters. However, with no annotations, no output schema, and sibling tools that represent related but distinct operations, slightly more context about what distinguishes this operation or what the status response looks like would improve 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?

Both parameters are fully described in the input schema ('File restore ID.' and 'File restore push ID.'), and schema description coverage is 100%. The description adds no extra parameter context, so the baseline score of 3 is appropriate.

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 verb ('Get'), a specific resource ('status of a single file restore push operation'), and a singular scope. It does not explicitly distinguish itself from sibling tools like slide_get_file_restore or slide_list_file_restore_pushes, which prevents a 5.

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

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

The description implies that the tool should be used when an agent needs the status of one file restore push operation, but it gives no explicit when-to-use guidance or exclusions. It does not mention alternatives such as browsing or listing file restore pushes, so usage context is only 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 provided, the description carries the full burden of behavioral disclosure. It explicitly reveals a key behavior: secret redaction, noting 'Same secret redaction as slide_list_image_exports: no Samba password', and it indicates the output includes connection info types. This adds meaningful context beyond the schema, though it does not mention error scenarios or authentication requirements.

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 wasted words. It front-loads the core action ('Get a single image export by ID'), then adds the most relevant output details and the redaction caveat. Every sentence earns its place and assists the agent 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?

For a simple one-parameter get-by-ID tool, the description provides adequate context: it states what the output contains (image type, connection info) and the redaction behavior. It does not mention not-found/error behavior, and with no output schema, a bit more return-structure detail could help, but the description substantially covers what an agent needs to call it correctly.

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

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

Schema description coverage is 100% (the parameter's purpose is already documented as 'Image export ID'). The description adds little semantic value beyond the schema, only reinforcing that a single export is fetched by this ID. Per the baseline rule for high schema coverage, a 3 is appropriate.

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-resource pair, 'Get a single image export by ID', which clearly identifies the tool's function. It further distinguishes the tool from list/browse siblings by emphasizing 'single' and 'by ID', and describes what the output contains (image type, ISCSI/NFS connection info), leaving no ambiguity.

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

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

The description implies usage when a specific image_export_id is known, but it does not explicitly state when to prefer this tool over slide_browse_image_export or other alternatives. The only sibling reference is about redaction parity with slide_list_image_exports, not about selection criteria, so guidance is implied rather than explicit.

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

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

With no annotations, the description carries the full burden. It discloses a meaningful behavioral trait: secret redaction (no IPsec PSK, no WireGuard private key) and the network components returned. However, it does not explicitly state that this is a read-only operation, nor does it mention auth requirements or error behavior, which would be useful given no annotations.

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

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

Two sentences with no fluff. The first sentence front-loads the purpose, and the second adds a necessary behavioral caveat about redaction. Every word earns its place, and the structure is easy to scan.

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

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

For a simple one-parameter, no-output-schema tool, the description is fairly complete. It conveys what the tool returns (port forwards, IPsec connections, WireGuard peers) and the redaction behavior, which is the key nuance. The main omission is explicit read-only/auth guidance, but the low complexity and clear purpose make this a minor gap.

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

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

The schema already covers network_id with 'Network ID' at 100% coverage, so the baseline is 3. The description's 'by ID' does not add extra semantic detail such as where to find the ID, format, or validation rules, so it does not elevate the score.

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

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

The description clearly states a specific verb and resource: 'Get a single disaster-recovery network by ID'. It lists the key contents (port forwards, IPsec connections, WireGuard peers), which distinguishes it from the many other get/list siblings and makes its purpose unmistakable.

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 when to use this tool: when you need a single network by ID rather than a list. However, it does not explicitly say when not to use it or point to alternatives like slide_list_networks for listing use cases. The only sibling reference is about redaction behavior, not routing the agent's choice.

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 must carry the behavioral disclosure burden. It does clarify the read-only nature ('Get') and the output scope ('storage locations and any deletions'). Still, it does not mention error behavior, authorization requirements, or whether 'deletions' means soft-deleted entries, destructive history, or something else.

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 with no wasted words. The core lookup semantics are front-loaded, and the return details follow naturally. Every part contributes to the reader's understanding.

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

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

For a one-parameter get operation with no output schema, the description gives a reasonable overview of what is returned. It is mostly complete for invocation purposes. It could be more complete by describing the response shape or not-found behavior, but the core behavior and return scope are clear enough.

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 100%, so the baseline is 3 even without additional parameter explanation. The description adds no meaning beyond what the schema already states—it just confirms the operation keys off snapshot_id. No format, examples, or constraints are provided.

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: 'Get a single snapshot by ID.' It also tells us what the response contains ('its storage locations and any deletions'), which distinguishes it from listing endpoints like slide_list_snapshots and from verification-specific endpoints like slide_get_snapshot_service_verification.

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 'by ID' phrasing implies this is for a direct lookup rather than a list or search, so the intended use is somewhat clear. However, it does not explicitly state when to choose this over slide_list_snapshots, nor does it mention any alternatives 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 provided, the description carries the full burden of behavioral disclosure. It does reveal a non-obvious trait: this is a predictive evaluation of boot/mount success, not a list of currently installed services. But it does not disclose whether results are cached or computed on demand, authentication requirements, or error behavior (e.g., snapshot not found).

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?

A single, front-loaded sentence where the main clause states verb+resource and the parenthetical earns its place by clarifying the tool's non-obvious semantics. There is no wasted wording. It could have included a brief usage-routing sentence, but 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?

For a low-complexity getter with one required parameter, no output schema, and no enums or nesting, the description is nearly sufficient: an agent knows how to call it and what the result means. Minor gaps remain — the shape of the returned verification results and whether verification is live or cached — but these are acceptable for this complexity level.

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 100%, with the schema already documenting snapshot_id as 'Snapshot ID.' The description adds no parameter-level detail — no format, constraints, or relationship between the snapshot and its verification state — so the baseline 3 applies.

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 ('Get'), a specific resource ('service-verification results for a snapshot'), and a clarifying parenthetical that explains the semantic payoff ('confirms which detected services would boot/mount successfully'). This parenthetical differentiates it from siblings like slide_get_snapshot (snapshot metadata) and slide_get_agent_services (detected services on an agent), so an agent can tell them apart.

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 parenthetical implies a use case — validating boot/mount success before relying on or restoring a snapshot — so an agent can guess when to invoke it. However, there is no explicit when-to-use or when-not-to-use guidance, no named alternatives, and no exclusions. The usage context is inferred rather than stated.

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

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

No annotations are provided, so the description carries the entire behavioral burden. It clearly signals a read-style operation returning a single record, but it does not disclose behavior for missing IDs, error responses, or authorization requirements. For a simple getter this is adequate, 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?

One short, front-loaded sentence contains no filler and conveys the essential operation and lookup key immediately.

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

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

For a one-parameter getter with no annotations and no output schema, the description covers the basic selection and invocation details. It is missing an explicit statement of the return shape and failure behavior, which leaves the entry slightly under-specified.

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

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

Schema description coverage is 100%, and the single parameter user_id is documented in the schema. The description only repeats the ID-based lookup concept without adding format, uniqueness, or source details 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 uses a specific verb ('Get'), a specific resource ('a single user'), and the lookup key ('by ID'). It also differentiates from the siblings slide_list_users and slide_get_user_avatar by emphasizing single-user, ID-based retrieval.

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 when-not-to-use guidance is provided, and no alternative tools are named. The usage context is implied: call this when you need one user's data by user ID, as opposed to listing users or fetching an avatar.

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 the output encoding as a base64 data URL, but does not mention error behavior for invalid user IDs, missing avatars, permissions, or whether a null/empty result is possible.

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 states the action and the return format with no wasted words. It is well-structured and immediately understandable.

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

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

For a single-parameter getter with no output schema, the description covers the core purpose and the return representation. It lacks explicit edge-case details such as what happens when a user has no avatar, but the tool is simple enough that this is a minor gap rather than a critical omission.

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 100% and the only parameter, user_id, is documented as 'User ID.' The description does not add additional meaning beyond indicating that the avatar belongs to a user, so the baseline score of 3 is appropriate.

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

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

The description clearly states the specific action ('Get a user's avatar image') and the resource. It also adds the key output detail ('returned as a base64 data URL'), which distinguishes it from sibling getters like slide_get_user.

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 about when to use this tool versus alternatives, such as slide_get_user or other user-related getters. It does not mention any conditions, prerequisites, or cases where another tool would be more appropriate.

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

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

With no annotations provided, the description carries the burden. It discloses that VNC password is redacted (same as list tool), which is a specific behavioral detail. It also describes the data returned. However, it does not mention error conditions, authentication requirements, or any other side effects. For a simple read-only get, this is adequate but not exhaustive, earning a 3.

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. The first front-loads the action and the key content (state, CPU/memory, network config, RDP endpoint). The second adds the redaction note efficiently. No filler or redundancy. Every sentence earns its place.

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

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

For a single-resource getter with one fully documented parameter and no output schema, the description is complete. It lists the returned fields and the redaction behavior, which is all an agent needs to decide and invoke correctly. No missing critical information for this scope.

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 100%: virt_id is described as 'Virtual machine ID.' The description adds no further meaning beyond stating 'by ID' in the text, which is redundant with the name and schema. Since the schema already documents the parameter fully, the description adds no additional value, so baseline 3 applies.

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

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

The description clearly states the verb 'Get' with a specific resource ('a single virtual machine by ID') and enumerates the returned data (state, CPU/memory, network config, RDP endpoint). This distinguishes it from the sibling slide_list_virtual_machines and other getters. It is unambiguous about scope and content.

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 when to use it: when you need a single VM by ID, contrasting with the list tool. It also references slide_list_virtual_machines for redaction context, linking to an alternative. However, it does not explicitly state 'use this instead of list when you have an ID' or give exclusions, leaving some inference to the agent.

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 must carry the behavioral disclosure burden. It conveys a read-only list operation and creation-date filtering, but does not mention pagination behavior, ordering, response shape, or any limits or 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 one sentence with no filler. It front-loads the verb and resource, and the parenthetical adds useful domain disambiguation without unnecessary length.

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 straightforward list operation with fully described parameters, this is adequate but not complete. The lack of annotations, output schema, and explicit sibling differentiation leaves gaps around expected return behavior and when another tool would be more appropriate.

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 100%, so the parameters are already fully documented with types, defaults, and enums. The description adds only the creation-date filtering concept, which does not meaningfully extend what the schema already states.

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: 'List Slide accounts', and clarifies the domain concept with 'top-level MSP/reseller billing entities'. This distinguishes it from related sibling tools like slide_get_account and slide_list_clients.

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

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

There is no explicit guidance about when to use this tool versus alternatives such as slide_get_account for a single account or slide_list_clients for client-level entities. The phrase 'top-level' implies hierarchy but no exclusions or alternative routing are stated.

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

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

With no annotations at all, the description carries the full burden of behavioral disclosure, and it does disclose a non-obvious trait: the endpoint deliberately omits the agent-encryption passphrase even when one exists. This is exactly the kind of behavioral caveat that could cause incorrect assumptions. It does not describe response structure or error behavior, but for a read-only list operation the passphrase guarantee is the most important behavioral point.

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 earns its place in two sentences: the first defines the resource and enumerates filters, and the second flags the critical passphrase limitation with an alternative pointer. There is no filler or repetition of schema text, and the most important caveat is placed at the end without burying the 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?

Given 9 optional parameters and no output schema, the description is reasonably complete: it explains the domain concept, lists the main filter categories, and warns about the passphrase omission. It does not specify the response shape or pagination behavior, which would be helpful since there is no output schema, but the absence is not critical for a simple list endpoint with fully documented parameters.

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

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

The input schema already describes all 9 parameters, so the baseline is 3. The description adds a useful conceptual mapping by saying agents are filterable by device, client, type, and pairing date, which aligns with device_id, client_id, agent_type, and paired_after/paired_before. It does not add format or boundary details beyond what the schema already states, so no higher score is warranted.

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

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

The description states a clear verb and resource: 'List agents' and immediately defines what agents are in this domain (protected systems paired to a Slide device). It also names the available filtering dimensions, which are specific enough to distinguish this from any other list tool. The explicit 'see slide_get_agent' pointer further separates it from the single-agent retrieval sibling.

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 a clear when-not condition: it 'never returns the agent-encryption passphrase' and directs the agent to slide_get_agent instead. This is valuable routing guidance because an agent might otherwise assume a list endpoint would include all agent details. It does not explicitly contrast this tool with other list-style siblings, but for a get-vs-list relationship the guidance is sufficient.

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 behavioral disclosure. It does convey that this is a read-style operation and lists filter dimensions, but it omits behavioral details such as default pagination, sorting behavior, and what the returned alert objects contain.

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 one short sentence that front-loads the core action, provides concrete examples, and summarizes filters without wasted words. It is easy to parse and appropriately sized.

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 list tool with zero required parameters and complete schema descriptions, the description plus schema is largely sufficient for calling the tool. The main gap is not explicitly connecting it to slide_get_alert or explaining pagination behavior, but the core selection and invocation context is present.

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 100%, so the schema already documents every parameter. The description adds value by summarizing the key filter groups, but it does not add meaningful detail beyond the schema's per-parameter descriptions.

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

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

The description names a specific verb and resource ('List alerts') and gives concrete examples of alert types, making the tool's purpose immediately clear. The plural 'alerts' and filter list also help distinguish it from the sibling slide_get_alert.

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 list semantics imply this is for retrieving multiple alerts rather than a single one, but the description does not explicitly state when to use it versus alternatives or when not to use it. No sibling is mentioned, so usage guidance is only 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?

No annotations are provided, so the description itself must convey behavioral traits. It implies a read-only listing operation, but does not explicitly state that it has no side effects, does not mention authentication requirements, rate limits, or pagination behavior beyond what the schema already includes. The description adds minimal behavioral context beyond the listing purpose, but that is acceptable for a simple enumeration 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 a single, concise sentence that front-loads the core purpose and the relationship to another tool. There is zero fluff or redundancy. Every word contributes 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?

For a simple enumeration tool with only pagination parameters and no output schema, the description is sufficient. It clearly states what it returns and why the returned values matter. It could optionally mention that the list is paginated or that no other dependencies exist, but the schema already covers pagination. Overall, an agent can successfully use this tool with the given information.

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

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

The input schema has 100% coverage for all four parameters (limit, offset, sort_by, sort_asc) with descriptions and defaults. The tool description does not add any additional meaning to these parameters, but it doesn't need to because the schema thoroughly explains them. Baseline 3 is appropriate since the description adds no extra parameter insights.

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 ('List'), a clear resource ('full set of audit action names'), and connects to the sibling tool's filter ('usable in slide_list_audit_logs' audit_action_name filter'). This distinguishes it from audit log list or resource types tools. An agent can immediately understand what this tool returns and how it relates to other 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 explicitly points to the context where this tool's output is used (the audit_action_name filter of slide_list_audit_logs), making the intended use obvious. It does not explicitly state when not to use it or mention alternatives like slide_list_audit_resource_types, but the reference to the specific filter provides clear contextual 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?

No annotations are provided, so the description carries the behavioral burden. 'List' and 'filterable' indicate a read-only query operation with no destructive side effects, which is transparent enough for a simple list tool. Still, it does not mention pagination behavior, default ordering, response shape, or any rate-limit/auth considerations beyond what the schema already states.

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

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

The description is a single, front-loaded sentence: it leads with the action and resource, then lists the main filtering capabilities. There is no filler, repetition, or vague language; every word earns its place.

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

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

For a read-only list tool with no required parameters and a fully described schema, this one-sentence description covers the core selection and invocation needs. It does not mention the singular get tool or helper list tools, but the resource name, list semantics, and parameter descriptions make the tool usable without those references.

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 100%, so parameters are already well documented. The description summarizes the filter axes ('action name, resource type, client, and audit-time range') but adds no new meaning beyond the schema. This matches the baseline for high schema coverage.

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: 'List audit log entries,' which clearly identifies the operation. It adds the key filter dimensions (action name, resource type, client, audit-time range), making it distinguishable from the singular slide_get_audit_log sibling. It does not explicitly mention that sibling or describe return fields, so it misses full distinction.

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

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

The description implies usage for retrieving multiple audit log entries and suggests filtering, which provides basic context. However, it does not explicitly state when to prefer this tool over slide_get_audit_log, nor does it mention related helper tools like slide_list_audit_actions. The usage is inferred rather than explicitly guided.

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 not mention that the operation is read-only, any permission requirements, pagination behavior, or potential error cases. The description only states what it returns, lacking transparency about limitations or 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 a single, front-loaded sentence that states the purpose and context with no unnecessary words. It is efficient and immediately clear.

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 explains the tool's purpose and where it is used, but it does not describe the response structure beyond listing names, nor does it address pagination despite having pagination parameters. With no output schema, more detail on return format and pagination would be helpful, but the description is minimally adequate 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?

The input schema describes all four parameters with 100% coverage, and the description adds no additional parameter-specific meaning. Since the schema already documents limit, offset, sort_by, and sort_asc, the baseline of 3 applies.

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 'audit resource type names', and explicitly ties it to the filter in slide_list_audit_logs, distinguishing it from other list tools like slide_list_accounts or slide_list_agents.

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 clear context by stating the tool is usable in slide_list_audit_logs' audit_resource_type_name filter, but it does not explicitly mention alternatives or when not to use it, so it stops short of a 5.

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 adds the context that each backup attempt may have succeeded or failed, which is useful. However, it does not explicitly state that the operation is read-only, mention pagination behavior, or describe any side effects. While 'list' implies a read operation, the description could provide more clarity on response structure or non-destructive nature.

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, well-structured sentence. It front-loads the core action ('List backup attempts') and then lists the filterable dimensions. There is no wasted wording, and it is immediately 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 tool has 11 parameters, all optional, and no output schema. The description covers the purpose and the main filter dimensions, which is sufficient for an agent to understand its basic usage. However, it does not explicitly mention that it returns a paginated list or that it is read-only, though these are somewhat implied by 'list' and the schema parameters. Given the complexity, the description is fairly complete but could be slightly more explicit about the operation's safety.

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 100%, so the baseline is 3. The description summarizes the filterable dimensions (agent, snapshot, device, time range), which aligns with the parameters. It adds a concise overview but does not provide syntax details beyond what the schema already documents.

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 ('List') and resource ('backup attempts'), and clarifies that each attempt may have succeeded or failed. This distinguishes it from slide_get_backup, which retrieves a single backup, and from other list tools. The purpose is immediately 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 usage as a list operation with filters, but it does not explicitly state when to use this tool versus alternatives like slide_get_backup or other list tools. It mentions filterable criteria, which suggests querying scenarios, but lacks explicit exclusions or alternative 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?

No annotations are provided, so the description carries the full burden of behavioral disclosure. It does not state that the operation is read-only (though inferable from 'list'), mention pagination behavior, describe the response shape, or disclose any side effects. With no annotations, the description fails to provide meaningful behavioral transparency.

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 brief, but it is under-specified. It is essentially the tool name rendered as a sentence and adds no value beyond the name. It does not earn its place as a useful description.

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

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

For a simple list tool with two documented pagination params and no output schema, a short description could be adequate. However, this one omits any explanation of response contents, typical usage, or differences from related billing list tools. The description alone is insufficient for an agent to know what to expect.

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 100%; both limit and offset have complete descriptions in the schema. The description adds nothing about parameters, but the schema already fully documents them. Baseline 3 is appropriate.

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 'List billing credit memos' is a near-verbatim restatement of the tool name itself. It names a verb and resource, so it is not misleading, but it adds no information beyond the name and does nothing to differentiate the tool from sibling list tools other than naming the resource, which the name already does. This is essentially a tautology.

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

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

The description provides no guidance about when to use this tool, what scenarios it fits, or how it relates to sibling tools like slide_list_billing_invoices or slide_list_billing_subscriptions. An agent receives no cues about selection or alternative choices.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It does not state whether the operation is read-only, what the return format is, whether the list is scoped to a specific account or all invoices, or any rate limits or side effects. The description is too sparse to convey meaningful behavior beyond the bare 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 a single sentence with zero filler, front-loading the action and resource. It is appropriately sized for a simple list tool and every word earns its place.

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

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

For a list tool with two optional parameters and no output schema, the description is too thin. It does not indicate the scope of the list (e.g., all invoices, current account), the response shape, or any filtering behavior. The agent cannot infer what a billing invoice object looks like or what fields are returned, creating a significant gap.

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

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

Schema descriptions cover 100% of the parameters (limit and offset), so the baseline is 3. The description adds no parameter-specific meaning, but the schema already documents pagination semantics adequately, so no penalty is warranted.

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 'List billing invoices' clearly states the verb (list) and the specific resource (billing invoices), distinguishing it from sibling tools like slide_list_billing_credit_memos and slide_list_billing_subscriptions. However, it does not explicitly differentiate itself from those tools, which prevents a perfect score.

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

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

The description provides no guidance on when to use this tool vs alternatives. It does not mention exclusions, prerequisites, or recommend other billing-related tools, leaving the agent to infer usage solely from the tool name.

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

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

No annotations are present, so the description carries the full burden for behavioral disclosure. 'List' implies a read-only collection operation, but the description does not clarify whether the result is a combined stream, filtered, or paginated beyond schema defaults, and it says nothing about response shape.

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?

'List subscriptions and device licenses.' is a single, front-loaded sentence with no filler or redundant restatement of the tool name. It is appropriately concise for a simple paginated list operation.

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 list tool with fully documented optional pagination parameters, the description is near-sufficient, but the lack of annotations and output schema leaves behavioral and return-value context underexplained. 'And device licenses' introduces some ambiguity about what is actually returned.

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 100%: limit and offset both have explicit descriptions with defaults. The description adds no parameter-level meaning, so a baseline 3 is appropriate.

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 ('List') and names the resource ('subscriptions and device licenses'), so an agent can infer this is a collection-fetching tool. It adds useful scope beyond the tool name but does not explicitly differentiate it from sibling billing list tools like slide_list_billing_invoices.

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 purpose statement implies this tool is for retrieving billing subscription and device license records, but it provides no explicit when-to-use guidance or exclusions. An agent must infer that other billing list tools are for invoices or credit memos from their names rather than from this description.

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 behavioral burden. It clearly describes a read-style list operation with creation-date filtering and implies no side effects. It does not mention return shape or pagination behavior, but those are partly inferable from the schema.

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?

A single, front-loaded sentence with no filler. The parenthetical disambiguates the resource type without adding unnecessary length.

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

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

For a low-complexity list tool, the description and fully documented schema are sufficient for an agent to invoke it correctly. The main gap is the lack of explicit routing to related tools, but the resource scope is clear and no required parameters or hidden constraints exist.

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 100%, so the schema already documents all parameters. The description adds a conceptual grouping (filterable by creation date) but does not enrich any individual parameter beyond what the schema states.

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?

States a specific verb ('List') and resource ('clients'), with a parenthetical clarifying that clients are the MSP's end customers. This cleanly distinguishes it from related tools like slide_get_client and slide_list_accounts.

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 use case is implied by the verb and resource name, but there is no explicit guidance about when to choose this over slide_get_client or slide_list_accounts. No alternatives or exclusions are mentioned.

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

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

No annotations are provided, so the description carries the behavioral burden. 'List' implies a read-only operation and the filterable-by-client/creation-date behavior is stated, but pagination behavior, default ordering, and output characteristics are not disclosed. For a non-destructive list tool this is adequate 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 front-loaded sentence with no wasted words. It states the verb, resource, and key filtering capabilities compactly.

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 seven fully documented parameters and a clear resource definition, the tool is mostly self-sufficient, but there is no output schema and no mention of pagination/return conventions. The description also lacks routing context relative to sibling get/list tools, leaving some completeness gaps.

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

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

Schema description coverage is 100%, so the baseline is 3. The description reinforces the client and creation-date filters, but it does not add meaning beyond the schema's already-detailed parameter descriptions for limit, offset, sorting, and timestamps.

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

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

The description names a specific verb ('List'), a concrete resource ('devices (physical or virtual Slide Boxes)'), and the available filter dimensions. This clearly differentiates it from singular get-style siblings like slide_get_device.

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 about when to use this tool versus alternatives such as slide_get_device or slide_list_agents. It does not state exclusions, prerequisites, or conditions that should route an agent to a sibling 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 must carry the behavioral transparency burden. It only says 'List' and does not disclose whether results are paginated, sorted, limited, or whether any authorization constraints apply. It also does not clarify whether 'configured VLAN interfaces' includes only active VLANs or all defined ones.

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

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

The description is a single, compact sentence that immediately conveys the tool's core function. There is no redundant wording or irrelevant detail, making it easy for an agent to parse quickly.

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

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

The tool is simple with one parameter, so the description is mostly adequate for invoking it correctly. However, it lacks guidance on how this differs from slide_get_device_vlan, does not mention pagination or return value shape, and provides no behavioral context such as read-only status. Given no annotations or output schema, more context would be valuable.

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 100%, with device_id described as 'Device ID.' The description does not add additional meaning to the parameter, but the schema already fully documents it, so the baseline score of 3 is appropriate.

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 ('List') and the resource ('a device's configured VLAN interfaces'). It is distinct from sibling tools like slide_get_device_vlan, which retrieves a single VLAN rather than listing all configured VLAN interfaces for a device.

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 when to use the tool: when you need the configured VLAN interfaces for a specific device. However, it does not explicitly state alternatives, such as using slide_get_device_vlan for a single VLAN, nor does it mention any exclusions or prerequisites beyond needing a device_id.

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

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

With no annotations, the description carries the behavioral disclosure burden. It adds useful semantic context by explaining that pushes are the act of copying a restored file back to a protected system, which helps the agent understand the operation's role. The verb 'List' implies a read-only behavior, but the description does not explicitly mention read-only status, output shape, pagination behavior, or any 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 a single, focused sentence that front-loads the core action and adds a concise clarifying parenthetical. Every word contributes meaning, and there is no repetition of schema details.

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 9-parameter list endpoint with complete schema descriptions, the description is adequate: it identifies the resource, the parent file restore context, and the filtering dimension. Given the absence of an output schema and annotations, some additional detail about return content could help, but the description plus schema is sufficient for an agent to invoke the tool correctly.

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

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

The input schema covers 100% of the 9 parameters with descriptions, so the schema already documents the parameter semantics well. The description adds only a general mention of start/end time filtering, but no additional meaning beyond the schema. Baseline 3 is appropriate.

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 ('List') and a specific resource ('push operations') with a helpful parenthetical defining what a push is in this context: copying a restored file back to a protected system. This clearly distinguishes it from list_file_restores and even from get_file_restore_push by establishing that it is the plural listing operation, though it does not explicitly 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 implies when to use the tool: when listing push operations for a file restore, with optional start/end time filtering. However, it gives no explicit guidance about when to prefer this over slide_get_file_restore_push or other related list endpoints, nor does it state any exclusions or prerequisites.

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 behavioral disclosure, but it is a simple read/list operation and 'List' clearly implies that. It adds useful context about what a file restore is, but it does not describe pagination behavior, default ordering, or what the response contains.

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

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

The description is a single efficient sentence that front-loads the primary action and resource, then adds a clarifying parenthetical. There is 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?

For a straightforward paginated list with six optional parameters and no output schema, the description is minimally adequate. It names the resource and its creation-date filter, but it omits any mention of return format, default pagination, or how this tool fits into a workflow with file-restore siblings.

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 100%, so the schema already documents all six parameters with reasonable detail. The description's phrase 'filterable by creation date' adds conceptual meaning for created_after/created_before, but it does not explain limit, offset, or sorting behavior beyond what the schema provides.

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: 'List file restores', and clarifies the concept with 'a snapshot exposed for browsing/downloading individual files'. It is not a tautology and identifies the object of the operation, though it does not explicitly distinguish itself from sibling tools like slide_list_file_restore_pushes.

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

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

The description provides no guidance on when to choose this tool over alternatives such as slide_get_file_restore, slide_browse_file_restore, or slide_list_file_restore_pushes. It implies usage through 'List file restores' but does not state exclusions or conditions that should route an agent to a different 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 adds a valuable and non-obvious security behavior: the live Samba password is never returned even if the underlying API includes it. The 'list' verb implies a read-only operation, and the redaction warning provides useful transparency that the schema alone could not convey.

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

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

Two sentences with no filler: the first states the action and defines the resource, and the second provides a crucial security caveat. Both sentences earn their place and the description is tightly structured and easily parsed.

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 the schema fully documents all six parametersating, the description covers the core concept, the filtering capability, and the one non-obvious response behavior. It does not describe the overall response shape, but for a list operation this is a minor gap and the description is sufficiently complete 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 100%, so the parameters are already well-documented. The description's mention of filtering by creation date echoes the created_after/created_before parameters but adds no new semantic detail or format guidance. The baseline of 3 is appropriate since the schema handles parameter 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 clearly identifies the operation as 'List image exports' and defines what an image export is in the parenthetical, giving the agent a precise resource and action. However, it does not explicitly differentiate this listing tool from its siblings (get_image_export, browse_image_export), so it stops short of a 5.

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

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

The phrase 'filterable by creation date' implies a use case and gives some context for when this tool would be appropriate. But it does not name any sibling tools or state when to prefer this over get_image_export or browse_image_export, nor does it provide explicit exclusions or conditional guidance.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It explicitly discloses a non-obvious and important behavior: secret fields are redacted even though the underlying Slide API returns them. It does not mention authentication or explicitly state that this is read-only, but the 'List' verb and redaction caveat provide adequate safety context for a listing operation.

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

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

The description is two sentences with no filler. The primary purpose is front-loaded, and the security-relevant redaction caveat is expressed in a single clear clause without redundant detail.

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

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

For a read-only listing tool with seven optional parameters fully documented in the schema, the description supplies essential purpose, filtering, and redaction context. It does not describe the exact response shape or pagination behavior, but those gaps are minor given the schema coverage and the straightforward nature of a list operation.

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

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

The schema already describes all seven parameters with 100% coverage, so the baseline is 3. The description adds that filtering by client and creation date is possible, which maps to client_id and created_after/created_before, but it provides no extra syntax, defaults, or meaning 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 combines a specific verb ('List') with a specific resource ('disaster-recovery networks') and adds filter dimensions. It is clear what the tool operates on, though it does not explicitly differentiate itself from siblings like slide_get_network beyond the singular/plural naming convention.

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 conveys the natural use case: enumerate disaster-recovery networks and filter by client or creation date. However, it gives no explicit guidance about when to prefer this tool over slide_get_network or when not to use it, leaving the agent to infer from naming conventions.

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 adds useful context that snapshots come from successful backups and are filterable by location/deletion state, but it does not mention read-only behavior, default filters, pagination, sorting, or response format. For a list operation, this is adequate 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, efficient sentence that leads with the action and resource, then highlights the most decision-relevant filter dimensions. There is no redundancy with 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?

For a 10-parameter list tool with no output schema and no annotations, the description provides the essential scope but relies heavily on the schema for defaults, enums, and time formats. It would be stronger if it explicitly mentioned the default non-deleted location filter or pagination behavior.

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

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

Schema description coverage is 100%, so the baseline is 3. The tool description only groups parameters at a high level ('by agent, location/deletion state, and backup start/end time range') without adding syntax or semantic detail beyond what the schema already provides.

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 ('List snapshots') and adds a meaningful scope qualifier ('taken as part of a successful backup'), plus the key filter dimensions. It is clear enough to distinguish from slide_get_snapshot, though it does not explicitly contrast with sibling tools like slide_list_backups.

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 as a filtered list operation and states the main filtering dimensions, but it does not explain when to prefer this over slide_list_backups or slide_get_snapshot. No exclusions or alternative tool names are given.

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 core behavior (list users) and mentions creation-date filtering, but does not disclose pagination behavior (limit/offset), sorting options, or the return format. For a list operation with six parameters, this is a notable gap.

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

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

The description is a single, front-loaded sentence with zero waste. It efficiently states the purpose and a key capability 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 six optional parameters and no output schema or annotations, the description is sparse. It covers the core purpose and date filtering but omits pagination, sorting, and response format details. While parameters are documented, the overall behavioral context is incomplete for a list operation.

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

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

Schema description coverage is 100%, so all parameters are already documented. The description adds the concept of creation-date filtering, which maps to the created_after and created_before parameters, but does not go beyond that. Since the schema covers everything, a baseline of 3 is appropriate.

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 (list), the resource (users), and adds a clarifying parenthetical that these are technicians with console access, which distinguishes it from other list tools like slide_list_accounts or slide_list_clients. It also mentions the filtering capability, making the purpose 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 implies when to use this tool (when you need to list users and possibly filter by creation date) but does not explicitly state when to use alternatives like slide_get_user for a single user. There is no direct comparison to siblings or mention of exclusions, leaving some inference required.

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

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

With no annotations present, the description carries the full behavioral transparency burden. It adds a meaningful security-related behavior: VNC connection info is included but the live VNC password is never returned, even though the underlying API provides it. This is exactly the kind of caveat an agent needs.

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 tightly written sentences carry the main action, the filterable aspect, and the key behavioral caveat. There is no filler, and the most important qualifying information is front-loaded.

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

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

Given the six optional parameters are fully described in the schema, the description covers the tool's core purpose and one important return-value behavior. The lack of an output schema means some return-structure detail is still unspecified, but the description provides enough for an agent to select and invoke the tool correctly in most cases.

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

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

The input schema already documents all six parameters with 100% coverage, so the baseline is 3. The description adds limited parameter-level meaning by mentioning filtering by creation date, which maps to created_after and created_before, but it doesn't elaborate on limit, offset, or sort behavior beyond what the schema already provides.

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 ('List') and a specific resource ('virtual machines created from a snapshot'), with an additional qualifier of filtering by creation date. This clearly distinguishes it from sibling tools like slide_get_virtual_machine, which focuses on a single VM rather than listing.

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 purpose is fairly self-evident as a listing operation, and the description points out what the tool returns, but it provides no explicit guidance about when to choose this over alternatives. There are no exclusions or comparisons to sibling tools such as slide_list_snapshots or slide_get_virtual_machine.

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 exist, so the description must stand alone. It usefully discloses that the search is limited to indexed file paths on a protected system and that indexing must be enabled, but it does not mention return values, pagination behavior, or authorization requirements. This is minimal but non-misleading contextual disclosure.

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

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

The description is a single sentence with no filler, and the crucial prerequisite is placed in a parenthetical at the end. It is appropriately sized and front-loaded.

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

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

For a read-only search tool, the description plus the fully documented schema gives an agent the core invocation details: required agent_id/search_term, pagination, and sort options. It lacks an explicit statement of what the returned matches look like, but with no output schema defined it does not need to enumerate return fields. The main gap is absence of guidance tying it to alternatives, which is already covered under usage guidelines.

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 100%, so the schema already documents all six parameters including defaults and the enum for sort_by. The description adds no param-specific detail beyond reinforcing that the target corpus is file paths, so a baseline 3 is appropriate.

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 the specific verb 'Search' and identifies the exact resource—'file paths indexed on an agent's protected system'—which is enough to understand the tool's scope. It does not explicitly contrast with siblings such as slide_get_agent_file_versions or slide_browse_file_restore, so it misses the top point on sibling differentiation.

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

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

The parenthetical 'requires file indexing to be enabled on the agent' provides a clear precondition for use, telling the agent when the tool is available. It does not name alternative tools or spell out when not to use it, but the context is sufficiently clear to qualify as 4.

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