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

No annotations are provided, so the description carries the full behavioral burden, yet it discloses nothing beyond the bare action. It does not say whether the comment is attributed to the caller, whether it notifies watchers, whether comments are editable or deletable afterwards, or what the call returns.

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 single short sentence is front-loaded and waste-free, but its brevity reflects under-specification rather than disciplined editing. There is no structure to speak of for a mutating operation.

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

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

For a write operation with no annotations and no output schema, the definition leaves critical gaps: success/failure behavior, side effects on ticket state or notifications, and any permission requirements are all unstated. Given the tool's complexity is low, only minimal context is needed, but even that is absent.

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

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

Schema coverage is 100% with both ticket_id and comment documented, so the schema already explains the inputs. The description adds nothing about ID format, comment length limits or accepted content, which is the baseline 3 for fully documented parameters.

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

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

States a specific verb (add) and resource (comment on a ticket), which is clearly distinct from the sibling create_ticket, update_ticket and get_ticket tools. It stops short of differentiating itself explicitly, but the action 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?

There is no guidance on when to use this instead of update_ticket or create_ticket, no preconditions such as ticket state or required permissions, and no mention of alternatives. The agent must infer the usage context entirely.

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

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

No annotations are provided, so the description carries the full burden. It states this is a GET, but does not disclose authentication requirements, rate limits, error behavior, response shape, or whether arbitrary paths may expose sensitive data.

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 clearly communicates the core operation without 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 an unrestricted API passthrough with no annotations and no output schema, the description is missing important context about permissions, error handling, and when dedicated tools should be preferred. It is enough to understand the basic mechanism but not enough to use it safely and correctly.

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

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

Schema coverage is 100%: the path parameter is documented with an example in the schema. The description adds only that any endpoint is allowed, without format constraints or path validation rules, so baseline 3 is appropriate.

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

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

States a specific verb ('GET') and resource ('NinjaOne API endpoint'), and implicitly contrasts with the api_post sibling. However, it does not distinguish itself from the many dedicated get_* tools such as get_device or get_ticket.

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 generic endpoint versus the dedicated sibling tools like get_device, list_devices, or get_ticket. The agent must infer that this is a fallback for endpoints without a dedicated tool.

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

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

No annotations at all, so the description carries the full burden for what is a write operation. It says nothing about authentication requirements, whether arbitrary writes can be destructive or irreversible, rate limits, or error behavior on an invalid path or body. For an unannotated raw-POST escape hatch, that is a substantial omission.

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 verb and resource come first. It is not padded, though its brevity is a symptom of the missing guidance rather than a virtue here.

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

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

With no annotations, no output schema, a nested request body, and fully arbitrary endpoint targeting, the definition leaves out too much an agent needs before calling: path formatting conventions, auth assumptions, and what a call actually returns or how failures surface.

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

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

Schema coverage is 100% and both parameters carry descriptions ('API endpoint path', 'Request body'), so the schema does the heavy lifting. The description adds no extra meaning such as path format, versioning prefix, or body shape, so the baseline 3 applies.

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

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

States a specific verb and resource: a POST request to a NinjaOne API endpoint. This clearly separates it from api_get (read) and from the purpose-built siblings like reboot_device or create_ticket. The only shortfall is that 'any endpoint' leaves the scope open, which is inherent to an escape-hatch tool.

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

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

There is no guidance on when to reach for this tool instead of a dedicated sibling such as create_ticket or reboot_device, nor on when it should be avoided. 'Generic ... any endpoint' hints it is a fallback, but the agent has to infer that with no statement of prerequisites or exclusions.

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

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

With no annotations, the description carries the full behavioral burden, yet says nothing about required fields, permissions, side effects (notifications?), or what is returned on success. For a mutation tool with zero annotation coverage this is a significant gap.

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

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

A single short sentence with the verb and resource front-loaded and zero bloat. It is efficient, though its brevity is partly under-specification rather than disciplined density.

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?

