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

Annotations already disclose the key traits: readOnlyHint=false (a write), idempotentHint=false (repeats create duplicates), destructiveHint=false (safe/non-destructive). The description adds nothing beyond this - it does not mention that followups are appended and irreversible, nor describe the effect of is_private. With annotations present the bar is lower, but no additional context is supplied.

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 waste and the action front-loaded. It is efficient, though its brevity means little guidance is packed in.

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

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

The tool is simple with an output schema (so return values need not be explained), full parameter coverage, and annotations covering the safety profile, making the definition minimally viable. However, it says nothing about duplicate-creation behavior (non-idempotent) or the visibility implications relevant to this mutation.

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 (content, changeId, is_private) are already documented in the schema, establishing the baseline of 3. The phrase 'comment/followup' loosely maps to the content parameter but adds no format, length, or visibility semantics beyond the schema.

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

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

The description states a specific verb ('Add') and resource ('comment/followup to a change'), so the operation is unambiguous. It does not distinguish this tool from near-identical siblings such as glpi_add_problem_followup or glpi_add_followup, but the resource noun makes the target 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 guidance on when to use this tool versus alternatives like glpi_add_followup, glpi_add_change_solution, or glpi_list_change_followups. No prerequisites (e.g., valid change ID, permissions) are stated, leaving usage entirely 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 this a non-readonly, non-idempotent write, and the description adds a genuinely useful side effect beyond them: the change status transitions to Solved. It does not state whether an existing solution is overwritten, required permissions, or notification side effects.

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

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

A single short sentence, front-loaded with the action, with the state-change consequence in parentheses. Nothing 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?

An output schema exists so return values need no explanation, and annotations cover the safety profile. However, for a mutating tool that changes status to Solved, the description omits whether the change must be in a particular state beforehand or whether permissions are required, leaving gaps an agent would want filled.

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 only two parameters, so the schema already documents changeId and content. The description adds nothing about parameter formats or constraints, which is the expected baseline when the schema does 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 (add) and resource (solution to a change), which is enough to distinguish it from the ticket and problem solution siblings by resource. It does not explicitly name those alternative tools, 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?

The description never says when to use this tool versus glpi_add_change_followup, glpi_update_change, or the ticket/problem solution variants. Usage must be inferred entirely from the name; no prerequisites or 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?

Annotations already declare readOnlyHint=false, idempotentHint=false, and destructiveHint=false, so the write-and-non-idempotent profile is covered structurally. The description adds nothing beyond that: it does not warn that repeated calls create duplicate followups, does not mention the private/public visibility effect, and does not state 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?

The single sentence is free of padding and front-loaded, which is good. But its brevity here stems from under-specification rather than disciplined editing, so it lands at an adequate-but-thin 3 rather than 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?

With four parameters, an output schema, and annotations in place, the structured metadata carries most of the load, but the description still omits the sibling routing and the duplicate-followup behavior an agent should know before calling. For a mutation tool in a family of near-identical followup tools, this is a meaningful 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 description coverage is 100%, so all four parameters (content, ticketId, users_id, is_private) are already documented in the schema, including defaults and the 1/0 privacy convention. The description adds no parameter-level meaning beyond what the schema provides, making the baseline 3 correct.

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 ("Add") and resource ("comment/followup to a ticket"), so the agent knows exactly what the tool produces. It does not, however, differentiate itself from the several sibling followup tools (glpi_add_problem_followup, glpi_add_change_followup), which is the only thing keeping it from a 5.

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

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

There is no when-to-use guidance, no prerequisites, and no mention of the alternative followup tools that exist for problems and changes. The agent must infer from the name alone that this is ticket-scoped rather than problem- or change-scoped.

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, idempotentHint=false, and destructiveHint=false, so the safety profile is covered. The description adds nothing else – no indication that the followup becomes part of the problem timeline, whether is_private affects visibility in a meaningful way, 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 short sentence with zero filler, front-loading the action. It is efficient, though arguably terse enough that it shades into under-specification rather than ideal 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?

An output schema exists, so return values need not be explained. But for a mutation tool the description omits when to use it versus sibling followup/solution tools and any behavioral context, leaving the definition only minimally adequate.

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

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

Schema description coverage is 100%, so the schema already documents problemId, content, and is_private (including the 1=private/0=public mapping). The description adds no parameter meaning 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?

States a specific verb (add) and resource (comment/followup to a problem), so an agent can tell it appends a followup to a problem record. It does not, however, differentiate itself from the many sibling followup tools (glpi_add_followup, glpi_add_change_followup, glpi_add_problem_solution); the problem-scope is only inferable from the name.

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

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

The description gives no when-to-use guidance and names no alternatives. With near-identical siblings (glpi_add_followup for tickets, glpi_add_change_followup for changes, glpi_add_problem_solution), an agent gets no help choosing among them beyond the tool name.

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

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

Annotations already declare the write/safety profile (readOnlyHint=false, destructiveHint=false, idempotentHint=false, openWorldHint=false). The description adds a genuine side effect not present in the annotations: the problem's status is changed to Solved as a result of the call. It stops short of covering repeatability (adding a second solution) 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 short sentence with the action front-loaded and the state consequence attached where it matters most. No filler, nothing to trim.

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

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

For a low-complexity two-parameter mutation tool with full schema coverage, complete annotations, and an output schema, the description covers purpose and the key state change. The one meaningful gap is disambiguation from the ticket/change solution siblings, which the description never addresses.

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 both parameters (problemId, content) are documented in the schema, so the baseline is 3. The description adds no format, constraint, or meaning beyond what the schema already states.

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

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

The description states a specific verb and resource ('Add a solution to a problem'), which is clear on its own. It does not, however, differentiate from near-identical siblings such as glpi_add_change_solution or glpi_add_solution, which an agent could easily confuse with this 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?

There is no statement of when to use this tool versus the sibling solution tools (glpi_add_solution, glpi_add_change_solution) or when a followup (glpi_add_problem_followup) is more appropriate instead. The parenthetical about status change is a consequence, not usage 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 already declare the safety profile (readOnlyHint=false, destructiveHint=false, idempotentHint=false, openWorldHint=false), so the bar is lower. The description adds a genuinely useful behavioral fact not captured by annotations: the ticket status transitions to Solved as a side effect. It still omits whether an existing solution is replaced and whether specific permissions are required.

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 core action front-loaded and the side effect in parentheses. Nothing is wasted and nothing is buried.

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 not be explained, and annotations cover the safety profile. The description notes the state change, which is the key behavioral fact for a mutation tool. Remaining gaps (replacement of prior solutions, permission requirements) are minor given the supporting structured data.

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 both parameters are documented there, so the baseline of 3 applies. The description adds no additional meaning about ticketId or content format beyond what the schema already provides.

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

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

States a specific verb and resource ('add a solution to a ticket'), and naming 'ticket' disambiguates it from the sibling solution tools glpi_add_change_solution and glpi_add_problem_solution. It stops short of explicitly routing the agent away from those siblings, but the resource noun is clear enough to select correctly.

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, no prerequisites (e.g. ticket must be open/assigned), and does not name alternatives such as glpi_add_followup or the change/problem solution variants. Usage context is entirely implied by 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?

