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

The annotations already declare readOnlyHint=false and destructiveHint=true, so the destructive profile is known. The description adds nothing beyond that: no statement that deletion is permanent/irreversible, no permission requirements, no note on whether schedules or report data referencing the report are affected. With annotations covering only the safety hint, this leaves meaningful behavioral gaps unaddressed.

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 short sentence with zero padding, front-loaded verb. It is efficient, though arguably under-specified rather than truly concise.

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

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

For a destructive mutation tool with an undocumented required parameter and no usage guidance, the description is inadequate; the output schema relieves it of explaining return values, but the irreversibility and identifier semantics that an agent needs before committing are 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 0% for the single parameter 'report_id', and the description offers no compensating detail about its format, source, or how to obtain it. The agent must infer the identifier entirely from the name.

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+resource ('Delete a custom report'), but it essentially restates the tool name with no additional specificity. It gives no hint about scope (per-user vs enterprise-wide), which distinguishes nothing from siblings like delete_data_source. Minimum viable, nothing more.

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 when-to-use guidance, no prerequisites, and no mention of alternatives (e.g., should a report be unpublished or archived instead of deleted). The agent gets no criteria for choosing this tool over the many other destructive/list siblings.

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

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

Annotations already declare destructiveHint=true and readOnlyHint=false, so the bar is lower; the description adds the non-obvious dependency that dependent reports must be removed first, which is genuine behavioral context. It omits whether the delete is reversible, required permissions, and cascade 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?

One sentence with a single embedded precondition; zero waste, and the destructive action is front-loaded before the caveat.

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?

An output schema exists, so return values need no explanation, and annotations already cover the safety profile. Combined with the stated precondition, the definition is nearly complete, missing only permission/scope and reversibility details.

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

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

Schema description coverage is 0% and the single parameter carries no description, so the description would need to compensate but does not. The name data_source_id is largely self-explanatory and the description confirms it targets a data source, so a baseline 3 is fair.

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+resource ('Delete a data source'), which is clearly distinguishable from sibling read tools like get_data_source and list_data_sources as well as the related delete_custom_report. It does not, however, name a sibling or scope the operation further.

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 '(delete reports that use it first)' supplies a concrete precondition for successful use, which is real actionable guidance rather than implied usage. It stops short of a 5 because it names no alternative tool or when-not-to-use condition.

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=false and destructiveHint=true, so the mutation profile is covered, but the description adds real behavioral context beyond them: the reboot warning plus 4-hour save window for users, the async default that returns an instance_id at once, and how to poll or cancel. That is exactly the kind of operational detail annotations cannot express.

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 primary action leads, followed by the input contract, the reboot caveat, and the async behavior, in a tight sequence. Every clause carries distinct, load-bearing information with no filler.

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

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

For a complex async mutation with no output schema, the description covers return behavior (instance_id), polling, and cancellation, which is most of what an agent needs. The gaps are the unexplained `wait_seconds` and `org_id`, which slightly reduce completeness.

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

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

Schema description coverage is 0%, so the description must compensate. It explains the tricky nested `packages` mapping (id of a list_missing_updates item -> versions[].version) and the `reboot` flag, but never mentions `wait_seconds` (whose default 0 is only obliquely implied by 'returns at once') or `org_id`. Partial compensation only.

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+resource ('Install updates now on the given endpoints') and situates it in the workflow by naming the sibling that supplies inputs (list_missing_updates) and the siblings that handle progress/cancel (list_automation_instance_endpoint_results, stop_automation_instance). An agent can distinguish it from all list_* siblings immediately.

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

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

Explicitly ties use to list_missing_updates output and documents the reboot decision ('No reboot unless reboot=true'). It also names the exact follow-up tools and their conditions (check progress with list_automation_instance_endpoint_results, cancel with stop_automation_instance), leaving nothing to 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?

The readOnlyHint=true annotation already establishes this as a safe read. The description adds useful context by disclosing what the response contains (script_text and columns), which matters since there is no output schema. It does not cover error behavior for an unknown ID or any access constraints.

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

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

One short sentence with no filler, and the resource is front-loaded before the returned fields. It is efficient, though too terse to earn a 5.

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 read tool with no output schema, naming the key returned fields is a genuine contribution. Still missing are the shape of the columns/script_text payload, pagination or size considerations, and behavior when the ID is invalid.

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

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

Schema description coverage is 0%, so the description must compensate for the single data_source_id parameter and does not. However, a lone, obviously-named identifier parameter leaves little ambiguity, so a baseline 3 is reasonable rather than a lower 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 states a specific verb and resource ('Get a data source') and names two returned fields (script_text, columns), so the agent knows what the tool retrieves. It does not, however, explicitly distinguish itself from the sibling list_data_sources or delete_data_source, relying on the name to carry that 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?

There is no when-to-use guidance, no prerequisite (e.g., needing a known data_source_id), and no mention of alternatives such as list_data_sources for discovery. The agent must infer the retrieval context entirely from the 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?

readOnlyHint=true already declares this is a safe read, so the description carries a lower burden, but it adds nothing beyond that: it does not say what 'full details' includes, whether it errors on unknown IDs, or permission 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?

A single front-loaded sentence with no wasted words. It is terse rather than structured, but concision itself is not the problem here.

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

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