A 3-parameter mutation tool with no annotations and no output schema needs at least a note on required fields, side effects, or the resulting ticket. The description leaves the agent without enough context to call it confidently.

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

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

Schema coverage is 100%, so 'title', 'priority', and 'description' are already documented in the schema and the description adds nothing beyond them. Baseline 3 applies when the schema does all the work.

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

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

States a specific verb ('Create') and resource ('support ticket'), so the agent knows exactly what the tool does. It does not differentiate itself from siblings like get_ticket or update_ticket, but the create-vs-read-vs-update distinction is implicit in the verb.

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 create a ticket versus when to use update_ticket or add_ticket_comment on an existing one, and no prerequisites or context for ticket creation. The agent must infer usage from the sibling names 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?

No annotations are provided, so the description carries the full burden. It discloses the 'active' filter, which is real behavioral information, but says nothing about pagination limits, default page size, total counts, or retry/rate-limit behavior for what could be a very large fleet-wide result set.

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 constraint ('across all devices') is stated immediately. It is arguably under-specified rather than padded, which is the better failure mode for conciseness.

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

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

With no annotations and no output schema, the description is the only source of behavioral context, and it omits result shape, pagination semantics, and result volume expectations for a potentially unbounded fleet-wide query. Adequate to identify the tool, not adequate to invoke it safely at scale.

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

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

Schema description coverage is 100% for both pagination parameters, so the schema already does the explanatory work. The description adds no guidance on defaults, maximum page size, or whether omitting the params returns everything, so baseline 3 is appropriate.

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

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

Specific verb ('Get') plus resource ('all active alerts') plus scope ('across all devices'), which implicitly separates it from the sibling get_device_alerts. It does not explicitly name the sibling, but an agent can tell this is the fleet-wide listing versus the per-device variant.

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

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

The phrase 'across all devices' implies the usage context (use this for org-wide triage, get_device_alerts for one device), but there is no explicit when-to-use or when-not statement, and no mention of whether results should normally be paginated through.

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

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

No annotations are provided, so the description carries the full disclosure burden, yet it says nothing about read-only safety, scope of the report, whether results are per-device or organization-wide, or what data is included. For a zero-parameter aggregate query, the scope of what is returned is precisely the missing behavior an agent needs.

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

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

A single short sentence with no filler and the action front-loaded. It is efficient, though its brevity reflects under-specification rather than disciplined editing.

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 should at least sketch what the status report contains and at what granularity; it does neither. With zero annotations and zero parameters, the description is the only channel for context and it provides almost none.

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 no parameters, so there is nothing for the description to disambiguate; baseline 4 applies. The empty schema is internally consistent with the description.

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 antivirus status report'), so the basic action is understandable. However, it gives no scope (fleet-wide vs. single device) and does not differentiate itself from nearby siblings such as get_device_health, get_device_alerts, or get_all_alerts.

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 indication of when this tool should be used versus get_device_health, get_device_alerts, or get_all_alerts, nor any prerequisite or exclusion. The agent must infer usage 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?

No annotations are provided, so the description carries the full behavioral burden, yet it says nothing about what 'detailed information' includes, whether it errors on unknown IDs, or whether any auth scope is needed. The read-only nature is only weakly implied by 'Get'.

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

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

One short, front-loaded sentence with no waste. It is efficient, though its brevity is achieved by omitting information rather than by 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 annotations and no output schema, the description should say roughly what comes back and whether the ID must be discovered first. 'Detailed information' leaves an agent guessing about the payload.

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

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

Schema coverage is 100% and the single parameter's description already names NinjaOne as the ID source. The tool description adds nothing beyond the schema, so the baseline 3 applies.

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

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

Clear verb+resource: retrieve details for one specific device. The word "specific" implicitly distinguishes it from list_devices and search_devices, but it never names those siblings 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?

Usage is only implied: an agent can infer this is the lookup-by-ID path rather than a bulk listing. No explicit when-to-use vs when-to-use-something-else guidance, and no mention that device_id must come from list_devices/search_devices.

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

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