Annotations already declare readOnlyHint=false, idempotentHint=false, and destructiveHint=false, so the mutation and idempotency profile is covered. The description adds the role mapping, which is behavioral context (the group becomes requester/observer/assigned), but says nothing about duplicate handling, permissions, or side effects beyond what the schema and annotations already convey.

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

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

Two short sentences with no filler; the core action is front-loaded and the role mapping follows immediately. Nothing an agent doesn't need.

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 relation-creation tool with full schema coverage, annotations, and an output schema, the description is nearly complete for correct invocation. It falls short only on selection context relative to siblings, which the usage guidelines also omit.

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

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

Schema description coverage is 100% and the schema already documents tickets_id, groups_id, and the type enum with identical wording. The description merely repeats the type mapping, adding no meaning beyond the structured fields, so the baseline of 3 applies.

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

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

States a specific verb and resource ('Add a group to a ticket') and enumerates the roles the group can take. The resource 'group' naturally distinguishes it from the sibling glpi_add_ticket_user, though no sibling is named 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?

The description explains what the tool does but gives no when-to-use guidance, no prerequisites, and no alternatives (e.g., glpi_add_ticket_user for users or glpi_list_ticket_groups to inspect existing groups). An 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?

Annotations already disclose the safety profile (not read-only, not destructive, not idempotent), so the description carries a lower burden, but it adds nothing behavioral beyond that — no permission requirements, no duplicate-handling, no note on how private tasks differ. The remaining text merely restates schema 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?

Two front-loaded sentences with no filler: the purpose comes first, then the required/optional field breakdown. Efficient, though the field enumeration largely duplicates the schema.

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

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

An output schema exists so return values need not be described, and annotations cover safety, but for a mutation tool the description omits any usage context, side effects, or prerequisites. It is minimally adequate rather than complete.

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

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

Schema description coverage is 100%, so the schema already documents every parameter. The description repeats the field list and value meanings (state 0/1/2, actiontime in seconds) rather than adding syntax or format detail beyond the schema, 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 gives a precise verb+resource ('Add a task to a ticket') that cleanly separates it from siblings like glpi_add_followup, glpi_add_ticket_user, and the read counterpart glpi_list_ticket_tasks. It does not, however, explicitly name any alternative to help route the agent.

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 the sibling tools an agent might confuse this with (followups, solutions, ticket users). Usage can only be inferred 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?

Annotations already declare the safety profile (readOnlyHint=false, idempotentHint=false, destructiveHint=false, openWorldHint=false), so the description is not obligated to restate it. It adds the fact that a user can occupy one of three roles, but says nothing about duplicate assignments, notifications, or required permissions.

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 short sentences, front-loaded with the core action, and the role mapping is placed where an agent will read it. Slightly redundant with the schema's type description, but there is no filler.

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

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

An output schema exists, so return values need not be described, and all three required parameters are covered by the schema. For a simple, fully-specified mutation the description is adequate, with only duplicate-handling behavior left unstated.

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 tickets_id, users_id, and the type enum are already documented in the schema. The description's type mapping repeats the schema verbatim and adds no extra meaning, making the baseline 3 correct.

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 ("Add a user to a ticket") and enumerates the three role kinds, so the operation is unambiguous. It doesn't name or contrast any sibling (e.g., glpi_add_ticket_group, glpi_list_ticket_users), but the scope is clear from the name-plus-description.

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 or when-not-to-use guidance is given, and no alternative is named even though close siblings exist (glpi_add_ticket_group, glpi_delete_ticket_user, glpi_update_ticket). The role list implies intent but supplies no routing logic.

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 carry the full safety profile (readOnlyHint=false, destructiveHint=true, idempotentHint=false), so the bar is lower. The description usefully adds session scoping and the multi-entity context, but it never explains what the destructiveHint implies, whether the switch is persisted or session-only, or what happens if the entity is not accessible to the user.

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

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

Three short sentences, front-loaded with the core action, then rationale, then the parameter hint. No filler and nothing repeated.

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 the tool is a simple two-parameter session switch. The description covers purpose, applicability, and the recursive option; only edge behavior (invalid/inaccessible entity, effect on subsequent calls) is unaddressed, which is a minor gap here.

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 both parameters are already documented in the schema. "Use is_recursive=true to include sub-entities" largely restates the schema's own "Include sub-entities (default: false)" and adds no extra syntax, format, or constraint detail. Baseline 3 applies when the schema does the heavy lifting.

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

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

The description names a specific verb and resource ("Change the active entity") and scopes it precisely to the current session, which distinguishes it from the sibling glpi_update_entity (which edits entity records) and glpi_get_my_entities. An agent can separate it from all other entity tools without opening a 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?

"Essential for multi-entity GLPI instances" gives a clear condition that selects this tool over the entity CRUD siblings, and the recursive hint tells the caller how to widen scope. It lacks explicit when-not guidance (e.g. that this is a session switch, not a persistent change) and never names an alternative 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?

Annotations already declare readOnlyHint, idempotentHint, destructiveHint=false, so the safety profile is fully covered. The description adds the behavioral note that no data is transferred and the call is cheap, which is genuine but modest added context; it says nothing about result shape or limits. A 3 is appropriate against a rich annotation 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?

Two compact sentences, no padding, with the core purpose front-loaded and the companion-tool pointer trailing. Every clause earns its place.

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

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

With an output schema present and both parameters documented in the schema, the description only needs to cover purpose, the cheap-count rationale, and how to build criteria — all of which it addresses. Nothing an agent needs to invoke it 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 100%, so the baseline is 3; however, the description adds meaning the schema does not by directing the agent to glpi_list_search_options to discover valid criteria field IDs, which is the main ambiguity for the 'criteria' array. This is a real value-add beyond the structured fields.

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 ('Count matching items') plus a scope qualifier ('without transferring them'), which functionally separates it from the search/list siblings that return records. An agent can tell what this does and how it differs from glpi_search without opening either 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 clear context — use it to answer 'how many' cheaply — and points to glpi_list_search_options as the way to discover criteria field IDs. It does not explicitly name glpi_search as the alternative when full records are needed or state when not to use this, so it falls short of a full 5.

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

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

Annotations already declare readOnlyHint=false, idempotentHint=false and destructiveHint=false, so the write/non-idempotent/non-destructive profile is covered. The description adds only a modest hint via 'Common fields', implying field sets vary by asset type, but says nothing about type-specific requirements, auth, or failure modes.

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

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

Two tight sentences, front-loaded with the operation and followed by the useful field list. No filler, though it is terse to the point of under-specification 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?

An output schema exists, so return values need not be described. However, for a polymorphic tool spanning nine asset types with a freeform input object, the description omits which fields are required or type-specific, leaving a real gap for correct invocation.

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

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

Schema coverage is nominally 100%, but the critical 'input' param is a freeform object with no documented fields, so the description's field list (name, entities_id, serial, etc.) adds genuine meaning the schema lacks. asset_type semantics (the enum) are only covered by the schema, not expanded here.

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 (asset), so the operation is unambiguous. It does not differentiate itself from siblings like glpi_update_asset or glpi_list_assets, but the create semantics are clear from 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?

