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?

With no annotations, the description carries full responsibility for behavioral disclosure. It only states the add operation without revealing side effects, idempotency, permission requirements, or implications for the other parameters. 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 succinct with no redundant words, but it is under-specified, omitting essential parameter details and usage context. It is concise but not adequately informative.

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

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

Given the tool has four parameters, no annotations, and no output schema, the description is incomplete. It only covers one parameter and provides no information about behavior, return values, or when to use it.

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

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

The schema has no descriptions (0% coverage), and the description only clarifies 'groups_id' as the GLPI group ID. The remaining three parameters (article_id, entities_id, is_recursive) remain unexplained, so the description compensates only partially.

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 (add a group) and the resource (KB article visibility), which distinguishes it from the sibling tool for profile visibility. 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 are any prerequisites or exclusion criteria mentioned. The description only explains one parameter and does not address 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?

No annotations are provided, so the description carries full burden. It only explains parameter semantics (profiles_id, entities_id, is_recursive) but does not disclose behavioral traits such as whether the operation is idempotent, what happens on duplicate entry, permission requirements, or any side effects. For a mutation tool, this lack of behavioral disclosure 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?

The description is concise, using a short sentence followed by three bullet points for parameter clarifications. Every line contributes relevant information with no redundant or filler 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?

Given no output schema and no annotations, the description covers the core parameters but misses other contextual needs: no return value information, no prerequisites, no mention of how this relates to sibling visibility tools (e.g., update vs add). It is adequate for a basic understanding but incomplete for full autonomous 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?

The schema has 0% description coverage per context signals. The description provides meaningful explanations for profiles_id, entities_id (with default 0 meaning root entity), and is_recursive (apply to sub-entities), which adds substantial value beyond the bare schema titles. However, article_id is not explained, though it is fairly self-evident as the target KB article.

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 'Ajoute un profil dans la visibilite d'un article KB' (Add a profile to a KB article's visibility), specifying a concrete verb and resource. It distinguishes from sibling tool add_kb_article_visibility_group by focusing on 'profil' (profile) rather than 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?

The description implies usage for adding a profile visibility entry, but does not explicitly mention when to use this tool versus alternatives like add_kb_article_visibility_group or the update variations. No exclusion or alternative guidance is provided, leaving the agent to infer from sibling names.

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

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

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?

With no annotations provided, the description carries the burden of behavioral disclosure. It explains that 'answer' accepts HTML and that 'is_faq=True' publishes to the public FAQ, adding meaningful context beyond the schema. However, it does not mention potential side effects, required permissions, or response behavior, preventing a perfect score.

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

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

The description is compact: a single opening sentence followed by a bullet-point list of parameters. Each bullet is concise and front-loaded with the parameter name and a short explanation. There is no redundant or unnecessary text.

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?

All four parameters are adequately described, and the tool's input semantics are clear. However, with no output schema, the description does not specify what the tool returns (e.g., created article ID or confirmation), leaving a minor gap for a create 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 fully compensates by explaining each parameter: name as title, answer as content/solution, category_id as optional, and is_faq with its default and effect. This adds significant meaning beyond the bare parameter names and 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 action: 'Cree un nouvel article dans la base de connaissances' (Create a new article in the knowledge base). The verb 'create' and the resource 'article' make the purpose unambiguous and distinguish it from sibling tools like update_kb_article or list_kb_articles.

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 creating new KB articles and provides contextual guidance on optional parameters (category_id, is_faq) and their effects. However, it does not explicitly exclude alternatives or mention when to use a different tool (e.g., update_kb_article for modifications), so it falls short of a 5.

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

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

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 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?

There are no annotations, so the description carries full responsibility for disclosing behavioral traits. It only says 'returns the complete detail' without addressing return format, error conditions, authentication needs, or whether the article must be visible/published. For a read operation, this is minimal disclosure but lacks any behavioral context beyond the basic action.

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 in French (8 words). It is front-loaded with the action 'Retourne' and immediately specifies the object. There is no waste, and it is appropriately sized for the tool's simplicity.

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

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

The tool is simple (1 parameter, no output schema, no annotations) and the description states the core purpose. However, it lacks context about what 'complete detail' includes, whether the article must be in a certain state, or any related sibling interactions. Given the low complexity, the description is minimally viable but leaves room for more details about return values and conditions.

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 1 parameter (article_id) with 0% description coverage. The description does not explicitly mention the parameter, but the phrase 'd'un article' implies that article_id identifies the article. Given that the parameter is a simple integer ID and its purpose is self-evident from the schema, the description provides marginal added meaning but does not fully compensate for the lack of schema 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 verb 'Retourne' (returns) and the resource 'le detail complet d'un article de la base de connaissances' (complete detail of a knowledge base article). It distinguishes itself from sibling tools like list_kb_articles and search_kb_articles by focusing on retrieving a single article's full detail.

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 does not mention any exclusions, prerequisites, or context for choosing get_kb_article over search_kb_articles or list_kb_articles. The agent receives no 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?