No annotations exist, so the description carries the full behavioral burden. The word 'active' hints at a filter (excluding resolved/dismissed alerts) but this is never defined, and nothing is said about permissions, pagination, or what the response contains for a read tool with no output schema.

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

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

A single short sentence with the scope constraint front-loaded and no filler. Nothing could be removed without losing information.

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

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

For a simple one-parameter read this is close to adequate, but with no annotations and no output schema the description should say what 'active' means and roughly what comes back. It leaves the return shape and the definition of 'active' entirely unspecified.

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?

Only one parameter (device_id) with 100% schema description coverage, so the schema already covers it. The description adds nothing beyond confirming the alert scope is device-level; baseline 3 applies.

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

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

States a specific verb and resource ('Get active alerts') scoped to a device, which implicitly separates it from the sibling get_all_alerts. It never names that sibling explicitly, so the differentiation is left partly 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?

There is no when-to-use guidance, no mention of get_all_alerts as the alternative for cross-device queries, and no preconditions stated. The agent must infer routing from the word 'specific device' 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?

No annotations are provided, so the description carries the full behavioral burden and discloses almost nothing: not whether this is a snapshot or historical trend, not what metrics are returned, not whether permissions are required, and not whether it is expensive or rate-limited. 'Report' hints at an aggregate payload but the agent cannot predict shape or cost.

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

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

A single front-loaded sentence with no filler or redundancy. It is arguably too terse given the total absence of annotations, but nothing in it 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?

With no annotations, no output schema, and no parameters at all, the description is the only source of information about this tool — yet it says nothing about the return contents, the targeting of the device, or the safety profile. An agent cannot call this confidently or know what it will receive.

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

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

The input schema is empty (0 parameters) and schema coverage is 100%, so the baseline is 4 and there are no parameters for the description to explain. The only residual concern is that with zero parameters it is unclear which device the report targets, which is a completeness issue rather than a parameter-documentation one.

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 ('device health report'), so the agent knows this is a read of health data rather than raw device attributes. However, it never differentiates itself from near-neighbors like get_device, get_device_alerts, or get_antivirus_status, and never defines what 'health' comprises.

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 exclusions, and no mention of the obvious alternatives (get_device_alerts, get_antivirus_status, get_os_patches) that also surface device condition data. The agent must infer selection purely from the tool name.

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

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

With no annotations, the description carries the full burden, and it only implies read-only behavior via the word 'Get'. It says nothing about permissions, pagination, result freshness, or whether the inventory is truncated for large devices.

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 — nothing wasted, but also nothing beyond the minimum. Brevity here is efficient rather than padded.

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

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

For a tool with zero annotations, no output schema, and no documentation of what 'software inventory' contains (application names, versions, install dates?), the description is too thin. An agent cannot predict the response shape or scope before calling it.

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

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

There is a single required parameter with 100% schema description coverage, so the schema already handles it; the description adds no format, sourcing, or lookup hints beyond 'for a device'. Baseline 3 applies per the high-coverage rule.

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

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

The description names a specific verb and resource ('Get software inventory for a device'), which is clearly distinguishable from write operations like reboot_device or run_script. However, it doesn't differentiate from adjacent device read tools such as get_device or get_os_patches, so the 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 no explicit when-to-use guidance, no prerequisites, and no pointer to alternatives despite many device-related siblings (get_device_health, get_antivirus_status, get_os_patches). The only usage signal is the implicit 'pass a device_id to get its software'.

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

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

No annotations are provided, so the description carries the full behavioral burden and it discloses nothing. It does not confirm this is a read-only operation, mention permission/auth requirements, or indicate what happens when the org_id is unknown (error vs empty).

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 words, front-loaded, with zero filler or repetition. It is efficient, though the terseness borders on under-specification rather than true 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?

For a trivial single-parameter getter the description is minimally adequate, but with no output schema and no indication of what "details" comprises, the agent cannot anticipate the response shape. A short clause on returned fields or error behavior would close the gap.

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

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