There is no guidance on when to use this versus glpi_update_asset or glpi_create_document, no prerequisites, and no indication of permissions or required context. It simply says what it does, leaving all usage decisions 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=false, idempotentHint=false, destructiveHint=false, and openWorldHint=false, so the mutation/non-idempotent profile is covered. The description adds no behavioral context beyond restating creation - no auth requirements, no side effects, no note that a follow-up update is required to add solutions.

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 compact sentences, front-loaded with the primary action and then the useful field hint. No filler, though the second sentence is quite terse for the value it carries.

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 not be described. But for a create tool whose input schema is a free-form blob, the description leaves the caller without field requirements, permissions, or minimum viable input.

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

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

The schema exposes only an opaque free-form 'input' object labeled 'Change fields' with additionalProperties, so the description's list of common fields (name, content, entities_id, users_id_requester) adds genuine meaning the schema lacks. However, it names only four of the many possible ITIL change fields and gives no types or required/optional status.

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 ('Create a new change'), which is clear enough to distinguish from glpi_update_change, glpi_get_change, and glpi_list_changes. It doesn't explicitly name a sibling for differentiation, but the resource+action 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?

There is no when-to-use guidance, no alternatives (e.g. glpi_create_ticket/glpi_create_problem), and no prerequisites such as required entities or permissions. The agent must infer everything about applicability.

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, destructiveHint=false, idempotentHint=false and openWorldHint=false, so the safety profile is covered. The description adds one useful behavioral nuance with '(metadata)' – that this creates a record rather than uploading file content – but says nothing about permissions, required fields, or side effects. With annotations carrying the safety burden, this is an adequate 3.

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

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

Two short fragments, front-loaded with the action, with no wasted prose. The trailing 'etc.' is an imprecise shortcut that slightly weakens precision.

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. However, for a creation tool with a fully free-form input object, the description does not indicate which fields are required or that linking the document to an item may require a separate call – gaps the opaque schema cannot fill.

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

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

The schema exposes only a single opaque free-form 'input' object (additionalProperties: {}), so the schema itself conveys almost nothing about field names. The description's 'Fields: name, entities_id, comment, etc.' adds genuine meaning beyond the schema. The vague 'etc.' keeps it from 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 ('Create a document') and the parenthetical '(metadata)' signals this creates the document record rather than attaching content, which meaningfully separates it from siblings like glpi_create_document_item or glpi_get_document. It stops short of naming those siblings explicitly, 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?

There is no statement of when to use this tool versus the many sibling document tools (glpi_create_document_item, glpi_get_document, glpi_list_documents), nor any prerequisites. The '(metadata)' hint implies a usage boundary but the agent must infer 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 already declare the write semantics (readOnlyHint=false, idempotentHint=false, destructiveHint=false), so the safety profile is covered. The description adds the meaningful detail that this creates a relation to a polymorphic target, but says nothing about what happens on a duplicate link attempt, required permissions, or whether it modifies the existing item.

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 zero filler. Nothing is repeated from the title or annotations and 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 a full output schema and complete annotations, the description only needs to convey the operation and its target space, which it does. The remaining gap is the absence of any usage context, but nothing required to invoke the tool correctly is missing.

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

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

Schema description coverage is 100% - documents_id, itemtype, and items_id are each documented in the schema. The description only echoes the itemtype concept ('Ticket, KnowbaseItem, etc.') without adding format or constraint detail, 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?

States a specific verb and resource ('Create a link between a document and an item') and even names example target types. An agent can distinguish it from glpi_get_document_item, glpi_list_document_items, and glpi_delete_document_item by name, though the description never explicitly contrasts them.

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

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

No when-to-use guidance, no prerequisites (e.g. the document must already exist via glpi_create_document), and no mention of when to prefer this over listing or fetching links. The agent must infer the 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?

Annotations already declare readOnlyHint=false, idempotentHint=false, and destructiveHint=false, so the safety profile is covered. The description adds field-level context (required name, parent semantics with 0=Root) but does not disclose permissions, error behavior, or what happens to unspecified 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?

The description is two short sentences and front-loads the core action. It is efficient, though the vague 'etc.' is slightly unhelpful.

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 and annotations cover the safety profile, reducing the description's burden. However, for a create tool with an open object schema, the incomplete field enumeration ('etc.') leaves agents uncertain about the full valid input set.

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 an open object with no field-level documentation, so the description carries nearly the full burden. It usefully identifies 'name' as required and explains entities_id as the parent entity with 0=Root, though the trailing 'etc.' leaves the field list incomplete.

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

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

The description uses a specific verb and resource ('Create a new entity'), making the tool's purpose immediately clear. It does not explicitly differentiate from sibling tools like glpi_update_entity or glpi_list_entities, but the action verb distinguishes it enough.

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

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

There is no guidance on when to use this tool versus alternatives such as glpi_update_entity or glpi_list_entities. The description only states the action, leaving usage context entirely 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 this as a non-read-only, non-destructive, non-idempotent write, so the safety profile is covered. The description adds the allowed itemtype values (Ticket/Change/Problem), which is useful behavioral context, but says nothing about required fields, validation, or side effects beyond the annotation 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?

Two short sentences, verb-first and front-loaded, with no filler. Nothing is wasted, though the field list could have been paired with required/optional markers.

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 not be described, and annotations cover the mutation profile. Still, for a create tool it omits which fields are mandatory and any constraint on content/comment, leaving real gaps for an agent filling the input object.

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 declared schema is a loose wrapper ("Template fields" with additionalProperties), so despite the reported coverage it documents no individual fields. The description compensates by naming name, content, comment, and itemtype and enumerating the itemtype values, which is genuine meaning the schema lacks.

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 ("Create a new followup template") and names the concrete fields it accepts. The verb distinguishes it from the sibling family (list/get/update_itil_followup_template), though it never explicitly contrasts with them.

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

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

There is no when-to-use guidance, no prerequisite (e.g. permissions, category linkage), and no mention of the alternative update/get/list siblings. Usage is only inferable from the create verb.

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, destructiveHint=false, and idempotentHint=false, so the write/non-destructive profile is covered structurally. The description adds nothing beyond that – no mention of whether names must be unique, whether a parent category is required or optional, or any permission requirement for a mutation tool.

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

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

One short, front-loaded sentence with no filler or repetition. It is efficient, though the extreme brevity leaves the definition under-specified for a mutation 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?

An output schema exists, so return values need not be described, and annotations carry the safety profile. However, for a create operation with a nested input object and a parent-category reference, the absence of any hierarchy or required-field context is a noticeable 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 description coverage is 100% and the nested input description already enumerates the fields (name, knowbaseitemcategories_id for parent, comment). The description adds no format, naming, or hierarchy detail 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 and resource ('Create a new knowledge base category'), which is unambiguous and clearly distinct from the list/get/update/delete category siblings. It stops short of explicitly differentiating itself from those siblings in text, so it does not reach a 5.

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

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

There is no guidance on when to use this tool versus alternatives such as glpi_create_knowbase_item or glpi_update_knowbase_category, and no prerequisites or parent-category requirements are mentioned. 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?