With no annotations, the description carries the full burden. It discloses the core behavior (returns visibility rules) and adds detail on the content (profiles, groups, users, entities). However, it does not explicitly state that it is read-only, require no side effects, or mention any permission requirements. Basic behavior is present but richer context is missing.

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

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

A single, front-loaded sentence that is concise and efficient. It conveys the purpose and output contents without wasted words, earning a top score for structure.

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 getter with one parameter and an output schema, the description is adequate. It identifies the resource and what the response contains, but lacks contextual guidance on how this tool fits with visibility management siblings or any usage caveats. Not incomplete, but no extra value beyond the basics.

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 references 'un article KB' but does not explicitly explain that the article_id parameter is the identifier for the KB article. The description adds minimal meaning beyond the parameter name and type, and fails to clarify the parameter's role or format.

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 visibility rules of a KB article, listing profiles, groups, users, and entities with access. The verb 'Retourne' specifies the action and resource, distinguishing it from sibling tools like get_kb_article (which returns the article itself) and the add/update visibility tools.

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

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

The description implies usage by being a getter for visibility rules, but does not explicitly state when to use this over alternatives, nor any exclusions or prerequisites. There is no mention of when not to use it or how it relates to sibling tools like add_kb_article_visibility_profile.

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?

No annotations are provided, so the description must stand alone. It implies a read-only listing but gives no details on ordering, pagination, or what the output contains. This is adequate for a simple list but lacks depth.

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

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

The description is a single, front-loaded sentence with no redundant words. It immediately conveys 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 (no parameters, no annotations, no output schema), the description sufficiently covers its function. However, it could explicitly mention the return type or note that it returns all categories without filtering, which would make it more 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 input schema is empty, so there are no parameters to document. Per the rubric, a zero-parameter tool receives a baseline of 4, and the description correctly doesn't attempt to invent 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 'Liste toutes les categories de la base de connaissances' clearly states the action (list) and the resource (knowledge base categories), distinguishing it from sibling list_itil_categories by specifying 'base de connaissances'.

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 like list_itil_categories. It does not mention use cases, prerequisites, or when not to use it.

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

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

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 must disclose behavioral traits, but it only mentions the underlying API endpoint. It does not explain expected output, pagination behavior, authentication requirements, or what happens when no parameters are provided, leaving significant ambiguity.

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 very concise at two sentences with no redundant words. However, the brevity sacrifices necessary detail, making it efficient but incomplete.

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 7 parameters, no annotations, and no output schema, the description is insufficient. It fails to describe parameter semantics, return values, or selection context, so the agent cannot reliably invoke it or interpret results.

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 any of the 7 parameters. It only states that all are optional and combinable, providing no value beyond the parameter names themselves. The agent has to infer meaning from names alone.

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 performs advanced ticket search via the GLPI /search/Ticket API, identifying the resource and the action. It is distinguishable from sibling tools like list_tickets and get_ticket by the 'search' concept, but it does not explicitly contrast with them.

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

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

No guidance is given on when to use this tool versus alternatives such as list_tickets or get_ticket. The only usage hint is that all parameters are optional and combinable, which informs parameter flexibility but not selection criteria or exclusions.

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

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

With no annotations, the description carries the full 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.

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 states the action 'Met a jour' (updates) but does not explain whether update_fields performs a partial update or full replacement, what happens if the article does not exist, whether permissions are required, or what the response looks like. 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: two short sentences that convey the primary purpose and examples. Every word contributes to understanding, with no redundant or extraneous content. It front-loads the core action and immediately lists relevant fields.

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

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

For a tool with only 2 parameters, one of which is a nested object, and no output schema or annotations, the description is under-specified. It does not clarify the update semantics, how to construct update_fields, error behavior, or any side effects. While it identifies the action and some field examples, it leaves critical operational details unknown.

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 itself provides minimal parameter details (just types and titles), so the description's mention of example fields (name, answer, is_faq, knowbaseitemcategories_id) adds useful meaning for the update_fields object. However, it does not explain the purpose of article_id or specify how update_fields should be structured, leaving ambiguity despite some added 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 clearly states the tool's function: 'Met a jour un article de la base de connaissances' (Updates a knowledge base article), specifying both the action (update) and the resource (knowledge base article). This distinguishes it from siblings like get_kb_article or create_kb_article, and the example fields further clarify the scope.

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

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

No guidance is provided on when to use this tool or its alternatives. The description does not mention prerequisites, such as needing an existing article_id, or when to prefer update_kb_article over other update tools for different resource types. There are no exclusions or alternative tool 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 carries the full burden of behavioral disclosure. While the description clearly indicates a mutation ('Met a jour'), it does not disclose potential side effects, error behavior, whether the update is partial or full replacement, or any permission requirements. This is a significant gap for a write 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 extremely concise: two lines for the purpose plus two parameter explanations. It is front-loaded with the action and resource, and every sentence earns its place. No fluff or repetition.

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

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

