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

Annotations are absent, so the description carries the burden. It discloses the meaning of is_private (visible only to technicians), which is a useful behavioral trait beyond the schema. However, it does not mention permissions, reversibility, or what happens on success/failure.

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, front-loaded with the purpose, and includes only the crucial parameter semantic. No wasted words.

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

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

For a simple 3-parameter mutation with no output schema, the description is minimally sufficient but lacks broader context like prerequisites (e.g., ticket existence) or permissions. It is not as complete as it could be.

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

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

Schema description coverage is 0%, so the description must compensate. It explains is_private semantics, which is the least obvious parameter, but leaves ticket_id and content without any added detail beyond their names.

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

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

The description uses the specific verb 'Ajoute' (adds) and identifies the resource 'un suivi à un ticket' (a follow-up to a ticket). This clearly distinguishes it from sibling read tools like list_followups and get_followup.

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 is provided about when to use this tool versus alternatives, such as list_followups or add_task. The description only states what it does without any context or exclusions.

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

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

No annotations are provided, so the description must carry the full behavioral burden. It only says a group is added to an article's visibility and does not disclose mutation side effects, permission requirements, whether existing visibility entries are replaced or appended, or how entities_id and is_recursive affect behavior.

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

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

The description is short, front-loaded, and structured with a parameter bullet. It avoids filler, though its brevity is partly due to omitted information rather than disciplined 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?

For a mutation tool with four parameters, no annotations, no output schema, and 0% schema description coverage, the description is incomplete. It omits the required article_id, the optional entity/recursive behavior, and any return or permission context.

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

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

Schema description coverage is 0%, so the description should compensate. It defines only groups_id as a GLPI group ID, leaving the required article_id and optional entities_id and is_recursive completely unexplained in both schema and description.

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

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