There is exactly one parameter with 100% schema description coverage, so the schema already documents org_id. The description adds no format hints (e.g., UUID vs numeric ID) or constraints beyond that, making the baseline 3 appropriate.

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

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

The description has a verb ("Get") and a resource ("organization details"), which is better than a tautology, but "details" is vague about what is actually returned. It also does nothing to distinguish itself from the sibling list_organizations, so an agent must infer that this one takes a single org_id and returns one record.

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 use this tool versus list_organizations, nor any prerequisite or context. The agent must infer from the required org_id alone that this fetches a single organization rather than enumerating them.

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

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

No annotations are provided, so the description carries the full disclosure burden, and it contributes almost nothing beyond 'status' — no indication of what status fields are returned, whether results are cached, whether auth or permissions are required, or whether missing patches are included.

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, which is appropriate in size. It is arguably too terse rather than too long, but nothing 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 one-parameter read tool with no output schema this is nearly adequate, but the word 'status' is left undefined and there is no behavioral or scoping context. A sentence on what the status covers and how it differs from software patches would close the gap.

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

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

Schema coverage is 100%, and the schema documents device_id, so the baseline of 3 applies. The phrase 'for a device' merely restates the required parameter without adding format or source-of-ID 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?

The description states a specific verb and resource ('Get OS patches status') scoped to a device, which is clearly actionable. However, it does not distinguish itself from the sibling get_software_patches, leaving the OS-vs-software patch scope ambiguous.

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

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

There is no guidance on when to use this tool versus get_software_patches or get_device_software, nor any stated prerequisites. The agent must infer the choice 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?

With no annotations, the description carries the full burden of behavioral disclosure and does not state that this is a read-only operation, whether results are paginated or complete, or what shape the patch status takes (installed vs missing, counts, timestamps).

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 efficient, though its brevity contributes to the missing differentiation and behavioral detail.

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

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

A read tool with no annotations and no output schema needs the description to explain the return content and how it differs from get_os_patches; neither is covered. For an agent choosing among several patch/software tools, this is under-specified.

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

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

Only one parameter and schema description coverage is 100%, so the schema already documents device_id fully. The description's 'for a device' merely echoes that; baseline 3 applies since no additional semantics are needed or added.

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 (software patches) scoped to a device, which is clearer than a bare name restatement. However, it never distinguishes itself from the sibling get_os_patches (or get_device_software), so an agent cannot tell from the text alone which patch tool applies.

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, and no mention of the obvious alternative get_os_patches. The agent is left to guess between two similarly named patch tools.

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

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

No annotations are provided, so the description carries the full behavioral burden, yet it discloses nothing about read-only safety, required permissions, error behavior for missing tickets, or what 'details' includes. For a tool with zero annotation coverage, this is a substantial gap.

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

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

The single sentence is front-loaded and wastes no words, but its brevity reflects under-specification rather than efficiency. It could easily carry one more sentence of routing or return-value context.

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 annotations, the description should explain what a 'ticket detail' record contains and how it differs from list-oriented siblings. Neither is covered, leaving the agent to guess at the return payload.

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

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

Schema coverage is 100% and the single ticket_id parameter is documented in the schema itself, so the baseline of 3 applies. The description adds no meaning beyond the schema, such as ID format or source of the ID.

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

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

The description names a specific verb and resource ("Get ticket details"), so the basic operation is identifiable. However, it offers no differentiation from sibling tools like create_ticket, update_ticket, or add_ticket_comment, and 'details' is left undefined.

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 call this tool versus its siblings, no prerequisites, and no mention of what happens with an invalid or unknown ticket_id. The agent must infer usage 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?

With no annotations, the description carries the full burden, but it only states the basic action. It does not disclose return format, ordering, pagination, whether deleted or blocked contacts are included, or any side effects. The read-only nature is implied but never explicit.

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 phrase with no wasted wording. Every word contributes to meaning, and the description is appropriately sized for a tool with no parameters and no complex behavior.

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

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