Annotations already declare the full safety profile (readOnlyHint=false, destructiveHint=false, idempotentHint=false, openWorldHint=false). The description adds almost nothing beyond that; the only extra behavioral signal is that 'answer' expects HTML content, and it omits permissions, duplicate behavior, or what happens if a referenced category is missing.

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 short sentences, front-loaded with the action and followed by field hints; no filler. The trailing 'etc.' is a minor weakness but the overall size is appropriate.

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 this is a mutation whose nested input object is effectively undocumented. Listing only three fields with 'etc.' leaves an agent guessing which fields are required to create a valid article.

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 nominally 100%, but the schema's single 'input' parameter is an untyped object with additionalProperties: {}, so it documents no actual fields. The description names three fields (name, answer, knowbaseitemcategories_id) and truncates with 'etc.', adding real value but leaving required/optional status and the full field set unspecified.

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 ('Create a new knowledge base article'), which cleanly separates it from the sibling list/get/update/delete knowbase tools. It doesn't explicitly name those siblings, but the create-vs-read distinction 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 glpi_update_knowbase_item or glpi_create_knowbase_category, no prerequisites such as an existing category ID, and no note about duplicate prevention despite idempotentHint=false.

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 non-readonly, non-idempotent, non-destructive, closed-world — the description adds essentially nothing beyond that. It does not mention required permissions, what the created object contains, or whether a followup/solution must be added separately.

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 short sentences, front-loaded with the action. Minimal but not padded; the field list earns its place by hinting at expected keys.

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 a fully open input object (additionalProperties), an output schema present, and a large sibling set, the definition is thin: no required-field info, no note that the returned payload is the created problem, no routing to related tools like glpi_add_problem_task or glpi_add_problem_solution.

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 input object is free-form with additionalProperties), and the description names four common fields: name, content, entities_id, users_id_requester. That is useful orientation but does not explain requiredness, types, or the full accepted field set, which the free-form schema also leaves open.

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+resource: 'Create a new problem.' Sibling set contains glpi_create_ticket and glpi_create_change, so the resource distinction (problem vs ticket vs change) is the key disambiguation and is stated. It does not explicitly call out the sibling distinction, keeping it at 4.

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, no mention of alternatives such as glpi_update_problem or glpi_create_ticket. The reader 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?

Annotations already declare this as a non-idempotent, non-destructive write, so the safety profile is covered. The description adds the expected timestamp format and warns that the ID is a reservation-item ID rather than an asset ID, but says nothing about overlap/conflict handling, permission requirements, or what happens when a slot is already taken.

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, zero filler, with the core action front-loaded and the two practical constraints (timestamp format, correct ID source) following. Every clause 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?

An output schema exists, so return values need no explanation, and the 80% schema coverage handles most parameters. What remains thin is conflict/idempotency behavior for a booking tool and whether users_id defaults to the calling user. Overall sufficient for an agent to invoke the tool correctly.

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

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

Schema coverage is 80%, so the baseline is 3. The value-add is the explicit warning that reservationitems_id is not the asset ID and must come from glpi_list_reservation_items, which prevents a likely class of caller error. The restated begin/end format duplicates the schema, and the undocumented 'comment' field is left unaddressed.

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 first sentence pairs a specific verb and resource ("Book a reservable item") that an agent can immediately distinguish from glpi_update_reservation, glpi_list_reservations, and glpi_get_reservation. It also names the prerequisite sibling tool, so the tool's role in the workflow 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 implies the workflow (fetch the reservation item first, then book it) but never states when to choose this over glpi_update_reservation or what conditions make a booking invalid. The pointer to glpi_list_reservation_items is a useful prerequisite hint, but timing and alternatives are left 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 disclose the safety profile (readOnlyHint=false, idempotentHint=false, destructiveHint=false, openWorldHint=false). The description adds no behavioral context beyond that — nothing about permissions, side effects, or what happens to the parent rule. It does list fields, but that is parameter, not behavioral, information.

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 core action and then the field list. No padding. The parenthetical enum values are useful, though the list format is slightly terse.

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 not be described, and annotations cover the safety profile. However, for a mutation tool, the description omits prerequisites (must the referenced rule exist?), permission requirements, and when to choose this over updating an existing action. Field names are covered, but operational context is thin.

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

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

The schema's single "input" object is loosely typed (additionalProperties with no defined nested fields), so the description's enumeration of rules_id, action_type, field, and value is genuinely compensating. It also supplies the action_type enum values (assign/regex_result/append_regex_result), which the schema omits (enums: 0). This adds real meaning beyond the schema.

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

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

States a specific verb and resource: "Create a new action for a rule." This is clearly distinguishable from siblings like glpi_update_rule_action or glpi_list_rule_actions by the verb. It does not explicitly name siblings, so it stops short of a 5.

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

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

There is no when-to-use guidance, no prerequisites (e.g., an existing rule/rules_id), and no mention of alternatives such as glpi_update_rule_action or glpi_create_rule_criteria. The agent must infer all routing 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 this is a non-read-only, non-idempotent, non-destructive, closed-world write, so the safety profile is covered structurally. The description adds nothing beyond that: it does not say whether criteria can be duplicated, whether condition/pattern values are validated, or what a duplicate create does (relevant since idempotentHint=false).

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 short sentences, purpose first, field list second, with no filler. It is tight, though the field list largely duplicates the schema's own description rather than adding new 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?

An output schema exists, so return values need not be explained, and annotations carry the mutation semantics. However, for a nested write against an existing rule, the absence of any prerequisite or rule-type constraint leaves the definition only minimally 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 reported at 100%, but the schema itself is a generic wrapper with additionalProperties={} whose only documentation is the same field list. The description does add one genuine clarification, "criteria (field name)", which disambiguates an otherwise confusing parameter name. No detail is given on legal condition operators or pattern formats, so this is baseline-plus.

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 ("Create a new criteria for a rule") and enumerates the fields involved, so the agent knows exactly what is being created. It stops short of distinguishing itself from close siblings such as glpi_create_rule_action or glpi_create_rule_ticket, which share the same rule-criteria family.

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, nor any prerequisite (an existing rule id, a valid condition value, or the rule type the criteria must match). The agent must infer the workflow entirely from the name and the sibling list.

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

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

Annotations already convey that this is a non-idempotent, non-readonly, non-destructive creation, so the safety profile is covered. The description adds nothing behavioral beyond that: no mention of permission requirements, validation failures, or the required follow-up steps. With annotations carrying the basics, additional context is what's missing.

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 compact sentences with the action front-loaded and the field list as supporting detail; no filler. The trailing 'etc.' is slightly evasive but costs little.

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 not be explained. For a create tool with an opaque nested object, however, the description omits prerequisites, auth, and lifecycle context (criteria/actions), leaving it only minimally sufficient.

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

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

The schema is a bare free-form 'input' object (additionalProperties: {}), so the nominal 100% coverage tells the agent almost nothing. The description compensates by naming concrete fields (name, match with AND/OR values, is_active, sub_type, ranking), which is real added value, though 'etc.' leaves the remaining fields unspecified.

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 ('Create a new ticket business rule') and the field list sharpens what kind of rule it is. It does not explicitly distinguish itself from the closely related glpi_create_rule_criteria / glpi_create_rule_action siblings, so a 4 rather than a 5.

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

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