The description states a specific verb ('Ajoute') and resource ('un groupe dans la visibilité d'un article KB'), making the core action clear. It distinguishes itself from profile-visibility siblings by naming a group rather than a profile, but it does not explicitly contrast with update_kb_article_visibility_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?

There is no guidance on when to use this tool versus alternatives such as update_kb_article_visibility_group or add_kb_article_visibility_profile. Usage is only implied by the tool name and the brief action statement.

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

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

With no annotations, the description carries the full burden of behavioral disclosure, but it only states the basic add operation and explains the effect of is_recursive and entities_id. It omits critical traits such as permission requirements, idempotency/deduplication behavior, side effects on existing visibility, and error cases.

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

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

The description is front-loaded with the tool's purpose and uses a compact bullet list for parameter clarifications. Every sentence and bullet earns its place with no redundancy.

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

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

For a mutation tool with four parameters, no annotations, and no output schema, the description is too thin. It fails to document the required article_id, does not describe permissions or side effects, and gives no indication of what happens when a visibility entry already exists.

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

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

Schema coverage is 0%, so the description must supply parameter meaning. It explains profiles_id, entities_id (0 = root entity), and is_recursive (apply to sub-entities), adding value beyond the bare schema. However, it completely omits the required article_id parameter, leaving a significant gap.

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

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

The description states a specific verb ("Ajoute") and resource ("un profil dans la visibilité d'un article KB"), clearly distinguishing it from the sibling add_kb_article_visibility_group (group vs profile) and update variants. An agent can tell what it does without opening the schema.

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

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

No guidance is given on when to use this tool versus alternatives, or on prerequisites such as required permissions or whether the article/profile must already exist. The description simply states what it does, leaving the agent to infer usage context.

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

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

With no annotations, the description carries the full burden of behavioral disclosure. It explicitly mentions a key side effect: 'le clôture automatiquement selon la config GLPI' (automatically closes it according to GLPI config). However, it does not disclose other potential behaviors such as permissions, reversibility, or what happens if the ticket is already closed, leaving gaps 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?

The description is concise and front-loaded, consisting of two short sentences that state the primary function and a key side effect. No unnecessary words or repetition.

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

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

Given the tool's simplicity (3 parameters, no output schema), the description covers the main action and one parameter, but it does not mention what the tool returns, any prerequisites (e.g., ticket must exist), or error cases. It is adequate but has notable omissions for a complete understanding.

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

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

The input schema has 0% description coverage, so the description must compensate. It adds meaning only for solution_type_id ('ID du type de solution si applicable'), but does not explain ticket_id or content, which are essential. The description provides minimal added value beyond the schema's parameter names.

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

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

The description clearly states the action: 'Poste une solution sur un ticket' (Post a solution on a ticket), which specifies the verb and resource. It also distinguishes from sibling tools like add_followup (which posts a follow-up) and get_solution (which retrieves a solution) by focusing on posting a solution, not just any comment.

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 clear context: it is used to post a solution on a ticket, and it automatically closes the ticket depending on GLPI configuration. It does not explicitly mention alternatives or exclusions, but the action and auto-close behavior imply when it should be used (when a solution is ready to be submitted).

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

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

No annotations are provided, so the description must disclose behavioral traits. It only states the core action and explains two parameter values (status, duration_seconds), but omits side effects, permissions, error behavior, or return value. For a mutation tool with zero annotations, this is insufficient.

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

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

The description is brief and front-loaded with the purpose, followed by a concise bullet list for two parameters. Every sentence earns its place with no redundancy or fluff.

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

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

With 6 parameters, no annotations, and no output schema, the description is not sufficiently complete. It does not explain what the tool returns, any prerequisites (e.g., ticket must exist), or the meaning of is_private and assigned_user_id, leaving significant gaps for safe autonomous use.

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

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

Schema description coverage is 0%, so the description must compensate. It provides useful semantics for status (1=To do, 2=Done) and duration_seconds (in seconds with example), but ignores ticket_id, content, is_private, and assigned_user_id, leaving four of six parameters unexplained.

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

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

The description clearly states 'Crée une tâche sur un ticket' (Creates a task on a ticket), providing a specific verb, resource, and context. This distinguishes it from sibling tools like list_tasks, update_task, and delete_task.

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

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

Usage is implied by the name and description: use this to add a task to a ticket. However, there are no explicit alternatives or exclusions mentioned, and no guidance on when to prefer this over related tools like add_followup or update_task.

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

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

No annotations exist, so the description carries full burden. It usefully discloses a non-obvious side effect (supplier_id triggers a Contact_Supplier link and adds a '_supplier_link' key to the result) and an input-format constraint (comment must be HTML, never Markdown). It doesn't mention auth requirements, failure modes, or duplicate handling, but the two disclosures are meaningful behavioral value beyond the schema.

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

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

Front-loaded purpose followed by a bulleted parameter legend that is easy to scan. Efficient for what it covers, though bullets are somewhat 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?

A 14-parameter mutation tool with no annotations, no output schema, and 0% schema coverage. The description discloses the key required param, the supplier-link side effect, and the comment format, but leaves most optional fields (address, phone, email, etc.) undocumented and says nothing about permissions or response beyond the '_supplier_link' key. Adequate but with clear gaps.

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

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

Schema description coverage is 0%, so the schema names 14 parameters with no explanation. The description compensates partially by explaining name, contact_type_id, supplier_id, and comment, but leaves 10 parameters (fax, town, email, phone, mobile, phone2, address, country, postcode, firstname) undocumented. Marginal value added, not full compensation.

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

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

States a specific verb (Crée) and resource (contact / personne-ressource chez un fournisseur) that clearly distinguishes it from update_contact and delete_contact in the sibling list. The parenthetical gloss on what a contact is adds useful specificity.

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?

Implies usage context through the parameter explanations (e.g., 'si fourni, le contact est rattaché'), but never explicitly says when to use this versus update_contact or how it relates to create_supplier in a workflow. No exclusions or prerequisites stated.

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

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

With no annotations, the description carries the full burden and does a decent job: it declares name as the sole required field, states that duration/notice/periodicity/billing are in MONTHS (GLPI convention), that supplier_id triggers a Contract_Supplier linkage, and that the result then contains the '_supplier_link' key. It omits auth/permission needs and other side effects, but the disclosed conventions are genuinely useful.

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

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

The purpose is front-loaded and the bullet list keeps each sentence focused on one parameter. No filler; the structure maps cleanly to the schema.

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

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

For an 11-parameter creation tool with no annotations and no output schema, the description is mostly complete but leaves contract_type_id and accounting_number entirely undocumented and gives only a partial picture of the return shape. Adequate but with clear gaps.

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

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

Schema description coverage is 0%, so the description must compensate, and it does for 8 of 11 params: it adds date format (AAAA-MM-JJ), the month unit convention for four numeric fields, the HTML-not-Markdown constraint for comment, and the behavioral effect of supplier_id. contract_type_id and accounting_number are left undocumented, keeping it short of 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 and resource ('Crée un contrat'), which is unambiguous. It does not, however, distinguish itself from siblings like update_contract or delete_contract beyond the verb. Clear but not sibling-differentiated.

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 update_contract or when a contract should instead be linked to a supplier/type. Field-level docs are provided, but no usage context, prerequisites, or exclusions are stated.

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

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

With no annotations, the description carries the full burden. It does disclose useful behavior beyond the schema: answer accepts HTML, and is_faq=True publishes into the public FAQ (a visibility side effect). However, it omits permissions/auth requirements, whether creation is reversible, and validation behavior for category_id.

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

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

Front-loads the purpose in one line, then a tight bullet list per parameter with zero filler. Well sized for a four-parameter mutation tool, though the bullets simply mirror the schema 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 no annotations and no output schema, the description covers purpose and all parameters but says nothing about the returned article identifier, required permissions, or error conditions. Adequate but leaves notable gaps for a write operation.

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

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

Schema description coverage is 0%, so the description must compensate and it largely does, defining all four parameters: name as the article title, answer as content/solution with HTML accepted, category_id as an optional KB category ID, and is_faq as public-FAQ publishing. It lacks format details for category_id (how to discover valid IDs) but adds real meaning over the bare 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+resource: 'Crée un nouvel article dans la base de connaissances.' An agent can tell this creates a KB article, distinguishing it from create_ticket/create_supplier, though it never explicitly contrasts with siblings like update_kb_article or add_solution.

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 mention of alternatives such as add_solution or update_kb_article. The agent must infer from the name alone when this tool is the right choice.

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

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

With no annotations, the description carries the full burden. It adds one useful behavioral constraint (comment must be GLPI-compatible HTML, never Markdown), but says nothing about permissions, what happens on duplicate names, what the response contains, or side effects of creating a supplier.

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?

Concise and front-loaded: the purpose sentence precedes three terse field bullets with no wasted words. The structure is efficient, though the bullets only cover a fraction of the actual parameters.

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 13-parameter mutation tool with no annotations and no output schema, the description is materially incomplete: ten parameters are unexplained and there is no account of authorization, validation, or result behavior. The HTML/Markdown constraint is helpful but isolated.

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

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

Schema description coverage is 0%, so the description must compensate, yet it documents only 3 of 13 parameters (name, supplier_type_id, comment). The HTML-not-Markdown note and the 'only required field' marker add real value, but the other 10 fields (fax, town, email, state, address, country, website, postcode, is_active, phonenumber) are undocumented in both schema and description.

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

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

The description opens with a specific verb+resource ('Crée un fournisseur'), which clearly identifies the create operation and implicitly distinguishes it from update_supplier, delete_supplier and list_suppliers. It does not, however, explicitly name or route away from those siblings, 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 alternatives, no prerequisites for creation, and no mention of the sibling tools it competes with. Only the field list is provided, which is parameter documentation rather than 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?

With no annotations, the description carries the full burden of behavioral disclosure. It adds the type and priority code mappings, which is useful, but it does not disclose side effects (e.g., notifications), whether authentication is required, what happens on successful creation, or whether the created ticket's ID is returned. This is minimal transparency for a create operation.

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

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

The description is exceptionally concise, consisting of one sentence and a short bullet list. It front-loads the main purpose and immediately provides the necessary value mappings for type and priority. Every line earns its place with no wasteful verbosity.

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

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

Given the tool has 7 parameters, no output schema, and no annotations, the description is incomplete. It does not explain the return value, required field semantics beyond names, or any post-creation behavior. An agent would lack critical context about the outcome of the operation and how to interpret the optional assignee/category fields. The description is minimally viable at best.

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

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

The input schema has 0% description coverage, so the description must compensate. It explains the meaning of 'type' (1=Incident, 2=Service request) and 'priority' (1 very low to 6 major), but it does not explain the other five parameters, including required 'name' and 'content' or optional fields like 'category_id', 'assigned_user_id', and 'assigned_group_id'. Some names are self-explanatory, but the description adds meaning to only 2 of 7 parameters.

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

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

The description clearly states 'Crée un nouveau ticket' (Creates a new ticket), which uses a specific verb and resource. This distinguishes it from sibling tools like update_ticket, delete_ticket, and list_tickets within the same ticket domain. The additional type and priority mappings reinforce 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?

No guidance is provided on when to use this tool versus alternatives. The description does not mention that update_ticket should be used for existing tickets, nor does it state any prerequisites or context such as requiring a valid category or assignee. The usage is implied by the tool name but not explicitly stated.

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

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

With no annotations, the description carries the full behavioral burden and does so well: it discloses that the default is a reversible trash operation with a concrete restore path, and that purge=True is definitive and IRRÉVERSIBLE. It omits permission requirements and error behavior, keeping it short of a 5.

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

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

Two tight bullet points, front-loaded with the basic action and then the flag trade-off; every clause carries decision-relevant information with no padding.

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 2-parameter destructive tool with no annotations and no output schema, the description supplies the crucial reversibility semantics an agent needs. Minor gaps remain around permissions, failure cases, and whether dependent records are affected.

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

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

Schema description coverage is 0%, so the description must compensate — and it fully explains the non-obvious purge parameter, including its default and the semantic difference between the two modes. contact_id is left implicit but is self-evident from the resource name.

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

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

States a specific verb (supprime) and resource (un contact) unambiguously. It does not explicitly contrast with sibling deletion tools (delete_ticket, delete_supplier, delete_contract) or with update_contact's soft-delete flag, so it is clear but not sibling-differentiating.

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 purge flag guidance effectively tells the agent when to use each mode: default for recoverable removal, purge=True only when permanent deletion is intended. It also names the recovery alternative update_contact(contact_id, {"is_deleted": 0}), though it does not state exclusions or warn about when NOT to purge.

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

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

With no annotations provided, the description carries the full behavioral burden and does so well: it discloses that purge=False is reversible, purge=True is permanent and irreversible, and that purge=True also removes the contract's links to its equipment and supplier. It also gives the exact update_contract call for reversing a soft delete.

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

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

The description is front-loaded with a one-line purpose, then uses a compact bullet structure to explain the two purge modes. Every sentence provides necessary operational information, with no filler or repetition.

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

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

For a deletion tool with no annotations, no output schema, and low schema description coverage, the description is complete enough to invoke correctly and safely. It covers the purpose, the parameter-dependent behavior, the irreversibility warning, the cascade side effect, and the reversal mechanism.

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

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

Schema description coverage is 0%, so the description must compensate. It thoroughly explains the non-obvious 'purge' parameter, including default value and both boolean effects, and contract_id is implied by the tool name plus the example update_contract(contract_id, ...). The contract_id parameter itself is not separately defined, but its meaning is unambiguous.

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

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

The description opens with a specific verb and resource: 'Supprime un contrat.' This clearly distinguishes it from sibling deletion tools for suppliers, contacts, tickets, tasks, and follow-ups. The added purge semantics further pin down what kind of deletion operation this is.

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 explicitly explains the default behavior (purge=False -> trash) and the irreversible mode (purge=True), and it names update_contract as the reversal path. However, it does not explicitly state when to prefer this tool over update_contract for soft deletion or when not to use it, so it falls just short of a full when/when-not/alternatives statement.

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

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

With no annotations, the description carries the full burden and does so: it declares the operation destructive, non-reversible from this tool, and notes the followup vanishes from the ticket's audit trail — non-obvious consequence an agent would otherwise assume away.

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

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

Front-loads the purpose in one short sentence, then a clearly marked ATTENTION block for the irreversible warning and alternatives. Every sentence earns its place with no filler.

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

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

No annotations or output schema exist, so the description must supply behavior — and it covers destructiveness, irreversibility, and routing. Only permission/auth requirements and the exact post-delete state of the ticket are unstated, which is a small residual gap for a mutation tool.

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

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

Schema description coverage is 0% and the single parameter followup_id is never explained in the description. Its integer id nature is inferable from the name, so the gap is minor, but the description adds nothing about format or scope.

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

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

States a specific verb and resource ('Supprime un suivi'), naming exactly what is deleted. Combined with the alternatives it names (update_followup, add_followup), an agent can distinguish it from every sibling 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?

Explicitly restricts use to followups published by mistake (wrong ticket, duplicate) and routes two distinct correct alternatives: update_followup for content fixes and add_followup for qualifying a conclusion. When-to-use, when-not-to-use, and alternatives are all present.

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

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

With no annotations, the description carries the full burden and discloses key traits: soft-delete vs permanent deletion, reversibility, and cascade effects on related entities. It does not mention required permissions or rate limits, but the core destructive behavior and side effects are clearly surfaced.

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

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

The description is front-loaded with the core action, then uses a bullet list for the purge modes and a final caution. Every sentence adds necessary information with no filler.

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

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

For a 2-parameter mutation tool with no output schema and no annotations, the description covers the essential behavioral details: default vs purge behavior, reversibility, cascade effects, and usage context. Nothing critical is missing that would prevent correct invocation.

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

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

Schema description coverage is 0%, so the description must compensate. It thoroughly explains the purge parameter (default false, reversible vs irreversible, cascade effects), though supplier_id is only implied by context and not further described. This adds substantial meaning beyond the bare 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 ('Supprime') and resource ('un fournisseur'), making clear it deletes a supplier. It also distinguishes this from the recovery path via update_supplier, so an agent can tell it apart from siblings like update_supplier and delete_contact.

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

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

It explicitly describes two modes: purge=False (reversible via update_supplier) and purge=True (irreversible, also removes links to contracts, contacts, materials, and tickets). It ends with a clear condition: only use it on a duplicate or an erroneous entry, which is exactly the when-to-use guidance needed.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It only mentions that a task is deleted, but does not clarify whether deletion is permanent, whether it cascades to related data, or what happens on error. The basic action is stated, but no additional behavioral traits are disclosed.

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

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

The description is concise and front-loaded with the verb, but it is under-specified for a destructive operation. It is a single short sentence that conveys the core action, but lacks any additional context that could be expected in a tool description.

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

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

For a simple delete operation with one parameter, the description is incomplete: it does not explain success/failure behavior, whether the action is reversible, or mention any side effects. Given that no annotations or output schema exist, the description should provide more context but does not.

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 has one parameter, task_id, which is self-explanatory by name and title, but the description adds no meaning beyond it. Since schema_description_coverage is 0%, the description fails to compensate by clarifying the parameter's purpose, constraints, or error behavior.

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 'Supprime une tâche' clearly states the action (delete) and the resource (task) with a specific verb, distinguishing it from sibling tools like list_tasks, add_task, and update_task.

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, nor does it mention prerequisites, permissions, or consequences. It simply states the action without any contextual instructions.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It states only that it deletes a ticket by ID, but does not disclose whether deletion is permanent, whether it cascades to linked items (e.g., followups, links), or if any permissions are required. This is a destructive operation with significant missing 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?

The description is a single, short sentence: 'Supprime un ticket par son ID.' It is front-loaded with the action and has zero wasted words, making it highly concise and easy to parse.

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

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

For a destructive operation with no annotations and no output schema, the description is incomplete. It does not explain the consequences of deletion (irreversibility, cascading effects), whether the operation is confirmable, or what happens if the ticket does not exist. While the tool is simple, an agent still lacks critical context to correctly assess the side effects.

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

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

The input schema has a single required parameter 'ticket_id' (integer) with no description, so schema coverage is 0%. The description 'par son ID' (by its ID) does add minimal clarification that the parameter corresponds to the ticket's ID. However, since the parameter name is self-explanatory and the description adds no format or constraint details, it only partially compensates for the schema gap.

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

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

The description 'Supprime un ticket par son ID' uses a specific verb ('Supprime' = deletes) and resource ('ticket') with a clear scope ('par son ID' = by its ID). This clearly states what the tool does and distinguishes it from sibling tools like update_ticket, get_ticket, and search_tickets.

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, nor does it mention any exclusions or prerequisites. The intended usage (deleting a ticket) is implied by the verb, but there is no explicit context such as 'use when a ticket should be permanently removed' or 'do not use if you need to archive instead'.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It only states that it returns details, but does not mention error behavior for nonexistent IDs, authentication requirements, or any side effects. For a read operation, the behavior is predictable, but the lack of any behavioral detail is a gap.

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

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

The description is a single, clear, front-loaded sentence. It conveys the essential action and object with no wasted words, earning a perfect score for conciseness.

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

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

For a simple single-parameter get-by-ID tool, the description is minimally sufficient to understand its purpose. However, it omits return format, error scenarios, and any prerequisites. Given the absence of annotations and output schema, the description is not fully complete but adequate for basic selection.

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

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

Schema description coverage is 0%, and the description does not explain the followup_id parameter beyond the schema. While the parameter name is self-explanatory, the description adds no semantic value, and the rubric requires compensation for low coverage.

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

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

The description uses a specific verb ('Retourne') and resource ('détail d'un suivi spécifique'), clearly indicating it fetches a single follow-up record. This differentiates it from sibling tools like list_followups (list) and add_followup (create), making the purpose unambiguous.

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

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

Usage is implied: this tool is for retrieving one follow-up by ID, especially when a list is already available. However, there is no explicit guidance on when to use it versus alternatives like list_followups or get_ticket, nor any exclusions or prerequisites.

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

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

No annotations are present, so the description must fully disclose behavioral traits. It only says 'lists groups,' omitting any details on read-only nature, authentication requirements, pagination, or side effects. For a simple list tool, this is minimal but leaves important context undisclosed.

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 that is front-loaded and contains no filler. Every word earns its place.

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

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

The description tells what the tool does but does not explain the return value shape, any limits, or broader context. Since no output schema exists, the agent is left without knowing what fields a group contains or if the list is paginated. This is a meaningful gap, though acceptable for a very simple tool.

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

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

With zero parameters, the schema completely covers parameter semantics. The baseline of 4 is appropriate as there is no additional parameter meaning the description could add.

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

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

The description clearly states the verb (list) and resource (GLPI groups), distinguishing it from sibling tools like list_tickets or get_users. It is specific and unambiguous.

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

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

No guidance is provided on when to use this tool versus alternatives, nor any preconditions or context. It simply states the function without usage direction.

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

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

No annotations are provided, so the description carries the full behavioral burden. It implies a read ('Retourne le détail complet') but omits whether visibility restrictions apply (relevant given sibling visibility tools), whether it errors on unknown/missing articles, and what the returned detail includes. For a tool with zero annotation coverage, this is a notable gap.

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

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

A single, front-loaded sentence with no wasted words. It is efficient, though the brevity is partly under-specification rather than true concision, and the French text sits inconsistently alongside the English sibling toolset.

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

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

With no annotations, no output schema, and an undocumented parameter, the description should do more work. For a lookup tool it is not catastrophic, but key details – visibility behavior, error cases, and parameter meaning – are all 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?

The schema has 0% description coverage for article_id and the description says nothing about the parameter's format, source, or constraints. The intent ('un article') hints at an identifier, but the description does not compensate for the undocumented parameter as it ideally should when coverage is this low.

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 ('Retourne') and resource ('le détail complet d'un article de la base de connaissances'), which maps cleanly to get_kb_article. It does not, however, explicitly distinguish itself from siblings like get_solution, search_kb_articles, or list_kb_articles, so the boundary is left to inference.

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

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

There is no guidance on when to use this tool versus search_kb_articles or list_kb_articles, nor any stated prerequisites such as needing a known article_id. The agent must infer the usage context entirely.

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

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

With no annotations, the description carries the full behavioral burden. 'Retourne' implies a read-only operation, and the listed entity types add useful context, but permissions, authorization requirements, and any rate limits are not disclosed.

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

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

The description is two compact lines with the action and returned entity types front-loaded. Every clause adds information, and 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 explained in detail. The description names the visibility categories returned and is sufficient for a simple one-parameter read operation, though it lacks alternative-tool routing guidance.

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

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

Schema description coverage is 0%, so the description should compensate. 'D'un article KB' implies that article_id identifies the target article, but it does not specify the parameter name, expected format, or type. For a single simple parameter this is minimally adequate.

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 ('Retourne') and resource ('règles de visibilité d'un article KB'), and enumerates the returned entity types (profils, groupes, utilisateurs, entités). It does not explicitly differentiate itself from sibling add/update visibility tools, but the read-oriented purpose is clear.

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

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

There is no guidance on when to use this tool versus alternatives such as add_kb_article_visibility_profile, update_kb_article_visibility_group, or get_kb_article. The agent must infer usage from the tool name alone.

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

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

No annotations are provided, so the description carries the full burden. It only says 'returns' which implies read-only, but does not disclose error behavior, permissions, or return format. For a get tool this is somewhat expected, but the lack of any behavioral detail beyond the name leaves gaps.

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, clear sentence with no wasted words. It is front-loaded and easy to parse, achieving conciseness without sacrificing the core purpose.

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, but with no output schema and no annotations, the description should explain what 'solution' means and what the return value looks like. It does not, and it also lacks any contextual guidance, making it incomplete.

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

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

Schema coverage is 0% for the single parameter ticket_id, and the description does not mention or explain it. The description offers no compensation for the schema's lack of parameter documentation.

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 'Retourne la solution d'un ticket' clearly states the tool retrieves a ticket's solution. It has a specific verb and resource, and while it doesn't explicitly differentiate from siblings, the sibling 'add_solution' is the write counterpart, and no other get-solution sibling exists.

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 is provided on when to use this tool vs alternatives like get_ticket or search. There is no mention of prerequisites, context, or exclusions.

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

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

The description discloses that the output includes readable labels ('avec libellés lisibles'), adding useful context beyond the tool name. However, with no annotations provided, it does not cover potential edge cases, auth requirements, or error behaviors, leaving gaps in transparency.

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

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

The description is a single concise sentence, front-loaded with the action and resource. It avoids unnecessary wording and is appropriately sized for a simple get operation.

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

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

Given the tool's simplicity (one parameter, output schema present), the description covers the core function and adds a note about readable labels. However, it lacks usage guidance and parameter-level detail, which is partially compensated by the self-explanatory parameter name and output schema.

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

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

The description does not specifically explain the ticket_id parameter; it only refers to 'un ticket', which is already evident from the parameter name. With 0% schema description coverage, the description fails to add meaningful semantics beyond the schema's field name and type.

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

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

The description clearly states the tool returns the complete detail of a ticket, using the verb 'Retourne' and identifying the resource ('un ticket'). It distinguishes from list/search tools by emphasizing a single ticket's full detail, though it does not explicitly name alternative tools.

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

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

No guidance is provided on when to use this tool versus alternatives like list_tickets or search_tickets. There is no mention of exclusions or prerequisites, leaving the agent without context for tool selection.

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

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

With no annotations, the description should carry the full burden of behavioral disclosure, but it offers no additional insights. It restates the tool's name ('get_users' vs 'Liste les utilisateurs') without revealing read-only status, authentication needs, response formats, or side effects.

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

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

The description is a single, direct sentence with no filler, repetitive, or extraneous content. It is appropriately sized for a parameterless, simple listing tool.

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

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

For a zero-parameter tool with no output schema, the description is minimally adequate: it states the core action and resource. However, it lacks any detail about return data, scope, or usage context, leaving the agent without useful operational specifics.

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

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

The input schema has zero parameters, so the baseline for parameter semantics is 4. The description has nothing to add since there are no parameter details to explain.

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

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

The description explicitly states 'List' (list) and 'utilisateurs GLPI' (GLPI users), clearly indicating the tool's action and resource. Since no sibling tool targets users, it successfully distinguishes itself from alternatives without needing 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?

No guidance is provided about when to use this tool versus others. The description only states what it does, not when it should be preferred, and there is no mention of alternatives, exclusions, or prerequisites.

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

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

The phrase 'Ferme proprement' adds a behavioral nuance beyond the name, indicating a graceful shutdown rather than an abrupt kill. However, with no annotations, the description does not disclose side effects, authentication requirements, or idempotency, leaving the agent with limited understanding of consequences.

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

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

The description is a single sentence that is direct and front-loaded, immediately conveying the action. No wasted words.

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

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

Given the simplicity of the operation and the existence of an output schema, the description covers the core action but omits contextual details such as when to close the session, whether it affects ongoing operations, or any cleanup behaviors beyond 'cleanly'. This is adequate but leaves some gaps.

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

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

The tool has zero parameters, and the description rightfully does not attempt to explain parameters. Per the baseline for 0-parameter tools, the description provides sufficient semantic value.

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 explicitly states the tool closes the active GLPI session, using a specific verb (closes) and resource (session). It clearly distinguishes from sibling tools that handle tickets, users, and knowledge base.

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 offers no guidance on when to use this tool or any exclusion criteria. There is no mention of prerequisites, alternatives, or timing relative to other operations.

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

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

With no annotations, the description carries the full burden of behavioral disclosure. It does not mention anything about the effect of existing links, directionality, permissions, idempotency, or return values. This is a significant gap 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?

The description is extremely concise, consisting of a single clear sentence plus a bullet list for link_type values. Every element earns its place with no unnecessary wording.

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

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

The tool is simple with only three parameters and no output schema. The description covers the main purpose and the link_type values, but it fails to explain directional semantics (which ticket is parent/child) or any behavioral outcomes. It is adequate but has clear gaps, especially given the lack of annotations.

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?

For ticket_id_1 and ticket_id_2, the schema provides only names, and the description adds no semantic meaning. However, the description does add meaning for link_type by enumerating its possible values, which is valuable. The coverage is incomplete, as the order/role of the two ticket IDs is not clarified, and the default value is not mentioned in the description.

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

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

The description clearly states the action ('Crée un lien') and the resource ('deux tickets'), which is specific and unambiguous. It does not explicitly distinguish from siblings like list_ticket_links or merge_tickets, but the core purpose is clear.

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

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

The description implicitly indicates when to use the tool (when you need to link two tickets), but does not provide explicit guidance on when not to use it or mention alternatives. It meets the 'implied usage' level but lacks direct exclusions or alternative references.

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

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

No annotations are provided, so the description must carry the full burden of behavioral disclosure. The verb 'Liste' signals a read operation, but the description does not disclose ordering, pagination, response format, or error behavior, which is a notable gap for a list operation.

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

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

The description is a single, concise sentence that immediately states the action and object. It contains no redundant words or filler, achieving maximum clarity in minimal space.

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

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

For a simple list operation with a single parameter, the description covers the core purpose, which is adequate. However, the lack of annotations and output schema, combined with missing behavioral details, leaves some ambiguity about the exact return shape and edge cases, though the tool itself is simple enough that the core intent is clear.

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 only parameter, ticket_id, is described only by its type and name in the schema (0% schema description coverage). The description mentions 'd'un ticket' but adds no additional meaning about the parameter's role, format, or constraints beyond what is already obvious from the name.

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

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

The description uses a specific verb ('Liste') and resource ('tous les suivis d'un ticket') to clearly state that it lists all follow-ups for a ticket. This distinguishes it from sibling tools like get_followup (single follow-up) and add_followup (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 purpose is inferred from the name and description, but there is no explicit statement of when to use it versus alternatives such as get_followup. The description does not mention exclusions or preconditions, but the usage is easily 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?

No annotations are present, so the description must carry the full burden of behavioral disclosure. It only lists category examples but does not describe the return format (e.g., an array of strings), whether the list is static or filtered by ITIL process type, or if any localization is applied. The description largely repeats the tool's name without adding operational insight.

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

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

The description is a single concise sentence that is front-loaded with the action and resource, followed by clarifying examples. Every word earns its place, and there is no redundant or verbose 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 zero-parameter, list-only tool, the description is largely complete: it states the tool's purpose and gives examples of the expected content. However, it omits any detail about the return structure (e.g., whether it returns a JSON array, or if categories are returned as strings or objects), which would be useful given the absence of an output schema.

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

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

The tool takes zero parameters, and the input schema is empty; thus the baseline of 4 applies. The description's examples are irrelevant to parameter semantics but do not detract. There is no parameter information needed beyond what the schema already conveys.

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

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

The description clearly states the tool's action ('Liste toutes') and resource ('catégories ITIL disponibles'), with concrete examples (Incident, Demande, Changement, Problème). It distinctly separates this from sibling tools like list_kb_categories by specifying ITIL categories.

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 usage guidance is provided, such as when to use this tool versus alternatives like list_kb_categories for knowledge base categories. The description does not mention prerequisites or typical use cases, leaving the agent to infer the tool's purpose from its name.

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

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

With no annotations, the description fully discloses the heavy response payload, the memory limit issue, auto-clamping behavior, and the response wrapper dict with _clamped_range_limit and _warning. It also states the unchanged behavior for range_start <= 60, giving the agent a complete behavioral model.

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

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

The description is well-structured, starting with the core purpose, then explaining the behavioral caveat, the clamp rule, and the warning wrapper. Each sentence contributes essential information with no fluff, and the length is justified by the complexity of the behavior.

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

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

The tool has no output schema, but the description covers the return format (dict with _clamped_range_limit and _warning) when clamping occurs. It addresses potential memory failures, making the description complete for safe usage. No additional details are necessary for a simple listing tool with pagination.

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

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

Schema description coverage is 0%, so the description must compensate. It explains how range_start and range_limit interact (range_start > 60 combined with range_limit > 10 triggers clamping) and clarifies the clamping effect. While it doesn't define them as offset/limit, it gives meaningful context that helps the agent choose appropriate values.

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 'List GLPI knowledge base articles with pagination' with a specific verb and resource, clearly distinguishing it from siblings like get_kb_article (single article) and search_kb_articles (search).

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

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

The description clearly implies usage for listing with pagination, but does not explicitly compare to alternatives such as search_kb_articles or mention when not to use this tool. The pagination and memory caveats provide context but not direct 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?

With no annotations, the description carries the full behavioral burden, yet it says nothing about whether the list is paginated, ordered, scoped to a knowledge base, or returns only visible categories. For a trivial read-only list the risk is low, but the disclosure is essentially absent.

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

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

A single front-loaded sentence with no filler or redundancy. Every word earns its place for a tool this small.

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

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

For a zero-parameter tool with no output schema, the main open question is what the returned category list contains and whether it is complete or filtered. That is unaddressed, leaving a modest but real gap.

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

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

The tool takes zero parameters, so the schema cannot add meaning and the baseline is 4. There is nothing parameter-related for the description to compensate for.

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 (Liste) and resource (catégories de la base de connaissances), and the KB qualifier implicitly separates it from list_itil_categories. It does not explicitly name that sibling or any other alternative, 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?

The description gives no indication of when to reach for this tool versus list_itil_categories or list_kb_articles, nor any prerequisite context. Usage is only inferable from the name and the absence of parameters.

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

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

No annotations are provided, so the description carries the full behavioral burden. It discloses the filtering semantics and pagination, which is useful, but says nothing about permissions, default ordering, what fields are returned, or that only_active defaults to true. For a listing tool with zero annotation coverage this is a significant gap.

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

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

Front-loaded with the core purpose followed by a tight bulleted parameter list. No wasteful sentences, though the parameter bullets are somewhat 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?

With 4 params, no annotations, and no output schema, the description covers intent and parameter meaning but leaves behavioral gaps: return format, ordering, and permission requirements are absent. Adequate but not complete for an unannotated tool.

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

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

Schema coverage is 0%, so the description must compensate — and it does, explaining each of the four parameters: name_contains is a partial-match filter, only_active maps to is_active=1, and range_start/range_limit handle pagination. It omits the defaults (e.g., only_active=true), but meaningfully documents every 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: listing suppliers registered in GLPI. This clearly distinguishes it from create_supplier, update_supplier, and delete_supplier siblings by verb. However it does not explicitly name which sibling to prefer or when, so it falls short of full sibling differentiation.

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

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

The read-only listing nature is implied by the verb and by the filter/pagination params, but the description never says when to use this tool versus alternatives, nor any prerequisites. Usage is inferable but not stated.

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

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

No annotations are provided, so the description carries the full burden. It only states the basic operation without disclosing that it is a read-only listing, what the return format looks like, ordering, or any side effects. This is a significant transparency gap.

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

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

The description is a single short sentence with no filler or redundant information. It is front-loaded and efficient for such a simple tool.

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

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

For a tool with one required parameter and no output schema, the description is minimally sufficient. Yet, the lack of any information about the return structure, ordering, or potential empty results leaves meaningful gaps in understanding what the tool delivers.

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 phrase 'd'un ticket' adds meaning by implying that ticket_id identifies the ticket whose tasks are listed. However, the description does not elaborate on the parameter's role, format, or constraints beyond what the schema already provides (integer, required).

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 'Liste toutes les tâches d'un ticket' clearly states the verb (list), the resource (tasks), and the scope (of a ticket). This differentiates it from sibling tools like list_tickets, get_ticket, and add_task, which have different resources or purposes.

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

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

The description implies usage when you need to retrieve all tasks belonging to a specific ticket, identified by ticket_id. However, it does not explicitly state when not to use it or mention alternatives such as get_followup or add_task.

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

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

With no annotations provided, the description carries full burden for behavioral disclosure. It only states the action without mentioning return format, pagination, permissions, or any side effects. The read-only nature is implicit but not explicit.

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

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

The description is a single concise sentence that clearly communicates the purpose without any extra fluff. It is front-loaded and every word earns its place.

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

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

Given the tool's simplicity (one parameter, no output schema, no annotations), the description covers the core purpose and parameter meaning. However, it lacks any mention of return value or usage context, so it is not fully complete for an agent to invoke it correctly in all situations.

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 has 0% description coverage, but the description's phrase 'd'un ticket' clarifies that ticket_id refers to the ticket whose links are listed. This adds meaning beyond the bare schema, but it doesn't provide additional detail about the parameter's format or constraints.

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

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

The description clearly states the tool's purpose: it lists all links of a ticket with other tickets. The verb 'liste' and resource 'liens d'un ticket' are specific, and it distinguishes itself from sibling tools like get_ticket or link_tickets.

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 is provided on when to use this tool versus alternatives. It doesn't mention that this is for viewing existing links, nor does it contrast with link_tickets or any other sibling tool.

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

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

With no annotations, the description must carry the full burden of behavioral disclosure. It does not explicitly state that the tool is read-only, has no side effects, or any constraints on use. While 'list' implies read-only behavior, the description does not mention sorting, scope, or any other behavioral traits beyond listing and pagination parameters.

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

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

The description is concise and front-loaded with the primary action, followed by bullet-point parameter clarifications. It is free of fluff, but the 'type' vs 'ticket_type' inconsistency and the slight repetition of pagination information prevent a perfect score.

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

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

The description provides essential filter code mappings but lacks explicit confirmation that filters are optional, fails to clarify the relationship between 'type' and 'ticket_type', and does not explain pagination mechanics beyond naming. Given no annotations and 0% schema description coverage, this is only partially complete for an agent to invoke the tool correctly.

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

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

The description adds valuable numeric mappings for status and type values, which is necessary given the schema provides no enums. However, it refers to 'type' while the schema parameter is 'ticket_type', creating a mismatch that could lead to incorrect usage. Pagination parameters are only described as 'pagination' without explaining offset/limit behavior, so the compensation for the 0% schema coverage is 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 clearly states the tool lists tickets with optional pagination, using a specific verb and resource. However, it does not distinguish this from sibling tools like search_tickets, which also retrieves ticket data, so it misses the opportunity for 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?

There is no guidance on when to use this tool versus alternatives, no exclusions, and no context about appropriate use cases. The description merely states functionality without clarifying relationships to sibling tools like search_tickets or get_ticket.

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

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

With no annotations provided, the description must carry the full burden of behavioral disclosure. It does so well: it states that source tickets are linked as duplicates (link_type=2), that follow-ups are copied conditionally, and that source tickets are closed with an explanatory follow-up. It also clarifies that the target ticket remains open. Missing details like reversibility or permission requirements, but the core actions are explicitly disclosed.

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

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

The description is well-structured with a clear one-line summary followed by bullet points of the tool's actions, then a parameter list. It is front-loaded, uses concise language, and every sentence adds value without 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?

Given the tool's complexity (4 params, conditional behaviors) and the lack of annotations, the description is remarkably complete. It covers all actions, parameter semantics, and conditional outcomes. The presence of an output schema means return values need not be described. There are no significant gaps for an agent to select and invoke this tool correctly.

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

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

The description explains all four parameters beyond the schema, providing meaningful context: target_ticket_id is 'the one that stays open', source_ticket_ids are the tickets to merge, and the boolean flags are explained with their conditions (e.g., 'copier les suivis... si add_followups=True'). This fully compensates for the 0% schema description coverage and adds value.

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

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

The description opens with a specific verb and resource: 'Fusionne un ou plusieurs tickets source vers un ticket cible' (merges one or more source tickets into a target ticket). It clearly distinguishes the merge operation from mere linking by detailing the side effects (linking as duplicates, copying follow-ups, closing source tickets). This differentiates it from sibling tools like link_tickets.

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

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

The description implies usage for merging duplicate tickets but does not explicitly state when to use this tool versus alternatives (e.g., link_tickets). It provides no exclusions or known alternative recommendations. The context is clear enough for an agent to infer, but there is no explicit guidance about when this tool should be preferred.

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

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

With no annotations provided, the description carries the full burden and excels. It discloses performance implications (LIKE '%keyword%' scan, 30-second timeout), runtime ID discovery with fallback, and version compatibility across GLPI 10 and 11. This goes far beyond a basic description.

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 dense but every sentence provides actionable value: purpose, default behavior, performance warnings, version compatibility, and parameter explanations. It is well-structured with a clear parameters list and 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?

Given the tool complexity, absence of annotations, and lack of output schema, the description covers purpose, parameters, performance caveats, fallback behavior, and version support. It is fully self-contained and leaves no critical gaps.

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

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

Schema description coverage is 0%, so the description must compensate. It explains keywords, search_content behavior and defaults, and lists range_start/range_limit as pagination. While the range parameters get minimal detail, the tool still adds substantial meaning beyond the raw 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 opens with 'Search knowledge base articles by keyword,' a specific verb+resource statement. It clearly distinguishes this from sibling tools like list_kb_articles and get_kb_article by focusing on keyword-based search rather than listing or retrieval.

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

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

The description provides clear context on when to use the tool and when to enable search_content, warning about performance risks on instances without FULLTEXT indexes. However, it does not explicitly name alternative tools or state when not to use this tool in favor of list_kb_articles.

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

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

With no annotations, the description carries the full burden. It usefully discloses that parameters are AND-combined and that content/followup searches use MySQL LIKE '%motif%' and are slower without a FULLTEXT index — real behavioral value. It omits return format, pagination behavior and any auth/permission notes.

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?

Well front-loaded: purpose first, then the three scopes, then the performance caveat. The bulleted structure is scannable. Slightly longer than strictly necessary but essentially every sentence 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?

For a 9-parameter search tool with no annotations, no output schema and 0% schema coverage, the description covers the hardest-to-guess semantics well. However it omits pagination (range_limit default 50, range_start) and assigned_user_id, which an agent needs to call it correctly.

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

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

Schema description coverage is 0%, so the description must compensate. It richly explains the three non-obvious text parameters (keywords=title, content_keywords=body, followup_keywords=followups) and names three filters. It leaves range_limit, range_start and assigned_user_id undocumented, so it does not fully cover the 9 parameters.

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

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

The description states a specific verb (Recherche), resource (tickets) and even the underlying API endpoint (/search/Ticket). It clearly distinguishes the tool's three text scopes from each other. It does not differentiate from sibling list_tickets/get_ticket, 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?

It gives strong when-to-use guidance for the three keyword scopes ('à ne pas confondre', followup_keywords indispensable pour l'analyse historique) and advises combining filters with status/category_id/ticket_type to limit the scan. It never states when to prefer this over list_tickets, so no explicit alternative routing.

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

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

With no annotations, the description carries the full burden of behavioral disclosure. It only states the basic result (count per assignee) but does not mention whether it includes all tickets regardless of status, how zero-count technicians are handled, or any other behavioral nuances. This is minimal transparency.

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

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

The description is a single, concise sentence that immediately conveys the tool's purpose. There is no wasted wording, and it is efficiently front-loaded with the action and resource.

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

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

Given the tool's low complexity (no parameters) and the presence of an output schema, the description sufficiently covers what the agent needs to know to invoke the tool. It explains the core functionality without needing to elaborate on return values, as those are defined by the output schema.

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

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

The tool has zero parameters, so the baseline is 4. There is no parameter information to add, and the description correctly focuses on the tool's output rather than input, making it appropriate for a no-parameter tool.

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

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

The description clearly states the specific verb 'retourne' and the resource: the number of tickets per assigned technician. It distinguishes itself from sibling stats tools like stats_by_priority and stats_by_status by focusing specifically on assignee.

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. It simply states what it does without any context about use cases, prerequisites, or exclusions. The agent must infer its usage solely from the tool name.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It states the tool returns a count, but it does not explicitly confirm that it is a read-only operation, does not mention any prerequisites or side effects, and lacks details about scope (e.g., all tickets vs. a subset). The description is too minimal to provide full transparency.

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

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

The description is a single, front-loaded sentence that directly states the tool's purpose. There is no redundant information, and it is appropriately sized for a tool with no parameters.

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

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

Given the tool's simplicity (no params, no annotations) and the presence of an output schema, the description sufficiently explains what the tool returns. It could be slightly more complete by explicitly noting that it is a read-only aggregate, but overall it covers the essential context for an agent to select and invoke the tool.

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

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

The input schema has zero parameters, so there is nothing for the description to clarify. According to the rubric, a baseline of 4 applies for 0 parameters. No additional information is needed or provided, which is appropriate.

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

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

The description clearly states the tool returns the number of tickets by ITIL category ('Retourne le nombre de tickets par catégorie ITIL'), which is a specific verb+resource combination. It distinguishes itself from sibling stats tools like stats_by_priority and stats_by_status by explicitly mentioning the category grouping.

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

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

The description implies usage: if you need ticket counts grouped by ITIL category, this is the tool. However, it does not explicitly state when to use this tool over alternatives or mention any exclusions, such as filtering options. The guidance is only implied through the tool's purpose, not articulated.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It only states the return value ('number of open tickets by priority') without clarifying output format, whether historical data is included, or whether the operation is read-only. While the verb 'Retourne' implies reading, this is minimal disclosure for a tool with no annotation support.

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

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

The description is a single, compact sentence that directly states the tool's purpose without redundancy. It is front-loaded with the action and the key output details, earning full marks for conciseness.

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

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

For a tool with no parameters and an output schema available, the description adequately states the core functionality. It could be more complete by mentioning the return format (e.g., mapping of priority to count), but the presence of an output schema reduces the need for such detail. The description is sufficient for a simple stats query.

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

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

The tool has zero parameters, and the input schema confirms this with 100% coverage. The description adds no parameter details because there are none to document, so the baseline of 4 is appropriate.

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

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

The description clearly states a specific verb ('Retourne' = returns) and resource ('le nombre de tickets ouverts par priorité' = number of open tickets by priority). It distinguishes itself from sibling stats tools like stats_by_status, stats_by_type, and stats_by_category by explicitly naming the aggregation dimension (priority).

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

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

The description implies its use for querying ticket counts grouped by priority, and the sibling tool names provide context for when to choose this over other stats tools. However, it does not explicitly state when to use this tool versus alternatives, nor does it mention any exclusions or prerequisites.

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

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

With no annotations provided, the description carries the burden of disclosing behavior. It reveals that the tool counts open tickets and groups them by status, which is a read-only statistical operation. However, it does not clarify details like whether all statuses are included, if there are any date filters, or the exact output structure beyond what the schema already provides.

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

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

The description is a single, concise sentence that is front-loaded with the core functionality. It contains no redundant words and effectively communicates the tool's purpose.

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

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

Given the tool's simplicity and the presence of an output schema, the description sufficiently conveys what the tool does. It counts open tickets grouped by status, which is a complete purpose for a stats tool. A slight gap is the lack of context about potential filters or edge cases, but these are not necessary for a basic stats retrieval.

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

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

The tool has zero parameters, and the schema is empty, so the description is not required to explain parameter semantics. The baseline for zero params is set to 4, and the description appropriately focuses on the operation itself rather than parameter details.

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

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

The description clearly states that the tool returns the number of open tickets per status, using a specific verb ('Retourne') and resource ('tickets ouverts par statut'). This distinguishes it from sibling stats tools like stats_by_priority, which focus on different dimensions.

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

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

The description implies the tool is used to get ticket counts grouped by status, but it does not explicitly state when to use it over alternatives or provide exclusions. Since the purpose is straightforward, the usage context is implied rather than clearly outlined.

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

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

With no annotations provided, the description carries full burden for behavioral disclosure. It only states the basic aggregation and does not clarify data scope, whether the count is global or filtered, or any assumptions about ticket states. No extra context beyond the obvious operation.

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

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

A single, succinct sentence that is front-loaded with the core action and resource. It avoids redundancy and is appropriately sized for a parameterless stats tool.

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

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

For a simple aggregation tool with no parameters and an output schema available, the description is mostly complete. It could explicitly state that it covers all tickets, but the lack of parameters implies global scope. The output schema covers return details, so no further description is necessary.

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

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

The tool has zero parameters, so schema provides no parameter semantics. The baseline for 0 params is 4, and the description adds no parameter information, but it doesn't need to. The description covers the only relevant semantic aspect by naming the ticket types.

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

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

The description clearly states the tool's function: returning the number of tickets by type, with the two types explicitly listed (Incident / Service Request). This specific verb+resource combination distinguishes it from sibling stats tools like stats_by_priority or stats_by_status.

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

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

The description provides no guidance on when to use this tool versus alternatives. It doesn't mention scenarios, exclusions, or related tools. The user must infer usage solely from the purpose.

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

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

With no annotations provided, the description carries the burden of behavioral disclosure. It explains the filtering logic (due date passed and unresolved) and the specific field used, making the behavior transparent. It doesn't explicitly state read-only nature, but the verb 'Retourne' implies a query operation, and there is no indication of side effects.

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

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

The description consists of two short sentences. The first sentence defines the core behavior, and the second adds the technical detail about the field. Every word contributes, with no redundancy or filler, making it highly concise and well-structured.

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

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

This is a simple zero-parameter stats tool with an output schema present. The description fully covers what the tool does, including the exact criteria. With no parameters, there are no additional inputs to document, and the output schema handles return value details. The description is complete for this level of complexity.

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

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

The tool has zero parameters, so the baseline is 4. The description does not need to explain parameters beyond the schema, which is empty. It adds no parameter information, which is appropriate since there are none.

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

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

The description clearly states the tool returns overdue tickets (due date passed and unresolved), using a specific verb 'Retourne' and defining exactly what qualifies. This distinguishes it from sibling stats tools like stats_by_priority or stats_by_status, which focus on other dimensions.

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

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

The description implies usage context: use this tool to get overdue tickets. It mentions the underlying GLPI field 'time_to_resolve', which helps the agent understand the data source. It doesn't explicitly state exclusions or alternatives, but for a zero-parameter stats tool, the intended use is clear.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It adds the scope of 'tickets résolus ou clos' but does not clarify the measurement basis (e.g., from creation to resolution), units (days, hours), or whether a time window applies. This is a read-only stat tool, but the description could be more explicit about the exact definition.

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 in French with no waste. It conveys the essential purpose and scope efficiently.

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

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

For a simple zero-parameter tool with an output schema, the description provides the core purpose and scope. It could add detail about the calculation method or units, but the output schema likely covers return values, making it reasonably 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?

The tool has zero parameters, and the schema is empty, so there is no parameter information to add. Following the baseline for 0-parameter tools, the description adequately suffices.

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

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

The description clearly states the tool returns the average resolution time for resolved or closed tickets. It uses a specific verb ('retourne') and specifies the resource and scope, effectively distinguishing it from sibling stats tools like stats_by_priority or stats_overdue.

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

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

The description implies usage for retrieving average resolution time of resolved/closed tickets but offers no explicit guidance on when to choose this tool over alternatives or any exclusion criteria. It lacks a direct comparison to sibling stats tools.

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