For a zero-parameter list tool, the description is minimally sufficient, but it lacks any clarification of what 'contacts' means in context, what the returned data looks like, or how it relates to get_contact and get_user. It is adequate but leaves a few practical gaps for an agent.

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

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

The tool has zero parameters, and the schema confirms this with 100% coverage. Since there is nothing to document, the description does not need to add parameter-level detail. Baseline 4 is appropriate for a parameterless tool.

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

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

The description states a specific verb ('List') and resource ('contacts'), clearly identifying the action. It distinguishes from get_contact by pluralizing 'all contacts', but it does not explicitly name or route to the sibling alternative for a single contact.

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

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

The description gives no guidance about when to use this tool instead of get_contact, get_user, or list_chats. There is no context for selecting this tool over alternatives, so the agent must infer 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?

No annotations exist, so the description carries the full behavioral burden and discloses almost nothing: not that it is a safe read-only operation, not the return shape, not what pagination defaults apply, and not whether results are scoped to an organization or the whole tenant. Only the mention of 'optional pagination and filtering' hints at behavior at all.

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 sentence with no filler, and the core action plus scope are front-loaded. Its brevity edges into under-specification rather than waste, so it is efficient but thin.

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

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

For a zero-required-param list tool with full schema coverage and no output schema, this is minimally adequate. The biggest missing piece is the 'filter' query syntax, which an agent cannot derive from the schema's one-line 'Device filter query' label and which the description does not supply.

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

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

Schema description coverage is 100%, so all three parameters are already documented in structured form, which sets the baseline at 3. The description restates that pagination and filtering exist but adds no syntax for the 'filter' query string or sensible defaults for pageNo/pageSize, so it adds nothing over the schema.

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

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

States a specific verb and resource ('List all devices') and scopes it to the NinjaOne system, so the operation is unambiguous. However, it never distinguishes itself from close siblings like search_devices or get_device, leaving the agent to infer that those are narrower lookup paths.

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

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

The phrase 'with optional pagination and filtering' implies the parameters are discretionary but gives no when-to-use or when-not-to-use guidance. With search_devices and get_device as siblings, the description should say which one to reach for, and it says nothing.

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

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

With no annotations at all, the description carries the full disclosure burden, yet it says nothing about permissions, whether the result is scoped to the caller's memberships, pagination, or result size. For an unannotated list tool this leaves meaningful behavioral questions unanswered.

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 no waste and the verb/resource front-loaded. It is appropriately sized, though it leaves no room for the scope qualifier that would help.

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 trivial zero-parameter list operation the description is adequate, but with no output schema and no annotations nothing tells the agent what a returned organization looks like or whether results are paginated or filtered.

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 is 4; the description cannot add parameter meaning and does not mislead about inputs.

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

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

The description names a specific verb ('List') and resource ('organizations'), which is clear enough. However, it says nothing about scope (all orgs the caller can see? all orgs in the tenant?) and does not distinguish it from the sibling get_organization, so an agent gets only a bare minimum of 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?

There is no when-to-use or when-not-to-use guidance, and no mention of the closely related get_organization sibling that fetches a single org. The agent must infer that this is the enumeration counterpart.

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

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

No annotations are provided, so the description carries the full behavioral burden, yet it discloses nothing about downtime, service interruption, required permissions, or the real-world impact of force vs graceful mode. It is effectively silent on behavior beyond the verb itself.

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

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

The single phrase is front-loaded and waste-free, but this is under-specification rather than conciseness. Nothing in the sentence earns its place because it duplicates the tool 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?

For a disruptive operation with no annotations and no output schema, the description should at least cover impact and the force/graceful distinction. As written, an agent cannot judge risk or side effects before invoking it.

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

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

Schema description coverage is 100%, with both device_id and the force/graceful enum documented in the schema, so baseline 3 applies. The description adds no meaning beyond it, notably omitting the operational consequences of each mode.

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?

"Reboot a device" merely restates the tool name reboot_device; it adds no scope, target, or distinguishing detail. It does not differentiate from siblings like run_script or get_device_health, though the verb+resource pairing 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?