No output schema exists, so return values need not be explained, but the description still leaves the agent without parameter meaning, permissions, or error behavior for a detail-retrieval tool. It is inadequate given the 0% schema coverage.

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

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

Schema description coverage is 0% for both required parameters (org_id, endpoint_id), and the description adds no meaning about their format or relationship. It fails to compensate for the documentation gap.

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

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

States a specific verb and resource ('Get full details of one endpoint'), and the singular 'one endpoint' implicitly distinguishes it from the sibling list_endpoints. It does not, however, differentiate from other single-resource siblings such as get_endpoint_status or get_endpoint_missing_updates.

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

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

No guidance on when to use this versus get_endpoint_status, get_endpoint_missing_updates, or list_endpoints. The reader must infer that this returns the general record while siblings return filtered views.

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, yet the description adds real behavioral context: the return envelope ({total, offset, has_more, items}), the default/max page size (20/200), and that `contains` is a server-side filter. Missing auth/permission notes, but the pagination contract is genuinely useful.

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?

Front-loads the purpose, then packs return shape, limits, and filter semantics into two dense sentences with little waste. Slightly comma-heavy but every clause carries 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?

With no output schema, the description steps in to describe the page envelope and paging behavior, and the filter semantics fill a real schema gap. It could say more about the required identifiers and what 'updates' contain, but an agent has enough 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 0%, so the description must carry the burden. It explains `contains` (server-side text filter on item fields, e.g. CVE id/product name) and documents limit/offset via the page-size note, but says nothing about org_id or endpoint_id besides their obvious names, leaving two parameters undocumented.

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

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

States a specific verb (List) plus resource (updates missing) scoped to 'one endpoint', which meaningfully distinguishes it from siblings like list_missing_updates and list_update_missing_endpoints. It stops short of naming those siblings explicitly, but the singular-endpoint scope is 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?

Offers operational guidance ('check `total` before paging through everything'), which implies a workflow, but gives no explicit when-to-use guidance or exclusions versus the closely related list_missing_updates / list_update_missing_endpoints siblings. Usage is implied 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?

Annotations already establish readOnlyHint=true, so safety is covered. The description adds useful context that the result is an aggregate count rather than a list, but says nothing about freshness, caching, or whether disconnected/pending are disjoint categories.

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. It is efficient, though the extreme brevity leaves gaps that other dimensions penalize.

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 read tool with no output schema, the description conveys what is returned at a high level. However, it omits usage context and return-shape details (e.g., whether counts are grouped or flat), leaving the agent to infer too much for a fully complete definition.

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

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

Schema coverage is 0% and the single parameter org_id is undocumented in the schema, but the description's phrase 'for an organization' maps directly to org_id and clarifies its meaning. It adds no format or ID-type detail beyond that.

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 the resource (endpoint counts) and the exact scope (per organization) plus the dimensions counted (connected/disconnected/pending). It doesn't explicitly distinguish itself from siblings like list_endpoints or get_endpoint, but the 'counts' framing makes the aggregate nature clear enough to separate it from the listing 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?

There is no when-to-use guidance, no mention of alternatives, and no stated preconditions. The agent must infer that this is for summary/status counts rather than endpoint enumeration.

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, so the safety profile is covered. The description adds only the scope word 'enterprise-wide'; it says nothing about aggregation level, permissions required, freshness of the data, or what the usage numbers represent.

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?

It is a single six-word fragment with no padding, so there is no waste, but it is under-specified rather than genuinely concise and lacks any front-loaded verb or object to orient the 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?

With no output schema and no parameter documentation, the description is the only source of information about what this call returns, and it provides essentially nothing beyond the tool name — an agent cannot tell whether the result is totals, per-endpoint rows, or a time series.

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 takes zero parameters, so the baseline of 4 applies; there is no parameter surface the description needs to explain.

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 phrase names the resources in scope (license/endpoint usage) and the scope (enterprise-wide), but it is a noun fragment with no verb, so the agent must infer that it retrieves/aggregates these metrics. It does not distinguish itself from the many list_*/get_* siblings that also operate on endpoints and reports.

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 statement of when to call this versus alternatives such as list_endpoints, get_endpoint, or the report tools. The 'enterprise-wide' qualifier hints at aggregate scope but no condition for selection is 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?

Annotations already declare readOnlyHint=true, so the safety profile is covered. The description adds essentially nothing beyond the name: no disclosure of what a 'category definition' contains, permissions required, or how the two entity kinds are distinguished in the response.

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 wasted words. It is concise, though brevity here reflects under-specification rather than disciplined economy.

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, no parameter documentation, and only a readOnlyHint annotation, the description should do more work. It leaves the report-vs-category duality, id sourcing, and return shape all unexplained for a tool that plays a distinct role among many list_* and get_* 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 0%, so the description must carry parameter meaning, but it only says 'by id'. It does not explain the id format, whether report ids and category ids share the same namespace, or how to obtain a valid id, leaving the single required parameter effectively undocumented.

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

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

