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

Beyond the readOnly/idempotent hints, the description details the exact return payload (per-datastore fields including GC last-run time and dedup factor). This adds substantial behavioral context about what the agent will receive, fulfilling the high bar.

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

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

The description is two sentences: the first states the purpose and scope, the second compactly lists return fields. No filler or repetition, 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 zero-parameter read-only tool with no output schema, the description fully covers what the agent needs: what is returned, for which resources, and which specific metrics are included. Nothing essential 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?

The tool has zero parameters and an empty schema, so there is no parameter detail to add. The description wisely focuses on output semantics, which is appropriate for a parameterless read operation; baseline for 0 params is 4.

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 ('usage statistics') with explicit scope ('all datastores'), and enumerates key data fields. This clearly distinguishes it from sibling tools like pbs_list_datastores (simple listing) and pbs_run_garbage_collection (mutating GC action).

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

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

The intended use case—retrieving usage, GC status, and dedup metrics—is evident from the context. However, it does not explicitly name alternatives or state when not to use it, which would earn 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?

Annotations already declare readOnlyHint, openWorldHint, idempotentHint, and destructiveHint, so the safety profile is covered. The description adds useful detail about what data is returned (e.g., CPU model, core count, usage percentage) but does not disclose any further behavioral traits such as permissions, rate limits, or potential side effects. This is acceptable given the simple read-only nature of the tool, but it adds no extra behavioral context beyond the 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?

The description is well-structured: a single introductory sentence followed by a bulleted list of return items. It is concise, with no filler or repetition, and the key information is front-loaded. Every line adds value, and the formatting makes the content 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?

Given the tool's low complexity (0 parameters, no output schema) and detailed annotations, the description is complete. It enumerates all the key return fields, leaving little ambiguity about what the tool does or what information it provides. There are no missing elements like prerequisites or return format requirements that would be expected for such a simple status 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 tool has zero parameters, so there are no parameter semantics to explain. The description does not need to compensate for any schema gaps since the schema is trivially complete at 100% coverage. The description's focus on return values is appropriate for a no-parameter tool, aligning with the baseline of 4 for 0 params.

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

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

The description clearly states the tool's function with a specific verb ('Returns') and a specific resource ('detailed status of the PBS node'), listing exactly what information is provided (CPU, memory, disk, swap, load averages, uptime, kernel version). This distinguishes it from sibling tools like pbs_get_version or pbs_list_datastores, which target different resources.

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 alternatives. It does not mention any prerequisites, use cases, or exclusions. While the tool's purpose is clear, there is no 'when to use' or 'when not to use' information beyond the implicit context of 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?

Annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false, covering the safety profile. The description adds that the tool returns both task status and log output, which is useful but not extensive. It does not mention potential errors, response formatting, or any side effects, but with strong annotations this is acceptable.

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

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

The description is extremely concise: two sentences plus an Args/Returns block. It is front-loaded with the main purpose and contains zero fluff or repetition. 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?

Given the tool's simplicity (one required parameter, read-only, idempotent, no output schema), the description fully covers what it does and what it returns. It mentions both status and log lines, which is sufficient for a getter tool. The annotations handle the safety and mutability context, so no additional information is needed.

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% for the single 'upid' parameter, and the schema already provides 'Task UPID string'. The description repeats 'The task UPID' without adding extra detail (e.g., format, where to find it, or examples). Since schema coverage is high, the baseline of 3 applies, and the description adds no meaningful parameter semantics 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 states 'Get the status and log output of a specific task by its UPID', using a specific verb ('Get') and resource ('status and log output' of a specific task). This clearly distinguishes it from siblings like pbs_list_tasks, which lists tasks, and pbs_get_node_status, which targets node status.

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 a specific task identified by UPID, which is clear from the context. It does not explicitly name alternatives or exclusions, but the sibling list and the focus on 'specific task' provide sufficient contextual guidance. No misleading or missing when-not information.

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?

Annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false, covering the safety profile. The description adds what data is returned (version, release, repository ID), which is useful but does not disclose additional behavioral traits such as authentication requirements or error handling. Since annotations carry the main safety burden, this is adequate but not exceptional.

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, front-loaded with the return value and followed by a usage tip. Every word earns its place; there is no fluff or repetition of schema information.

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

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

For a zero-parameter, diagnostic tool, the description is fully complete. It states what the tool does, what it returns, and when to use it. No output schema exists, but the description covers the essential return fields. The sibling tools are distinct, and this simple tool needs no further elaboration.

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

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

There are zero parameters, so the schema is trivially complete. The description does not need to explain parameters, and the baseline for 0 params is 4. The description focuses on output, which is appropriate for a parameterless tool.

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

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