No guidance on when to use this versus alternatives (run_script, get_device_health) or preconditions for rebooting. The agent is left to infer everything about appropriate selection.

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

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

With no annotations, the description carries the full burden and discloses almost nothing: it doesn't say whether execution is synchronous or asynchronous, whether it waits for completion, what is returned (script exit code, stdout, status object), whether it is destructive or requires elevated permissions, or whether calls can be retried safely. Only the implicit 'this performs an execution' signal is conveyed.

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 no filler and the core action front-loaded. It is efficient, though the brevity borders on under-specification for an execution 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?

For a tool that executes arbitrary scripts on a device with a nested free-form parameters object, no annotations, and no output schema, the description should explain execution semantics, return behavior, and risk. Almost all of that is missing, leaving the agent unable to predict the outcome of a call.

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

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

Schema coverage is 100%, so device_id, script_id, and the free-form parameters object are already documented, and the baseline of 3 applies. The description adds no extra meaning, such as expected shape or examples of the nested parameters object or how built-in action names differ from script IDs in practice.

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 ('Run a script or built-in action on a device'), which is enough to distinguish it from read-only siblings like get_device or list_devices. The dual scope ('script or built-in action') slightly blurs whether it overlaps with actions like reboot_device, but the core purpose 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?

There is no statement of when to use this tool versus siblings, even though reboot_device and api_post are plausible alternatives for executing actions on a device. No prerequisites, no constraints, no exclusions are given.

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

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

With no annotations, the description carries the full disclosure burden and falls short: it doesn't confirm read-only behavior, describe the result shape, mention pagination, result caps, or supported filter operators beyond the schema's two examples. For a search endpoint, the absence of any result-limit or matching-semantics detail is a real gap.

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

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

A single front-loaded sentence with no wasted words. It is efficient, though the brevity edges into under-specification for a tool with sibling alternatives.

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

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

The tool is simple (one required parameter, no output schema), so the schema does most of the work. Still, the description leaves the list-vs-search distinction and any result-set behavior unaddressed, which matters given list_devices sitting next to it.

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

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

Schema coverage is 100% and the schema already documents the single 'filter' parameter with two concrete examples. The phrase 'filter syntax' in the description adds almost nothing beyond the schema, so baseline 3 applies.

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

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

The description names a specific verb ('Search') and resource ('devices'), so the basic operation is unambiguous. However, it never distinguishes this from the sibling tool list_devices, leaving the agent to guess whether searching and listing differ in filtering capability or result 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?

There is no guidance on when to use this tool versus list_devices or get_device, and no prerequisites or exclusions are stated. The agent must infer that 'search' means server-side filtering, which is a guess rather than a documented rule.

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

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

No annotations are provided, so the description carries the full disclosure burden, and it discloses nothing. It does not say whether this is a partial update (omitting fields leaves them unchanged) or a full replace, whether extra permissions are required, whether changes are reversible, or what the response contains.

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

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

A single four-word sentence with no padding, and the core verb is front-loaded. Its brevity, however, comes from under-specification rather than discipline, so it earns no more than a middling 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 a mutation tool with four parameters, zero annotation coverage, and no output schema, the description is far too thin. An agent cannot tell whether the call returns the updated ticket, how partial updates are handled, or what failure modes exist.

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

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

Schema description coverage is 100% and all four parameters (title, status, ticket_id, description) are documented inline, so the schema does the heavy lifting. The description adds no meaning beyond the schema, which is the baseline case for a 3.

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

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

"Update a ticket" names a specific verb and resource, so an agent knows the general operation. But it adds essentially nothing beyond the tool name and gives no differentiation from siblings such as create_ticket, get_ticket, or add_ticket_comment, nor does it indicate which aspects of a ticket are updatable.

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 prerequisites or permissions, and no routing to alternatives like create_ticket for new tickets or add_ticket_comment for comments. An agent must infer everything about selection 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.