States a specific verb (Get) and resource (report/category definition), which is better than a tautology. However, the dual-nature 'report (or category)' is unexplained, and it does not clearly differentiate itself from siblings like list_reports, list_report_data, or get_data_source beyond the get/list contrast.

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 over list_reports, list_report_data, or any other sibling. The agent must infer that it fetches a single definition by id versus listing, with no conditions or alternatives named.

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, so safety is covered. Beyond that, the description adds only the org-scoping constraint and says nothing about what a miss returns, whether the CVE must exist in the org, or any error semantics. Value added over structured fields is minimal.

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 short sentence with the resource front-loaded and zero filler. It is arguably terse to the point of under-specification, but nothing in the sentence is wasted.

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-param read tool with readOnlyHint and no output schema, the description is minimally viable. It omits any indication of what detail fields are returned or how a not-found CVE is surfaced, which would help an agent decide between this and the list/search 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 coverage is 0%, so the schema documents nothing about cve_id or org_id. The description partially compensates by implying CVE identifier and organizational scope, which maps to both required params, but it gives no format (e.g., CVE-YYYY-NNNN) or org-id sourcing detail.

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+resource combination: fetch details for exactly one CVE scoped to an organization. The singular 'one CVE' implicitly contrasts with list_vulnerabilities, though the sibling is never named. An agent can tell what it does without opening the schema.

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 when-to-use guidance, no prerequisites, and no explicit routing to list_vulnerabilities for bulk retrieval or to list_vulnerability_endpoints for affected hosts. The agent must infer that this is the single-item lookup from the name alone.

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, so the safety profile is covered, and the description adds real context beyond that: the pagination envelope {total, offset, has_more, items}, the default/max limits, and that `contains` is server-side filtering on item fields rather than a client-side match. It stops short of describing item shape or auth/scope 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?

Three tight sentences with zero filler, front-loaded on what the tool returns, then pagination, then the one non-obvious parameter. Every sentence carries information an agent needs.

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 usefully supplies the return envelope and paging contract, which is the main thing an agent needs here. Remaining gaps are minor: item field composition and how org_id/instance_id should be sourced.

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

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

Schema description coverage is 0% across 5 parameters, so the description must compensate and only partly does. It explains `contains` semantics and the limit defaults/max well, but leaves org_id, instance_id, and offset's relationship to `total` unexplained.

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

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

The description states the resource precisely: per-endpoint results of one automation run, scoped by instance_id. It distinguishes itself from siblings like list_automation_instances and list_automation_schedules by narrowing to endpoint-level results, though it never uses an explicit verb like 'list'.

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

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

Usage is implied rather than stated - you call it to inspect the endpoint-level output of a run. It does give operational guidance ('check `total` before paging through everything'), but names no alternative tool and no when-not-to-use condition versus the other list_* siblings.

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

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

With readOnlyHint=true already covering the safety profile, the description adds real value: it discloses the return envelope {total, offset, has_more, items} despite no output schema, plus default/max page size and the server-side nature of `contains`. It omits auth scope and ordering of returned items, keeping it short of a 5.

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

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

Three dense sentences, front-loaded with the purpose before the return shape and filter caveat; every sentence carries information. The 'CVE id or product name for vulnerabilities' example is slightly off-topic for an automation-runs listing but is small overhead.

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 4-parameter list tool with no output schema and bare annotations, the description supplies the missing return structure, pagination contract, and filter semantics. It stops short of describing the item fields or ordering, but an agent has enough 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 coverage is 0%, so the description must carry the load, and it does for most parameters: it gives limit default 20 and a max of 200 that the schema lacks, explains `contains` as a server-side text filter over item fields with concrete examples, and ties offset/total to paging. Only org_id is left to inference.

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

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

States a specific verb and resource ('List automation runs (instances) in an organization') and disambiguates the 'instances' naming with the 'runs' gloss, which helps separate it from the sibling list_automation_schedules. It does not, however, explicitly name any sibling to contrast against.

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

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

Provides an operational tip ('check `total` before paging through everything') that implies a usage pattern, but never states when to choose this tool over list_automation_schedules or how it relates to stop_automation_instance. Usage is implied rather than directed.

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 only declare readOnlyHint=true, so the description adds real value: the exact page envelope {total, offset, has_more, items}, the limit default (20) and ceiling (200), and the fact that `contains` is a server-side filter. It does not mention auth/scope requirements, but the pagination contract is well disclosed.

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

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

Three sentences, front-loaded with purpose, then return shape, then filter guidance. The CVE/product-name example is aimed at vulnerabilities rather than schedules and reads as slightly misplaced, costing a little clarity.

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 usefully supplies the return envelope and pagination bounds, and the readOnly annotation covers safety. Missing org_id/auth context and any sibling routing keep it just short of 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 0%, so the description must carry the load. It explains limit's default and max and the semantics of `contains`, but says nothing about `offset` behavior or what org_id must reference, leaving two of four parameters undocumented.

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

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

States a specific verb and resource ('List automation schedules in an organization'), which clearly separates it from siblings like list_automation_instances or list_reports. It stops short of explicitly naming how it differs from those siblings, but the resource is unambiguous.

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

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

Offers operational advice ('check `total` before paging through everything') and explains when `contains` applies, which hints at usage. However it never states when to use this tool versus list_automation_instances or other listing siblings, so the routing guidance 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?