There is no when-to-use guidance, no prerequisites (e.g. that criteria/actions must be added afterward to make the rule functional), and no reference to the list/get rule siblings. The agent must infer everything 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 this as a non-read-only, non-idempotent, non-destructive, non-open-world write, so the safety profile is covered. The description adds nothing behavioral beyond that — no mention of side effects such as rule engine processing, notifications to assigned users, or that repeated calls create duplicate tickets (relevant given idempotentHint=false).

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

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

Two sentences, action first, then a compact field list. Every token is doing work; the only minor flaw is that the field list is unprioritized and mixes identifiers with display fields without signaling requiredness.

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 create tool with an opaque nested-object schema and an output schema, the description gives useful field hints but omits required fields (name/content), entity/permission context, and creation side effects. Adequate to attempt a call, but an agent would likely need to guess at required inputs.

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 effectively an opaque passthrough ('Ticket fields' with additionalProperties: {}), so the description carries the real semantic load by naming key fields and decoding the type enum ('1=Incident, 2=Request'). This adds genuine meaning beyond the schema, though it omits which fields are required and the accepted values for urgency/impact/priority.

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+resource ('Create a new ticket'), which is straightforward and clearly distinct from sibling mutations like glpi_update_ticket, glpi_create_problem, and glpi_create_change. It does not explicitly contrast itself with those siblings or explain scope (e.g., which entity the ticket lands in), so it falls short of a 5.

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

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

There is no guidance on when to use this tool versus glpi_create_problem, glpi_create_change, or glpi_list_tickets, no mention of prerequisites (auth, entity selection), and no note about required vs optional fields. The description only lists candidate fields, leaving routing and preconditions entirely 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=false, idempotentHint=false, destructiveHint=false, and openWorldHint=false, covering the safety profile. The description adds the semantic effect — that it creates an approval request assigning a validator — which is useful context beyond the generic 'create', but it omits side effects such as notifications to the approver or the request's pending-state behavior.

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

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

A single efficient sentence with the action and key parameter front-loaded and no filler. It is appropriately tight, though for a mutation tool it is arguably too sparse to fully earn its place.

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

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

An output schema exists and annotations cover the safety profile, so return values and reversibility need not be explained. However, for a create/mutation tool the description leaves the agent without any prerequisite context (ticket must exist, approver must be a valid user), which is a meaningful 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 description coverage is 100% (ticketId, users_id_validate, comment_submission all documented in the schema), so the baseline is 3. The description names users_id_validate but adds no format, constraint, or meaning beyond what the schema already provides.

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

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

The description states a specific verb (Create) and resource (approval request/ticket validation) and identifies the key actor field (users_id_validate). It implicitly distinguishes itself from the list/update/delete ticket-validation siblings via the verb, but never names or contrasts them 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?

There is no guidance on when to use this versus alternatives. It doesn't state prerequisites (e.g., that the ticket must exist and be in a validatable state) or mention the sibling glpi_update_ticket_validation / glpi_list_ticket_validations that an agent might confuse this with.

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 the safety profile (write, non-idempotent, non-destructive), so the bar is lower. The description adds useful context by naming the required field and how email is routed through the _useremails array, but it omits what happens on duplicate logins, required permissions, and whether the password is stored hashed.

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 compact sentences with the required field front-loaded and no filler. Every clause carries information, though the '_useremails array' phrasing is slightly cryptic without an example.

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 not be explained, and annotations cover the mutation safety profile. For a create tool the entry covers the essential minimum (required field plus common fields), though it stops short of permissions, dedup behavior, and more complete field 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?

The input schema is a single free-form 'input' object with only the placeholder text 'User fields', so the schema itself conveys essentially nothing despite the nominal 100% coverage. The description compensates by naming the required field (name/login) and the common fields (realname, firstname, password, email via _useremails), which is meaningfully more than the schema provides.

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

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

States a specific verb ('Create') and resource ('GLPI user'), making the operation unambiguous and clearly distinct from the sibling write tool glpi_update_user or the readers glpi_get_user/glpi_list_users. It does not explicitly name an alternative, but the name and phrasing leave no ambiguity about what the tool does.

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

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

The description says nothing about when to use this tool versus the alternatives in the sibling set (e.g. glpi_update_user for existing users, glpi_search_user_by_email for dedup checks). No prerequisites, no conditions, no exclusions – the agent must infer usage entirely 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?

Annotations already declare readOnlyHint=false, idempotentHint=false, destructiveHint=false and openWorldHint=false, so the safety profile is covered structurally. The description adds no behavioral context beyond a field list: no mention of required permissions, that duplicate webhooks are possible (non-idempotent), or whether the webhook is immediately armed after creation.

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

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

Two sentences, front-loaded with the action and then the field inventory. Not padded, though the field enumeration is a bare list rather than prioritized into required vs optional.

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 not be described, and the field list gives reasonable coverage. However, with a fully open nested input object the description does not say whether any of these fields are required or what a minimal valid payload looks like, leaving a gap for a create mutation.

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

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

The schema's only property is an untyped free-form 'input' object, so the description is the sole source of field-level meaning. Naming name, url, itemtype, event, payload, http_method and use_cra_challenge, plus examples for itemtype (Ticket) and event (new/update/delete), materially compensates for the empty nested 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 ('Create a webhook'), which is unambiguous against siblings like glpi_update_webhook, glpi_delete_webhook, and glpi_set_webhook_active. It does not explicitly differentiate itself from those siblings, but the create verb makes the distinction inferable without opening a 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?

There is no when-to-use or when-not-to-use guidance. Given five sibling webhook tools (update, delete, set_active, list, get), a sentence such as 'use glpi_update_webhook to modify an existing webhook' would be expected and is absent.

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 idempotentHint=true, so the safety and repeat-call profile is covered. The description's 'Permanently' reinforces irreversibility, which is mildly additive, but it omits the audit-trail reason requirement and any permission/authorization caveats. With annotations carrying most of the behavioral burden, a 3 is appropriate.

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 zero filler. It is efficient, though arguably terse enough that it omits useful routing information rather than merely being compact.

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?

Output schema exists and annotations are rich, so return values and safety need not be explained. The remaining gaps are sibling disambiguation (glpi_delete_document_item) and the mandatory reason parameter, which the schema covers but the description never acknowledges.

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% (documentId and required reason with audit-trail note), so the description adds nothing beyond naming the ID argument. Baseline 3 is correct when the schema does all the parameter 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 and resource ('Permanently delete a document') and the identifier scope ('by ID'), so the agent knows exactly what entity is affected. However, it does not differentiate from the close sibling glpi_delete_document_item, which deletes a document-item association rather than the document itself.

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 prerequisite or permission context, and no pointer to alternatives such as glpi_delete_document_item or glpi_list_documents. 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?

Annotations already declare destructiveHint=true, idempotentHint=true, and readOnlyHint=false, so the safety profile is covered structurally. The description adds nothing beyond that – it doesn't note that only the association is removed (not the document), nor that the required reason is an audit-trail field.

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 zero waste, though it is terse to the point of under-specification rather than being optimally informative.

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

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