The description clearly states the tool returns the Proxmox Backup Server version, release, and repository ID, using the specific verb 'Returns'. This uniquely identifies its purpose among the sibling tools, which focus on nodes, sync jobs, tasks, and datastores.

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 says 'Use this to confirm connectivity and check which PBS version is running', giving clear context for when to use the tool. It does not name alternative tools for exclusion, but the sibling list and specific language make the appropriate usage obvious.

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?

Annotations already establish readOnly, idempotent, non-destructive behavior. The description adds value by disclosing return fields (GC schedule, prune schedule, keep-* retention counts), which goes beyond annotations. No contradictions.

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 tight sentences: the first states the action and scope, the second enumerates the return contents. Every word earns its place with zero filler.

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

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

Despite lacking an output schema, the description fully explains what is returned. The tool is a simple read-only list, and the description covers purpose, scope, and return shape sufficiently for an agent to invoke it correctly.

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

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

Parameter count is 0, so the schema needs no explanation. The description correctly omits parameter details; baseline of 4 for no-parameter tools 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 it lists all configured datastores on the PBS server, naming specific fields (paths, comments, retention settings). This is a specific verb+resource that distinguishes it from siblings like list_snapshots or list_groups.

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

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

The description gives clear context: it's a listing operation for datastores. It doesn't explicitly mention when not to use it or alternatives, but the scope is obvious enough for an agent to select it over other list tools.

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

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

Annotations already cover the read-only, idempotent, non-destructive nature. The description adds context beyond annotations by explaining that groups are organized by backup type and ID, and by specifying the returned fields (type, ID, last backup time, backup count, owner). This provides useful behavioral insight without contradicting the 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?

The description is front-loaded with the core purpose sentence, followed by concise Args and Returns sections. Every line is necessary, there is no filler, and the structure makes it easy to scan. It achieves high clarity with minimal 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?

With no output schema, the description properly documents the return value as an array of backup groups with specific fields. The input schema fully covers parameters, and annotations cover safety. For a simple list tool, this description is complete: it states what it lists, the parameters, and the expected output shape.

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 both 'store' and 'ns' already documented in the input schema. The description's Args section merely restates these definitions without adding syntax, format, or relationship details, so it contributes no additional value beyond the structured data.

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 identifies the resource as 'backup groups in a datastore'. It further distinguishes from sibling tools by mentioning the organization by backup type (vm, ct, host) and ID. This clearly states the tool's function and scope.

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

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

The description implies the tool is for listing backup groups, but it does not explicitly state when to use this tool over other list tools (e.g., list_snapshots) or provide exclusions or alternative scenarios. Guidance is only implied through the resource type.

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?

Annotations already declare read-only/idempotent/safe, and the description adds behavioral context by specifying the return format (array of namespace paths and comments) and the optional parent parameter's role in listing child namespaces. No contradictions.

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 brief and well-structured: a one-sentence purpose, a concise args list, and a returns line. No redundant or extraneous content.

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 listing tool, the description covers purpose, parameters, and return format. It lacks details on edge cases like errors or empty results, but these are not critical given the annotations and simplicity.

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 fully describes both parameters (store, parent). The description adds marginal value by clarifying that parent is used to list children of a namespace, supplementing the schema's 'Parent namespace path'.

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 resource ('backup namespaces in a datastore'), clearly distinguishing it from sibling list tools like pbs_list_datastores and pbs_list_snapshots. The scope is precise and 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 its use case through its title and content, but does not provide explicit guidance on when to use it versus alternatives, such as when enumerating namespaces before listing snapshots. No 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?

Annotations already declare readOnlyHint=true, openWorldHint=true, idempotentHint=true, and destructiveHint=false, so the safety profile is well covered. The description adds useful behavioral context by specifying the return fields (ID, store, schedule, retention settings, namespace, disabled status), which goes beyond the annotations. No contradictions.

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

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

The description is extremely concise: one sentence stating the purpose, followed by a short 'Returns:' section. Every sentence earns its place, and the structure is front-loaded with the main 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?

The tool is a simple list operation with no parameters, no output schema, and strong annotations (read-only, idempotent, open-world). The description completely covers what it does and what it returns. The only minor gap is no explicit statement about whether this list is affected by namespaces or permissions, but the openWorldHint and sibling context mitigate that. Overall, complete for its simplicity.

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?