Annotations only declare readOnlyHint=true; the description adds substantive behavioral context beyond that: the exact pagination envelope {total, offset, has_more, items}, the default page size (20) and hard cap (200), and the fact that `contains` is evaluated server-side against the items' own fields. That is meaningful contract detail an agent could not get from annotations alone.

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

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

Three tightly packed sentences, front-loaded with the purpose and then the return/pagination contract. Every clause adds information; the only minor cost is density, with several facts compressed into a single trailing sentence.

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 steps in to describe the return envelope and paging semantics, and it covers the filter and size limits an agent needs to call this correctly. Remaining gaps (offset semantics, error behavior) are minor for a read-only list tool.

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

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

Schema description coverage is 0%, so the description carries the burden and largely meets it: it documents limit's default and max, and explains `contains` as a server-side text filter with concrete examples (CVE id, product name). Offset is not defined directly, though it is legible from the returned pagination shape, leaving one parameter only partially covered.

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 gives a specific verb+resource ('List data sources') and goes further by defining what a data source is ('PowerShell scripts agents run to feed reports'), which separates it from sibling list_reports/list_report_data. It never names an alternative tool to route between, so sibling differentiation is implied rather than explicit.

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 offers real usage advice — use `contains` as a server-side text filter and 'check `total` before paging through everything' to avoid over-fetching. However, there is no statement of when to use this tool versus list_reports, get_data_source, or other siblings, and no exclusion 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?

Annotations only declare readOnlyHint=true, so the description carries most of the burden and does well: it discloses the paginated return envelope {total, offset, has_more, items}, the default and maximum page size (20/200), and that `contains` filtering happens server-side on the items' own fields. It could still note ordering or what happens at the end of paging (has_more semantics are implied, not explained).

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

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

Three sentences, front-loaded with scope, then pagination facts, then the filter caveat; nothing is padded. Slightly dense in the last sentence, but every clause carries 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?

With no output schema and only a readOnlyHint annotation, the description supplies the response shape, paging limits, and filter semantics the agent needs. It is close to complete, missing only ordering/paging-termination details and any mention of cross-tool selection.

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

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

Schema description coverage is 0%, so the description must compensate, and it does for the two non-obvious parameters: `contains` is defined as a server-side text filter over items' own fields with an example, and `limit` is given its default (20) and cap (200). The required org_id and group_id are left to their names, which is reasonable but leaves them unverified.

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 gives a clear verb+resource ('List endpoints in an endpoint group') that resolves the ambiguity of 'members' in the tool name. It does not, however, distinguish itself from nearby siblings like list_endpoints or list_endpoint_groups by stating when its scoped view is the right one.

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 offers practical usage advice ('check `total` before paging through everything') and explains what `contains` is for, but never states when to pick this tool over list_endpoints / list_endpoint_groups or what conditions make a group-scoped listing necessary.

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 readOnlyHint=true already declaring the safe-read profile, the description adds real context beyond annotations: the pagination envelope {total, offset, has_more, items}, the default/max page size, and that `contains` is a server-side filter rather than client-side. It does not disclose auth or rate-limit behavior, but the added value is substantial.

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

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

Three tight sentences, front-loaded with the core action, then return shape, then filter semantics. No filler, though the parenthetical about vulnerability fields is slightly tangential for an endpoint-group tool.

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

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

No output schema exists, yet the description describes the return envelope and pagination fields, and it covers the filter parameter's behavior. Combined with a simple read-only, four-parameter schema, an agent has what it needs to call this correctly.

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

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

Schema description coverage is 0%, so the description must carry parameter meaning. It documents limit's default (20) and cap (200), reveals offset through the paging envelope, and explains `contains` semantics with examples (CVE id, product name). org_id is only implied by 'in an organization'.

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 and resource: 'List endpoint groups in an organization.' The resource is distinct from siblings like list_endpoints or list_endpoint_group_members, though it doesn't explicitly name those siblings to draw the boundary.

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

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

Provides operational guidance ('check `total` before paging through everything') and explains what `contains` filters on, which is genuinely useful. However, it never says when to prefer this tool over list_endpoint_group_members or list_endpoints, 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?

Annotations only declare readOnlyHint, so the description carries the rest and delivers: the pagination envelope {total, offset, has_more, items}, the limit default of 20 with a hard max of 200, and the fact that `contains` is a server-side filter. It does not disclose rate limits or auth requirements beyond org_id being required, but the added context is substantial.

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

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

Three dense sentences, front-loaded with the purpose, then return shape, then filtering/paging advice. Every sentence carries information, though the parenthetical CVE example adds mild noise for a software-inventory tool.

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

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

With no output schema, the description usefully supplies the response envelope and the pagination contract, which an agent needs to page correctly. It stops short of describing what fields each item contains (name, version, vendor, etc.) or what 'installed' excludes.

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

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

Schema description coverage is 0% across 5 params, so the description must compensate. It documents `limit` (default 20, max 200) and `contains` (server-side text filter on item fields), but org_id, endpoint_id, and offset are left to inference, and the `contains` example (CVE id) is borrowed from a different resource and may mislead for an installed-software listing.

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 (software installed) with an explicit scope qualifier (on one endpoint), which cleanly separates it from org-wide siblings like list_vulnerabilities or list_missing_updates. An agent can pick this tool without opening the schema.

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?