Annotations cover the destructive/idempotent profile and an output schema exists, so return values need not be described. However, for a destructive mutation the description leaves the caller without confirmation that only the link is removed and the document is preserved, which is the key semantic an agent needs.

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

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

Schema description coverage is 100%, and the schema documents both documentItemId and the required reason with its audit-trail purpose, so the baseline of 3 applies. The description's 'by ID' adds no meaning beyond what the schema provides.

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

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

The description states a specific verb ('Remove') and resource ('Document_Item link'), which is enough to distinguish it from glpi_delete_document (which deletes the document itself, not the link). It does not explicitly name or differentiate from the sibling it could be confused with, so it falls short of a 5.

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

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

There is no guidance on when to use this versus glpi_delete_document or glpi_list_document_items, no prerequisites, and no stated side effects beyond the implicit deletion. The agent must infer usage 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 destructiveHint=true, idempotentHint=true and readOnlyHint=false, so the safety profile is largely covered. The description reinforces permanence/irreversibility, which is marginally more than the annotation states, but omits important behavior such as whether child entities/items are cascade-deleted and what authorization the operation requires.

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 short, front-loaded sentences with no filler. The warning clause duplicates what the destructiveHint annotation already conveys, so it is not purely additive, but the text is efficiently sized for the tool's simplicity.

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

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

An output schema exists, so return values need not be explained, and the annotations carry the destructive profile. What remains missing for a destructive, low-level admin tool is cascade/impact behavior and any prerequisite or confirmation guidance, leaving it only minimally complete.

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

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

Schema coverage is 100%, and the schema itself documents both parameters including the required 'reason' audit-trail field. The description adds only the 'by ID' hint for entityId and says nothing about the mandatory reason, so it cannot exceed the baseline.

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 and resource ('Permanently delete an entity') and the 'by ID' qualifier pins the identifier. It does not, however, distinguish this from the many sibling delete tools (glpi_delete_document_item, glpi_delete_knowbase_item, etc.) or from glpi_update_entity, so the agent gets no help routing between them.

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

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

There is no indication of when to choose this tool over alternatives, no prerequisites (e.g., permission level, whether the entity must be empty), and no note that glpi_update_entity is the non-destructive path. The only guidance is the irreversible warning, which is about risk rather than usage.

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

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

Annotations already declare destructiveHint=true, idempotentHint=true, and readOnlyHint=false, so the safety profile is largely covered. The description adds 'Permanently', which clarifies irreversibility beyond the destructive hint, but it omits other useful context such as whether deletion cascades to child items or requires special permissions.

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

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

The description is a single, front-loaded sentence with no wasted words. It states the core action clearly and immediately.

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

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

Given the simple delete operation, rich annotations, complete parameter schema, and presence of an output schema, the description is nearly sufficient. It could mention the mandatory audit reason or the permanence of deletion more explicitly, but those are covered by structured fields.

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

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

Schema description coverage is 100%, so the schema already documents both parameters, including the required 'reason' for audit trail. The description adds no additional parameter meaning or formatting details, 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 states a specific verb ('delete') and resource ('knowledge base category') and adds the scope modifier 'permanently'. It distinguishes the tool from sibling operations on knowledge base items (e.g., glpi_delete_knowbase_item) by naming the category resource, but does not explicitly differentiate from other category tools like update or create.

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

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

The description provides no guidance on when to use this tool versus alternatives, such as glpi_delete_knowbase_item or glpi_update_knowbase_category. It simply restates the operation without context about prerequisites, exclusions, or the required audit reason.

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, idempotentHint=true and readOnlyHint=false, so the safety profile is fully covered by structured data. The word 'Permanently' reinforces irreversibility but adds little beyond destructiveHint, and nothing is said about the required audit reason, permissions, or failure behavior, so this is a baseline 3 with no contradiction.

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 zero filler, and the destructive qualifier is placed first. It is efficient, though the brevity doubles as under-specification for a destructive 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?

An output schema exists, so return values need not be described, and annotations cover the safety profile. Still missing for a permanent-delete tool: whether the audit reason is mandatory (schema says required, description does not warn), and what happens to the item's attachments or children.

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

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

Schema description coverage is 100%: the required 'reason' parameter is documented as an audit-trail obligation with a minLength constraint, and 'knowbaseId' is typed. The description adds no syntax or format nuance, so the schema does all the work and the baseline 3 applies.

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

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

The description gives a specific verb and resource ('Permanently delete a knowledge base article'), which is unambiguous and tells the agent exactly what object is affected. It does not, however, differentiate itself from same-family mutators such as glpi_delete_knowbase_category or glpi_delete_document_item beyond the resource noun.

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 alternatives, no prerequisites, and no warning about when not to call it. The agent must infer that this is the terminal step after listing/getting an item, with nothing in the text to confirm that.

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, idempotentHint=true, and readOnlyHint=false, so the safety profile is fully covered. The description adds only the link-removal framing and ID provenance, but says nothing about whether the ticket or group itself survives, permissions required, or audit consequences beyond what the schema already notes for 'reason'.

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 zero waste; the operation is front-loaded and the ID-provenance hint is attached to the parameter it concerns. Nothing redundant is repeated from the title or 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?

Output schema exists, so return values need not be described, and both required parameters are fully documented in the schema. For a two-parameter destructive link-removal with annotation-covered safety, this is nearly complete, though a note on consequences (e.g., that only the association is removed, not the group) would close the remaining 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 description coverage is 100%, with both parameters documented in the schema (including the audit-trail purpose of 'reason'). The description only clarifies where groupTicketId comes from, so the baseline 3 applies — schema does the heavy lifting.

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

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

States a specific verb and resource ('Remove a group-ticket link') and names the identifier type used to locate it. This clearly distinguishes it from glpi_add_ticket_group and glpi_delete_ticket_user without needing to open 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?

Explicitly tells the agent where to obtain the required ID ('get the ID from glpi_list_ticket_groups'), which is genuine routing guidance. It does not state when-not to use this tool or what happens to the underlying ticket/group entities, so it stops short of full 5-level 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 already declare destructiveHint=true, idempotentHint=true and readOnlyHint=false, so the safety profile is covered by structured data. The description adds only the ID-provenance hint and says nothing about irreversibility, permission requirements, or what the audit reason is used for, so it adds limited context.

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 that front-loads the action and resource and parenthesizes the only non-obvious prerequisite. Zero wasted words.

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

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

An output schema exists, so return values need not be explained, and annotations cover the mutation/idempotency profile. With two fully documented parameters, the definition is essentially complete; only a note about the effect of removing a link would add value.

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 both ticketUserId and reason are already documented in the schema, with reason's audit-trail purpose and 10-char minimum made explicit there. The description adds only the sourcing note for ticketUserId, which is the expected baseline when the schema does the heavy lifting.

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

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

States a specific verb (Remove) and resource (user-ticket link) plus the exact identifier semantics (Ticket_User ID). It is clearly distinguishable from siblings like glpi_add_ticket_user and glpi_delete_ticket_group.

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 tells the agent where to obtain the required ID (glpi_list_ticket_users), which is the key prerequisite for calling this. It does not state when-not to use it or name alternative removal paths, so it stops short of full routing guidance.

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

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