There are no parameters, and the schema coverage is 100% (vacuously, as there are no properties). The description adds meaning by detailing the exact fields returned in the array, which is the only semantic content an agent needs. Since there are 0 params, baseline is 4 per the rubric, and the description provides additional relevant info.

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 resource ('all configured scheduled prune jobs'), and it clearly distinguishes from siblings by naming the specific job type (prune jobs) as opposed to sync jobs, verification jobs, tasks, etc. The first sentence is clear and direct.

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 implicitly indicates this is for listing scheduled prune jobs, and the return field list clarifies what information is provided. However, it does not explicitly state when to use vs. alternatives like pbs_prune_datastore (which performs pruning) or pbs_list_verification_jobs. Context is clear but no 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?

Annotations already declare readOnlyHint, openWorldHint, idempotentHint, and destructiveHint=false, so the safety profile is covered. The description adds value by outlining the return payload (array with name, host, port, auth-id, fingerprint, comment), which is useful behavioral context beyond the 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?

The description is brief: one purpose sentence and one return-format line. It contains no fluff and is front-loaded with the core action.

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

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

Given the zero-parameter, read-only nature of the tool, the description fully covers what the agent needs: what the tool does and what it returns. No output schema exists, so the explicit field list compensates well.

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?

No parameters exist, and the schema covers everything. The description does not need to explain parameters, so the baseline 4 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 action (List), the resource (configured remote PBS servers), and the context (used for sync jobs). It distinguishes from sibling tools like pbs_list_datastores or pbs_list_groups by specifying 'remote PBS servers'.

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 tool is for viewing configured remote PBS servers for sync job management, but it does not explicitly mention when to use it over the sibling tools or provide exclusion criteria. There is no direct alternative guidance, so it earns a 3 for implied usage.

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

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

Annotations already declare readOnlyHint=true, openWorldHint=true, idempotentHint=true, and destructiveHint=false, covering safety. The description adds a Returns section detailing the fields in the snapshot array (type, ID, timestamp, etc.), which goes beyond annotations and helps the agent understand the output.

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 and well-structured with 'Args:' and 'Returns:' sections. The Args list largely duplicates the schema, but the overall length is still reasonable and the purpose is front-loaded. No waste but some redundancy.

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

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

There is no output schema, but the description includes a Returns section that lists the snapshot fields, which compensates. All parameters are covered, and annotations provide safety context. It doesn't discuss error conditions or pagination, but for a simple read-only list tool, the description is fairly complete.

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

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

Schema coverage is 100%, and the description essentially restates the parameter descriptions found in the schema. It adds minimal new meaning beyond what's already in the input schema, so 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 uses the specific verb 'List' with the resource 'snapshots in a datastore' and mentions optional filtering by backup type and ID. This clearly distinguishes it from sibling tools like pbs_list_tasks or pbs_list_datastores.

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 makes the purpose clear: list snapshots with optional filters. It doesn't explicitly state when to use this tool over alternatives, but the resource is unambiguous and the filtering options are described. No exclusions are provided, but the context is clear enough.

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?

Annotations already declare readOnlyHint, idempotentHint, and non-destructive behavior. The description adds the return field list (ID, local store, remote name, etc.), which provides useful context beyond the annotations, especially since no output schema exists.

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

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

The description is two sentences: first states the purpose clearly, second enumerates the return fields. No fluff, no redundant phrasing, and each 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 simple zero-parameter listing tool, this is complete. It defines what it lists (sync jobs), includes the return array and key fields, and the annotations cover safety and side-effect 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?

There are zero parameters, so the baseline is 4 per the rubric. The description correctly does not add parameter details, and the schema coverage is trivially 100%.

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

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

The description uses the specific verb 'List' and identifies the exact resource: 'configured sync jobs that replicate data between PBS servers.' This clearly distinguishes it from sibling tools like pbs_list_verification_jobs or pbs_list_prune_jobs by focusing on sync jobs.

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 makes it clear this is for listing sync jobs, and the sibling names (e.g., pbs_run_sync_job) help imply when to use it. However, it does not explicitly state exclusions or alternative tools, 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?

Annotations already declare readOnly, idempotent, and non-destructive hints. The description adds useful context beyond annotations: it specifies the return fields and constrains results to 'recent' tasks. This is valuable behavioral 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 concise and well-structured: a clear first sentence, a compact Args block, and a Returns line. Every sentence serves a purpose, with no fluff or repetition.

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

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

For a simple list operation, the description is complete: it names the resource, parameters, and return shape. It does not over-explain pagination or sorting, which is acceptable given the schema covers limit constraints. The lack of an output schema is mitigated by the explicit return description.

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 repeats parameter info and also matches the schema's examples for typefilter and statusfilter, adding no new semantic value. The only marginal addition is the default/max for limit, already present in the schema.

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

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