Gives practical invocation guidance for paging (check `total` before paging through everything) and explains what `contains` filters against, but never states when to choose this tool over list_missing_updates, list_vulnerabilities, or get_endpoint. Usage is implied rather than contrasted with alternatives.

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

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

Annotations only declare readOnlyHint=true, and the description adds real behavioral context beyond that: the pagination envelope shape, the default and maximum page size, and the fact that `contains` is server-side filtering on item fields. It stops short of noting ordering, permissions, or what happens with an unknown org_id.

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

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

Three dense sentences, front-loaded with the purpose, then return shape, then the trickiest parameter. The CVE/product example for `contains` is slightly tangential for an endpoints listing and costs a few words, but nothing is 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?

With no output schema, the description must explain returns, and it does so via the {total, offset, has_more, items} envelope. For a read-only list tool with one required id this is close to sufficient, lacking only item-field detail and result ordering.

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

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

Schema description coverage is 0%, so the description carries the full burden and largely does: it documents `limit` (default 20, max 200), the paging role of `offset`, and the exact semantics of `contains` as a server-side filter on the items' own fields. `org_id` is left unexplained, though its meaning is self-evident from context.

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 and resource ('List all managed endpoints (computers)') plus the scope ('in an organization'), so an agent can distinguish it from get_endpoint without opening a schema. It does not explicitly name or contrast with siblings, so it falls short of the top mark.

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

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

Usage is implied rather than spelled out: it advises checking `total` before paging and explains what `contains` filters, which helps correct invocation. It never says when to prefer this tool over list_endpoint_group_members, list_vulnerability_endpoints, or search, so no explicit alternative routing 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?

readOnlyHint=true already signals a safe read, and the description meaningfully adds the paged return shape {total, offset, has_more, items}, the limit bounds (default 20, max 200), and that `contains` is a server-side filter over item fields. This goes beyond the annotation with concrete paging/filter behavior; only rate limits or auth needs are absent.

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

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

Three tight sentences, front-loaded with purpose before mechanics, and each sentence carries distinct information (purpose, return shape/bounds, filter semantics plus paging advice). No filler.

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

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

With no output schema, the description usefully describes the page envelope and the `total` field that gates paging, plus filter semantics. It is nearly complete; only the meaning of `offset`/`org_id` and the nature of returned items are left implicit.

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

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

Schema description coverage is 0%, so the description carries the param burden. It documents `limit` (default 20, max 200), implies `offset` via the paging guidance, and explains `contains` as a server-side text filter with examples; only `org_id` is left to its self-evident name.

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 clear verb (List) and specific resource (missing OS/third-party updates) scoped 'across an organization', which implicitly separates it from endpoint-level siblings like list_endpoint_missing_updates. However, it never names an alternative tool, so the differentiation from list_vulnerabilities and the endpoint-scoped siblings is left to inference.

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

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

Provides operational guidance ('check `total` before paging through everything') and explains what `contains` filters on, which implies how to page efficiently. It does not state when to prefer this org-wide listing over list_update_missing_endpoints or list_vulnerability_endpoints, so alternative-selection guidance is missing.

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 only declare readOnlyHint=true, but the description adds the actual response envelope ({total, offset, has_more, items}), the page-size bounds (default 20, max 200), and the fact that `contains` filters server-side on the items' own fields. That is material behavior an agent needs and cannot get from 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?

Three front-loaded sentences with no filler, and the most important instruction (call first) leads. The `contains` clause is information-dense with nested parentheticals, which slightly taxes readability but every clause carries 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?

There is no output schema, so the description compensates by describing the pagination envelope and how to decide whether to page. Combined with the readOnlyHint annotation and the call-order guidance, an agent has everything needed to invoke this 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 0%, so the description must carry the load: it documents `limit` (default 20, max 200) and `contains` (server-side filter over item fields, with a CVE/product example). `offset` is only implied by the paging envelope, so one parameter remains under-explained.

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+resource ('List all organizations') and immediately positions the tool in the workflow ('Call this first to get the org_id other tools need'), which distinguishes it from every other list_* sibling that requires an org context.

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

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

Explicitly prescribes calling order ('call this first') and the downstream reason (other tools need org_id). It also gives concrete filtering advice — use `contains` for server-side text filtering and check `total` before paging — so an agent knows exactly when and how to invoke it.

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

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

Annotations declare readOnlyHint=true, so the safety profile is covered; the description adds value beyond that by disclosing the return envelope {total, offset, has_more, items}, the limit default of 20 with a max of 200, and the fact that `contains` is applied server-side over item fields. It does not state auth/permission requirements, which is a minor gap for a read tool.

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

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

Two dense sentences with zero filler: the return shape and paging advice come first, then the non-obvious `contains` semantics. Nothing is redundant with the schema or the name.

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?

No output schema exists, and the description compensates by describing the page envelope and has_more flag, which is what an agent needs to page correctly. Combined with the max-limit and filter semantics, it is nearly complete; only permission requirements and behavior for large reports are unaddressed.

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

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