Given the simplicity of the tool (two parameters, no output schema), the description provides sufficient context to invoke it correctly. It covers both parameters and gives a few extra hints. It lacks information on return values or error cases, but that is not critical for a simple update 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. It explains that visibility_id is the ID of a KnowbaseItem_Group entry obtained via get_kb_article_visibility, and provides an example of update_fields. This adds meaningful context beyond the bare schema, but it doesn't enumerate possible fields beyond the example.

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 'Met a jour' (update) and the resource 'regle de visibilite par groupe d'un article KB' (visibility rule by group of a KB article). It differentiates from sibling tools like update_kb_article_visibility_profile and add_kb_article_visibility_group by specifying 'par groupe'.

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 a concrete usage hint: visibility_id is obtained via get_kb_article_visibility. It also gives an example of update_fields, implying the tool is used for partial updates of group-based visibility rules. However, it does not explicitly state when to use this tool over the profile version, so it misses the 'when-not' part for a full 5.

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

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

With no annotations provided, the description must fully disclose behavioral traits. It identifies the operation as an update ('Met a jour') but does not cover side effects, error behavior, required permissions, or reversibility. The parameter hints are useful but do not address behavioral aspects beyond the basic mutation intent.

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 concise sentences, front-loading the main purpose and then providing parameter details. There is no redundancy or irrelevant information. Every phrase contributes to understanding the 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?

The description gives the essential purpose and parameter semantics, including a useful prerequisite, but omissions remain: no return value description, no mention of error handling, and no indication of valid fields beyond the example. Given the tool's relative simplicity, the description is adequate but leaves notable gaps for an agent to fully anticipate outcomes.

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 descriptions provide 0% coverage, so the description fully carries the parameter semantics. It clearly explains visibility_id as the ID from get_kb_article_visibility and update_fields as a set of fields to modify, with a concrete example ({'entities_id': 1, 'is_recursive': 1}). This exceeds minimal compensation, making both parameters understandable.

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 verb ('Met a jour' = update), resource ('une regle de visibilite par profil d'un article KB' = a visibility rule by profile of a KB article), and distinguishes it from sibling tools like update_kb_article_visibility_group by specifying 'par profil'. This unambiguous purpose makes the tool easy to select.

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 updating profile-based visibility rules but does not explicitly compare with alternatives (e.g., update_kb_article_visibility_group) or state when not to use it. It provides a helpful prerequisite (visibility_id obtained via get_kb_article_visibility) but lacks clear 'when/when-not' 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?

No annotations are provided, so the description carries the full burden. It only states that the tool updates a task and lists example fields, without disclosing side effects, permissions, error behavior, or whether the update is partial or full, leaving significant behavioral context unknown.

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 and front-loaded: a single action sentence followed by a short list of examples. Every word earns its place, 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?

The tool has an open-ended update_fields object, no output schema, and no annotations. The description provides only a few examples without explaining update semantics (e.g., partial vs full update), error cases, or return behavior, leaving notable gaps for an agent.

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

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

The description adds value beyond the schema by listing example keys (state, content, actiontime, users_id_tech) and hinting at valid values for state (1/2). Since update_fields is an arbitrary object with no schema descriptions, these examples help clarify expected structure.

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 'Met à jour une tâche' (Updates a task) and gives example fields, making the tool's purpose specific and distinct from siblings like add_task, delete_task, and update_ticket.

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

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

The description implies this tool is for modifying existing tasks but does not explicitly state when to use it versus alternatives, nor does it mention any prerequisites, exclusions, or when not to use it. The examples hint at usage but provide no explicit 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 provided, the description carries the full burden. It does convey a key behavioral trait: the update is partial (only pass fields to change), which is valuable. However, it does not disclose authentication requirements, return values, or error behavior. While it is not misleading, it lacks depth expected for a mutation tool without 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 two short sentences. The first states the purpose, and the second provides usage guidance and examples. Every word earns its place, with no fluff or repetition of schema details.

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 tool with 2 parameters, no output schema, and no annotations, the description covers the essential aspects: what it does and how to use it (partial update). It could be more complete by mentioning the return value or indicating that a ticket must already exist, but the provided guidance is sufficient for basic 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 lists example fields (status, priority, name, content, itilcategories_id) and clarifies that update_fields should contain only the fields to modify. This adds significant meaning to an otherwise opaque object with additionalProperties. ticket_id is self-explanatory from the schema.

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

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

The description clearly states 'Met à jour un ticket' (Updates a ticket), which is a specific verb+resource combination. Since sibling tools include create_ticket, delete_ticket, and get_ticket, the use of 'update' distinguishes the intended action, and 'ticket' makes the resource unambiguous.

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

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

The description provides explicit usage guidance: 'Passer uniquement les champs à modifier' (Only pass the fields to modify), which tells the agent how to structure the update_fields object. It also gives example field names. However, it does not mention when not to use this tool or alternatives, so it just misses the top score.

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