The description uses a specific verb ('List') and resource ('recent tasks on the PBS node') and clearly states what is returned (UPID, type, user, start/end times, status). It implicitly distinguishes itself from sibling tools that target specific job types like sync or verify jobs.

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 general use for listing all tasks, but it does not explicitly state when to use this tool versus dedicated listers like pbs_list_sync_jobs or pbs_list_verification_jobs. No when-not-to-use guidance is provided, though the examples of type filters suggest filtering capabilities.

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?

Annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false, covering the safety profile. The description adds the return format (array of verification jobs with specific fields), which provides useful behavioral context beyond annotations without contradicting them.

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

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

The description is two sentences: the first states the purpose, the second lists the return fields. It is front-loaded, concise, and every sentence adds value without redundant wording.

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 parameterless list tool with rich annotations, the description is complete. It clearly states what is listed and enumerates the return fields, which is especially important given the lack of an output schema.

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

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

The tool has zero parameters, so the baseline is 4 as per guidelines. The description does not need to explain parameters, and the schema already covers all (void) properties. The return field list is a bonus for understanding output, not parameters.

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

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

The description uses a specific verb 'list' with a clear resource 'scheduled verification jobs' and scope 'configured on the PBS server'. This distinguishes it from siblings like pbs_run_verification_job (run vs list) and pbs_list_sync_jobs (different resource type).

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 clearly implies the tool is for listing verification jobs, but does not explicitly state when to use it versus alternatives such as pbs_run_verification_job or pbs_list_tasks. No exclusion or comparison guidance is provided, 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?

The description adds useful behavioral context beyond the annotations: it explains the consequence of protection (cannot be pruned or deleted) and notes the return value. Annotations already indicate non-read-only, non-destructive, and idempotent behavior, so the description's additional semantic context is valuable and does not contradict the 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?

The description is well-structured and front-loaded: a concise summary sentence, then a clear Args list, then Returns. It is appropriately sized for a tool with 6 parameters. The only slight redundancy is repeating schema descriptions, but the organization is effective.

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

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

Given the tool's moderate complexity (6 params, 5 required) and the presence of annotations (readOnlyHint, idempotentHint, etc.), the description adequately covers the main behavior, the effect of protection, and the return value. It is not overly verbose but provides enough context 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?

Schema description coverage is 100%, so the baseline is 3. The description repeats parameter information from the schema and adds only a minor extension: an example format for backup_time ('2025-03-22T04:00:00Z'). The description does not substantially enhance parameter understanding 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 clearly states the tool's function: 'Set or remove protection on a backup snapshot.' This uses a specific verb ('set/remove') and resource ('protection on a backup snapshot'), and it is clearly distinguished from sibling tools like pbs_list_snapshots or pbs_prune_datastore by the unique protection action.

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

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

The description provides context on when to use this tool by explaining the effect: 'Protected snapshots cannot be pruned or deleted.' This implies use cases (e.g., preventing accidental deletion) without explicitly naming alternatives or exclusions. The guidance is clear but not as explicit as naming sibling tools for contrast.

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?

Annotations already declare destructiveHint=true and readOnlyHint=false. The description adds the dry-run capability, noting that it can show what would be pruned without removing, and discloses the return as a Task UPID or dry-run results. This goes beyond the structured annotations to describe safe preview behavior and asynchronous execution.

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 summary sentence is immediately followed by a compact Args list and a Returns line. Every parameter is listed with a one-line description, and the front-loaded purpose statement makes the tool's function instantly 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?

Given the tool's complexity (11 parameters, retention policies) and lack of output schema, the description adequately covers the operation's purpose, dry-run mode, and return value. It does not delve into policy interaction details or potential long-running behavior, but the return 'Task UPID' hints at async execution. A minor gap is not explaining prerequisites or error conditions, but it is sufficient for agent 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 parameters are already well-documented. The description repeats the parameter list with minor clarifications (e.g., backup_type values, dry_run default), but does not add 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 opens with a specific verb-action: 'Run a prune operation on a backup group to remove old snapshots per retention policy.' This clearly distinguishes it from sibling operations like garbage collection or verification. The resource is precisely the backup group defined by store, backup_type, and backup_id.

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 retention-based snapshot cleanup but does not explicitly state when to use this tool versus siblings such as pbs_run_garbage_collection or pbs_protect_snapshot. There are no exclusions or alternative tool references, leaving the decision to the agent's inference.

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

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