With 0% schema description coverage, the description carries the burden and does substantively: `contains` is explained as a server-side text filter on item fields with concrete examples (CVE id, product name), and `limit` is given both default and ceiling. offset/org_id/report_id are left to name inference, which keeps it short of a 5.

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+resource ('Get the rows of a report for an organization'), which is meaningfully distinct from listing report metadata. It doesn't explicitly name the sibling it is not (list_reports, get_report_or_category), so an agent must still infer the boundary, but the resource is precise.

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?

Gives real usage guidance for pagination ('check `total` before paging through everything'), which is genuinely actionable. However, it offers no when-to-use/when-not guidance relative to list_reports, get_report_or_category, or requery_report, so tool selection among siblings is left to 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 only declare readOnlyHint=true; the description adds the return envelope ({total, offset, has_more, items}), the pagination bounds (default 20, max 200), and that `contains` is a server-side filter on the items' own fields. That is substantive behavior beyond the annotation, though nothing is said about error content shape or rate limits.

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

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

A single tightly packed paragraph, front-loaded with the purpose and then pagination and filter details. Every sentence carries information, though the backtick-laden filter sentence is dense enough to slow reading.

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, zero annotation detail beyond read-only, and 0% schema coverage on 5 params, the description carries the full burden. It covers the return envelope and one parameter but leaves the identity/paging parameters unexplained for an agent that cannot fall back on structured docs.

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

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

Schema description coverage is 0% across 5 parameters, so the description must compensate. It explains `limit` bounds and `contains` semantics well, but says nothing about `org_id`, `report_id`, or `offset`, leaving three parameters entirely undocumented.

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

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

The description gives a precise verb+resource+scope: endpoints where a report's data source script failed, including the error. This implicitly separates it from list_report_data (which returns successful data), but no sibling is named, so an agent must infer the boundary.

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 operational guidance ('check `total` before paging through everything') but no explicit when-to-use vs. when-not-to-use guidance against siblings like list_report_data or requery_report. Usage is implied by the narrow purpose 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?

Annotations only supply readOnlyHint=true, so the description carries the rest. It discloses the return envelope {total, offset, has_more, items}, the limit default of 20 with a max of 200, and that 'contains' is a server-side filter on item fields – solid behavioral context beyond the annotation.

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

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

Three tight sentences, front-loaded with the purpose, then return shape, then the filter/paging tip. No filler, though the parenthetical CVE/product example is slightly tangential to a reports list.

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 usefully specifies the return envelope and pagination semantics, plus the filter behavior. It is close to complete for a read-only list tool, missing only explicit routing guidance versus sibling listers.

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

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

Schema coverage is 0%, so the description must compensate, and it largely does: it explains 'contains' as a server-side text filter over item fields and documents limit's default and cap. 'offset' is only implied by the return shape rather than explained, leaving a small gap.

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

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

States a specific verb and resource ('List available reports and report categories'), which is clearer than a bare name restatement. It doesn't explicitly differentiate itself from close siblings like list_report_data or get_report_or_category, but the mention of 'report categories' provides meaningful 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?

Provides operational guidance on filtering ('contains' is a server-side filter) and paging ('check total before paging through everything'), which is genuinely useful. However, it never states when to use this tool versus list_report_data, get_report_or_category, or list_report_errors, so tool selection is left to 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 declare readOnlyHint=true, and the description usefully adds the pagination shape {total, offset, has_more, items} plus the limit default/max. However, the illustrative filter example ('CVE id or product name for vulnerabilities') is misplaced on a roles tool and risks confusing the agent about what is being listed.

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?

Front-loads the core purpose ('List roles') then layers return shape and paging advice in an economical two-sentence block. The CVE/product clause is off-topic noise that slightly dilutes otherwise tight phrasing.

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 present, the description steps in to define the return envelope and document pagination bounds, which is the key missing structure for a low-complexity list tool. Only the unexplained `offset` keeps it from being fully complete.

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

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

Schema description coverage is 0%, so the description must carry the parameter burden. It explains `contains` as a server-side text filter and gives limit bounds (default 20, max 200), but leaves `offset` unexplained, leaving one of three parameters undocumented.

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

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

States a clear verb+resource ('List roles'), so an agent knows exactly what it retrieves. It does not differentiate itself from the many sibling list_* tools, but the purpose itself is unambiguous.

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

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

Implied usage only: it hints at a paging workflow ('check `total` before paging through everything') and describes the `contains` filter, but never states when to use this tool versus siblings or what preconditions apply.

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

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

Annotations already declare readOnlyHint=true, so the safety profile is covered. The description adds genuinely new behavioral context beyond annotations and schema: the response envelope ({total, offset, has_more, items}), the enforced limit ceiling of 200 (schema only shows default 20), and the fact that `contains` filtering happens server-side on item fields.

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

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

Three sentences, front-loaded with purpose, then response shape, then filter semantics; little waste. Slightly dense but each clause carries information an agent cannot get from the structured fields.

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

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

With no output schema, the description usefully documents the pagination envelope and the max limit, and it clarifies the ambiguous `contains` param. The remaining gap is the meaning and expected format of the required package_id/version_id identifiers, which an agent must still infer.

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

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