The annotations already declare this operation destructive, non-read-only, and idempotent. The description adds no further behavioral context such as permission requirements, permanence of deletion, or the mandatory audit reason, so it contributes little beyond the structured safety hints.

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

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

The description is a single front-loaded sentence with no filler or repetition. It is appropriately sized for a simple delete tool and wastes no words.

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

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

With annotations covering the destructive/idempotent profile, a full input schema, and an output schema, the description is adequate for correct selection and invocation. It omits mention of the required audit reason, but the schema already enforces and explains that requirement.

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

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

Schema description coverage is 100%, so the schema fully documents both parameters, including the required audit reason. The description adds only 'by ID', which does not meaningfully extend the schema's parameter documentation. Baseline 3 applies when the schema carries the parameter 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?

The description states a specific verb and resource: 'Remove a validation request by ID.' It clearly identifies what is deleted and that an ID is required. It does not explicitly distinguish this tool from its create/update/list ticket-validation siblings, but the resource is specific enough to be understood.

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, no prerequisites, and no alternatives. It does not mention when to delete a validation request versus updating or listing validations, leaving the agent to infer usage 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 declare destructiveHint=true and idempotentHint=true, so the safety profile is already known. The description adds meaningful context beyond that: the default action is a recoverable trash, and purge escalates to irreversible removal. It does not mention the required audit reason, but the schema covers that.

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 short sentences with zero filler; the core action leads and the important purge nuance follows immediately.

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

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

An output schema exists, so return values need no explanation, and the annotations carry the safety profile. The description covers the key behavioral nuance; only the required reason/audit-trail expectation is left purely to the schema.

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

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

Schema coverage is 67%, with webhookId and reason documented in the schema while purge has no schema description. The description compensates by explaining exactly what purge does, which is the one undocumented parameter.

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

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

States a specific verb and resource ('Delete a webhook') and immediately clarifies the two deletion modes (trash vs purge). The webhook resource makes it unambiguous against the many other glpi_delete_* siblings.

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

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

It gives a condition for choosing purge ('to remove it permanently instead of trashing it'), which is genuinely useful, but it offers no guidance on when to delete a webhook at all versus alternatives like glpi_set_webhook_active for disabling one.

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

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

Annotations already declare readOnlyHint, idempotentHint, and destructiveHint=false, so the safety profile is fully covered. The description adds only the sibling routing, disclosing no further behavioral traits such as auth requirements, error behavior, or the essential/all field trimming effect on results.

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 short sentences, front-loaded with the core action and followed immediately by the disambiguation rule. Zero filler.

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

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

An output schema exists, so return values need no explanation, and the sibling for detail is named. Complete for the retrieval task, though it omits any note on what the asset ID refers to across types or the effect of expand_dropdowns on output.

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

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

Schema description coverage is 100%, and the schema richly documents all five parameters including enums and the fields/format semantics. The description adds no parameter meaning beyond what the schema provides, so it sits at the baseline.

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 (Retrieve), resource (asset), and scope (single, by type and ID). It also names the sibling glpi_get_asset_details and when to prefer it, so an agent can distinguish the two without opening either 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?

Explicitly routes hardware-detail lookups to glpi_get_asset_details, giving a clear condition that selects the alternative. It stops short of stating when-not to use this tool for non-hardware cases, but the guidance is concrete and actionable.

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

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

Annotations already declare readOnly/idempotent/non-destructive, so the safety burden is low. The description adds genuinely useful behavior: dropdown IDs are resolved to names, the default section set, and that softwares/networkports are the bulk of the payload. It doesn't cover pagination/truncation (schema does), but this is solid added context.

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 the core value (enriched view in one request), with no filler. Slightly dense in the second 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?

An output schema exists, so return values need not be explained, and the description covers default content, section behavior, and ID resolution. The remaining gap is the unstated relationship to the sibling glpi_get_asset and the default-sections inconsistency, but overall it is complete enough to call correctly.

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

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

Schema description coverage is 100%, so the baseline is 3 and the schema already documents fields/format/sections/max_items. The description adds the 'bulk payload' hint for choosing sections, but it also conflicts with the schema: the description implies softwares/networkports are not default while the schema states the default is 'devices, disks, softwares, networkports', which muddies rather than clarifies.

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 ('Enriched asset view in one request') and enumerates the default content (OS, processors, memory, disks), so an agent immediately knows what it returns. It does not explicitly distinguish itself from the sibling glpi_get_asset / glpi_list_assets, though 'enriched' implies it, so it falls short of a 5.

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

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

Gives real usage context — request ['softwares'] or ['networkports'] explicitly because they dominate the payload — which helps an agent size its request. However, it never says when to choose this over glpi_get_asset or glpi_list_assets, and gives no when-not guidance, 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?

Annotations already declare the safe read-only, idempotent profile, so the bar is lower. The description adds genuine behavioral context beyond them: related IDs come back with names beside them and status/priority labels are localized to the GLPI user's language, which materially affects how the agent should interpret the output.

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

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

A single tight sentence with the core action front-loaded and no filler. 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?

An output schema exists, so return values need not be described, and the safety profile is covered by annotations. The description is adequate for a simple ID lookup, though it omits error/not-found behavior or permission requirements.

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

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

Schema description coverage is 100%, so all four parameters (fields, format, changeId, expand_dropdowns) are already documented in the schema, which sets the baseline at 3. The description only loosely echoes the dropdown-expansion behavior ('names beside the IDs') without adding format or syntax 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 and resource ('Retrieve a change by ID'), so the agent knows exactly what it returns. It does not differentiate itself from near-siblings like glpi_list_changes or glpi_get_ticket, but the verb+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?

There is no when-to-use guidance, no mention of alternatives (e.g. glpi_list_changes for browsing, glpi_update_change for modification), and no prerequisites. Usage is only implied by 'by ID'.

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

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

Annotations already declare readOnlyHint, idempotentHint, destructiveHint=false and openWorldHint=false, so the safety profile is fully covered. The description adds nothing beyond that – no error behavior for a missing/invalid ID, no note on the fields/format defaults, no pagination or permission context.

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 zero waste. It is efficient, though borderline under-specified rather than genuinely concise-and-complete.

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 and schema coverage is 100%, so return values need no explanation in the description. Still, for a tool sitting among several document siblings, the lack of any routing or behavioral note leaves a modest gap that the structured fields do not fill.

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 both optional parameters (fields, format) carry full enum descriptions in the schema, so the baseline is 3. The description's 'by ID' only restates the required documentId and adds no syntax or default information beyond the schema.

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

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

States a specific verb and resource ('Retrieve a document by ID'), which is unambiguous on its own. It does not distinguish itself from siblings like glpi_list_documents or glpi_get_document_item, so an agent must infer the difference from the names alone.

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 the sibling document tools (list_documents, get_document_item). The 'by ID' phrasing implies single-item retrieval, but no alternatives or conditions are 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, idempotentHint, destructiveHint=false and openWorldHint=false, so the safety profile is covered. The description adds nothing beyond 'by ID' — no note on what the link represents or how missing IDs behave — so it contributes little extra context.

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. Efficient, though its brevity is achieved by omitting rather than by distilling useful content.

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

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