Annotations already indicate readOnly=false, idempotent=false, and destructive=false. The description adds the useful detail that the tool returns a task UPID that can be tracked, but it does not disclose potential side effects of garbage collection (e.g., deletion of unreferenced data) or prerequisites. This adds some context but not rich behavioral 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 concise, front-loaded with the purpose, and followed by simple Args and Returns sections. Every sentence adds value, and there is no redundancy.

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

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

For a single-parameter tool with annotations and no output schema, the description covers the purpose, the parameter, and the return value, including a tracking hint. It could be more complete by explaining what garbage collection does or when to run it, but the tool is simple and well-specified enough for an agent to use correctly.

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

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

The input schema has one parameter 'store' with the description 'Datastore name,' and the description repeats the same information in the Args section. Since schema coverage is 100%, the description adds no additional meaning beyond the schema, so 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 'Start a garbage collection job on a datastore,' clearly identifying the verb (start) and resource (garbage collection job). This distinguishes it from sibling run tools like pbs_run_verify and pbs_run_sync_job, which perform different 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 description gives clear context: this tool is for starting a GC job on a datastore, and it notes that the returned UPID can be tracked with pbs_get_task_status. It does not explicitly exclude alternatives or state when not to use, but the purpose is unambiguous given the sibling tool 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?

While annotations already flag this as a non-read-only operation, the description adds meaningful behavioral context by stating that it returns a Task UPID, indicating an asynchronous task is started. This is valuable since there is no output schema. It stops short of detailing side effects, prerequisites, or failure modes, but the core behavior is 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 compact and well-organized, leading with a clear one-line purpose followed by structured 'Args' and 'Returns' sections. Every sentence has value and the content is front-loaded, making it easy for an agent to quickly parse the essential information.

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

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

Given the tool's simplicity (one parameter, no output schema) and the supporting annotations, the description covers the essential information: what it does and what it returns. It is adequate for an agent to invoke the tool correctly, though it could add a note about retrieving the ID (e.g., via pbs_list_sync_jobs) or potential error conditions for a fully complete picture.

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 provides a description for 'id' as 'Sync job ID', and the tool's Args section simply repeats that same text. With 100% schema coverage, the description adds no new meaning or guidance about the parameter's format, source, or constraints beyond what the schema offers, so the baseline score 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 tool's function with a specific verb ('trigger'), a resource ('sync job'), and a scope ('configured... by ID'). It also naturally distinguishes itself from sibling tools by focusing on sync jobs rather than listing, verification, or other 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 description implies usage when a sync job ID is already known and you want to start it manually, but it does not explicitly mention alternatives or when not to use this tool. No direct contrast with siblings like pbs_list_sync_jobs or pbs_run_verification_job is 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?

Annotations already indicate a non-read-only, non-idempotent operation; the description adds that it returns a Task UPID for the started job, but does not disclose failure modes, prerequisites, or specific side effects beyond starting the job.

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 and well-structured, with a clear one-sentence purpose followed by an Args/Returns breakdown, containing no unnecessary words.

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

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

For a tool with one parameter and no output schema, the description covers the purpose, parameter, and return value, though it lacks error-handling or prerequisite context, which is 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 single parameter 'id' is fully described in both the schema and the description, but the description adds no additional semantic meaning 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 clearly states the tool's function with a specific verb ('trigger'), resource ('configured verification job'), and method ('by ID'), distinguishing it from listing or other run 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 implies usage (manually triggering a configured verification job) but does not explicitly state when to use it instead of alternatives like pbs_run_verify or pbs_list_verification_jobs, nor does it provide 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?

The description adds behavioral context beyond annotations by disclosing the default for ignore_verified (true), the conditional re-verify behavior via outdated_after, and the return of a task UPID. This supplements the annotations which already indicate non-readonly, non-idempotent, and non-destructive behavior.

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

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

The description is succinct with a one-sentence summary followed by a clear parameter list and return value. No redundant sentences or fluff.

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

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

The tool is completely described for practical invocation: purpose, parameters, and return type. The only missing piece is clarification of its relationship to the sibling pbs_run_verification_job, which is a minor gap in context.

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

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

Schema coverage is 100%, so the description does not need to restate parameter meanings. It does add the default for ignore_verified and explicitly marks optionality, which slightly exceeds the schema, but otherwise repeats schema descriptions.

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

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

The description clearly states 'Start a verification job on a datastore to check backup integrity', which uses a specific verb and resource. This distinguishes it from list-type siblings like pbs_list_verification_jobs, though pbs_run_verification_job is not addressed.

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 starting backup integrity checks, but does not provide explicit when-to-use guidance or mention alternatives. Given the presence of a similarly named sibling (pbs_run_verification_job), the lack of differentiation is a notable gap.

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