Schema coverage is 0%, so the description carries the full burden, yet only `contains` (with example field targets) and `limit` (max 200) receive explanation. The three required parameters org_id, package_id and version_id, plus `offset`, are left completely unexplained, so compensation is partial.

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 and resource with a qualifying scope: endpoints missing one particular update package version. This implicitly distinguishes it from the loosely-scoped sibling list_missing_updates, but no sibling is named or explicitly excluded, so it lands at 4 rather than 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?

Provides a real operational hint ('check total before paging through everything') and explains that `contains` is a server-side text filter, which implies when the filter is worth using. However, it never says when to choose this tool over list_missing_updates or get_endpoint_missing_updates, so usage 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?

Goes well beyond the readOnlyHint annotation by disclosing the response envelope ({total, offset, has_more, items}), pagination bounds (limit default 20, max 200), and that `contains` is a server-side filter on item fields. The only gap is no visibility into auth or rate limits.

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

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

Front-loads purpose and packs return shape plus filter behavior into a compact space with no filler. However, the illustrative example '(e.g. CVE id or product name for vulnerabilities)' is irrelevant to a users listing and reads as boilerplate copied from another tool, which muddies an otherwise efficient entry.

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 usefully documents the return envelope and pagination contract, and covers the non-obvious `contains` parameter. The missing piece is any `offset` explanation, but overall it is complete enough to call 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 coverage is 0%, so the description must carry all parameter meaning. It explains `contains` (server-side text filter) and bounds `limit` (default 20, max 200) but says nothing about `offset` semantics. Partial compensation for the coverage gap.

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

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

States a clear verb+resource ('List console users'), which is easy to distinguish from the mostly non-user siblings. It does not explicitly contrast itself with other list_* tools, but the resource is specific enough that an agent can identify it.

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

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

Provides practical usage advice ('check `total` before paging through everything') and explains the purpose of `contains`, which implies a filtering workflow. However, it never states when to use this vs. alternatives or any exclusions, so guidance 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 readOnlyHint=true already covering the safety profile, the description adds real context: the pagination envelope {total, offset, has_more, items}, the limit default 20 / max 200, and the fact that `contains` is a server-side filter on item fields. It omits auth requirements, rate limits, and item field shape, so it stops short of 5.

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

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

Three sentences, zero filler, front-loaded with the resource and scope before the pagination and filter mechanics. Every clause (envelope shape, limit bounds, filter semantics, total-check tip) adds information an agent needs.

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?

No output schema exists, and the description compensates by describing the return envelope and pagination contract, plus filter semantics. Missing only item-level field detail and ordering/authorization context, which is minor for a read-only list tool.

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

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

Schema coverage is 0%, so the description carries the full burden and largely does: it documents `limit` (default 20, max 200), `offset` (implicitly via the paging envelope), and `contains` as a server-side text filter on item fields with examples. Only `org_id` is left unexplained, which is self-evident from the tool's stated organization scope.

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 and resource ('List vulnerabilities (CVEs)') plus scope ('detected in an organization'), which separates it from get_vulnerability and list_vulnerability_endpoints by implication. It does not explicitly name those siblings or contrast its per-CVE view with the per-endpoint view, so it falls short of full sibling differentiation.

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

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

Offers one genuine usage tip ('check `total` before paging through everything') and implies a paging workflow, but never states when to use this tool versus list_vulnerability_endpoints or get_vulnerability, and gives no prerequisites. Usage is implied rather than 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?

Annotations already cover the read-only safety profile, so the bar is lower, and the description adds genuinely useful behavior: the exact page envelope {total, offset, has_more, items} even though there's no output schema, the default/max limit, and that `contains` is a server-side filter on items' own fields. It stops short of noting auth/org-scoping 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?

Front-loads the purpose, then the return shape, then the filter tip in three tight sentences with no filler. The parenthetical pagination detail is dense but earns its place given the absence of an output 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 5-param read tool with no output schema, the description covers the return envelope, pagination limits, and the non-obvious `contains` filter well. It is only slightly incomplete on org_id/cve_id semantics, which are largely self-explanatory.

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

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

Schema description coverage is 0%, so the description must carry parameter meaning. It explains `contains` in detail and gives the limit default (20) and max (200), but says nothing about offset, org_id, or cve_id semantics, leaving several parameters undefined in both places.

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 and resource: list endpoints affected by a CVE. An agent can tell it apart from list_vulnerabilities and list_update_missing_endpoints by the resource being endpoints-of-a-CVE. It never names a sibling explicitly, so differentiation relies on inference.

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

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

Provides an efficiency tip ('check total before paging through everything') that guides pagination usage. But it gives no when-to-use-vs-alternatives guidance relative to list_vulnerabilities, get_vulnerability, or list_endpoints, so selection between siblings is 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?

Annotations already declare this is a non-read-only, non-destructive write, so the safety profile is covered. The description usefully adds upsert semantics (data_source_id updates in place, dependent reports auto-pick up new columns), but omits side effects on existing scripts, authorization needs, and rate/limits.

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

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

Two tight sentences, front-loaded with the primary action and the conditional extras. No filler, though the parenthetical clause is slightly dense.

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 5-param mutation tool with no output schema and no param descriptions, the description covers the conditional params but says nothing about required params (name/script/columns), return values, or error behavior. Adequate but with visible 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 0% across 5 params, so the description has to carry the load. It explains data_source_id (in-place update) and report_name (optional report) and implies what columns does, but leaves name and script (the PowerShell content) unexplained.

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

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