For a simple read tool with an output schema and rich annotations, the description need not explain return values or safety. The structured fields carry nearly everything an agent needs; only usage routing 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 description coverage is 100%, so documentItemId, fields, and format are fully documented in the schema. The description adds no formatting or field-set details, matching the baseline of 3 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 (Retrieve) and resource (Document_Item link) with the selection key (by ID). Clearly distinct from siblings like glpi_list_document_items or glpi_create_document_item, though it never names them 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?

No when-to-use guidance and no mention of alternatives. Retrieval by ID implies single-item lookup versus a list, but the agent is left to infer this from the name and schema 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, idempotentHint, destructiveHint=false and openWorldHint=false, so the safety profile is fully covered elsewhere. The description adds nothing on top of that: no note that a nonexistent ID fails or returns empty, no hint about what the 'essential' vs 'all' field sets change in practice. With annotations carrying the load this is a minor gap, but the description contributes zero behavioral context.

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, front-loaded sentence with no filler. It is efficient rather than padded, though it is arguably terse enough to be 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?

An output schema exists and all three parameters (including both enums) are described in-schema, so the description need not explain return values or formats. What remains missing for a lookup tool is any failure/not-found behavior or routing guidance, leaving it minimally adequate.

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

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

Schema description coverage is 100% and both enums are documented in-schema, so the description's phrase "by ID" only restates the required entityId parameter. Baseline 3 is appropriate when the schema does all the parameter 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 and resource ("Retrieve an entity by ID"), which cleanly separates it from glpi_list_entities, glpi_create_entity, glpi_update_entity and glpi_delete_entity. It stops short of naming those siblings or the condition that selects this tool over them, so it lands just below the top band.

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 alternatives, and no statement of when this is preferable to glpi_list_entities or glpi_get_my_entities. The ID-based retrieval is only implied by the tool name and purpose line.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, destructiveHint=false and openWorldHint=false, so the safety profile is fully covered. The description adds that the payload covers active entity, profile, and user details, which is modest added context, but says nothing about auth requirements or session-expiry behavior beyond what a session call implies.

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

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

Two short sentences, front-loaded with the action and payload, no filler. Slightly under-informative rather than bloated, so it earns its length without standing out as exemplary.

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-value documentation is not required, and the description still previews the key contents (entity, profile, user). For a zero-required-parameter, read-only introspection tool with full annotation and schema coverage, this is essentially complete.

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

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

Schema description coverage is 100% and both parameters are enums with documented values and defaults ('essential'/'all', 'json'/'markdown'), so the schema does the heavy lifting. The description contributes no parameter guidance at all, which is the expected baseline of 3 in this case.

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 ('full session info') and enumerates the contents: active entity, profile, user details. It is clearly distinct from sibling session-adjacent tools like glpi_get_my_entities or glpi_get_my_profiles, though it does not explicitly name those alternatives.

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

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

The description gives an implied usage context ('useful for debugging and verifying the current session context') but no explicit when-to-use versus when-not rules, and it never points to a sibling for a narrower query such as current entities or profiles.

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

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

Annotations already declare readOnlyHint, idempotentHint, destructiveHint=false and openWorldHint=false, covering the safety profile fully. The description adds nothing beyond that – no note about missing-group behavior, permission scope, or response shape – so it contributes no extra behavioral value.

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 and lookup key front-loaded and zero filler. It is efficient, though the brevity edges toward under-specification rather than model 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 a rich schema, an output schema, and full annotation coverage, the description needs to carry little – but for a lookup tool sitting among list/search siblings it should still indicate the ID-known precondition and point to glpi_list_groups.

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 clear docs on fields and format enums and the groupId type. 'By ID' aligns with the required groupId param but adds no syntax or constraint detail 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?

States a specific verb and resource ('Retrieve a group') plus the lookup key ('by ID'), so the agent knows exactly what it returns. It does not distinguish itself from the sibling glpi_list_groups, which is the obvious alternative for group lookups.

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 and no mention of glpi_list_groups as the alternative when the ID is unknown. The agent must infer that this tool requires a known groupId from the 'by ID' phrasing 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, idempotentHint, destructiveHint=false and openWorldHint=false, and the description adds nothing on top of that — no not-found behavior, no indication of caching or staleness. With a lower bar due to annotations, it still contributes zero behavioral context.

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, front-loaded with the verb and resource, with no filler or redundancy.

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

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

With an output schema present and 100% parameter coverage, the description is nearly sufficient for a simple read tool; the only shortfall is the absence of any guidance on usage or missing-ID handling.

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

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

Schema description coverage is 100%, so the schema already documents categoryId, fields, and format in detail; baseline 3 applies. The description's 'by ID' merely restates the required parameter and adds no syntax or semantics beyond the schema.

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

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

States a specific verb (Retrieve) and resource (ITIL category) scoped to a single item via ID, which implicitly separates it from the sibling glpi_list_itil_categories. It does not explicitly name that sibling, but the singular/plural distinction 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 when-to-use guidance, no prerequisites, and no named alternative. The agent must infer that this is the single-item lookup versus glpi_list_itil_categories, and gets no signal about what to do when the ID is unknown.

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

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

Annotations already declare readOnlyHint, idempotentHint, non-destructive and closed-world, covering the full safety profile of a simple read. The description adds no behavioral context beyond that (e.g. what happens on a missing/invalid ID), so it neither helps nor contradicts.

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 zero filler; the resource and lookup key come first. Nothing could be trimmed without losing meaning.

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

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

With an output schema present and 100% parameter coverage, the return values and inputs are handled by structured fields, and annotations cover safety. For a simple single-item read this is nearly complete; only explicit sibling routing is missing.

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

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

Schema description coverage is 100% and the schema documents all four parameters including the 'fields' and 'format' enums. The description adds nothing about parameters, so the baseline of 3 applies since the schema does the heavy lifting.

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

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

States a specific verb ('Retrieve') and resource ('followup template') scoped by identifier ('by ID'), which implicitly distinguishes it from the list/create/update siblings. However, it never names those alternatives, so an agent gets no explicit differentiation.

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

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

The phrase 'by ID' implies the caller must already hold a templateId, but there is no statement of when to use this versus glpi_list_itil_followup_templates or when it should not be used. No prerequisites or alternatives are given.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false, so safety is covered structurally. The description adds nothing beyond that—no note on behavior when categoryId does not exist, permission requirements, or whether a missing ID errors versus returns 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?

One short sentence, front-loaded with the verb and resource, with zero padding. It is efficient, though its brevity borders on under-specification rather than true concision.

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 the annotations cover the read-only nature. However, for a 3-parameter tool with optional fields/format controls, the description omits any context about default behavior or error handling, leaving it only minimally adequate.

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

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

Schema description coverage is 100%, so the schema already documents categoryId, fields ('essential'/'all'), and format ('json'/'markdown'). The description's 'by ID' adds no meaning beyond the schema, so the baseline 3 applies.

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