States a specific verb+resource: publishes a PowerShell script as an Action1 data source and optionally a custom report. It clearly contrasts with the list_/get_data_source siblings by being the only publish/create-style tool, though it doesn't name a sibling explicitly.

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?

Gives concrete conditional guidance: pass report_name to also build a custom report, and pass data_source_id to update an existing source in place rather than create a new one. It does not address alternatives or prerequisites like permissions.

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=false and destructiveHint=true, so the write/action nature is covered structurally. The description adds useful context that this instructs remote agents to re-run a script 'now', but it does not explain what the destructive hint means in practice (data overwrite, irreversibility) or the async/remote nature of the trigger.

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 padding. The word 'agents' is slightly ambiguous (endpoint agents vs. caller agents), which keeps it from a top score.

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 an action tool flagged destructive with two undocumented parameters, the description is too thin; an output schema exists so return values need not be explained, but the trigger semantics and destructive implications remain unaddressed.

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

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

Schema description coverage is 0%, so the description carries the full burden for org_id and report_id, yet it adds no explicit meaning beyond what the self-descriptive names imply. Neither parameter's format nor expected values are clarified.

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 (re-run) on a specific resource (the report's data source script), which is clearer than a bare name. It does not, however, distinguish itself from related siblings such as run_script or list_report_data, leaving the agent to infer the 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?

There is no when-to-use, when-not-to-use, or alternative-tool guidance. The agent is given the action but no context about when re-querying is warranted versus reading existing report data.

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?

Goes well beyond the destructiveHint=true/readOnlyHint=false annotations: it discloses SYSTEM privilege, synchronous wait semantics, stdout truncation at ~10,000 chars, 'never reboots', and that offline endpoints remain pending. These are exactly the operational traits an agent needs before firing a remote script.

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?

Four tight sentences, front-loaded with the action and privilege context, with no filler. Each clause (return format, no reboot, offline handling) carries distinct operational 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 destructive synchronous mutation with no output schema, the description covers privilege level, return shape (status + capped stdout), reboot behavior, and the async/offline path. Nothing an agent needs to call it safely and 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 coverage is 0%, so the description must carry the load. It clarifies wait_seconds ('wait up to wait_seconds') and endpoint_ids provenance (ids from list_endpoints) and implies script is PowerShell, but org_id is entirely unexplained and no formats/defaults are given, so the low-coverage schema is only partially compensated.

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

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

States a specific verb (Run), resource (PowerShell script), execution target (given endpoints) and privilege context (as SYSTEM, now = synchronous). This clearly separates it from siblings like deploy_updates (patch deployment) and the list_* read 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?

Gives concrete routing: endpoint ids come from list_endpoints, and offline endpoints 'stay pending - check later with list_automation_instance_endpoint_results(instance_id)'. This is real alternative/context guidance, though it never explicitly states when to prefer this over a scheduled automation or deploy_updates.

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?

readOnlyHint=true already tells the agent this is a safe read, and the description only adds the organizational scope. It discloses nothing about pagination behavior tied to 'limit', result ranking, or how matches across different entity types are returned.

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 scope qualifier sits at the end where it belongs. It is efficient, though arguably undersized given the documentation gaps elsewhere.

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?

An output schema exists so return values need no explanation, but for a three-parameter tool with zero schema descriptions the entry is thin. It omits query format, limit semantics, and any routing advice, leaving the agent under-informed despite the low structural complexity.

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

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

Schema description coverage is 0% across three parameters, so the description carries the full burden and fails to meet it. 'query' and 'org_id' are only loosely implied by 'full-text search... in an organization', and 'limit' is never addressed at all.

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 (full-text search) and resource scope (endpoints, software, in an organization), which is enough to separate it from the list_*/get_* siblings. The trailing 'etc.' weakens precision about exactly what entity types are searchable, but the core purpose is unambiguous.

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

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

The description gives no when-to-use guidance and never names an alternative. An agent cannot tell from this text whether 'search' is preferred over list_endpoints or get_endpoint for a given lookup, or what query syntax is expected.

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, so the interruption profile is known. The description adds that the target is a *running* automation (via deploy_updates/run_script), but does not say what happens to partial work, whether the stop is reversible, or what permissions are needed.

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 short sentence, front-loaded with the verb and resource. Efficient, though the parenthetical example is slightly loose ('run' vs. an instance) rather than wasteful.

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

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

For a destructive mutation tool with no output schema and two undocumented required params, the description is too thin. It never clarifies what an 'instance' is, how to obtain instance_id, or the effect of stopping mid-run, leaving key operational 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 0% and neither org_id nor instance_id is explained in the description. With two required params fully undocumented in both places, the description fails to compensate for the coverage gap.

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

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

States a specific verb and resource ('Stop a running automation') and grounds it with concrete examples (deploy_updates, run_script runs). An agent can distinguish it from the actual deploy/run siblings, though it does not name them as distinct 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?

Implied usage is clear from context ('a running automation'), but there is no explicit when/when-not guidance, no mention of prerequisites, and no routing to alternatives such as listing instances before stopping one.

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