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

Annotations declare readOnlyHint=true, so the agent knows this is a safe read operation. The description adds that the board includes columns and filter settings, but provides no additional behavioral context such as permissions, errors, or pagination. It does not contradict annotations.

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

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

The description is a single concise sentence that front-loads the action and resource. There is no redundant information, making it highly efficient.

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 only one parameter, is marked read-only, and has an output schema, the description adequately conveys the core functionality. It could be improved by noting that it fetches a single board by ID or mentions potential errors, but for its simplicity it is fairly complete.

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

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

Schema description coverage is 100% with the parameter board_id described as 'Board identifier'. The tool description does not add further meaning to this single parameter, so baseline 3 applies.

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

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

The description uses a specific verb ('Get') with a clear resource ('Yandex Tracker board') and specifies the included content ('columns and filter settings'). This distinguishes it from sibling tools like boards_list and board_get_sprints.

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 via the verb 'Get' but does not explicitly state when to use this tool versus alternatives such as boards_list for listing or board_get_sprints for sprint details. No exclusions or alternative comparisons are provided.

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

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

Annotations already declare readOnlyHint=true, covering the safety profile. The description adds the 'all' scope for sprints, which is useful, but it does not disclose pagination, ordering, or error behavior. With annotations covering read-only semantics, this modest addition is acceptable but not rich.

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

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

The description is a single, front-loaded sentence with no filler. It immediately states the action and resource, making it appropriately concise for 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 simple read-only list tool with one fully described parameter and an output schema, the description sufficiently conveys the purpose. The output schema eliminates the need to detail return values, and the annotations cover safety, making the description 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 provides 100% coverage for the single parameter board_id with a description ('Board identifier'). The tool description does not add any further semantic detail about the parameter, so it does not exceed what the schema already provides.

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

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

The description clearly states the action ('Get') and resource ('all sprints') with a specific scope ('associated with a Yandex Tracker board'). It distinguishes the tool from siblings like sprint_get, which targets a single sprint, and boards_list/board_get, which retrieve board metadata.

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

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

The description gives clear context that this tool lists sprints for a board, implying the appropriate scenario for use. However, it does not explicitly mention when not to use it or name alternatives like sprint_get for individual sprints, so it falls short of explicit exclusion guidance.

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

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

The readOnlyHint annotation already covers the safety profile, and the description adds the useful behavioral context that results are scoped to the current user's accessibility. This exceeds the baseline by providing auth-related context beyond the annotation, though it does not discuss pagination or output format (which may be covered by the output schema).

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

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

The description is a single, front-loaded sentence that conveys the essential purpose and scope without any filler. Every word contributes meaning, making it appropriately 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?

Given the tool's simplicity (0 parameters, read-only annotation, and an output schema present), the description is complete. It specifies the resource type, the scope (current user), and the action (get all). There is no need to explain return values since the output schema handles that.

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 and full schema coverage (empty schema), the baseline for parameter semantics is 4. The description does not need to elaborate on parameters, and it adds no parameter-related meaning because there are none. This matches the baseline.

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

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

The description uses a specific verb ('Get all') with a clear resource ('Yandex Tracker issue boards') and a scope qualifier ('available to the current user'). This clearly distinguishes it from sibling tools like 'board_get' (which likely retrieves a single board) and 'board_get_sprints' (which retrieves sprints for a board).

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 a use case (list all boards for the current user) but does not explicitly contrast it with alternatives. It does not mention when to use this instead of 'board_get' or other board-related tools. Context is clear but exclusions are absent, so it meets the 'implied usage' level.

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

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

Annotations only indicate readOnlyHint=false, so the description carries the burden of behavioral disclosure. It mentions 'Start a bulk update' but does not clarify whether this is asynchronous, what the response contains, whether changes are reversible, or any side effects. 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 a single concise sentence that front-loads the core purpose. There is no fluff or redundant information; every word contributes to understanding what the tool does.

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?

Despite having an output schema and fully covered parameters, the tool is a complex bulk operation with 5 parameters. The description fails to mention asynchronous behavior, return format, or how it relates to single-entity updates. This is insufficient context for an agent to confidently 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?

Schema description coverage is 100%, so the schema fully documents each parameter. The description adds minimal value beyond reiterating entity types, but it does reinforce that the update applies to multiple entities. Baseline 3 is appropriate because the schema handles parameter semantics.

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

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

The description states a specific action ('Start a bulk update') with a defined resource ('Yandex Tracker projects, portfolios, or goals'). It clearly conveys the tool's purpose and distinguishes it from single-entity operations like entity_update, though it does not explicitly reference sibling 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 phrase 'bulk update' implies usage when updating multiple entities at once, and the listed entity types give context. However, there is no explicit guidance on when to prefer this over entity_update or entity_create, nor any mention of limitations or alternatives.

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

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

Annotations already declare readOnlyHint=true, and the description's 'Search' aligns with that. The description adds no extra behavioral context (e.g., pagination, result limits), so it meets the baseline but does not exceed it.

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, focused sentence that immediately conveys the tool's core function. No filler or redundant phrasing.

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

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

Given the rich input schema (all params documented), readOnlyHint annotation, and presence of an output schema, the description adequately covers the tool's purpose. Additional behavioral details are already captured in the schema, so the description is sufficient.

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

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

Schema description coverage is 100%, so baseline is 3. The description mentions 'filters and sorting' which maps to filter/order_by params, but does not add meaning beyond the schema's detailed parameter descriptions.

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 action ('Search') on a defined resource ('Yandex Tracker projects, portfolios, or goals') and mentions key capabilities (filters, sorting). This distinguishes it from sibling tools like entity_get (single entity fetch) and issues_find (issue 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 implies usage for searching across entity types, and the context is clear. It does not explicitly exclude alternatives or mention when not to use, but the action and resource are unambiguous enough for an agent to infer applicability.

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

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

Annotations include readOnlyHint=false, and the description's 'Create' is consistent with a write operation. The description adds the range of entity types that can be created (project, portfolio, goal), which is not in annotations. However, it does not disclose other behavioral aspects like permission requirements or response behavior.

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

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

The description is a single, concise sentence that front-loads the key action and resource, with 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?

The schema is rich with parameter descriptions, an output schema is present, and annotations indicate read/write status. The description covers the core purpose, but it lacks usage context or prerequisites. Given the schema richness, the minimal description is adequate.

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

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

Schema description coverage is 100%, with each parameter having a clear description. The tool description does not add parameter-specific meaning beyond the schema, so the baseline score of 3 is appropriate.

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

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

The description uses the specific verb 'Create' and identifies the resource as 'a Yandex Tracker project, portfolio, or goal.' It clearly distinguishes this tool from siblings like entity_update and entity_delete, which modify or remove entities.

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 that it is for new entities only, nor does it reference entity_update or entities_bulk_update as alternatives. No when-to-use or when-not-to-use context is provided.

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

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

Annotations already indicate destructiveHint=true and readOnlyHint=false, so the description does not need to restate that deletion is destructive. It adds the target entity types, but these are also present in the schema enum. No additional behavioral traits like irreversibility or permissions are mentioned, but this is acceptable given the annotations.

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

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

The description is a single, sharply focused sentence with no redundant words or filler. It is appropriately concise for a simple deletion 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?

Given the destructive annotation, the full input schema, and presence of an output schema, the description is sufficient for an agent to understand the tool's purpose. It lacks some extra context like irreversibility, but the annotations cover the key safety aspect.

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

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

Schema description coverage is 100%: all three parameters have descriptions. The description does not add meaning beyond the schema, so it stays at the baseline of 3.

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

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

The description states the specific action ('Delete') and the resource types ('Yandex Tracker project, portfolio, or goal'), making it clear what the tool does. It distinguishes itself from sibling tools like entity_create and entity_update by focusing solely on deletion.

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, but there is no explicit guidance on when to use this tool, prerequisites, or alternatives. The description does not specify when not to use it, though the scope 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?

Annotations already declare readOnlyHint=true, so the read-only nature is covered. The description adds the ability to specify 'expand' for attachments and 'fields' for additional data, which hints at response shaping. However, it doesn't disclose behavior like default fields returned, pagination, or error conditions, but given the annotation, descriptive value is adequate.

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?

Single sentence front-loads the core action, and the description is appropriately sized for a straightforward getter tool. No redundant fluff; 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 complexity (4 params, simple getter), output schema exists, and annotations indicate read-only, the description is nearly complete. It doesn't list return fields, but output schema covers that. Missing a bit: mention that entity_id can be shortId is included, but some usage context (e.g., differences between id types) is minimal. Still sufficient.

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

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

Schema description coverage is 100% with detailed descriptions for each parameter (entity_type, entity_id, expand, fields). The description echoes schema for entity_type but adds that id can be numeric shortId, which is valuable. Baseline 3 is raised because the description clarifies shortId usage and explains expand/fields beyond their schema descriptions.

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?

Description states specific verb+resource: 'Get a Yandex Tracker project, portfolio, or goal by id or shortId.' It clearly lists the three entity types, distinguishing from sibling tools like queue_get_metadata or issue_get. The scope is explicit.

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

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

The description implies when to use: when you need a project, portfolio, or goal by ID/shortId. It doesn't explicitly name alternatives or exclusions, but the context with sibling tools (entity_get_events, entity_create) makes usage clear. Some guidance about when not to use (e.g., for issues use issue_get) would elevate it, but it's not misleading.

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

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

Annotations declare readOnlyHint=true, so the agent already knows this is a safe read operation. The description adds that it returns 'event history,' but no additional behavioral details such as ordering or event scope beyond what the schema already provides. With annotations covering safety, this adds minimal extra context, warranting a mid-range 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 a single, front-loaded sentence that directly states the tool's purpose without filler or redundant information.

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

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

The tool has a rich schema with parameter descriptions and an output schema, while annotations confirm read-only behavior. The description, though brief, fully explains what the tool does and for which entity types, making it complete for an agent to select and invoke correctly.

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

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

Schema description coverage is 100%, and the input schema already contains detailed explanations for each parameter, including mutual exclusivity for from_id and selected, direction, and per_page. The description contributes no parameter-level information, so the baseline of 3 applies.

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

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

The description uses the specific action 'Get the event history' and explicitly names the resources: 'Yandex Tracker project, portfolio, or goal.' This clearly distinguishes it from sibling tools like entity_get (which retrieves entity details) and issue_get_changelog (which covers issues).

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 entity event history by naming the three entity types, providing clear context for when to use it. However, it does not explicitly exclude other cases (e.g., issues) or mention alternatives like issue_get_changelog, so no exclusions are stated.

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

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

The description adds no behavioral context beyond the annotation. It does not mention whether updates are partial or full, any permission requirements, or effects on unspecified fields. With only readOnlyHint=false in annotations, the agent gains no additional safety or 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 sentence that conveys the essential purpose without extraneous words. It is perfectly concise and front-loaded.

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?

While the schema and output schema are rich, the description does not address usage guidance or behavioral nuances. It is minimally sufficient for purpose identification but leaves gaps in when-to-use context, so it is not fully complete.

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

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

Schema description coverage is 100%, so the parameters are already fully documented. The description itself adds no parameter-level detail, matching the baseline for full schema 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 states a specific verb ('Update') and resource ('a Yandex Tracker project, portfolio, or goal'), clearly distinguishing this tool from sibling tools like issue_update. It precisely enumerates the supported entity types, leaving no ambiguity about 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 versus alternatives such as entity_create, entity_delete, entities_bulk_update, or issue_update. There are no usage scenarios, exclusions, or alternative recommendations.

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

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

With readOnlyHint=false in annotations, the mutating nature is already disclosed. The description adds minimal behavioral context beyond the annotation, mainly the two modes of defining conditions, which is also described in the schema. No contradiction exists.

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 front-loads the verb and resource. Every word adds value and no unnecessary details are included.

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 detailed schema and presence of an output schema, the description adequately conveys the tool's purpose. It doesn't need to explain return values. Missing explicit mention of prerequisites or side effects, but those are not critical for a create operation with clear schema coverage.

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

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

Schema description coverage is 100%, so parameters are already well-documented. The description's mention of 'query or field conditions' adds little new meaning beyond the schema, which already notes mutual exclusivity. Baseline 3 applies.

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

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

The description clearly states the action ('Create') and the resource ('saved Yandex Tracker issue filter'), and mentions the two ways to define it ('using query or field conditions'). It distinguishes from sibling tools like filter_update (which modifies) and filter_get (which retrieves) by focusing on creation.

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 verb 'create' implies this is for new filters, but there is no explicit 'when to use vs alternatives' or mention of filter_update for existing filters. The usage is implied rather than clearly stated, so it meets the 'implied usage' bar but not higher.

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

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

The readOnlyHint=true annotation already covers the safe-read nature of the tool. The description adds no extra behavioral context (e.g., pagination behavior, result limits, or differences from a direct issue search), but it also does not contradict the annotation. With the annotation in place, a midpoint score is appropriate.

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

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

The description is a single, front-loaded sentence that efficiently captures the core action and result. It contains no redundant filler and every word adds value.

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

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

Given the rich input schema, the readOnlyHint annotation, and the presence of an output schema, the description is sufficient for basic invocation. It lacks explicit guidance on when to choose this over sibling search tools, but that gap is more about usage guidelines than completeness of the tool's contract.

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?

All five parameters (filter_id, page, per_page, fields, include_description) have descriptions in the input schema, providing 100% coverage. The tool description itself does not elaborate on parameters, but the schema fully documents their meaning, so the baseline of 3 applies.

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

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

The description clearly states that the tool executes a saved Yandex Tracker filter and returns matching issues. The verb 'execute' and the resource 'saved filter' make the function explicit, and it is distinguishable from sibling tools like filter_get (which retrieves filter metadata) and issues_find (which searches issues directly).

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

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

The description provides no guidance on when to use this tool versus alternatives such as issues_find or filter_get. It only states what the tool does, leaving the agent to infer from the name that a saved filter_id is required. There is no mention of scenarios where this tool is 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?

The readOnlyHint annotation already signals a safe read operation. The description adds no additional behavioral context such as permissions, error handling, or return behavior beyond restating the resource and parameter. This does not contradict the annotation, but it offers no extra 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 (10 words) that front-loads the action and resource. Every word earns its place with no redundancy.

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

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

Given the tool's simplicity, one parameter, an output schema, and a readOnlyHint annotation, the description is largely sufficient. However, it does not offer comparison with sibling tools or mention potential error cases, leaving a minor gap in guidance.

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

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

Schema description coverage is 100% for the single parameter (filter_id). The tool description's 'by id' adds no new meaning over the schema's 'Saved filter identifier' and minimum value, so the baseline of 3 applies.

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

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

The description uses a specific verb ('Get') with a clear resource ('a saved Yandex Tracker issue filter') and parameter ('by id'). It distinguishes from sibling tools like filter_create, filter_update, and filter_find_issues, which have different 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 its usage: retrieve a saved filter by its identifier. However, it provides no explicit guidance on when to use this tool versus alternatives (e.g., filter_find_issues for finding issues in a filter), nor does it state 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 annotation readOnlyHint=false already signals a mutation, and the description merely repeats the update action without adding behavioral context. It does not disclose partial-update behavior, whether unspecified fields are preserved, or the effect on the saved filter.

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, focused sentence that immediately conveys the operation. It contains no filler or redundancy and is appropriately sized for a simple update 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 rich schema and output schema cover parameter details and return values, so the minimal description is partially sufficient. However, it omits usage context such as whether this replaces the entire filter or only provided fields, and when to prefer sibling filter_create.

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

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

Schema description coverage is 100%, and every parameter has its own description, so the tool description adds no new parameter meaning. The baseline 3 applies because the schema documents parameter roles and constraints thoroughly.

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 ('Update') and the resource ('saved Yandex Tracker issue filter'), distinguishing it from siblings like filter_create and filter_get. The verb and resource are 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 like filter_create or filter_get. The description relies solely on the word 'Update' and offers no exclusions, prerequisites, or alternative recommendations.

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

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

The readOnlyHint annotation already covers the read-only nature. The description adds context that the returned fields are global and usable in issues, which is useful. However, it does not describe pagination, ordering, or other behavioral details, though these are less critical for a simple list endpoint.

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 without any fluff. Every word contributes to conveying 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 zero-parameter, read-only nature and the presence of an output schema, the description fully covers the tool's purpose. It clearly explains what the tool returns and its scope, with no missing critical information.

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 is fully covered. The description adds no parameter-specific semantics, but none are needed. The tool has no input requirements, 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 states 'Get all global fields available in Yandex Tracker that can be used in issues' with a specific verb, resource, and scope. It clearly distinguishes from sibling tools like queue_get_fields by emphasizing 'global' and 'can be used in issues'.

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 does not explicitly mention when to use this tool versus alternatives. The word 'global' implies a distinction from queue-specific fields, but no direct comparison or exclusion is provided. Usage context is implied rather than stated.

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

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

The annotation readOnlyHint=true already signals a safe read operation. The description adds that the tool retrieves all issue types for create/update operations, but it does not disclose return format, sorting, or edge cases. Since the schema and output schema provide structural details, the description offers modest additional 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 sentence that immediately states the action and resource, with no filler or repetition. It is front-loaded and efficiently 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 zero parameters, a readOnly annotation, and an output schema, the description fully covers what the tool does and when it is relevant. It explains the data's usage context, making it complete for an agent to decide when to call this 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 tool has zero parameters and the schema coverage is 100% for an empty properties object. Per rubric, zero-parameter tools receive a baseline of 4. The description adds context about the returned data's purpose but there are no parameter semantics to elaborate on.

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 'Get' and clearly identifies the resource as 'all issue types available in Yandex Tracker'. It further explains the purpose ('can be used when creating or updating issues'), which distinguishes it from sibling tools like get_statuses or get_priorities.

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 states the context for use ('when creating or updating issues'), which implies when to call this tool. However, it does not explicitly name alternative tools or specify when not to use it, so it lacks full exclusionary guidance.

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

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

The annotation readOnlyHint=true already communicates that this is a safe read operation. The description adds useful context about the scope ('available in Yandex Tracker' and 'can be used in issues'), which goes beyond the annotation. No additional behavioral traits like pagination or auth are disclosed, but the output schema covers return details.

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 states the verb, resource, and scope without any filler or redundant phrasing. It earns its place entirely and has 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?

With no parameters, a readOnlyHint annotation, and an output schema present, the description fully covers what an agent needs to know to select and call this tool. The description's statement of scope completes the picture for a simple metadata-lookup 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 tool has zero parameters, so the schema is complete and there is nothing to explain. The description appropriately focuses on what the tool returns rather than parameter details. Baseline of 4 applies for parameterless tools.

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 'Get' and names the resource 'all priorities available in Yandex Tracker', with the functional scope 'can be used in issues'. This clearly distinguishes it from sibling tools like get_statuses or get_issue_types, which target different reference data.

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 the use case: an agent should call this when it needs the list of priorities available for issues in Yandex Tracker. It does not name alternative tools, but for a no-argument lookup there are no obvious competing tools for this specific data.

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

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

The annotations already declare readOnlyHint=true, so the safety profile is covered. The description adds the scope ('all resolutions') and the context ('when closing issues') but does not disclose additional behaviors like ordering, filtering, or response format. This is acceptable for a simple list retrieval with annotations present.

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, focused sentence that immediately states the action and resource. It is front-loaded with the tool's purpose and contains 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 has no parameters and the output schema exists, the description is sufficient for an agent to understand the tool's role. The context 'when closing issues' and the scope 'all resolutions' provide complete guidance for this low-complexity read 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?

The tool has zero parameters, so the schema fully covers the input space (100% coverage). Per the rubric, a no-parameter tool gets a baseline of 4. The description does not need to add parameter details, as none exist.

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 identifies the tool's purpose: retrieving all resolutions in Yandex Tracker used when closing issues. It uses a specific verb ('Get') and resource ('resolutions'), and the context 'when closing issues' distinguishes it from sibling tools like get_statuses or get_issue_types.

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 intended use case ('when closing issues'), which helps the agent select it for issue closure scenarios. However, it does not explicitly mention alternatives or exclusions, though the context is reasonably clear among the many sibling getter 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?

The readOnlyHint annotation already covers the safety profile. The description adds a contextual detail that only statuses usable in issues are returned, which is mildly informative. It does not describe pagination, return format, or other behavioral traits, but the output schema fills some 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 concise sentence that front-loads the action ('Get all statuses') and provides necessary qualifying context without any fluff. 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?

For a simple, parameterless, read-only tool with an output schema, the description adequately explains what the tool returns. The context of 'available in Yandex Tracker' and 'usable in issues' is sufficient for the agent to use it correctly, and the output schema covers return structure.

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 is empty and schema description coverage is trivially 100%. The baseline for 0 params is 4, and the description does not need to explain any parameters. It appropriately focuses on the tool's purpose.

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 it gets all statuses available in Yandex Tracker that are usable in issues, with a specific verb and resource. It distinguishes itself from sibling reference-data tools by naming the exact entity (statuses) and scoping to issue-usable statuses.

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 explicit guidance on when to use this tool versus alternatives such as get_issue_types or get_resolutions. It only states what it does, leaving the agent to infer usage from the name. There is no mention of exclusions or alternative 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 only readOnlyHint=false, the description adds valuable behavioral context: @login mentions do not trigger notifications, and summonees must be used instead. This goes beyond the annotation but does not disclose other side effects like follower changes (which are covered in the schema).

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

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

Two focused sentences: the first states the tool's purpose, the second delivers the critical usage warning. No fluff, front-loaded, and every sentence 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?

For a comment-creation tool with a complete schema and output schema, the description covers the essential purpose and the key gotcha. It lacks details on prerequisites or auth, but those are not necessary given the tool's simplicity and schema coverage.

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

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

Schema coverage is 100%, so baseline is 3. The description adds extra semantics for the summonees parameter by warning about @login behavior, which is not explicit in the schema. This elevates the parameter meaning beyond the property descriptions.

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 'Add a comment to a Yandex Tracker issue' with a specific verb and resource. It distinguishes from siblings like issue_update_comment and issue_delete_comment by the action 'add'.

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 an explicit 'IMPORTANT' guideline: do not rely on '@login' in text to mention people; use the `summonees` parameter instead. This is a clear when-not/alternative instruction, though it does not contrast this tool with sibling comment-editing 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?

The annotations only provide readOnlyHint=false, so the description carries the burden of explaining behavior. It does so by clarifying the directional semantics of the relationship (e.g., 'depends on' means issue_id depends on the linked issue) and stating that it returns the created link. This goes beyond the annotation and adds meaningful 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 three sentences long, with the main action front-loaded. Every sentence earns its place: the first states the purpose, the second explains relationship semantics with examples, and the third notes the return value. 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?

The tool has an output schema, so return values are covered elsewhere. With 3 required parameters, one enum, and clear semantics, the description is complete for the tool's complexity. It could mention error cases like invalid issue IDs, but that is not essential given the schema richness.

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

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

Schema coverage is 100%, so the baseline is 3. The description adds significant value by explaining the 'relationship' parameter with concrete examples, clarifying how issue_id relates to the linked issue. This enriches the schema descriptions without repeating them verbatim.

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 begins with 'Create a link between a Yandex Tracker issue and another issue,' which is a specific verb+resource statement. It clearly distinguishes this tool from siblings like issue_delete_link and issue_get_links, and the relationship examples further clarify the tool's purpose.

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

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

The description explains when to use the tool (to create links) and provides concrete guidance on choosing the 'relationship' parameter with examples like 'depends on' and 'is dependent by.' It explicitly says to use 'relates' for a simple connection. While it doesn't mention alternatives or exclusions, the context is sufficient for this simple creation 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?

The annotation readOnlyHint=false already signals this is a write operation, and the description's 'Add' aligns. However, the description adds no additional behavioral context such as whether the worklog is appended, any permission requirements, or that it will be visible via issue_get_worklogs. It does not contradict annotations, but also provides no extra transparency beyond the annotation.

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

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

The description is a single, concise sentence that precisely captures the tool's purpose without unnecessary verbosity. It is front-loaded with the verb and resource, making it easy to scan.

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

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

Given the simple nature of the operation, rich parameter schema, and presence of an output schema, the description is adequate for a basic add-worklog tool. It clearly indicates the primary action, though it could have mentioned typical side effects or that worklogs are associated with an issue, but those are already implied by the schema and tool name.

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?

Since the schema description coverage is 100%, the parameters are already fully documented in the schema. The tool description itself adds no additional meaning to parameters, instead relying on the schema's definitions for issue_id, duration, start, and comment. This meets the baseline but does not exceed it.

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 worklog entry') and the specific resource ('to a Yandex Tracker issue'), with the parenthetical 'log spent time' clarifying intent. It distinguishes from sibling tools like issue_update_worklog and issue_delete_worklog by focusing on the creation aspect.

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 for logging time on an issue, but provides no explicit guidance on when to use it versus alternatives such as issue_update_worklog or issue_delete_worklog. There are no exclusions or alternative recommendations, leaving usage context implicit.

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

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

With annotations only indicating readOnlyHint=false, the description carries the burden of disclosing behavior. It clearly states it automatically finds and executes a transition, requires pre-calls for resolution selection, and returns the list of transitions in the closed status. This provides meaningful context beyond the minimal annotation.

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

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

The description is appropriately structured: a clear first sentence, a brief explanation of the tool's convenience, then a numbered list of prerequisites, and a final note on return value. Every sentence adds necessary information with no redundancy.

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

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

The description is comprehensive for a mutation tool: it explains prerequisites, how to pick a valid resolution, what the tool does automatically, and what it returns. Given the output schema exists, the description covers the necessary workflow without over-explaining details already in structured fields.

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

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

Schema coverage is 100%, giving a baseline of 3. The description adds valuable context by explaining that resolution_id must be chosen from the issueTypesConfig matching the issue's type, which clarifies the selection process beyond the schema's simple 'must be from get_resolutions' statement.

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 'Close a Yandex Tracker issue with a resolution' using a specific verb and resource. It distinguishes itself from siblings by explaining it is a convenience tool that automatically finds a 'done' transition, differentiating it from generic transition execution or update 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 provides clear context on when to use the tool (closing issues) and gives mandatory pre-steps that must occur before calling. It does not explicitly name alternative tools for other scenarios (like issue_execute_transition), so it falls short of a 5, but the guidance is strong.

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 merely restates the action without additional behavioral context. Annotations already indicate readOnlyHint=false, and the description adds no details about required permissions, side effects, or what happens on success. This is comparable to the update_drive example where mutation tools need more disclosure.

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 exactly one short sentence with no filler or redundancy. All words are useful, and it is front-loaded with the primary action.

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 is minimal but combined with a rich schema and output schema, it provides baseline adequacy. However, it lacks a high-level summary of prerequisites (like calling queue_get_fields) that is critical for successful use, leaving the agent to discover it in parameter descriptions.

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

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

Schema description coverage is 100%, so the baseline is 3. The description itself adds no parameter-level meaning; all semantic details are provided by the input schema, especially the 'fields' parameter's IMPORTANT note. This is acceptable but not enhanced.

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 action ('Create a new issue') and target resource ('Yandex Tracker queue'). It distinguishes from sibling tools like issue_update, issue_close, and issue_move by making the creation intent explicit.

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

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

The description implies usage when a new issue needs to be created, but does not explicitly mention when not to use it or alternatives. The important prerequisite about calling queue_get_fields is present only in the parameter schema, not the description, so guidance is limited to implication.

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

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

Annotations already declare destructiveHint=true and readOnlyHint=false. The description adds no additional context such as irreversibility, permission requirements, or impacts on related data. It merely restates the 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?

Entry is a single concise sentence, 'Delete an attachment from a Yandex Tracker issue', with no filler, redundancy, or extraneous 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 delete operation, the description paired with the 100% schema coverage, destructive hint annotation, and output schema is adequately complete. It could benefit from noting permanence, but that is not essential given the annotation.

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

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

Schema coverage is 100% with both issue_id and attachment_id described. The description adds no extra parameter semantics beyond identifying the two required identifiers.

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?

Description states 'Delete an attachment from a Yandex Tracker issue' with a specific verb and resource. It clearly distinguishes from sibling tools like issue_upload_attachment or issue_get_attachments.

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 does not mention prerequisites, permissions, or any conditions under which deletion should be performed. Only the basic action is 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?

The readOnlyHint annotation (false) already indicates a write operation, and the description's 'Delete' aligns. However, it adds no extra behavioral context such as permanence, permissions, or side effects, which is a gap for a destructive 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 that immediately states the action and resource. No superfluous information.

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

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

Given the low complexity, complete schema, and presence of annotation and output schema, the description is sufficient for the agent to understand the tool's purpose and usage. It lacks some deeper behavioral context, but the overall package is complete.

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

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

Schema coverage is 100% with clear descriptions for both issue_id and comment_id. The description adds no parameter detail, but this is acceptable because the schema fully documents the 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 'Delete a comment from a Yandex Tracker issue' uses a specific verb and resource, clearly distinguishing this tool from siblings like issue_add_comment and issue_update_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 clearly states the tool's action and context, making it obvious when to use it. However, it does not explicitly mention alternatives or exclusions, which prevents 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?

Annotations only provide readOnlyHint=false, so the description must add behavioral context. It adds the workflow hint about using issue_get_links, but does not disclose whether deletion is permanent, requires special permissions, or has side effects. No contradiction with annotations exists.

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

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

Two sentences, directly front-loaded with the purpose, followed by a useful usage hint. No wasted words or redundant information.

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

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

For a simple delete operation with two well-documented parameters and an output schema, the description covers the essential workflow. Including the prerequisite for retrieving link IDs makes it reasonably self-contained, though a note on irreversibility would add completeness.

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

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

Schema coverage is 100% with clear descriptions for both parameters (link_id 'as returned by issue_get_links' and issue_id format). The description's mention of issue_get_links adds little beyond the schema, so baseline 3 applies.

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

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

The description explicitly states 'Delete a link between a Yandex Tracker issue and another issue', combining a specific verb (delete) with a clear resource (issue link). This distinguishes it from sibling tools like issue_add_link (which adds) and issue_get_links (which retrieves).

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

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

The description gives a direct usage prerequisite: 'Use issue_get_links to retrieve the link IDs for an issue.' This tells the agent where to obtain the required link_id and implies this tool is used after retrieval. It doesn't explicitly list exclusions, but the context is clear enough.

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

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

Annotations already indicate readOnlyHint=false, signaling a write operation. The description's 'Delete' verb aligns with this. However, it adds no further behavioral details such as permanence, required permissions, or side effects. Given that annotations cover the basic safety profile and the description is consistent, it provides minimal additional 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 sentence with no unnecessary words. It is front-loaded with the verb 'Delete' and the resource, making it easy to scan and understand immediately.

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

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

The tool is a simple delete operation with an output schema and annotations, and the schema fully documents parameters. The description provides enough context for an agent to know what the tool does. It lacks explicit mention of irreversibility or permission dependencies, but for a basic deletion action, the information is sufficiently complete.

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

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

Schema description coverage is 100%, so both parameters (issue_id and worklog_id) are fully documented in the schema itself. The description does not add any extra parameter semantics. Per the rubric, with high schema coverage, the baseline is 3, and the description contributes nothing beyond the schema.

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

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

The description uses the specific verb 'Delete' and identifies the resource as 'worklog entry (spent time record)' within a Yandex Tracker issue. This clearly distinguishes it from sibling worklog tools like issue_add_worklog and issue_update_worklog, which perform different operations.

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 makes the usage context clear: it is for removing spent time records from an issue. However, it does not explicitly mention when to use this tool over alternatives or state exclusions, such as permission limitations or inability to delete certain worklogs. Still, the context is unambiguous for a straightforward delete operation.

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

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

Annotations already declare readOnlyHint: true, so the safety profile is known. The description adds the behavioral detail that the file is returned as an 'MCP embedded binary resource,' which clarifies the output format. It does not discuss authorization, file size limits, or streaming behavior, but these are not expected to be critical given the annotation coverage.

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 gets straight to the point. It is well-structured and front-loaded with the action, containing no unnecessary words.

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

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

With readOnlyHint annotations, an output schema, and fully described parameters, this simple download tool is adequately specified. The description covers the essential behavior (downloading as a binary resource), and the schema fills in prerequisite details. There is no missing critical context for an agent to invoke it correctly.

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

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

Schema description coverage is 100%, with each parameter (issue_id, attachment_id, file_name) having a clear description. The tool description itself adds no additional parameter semantics, but the baseline of 3 applies when the schema fully documents 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 uses a specific verb ('Download') and identifies both the resource ('attached file') and the output format ('MCP embedded binary resource'). This clearly distinguishes it from sibling tools like issue_upload_attachment, issue_delete_attachment, and issue_get_attachments (which lists attachments).

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 itself does not explicitly state when to use this tool versus alternatives. However, the schema parameter descriptions (e.g., 'returned by issue_get_attachments') imply a dependency on first listing attachments, giving implicit sequencing guidance. No exclusions or alternative tool mentions are provided.

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

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

The description adds value beyond the readOnlyHint=false annotation by stating that invalid transition IDs will be rejected and that the tool returns a list of new transitions for the new status. This helps the agent understand expected behavior and error cases, though it does not detail every side effect.

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 well-structured, with the main purpose first, followed by critical usage guidance and return value information. No filler or redundant phrasing.

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

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

Given the presence of an output schema and full parameter descriptions, the description sufficiently covers the core behavior, prerequisite, and return value. It could include example usage or edge cases, but it is complete enough for a well-specified tool.

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

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

Schema coverage is 100%, so all parameters already have detailed descriptions. The tool description reiterates the constraint on transition_id but does not add significant new semantic information beyond the schema.

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

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

The description clearly states the tool's function: executing a status transition for a Yandex Tracker issue. It uses a specific verb ('Execute') and resource ('status transition'), distinguishing it from sibling tools like issue_get_transitions or issue_update.

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 explicitly instructs users to call issue_get_transitions first and only use transition IDs returned by that tool. It also warns against arbitrary transition IDs, providing clear usage prerequisites and avoiding common pitfalls.

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

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

The readOnlyHint annotation already declares this as a safe read operation, lowering the burden on the description. The description adds no extra behavioral context beyond the annotation, but it is consistent with it. No contradictions, but no additional disclosure of return behavior or potential large payloads (which is only implicitly covered in the schema).

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

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

The description is a single sentence of nine words, front-loaded with the verb and resource. There is zero waste; 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?

For a simple read-only getter with full annotations, an output schema, and well-documented parameters, the description is sufficient. It could mention that this is the main issue retrieval versus sub-resource tools, but the output schema and sibling names provide enough context for a capable 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?

Schema description coverage is 100%: both issue_id and include_description have detailed descriptions. The tool description itself adds no parameter semantics, but per the rubric, with high schema coverage the baseline is 3. The description does not need to compensate.

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 ('Get'), resource ('Yandex Tracker issue'), and lookup method ('by its id'). However, it does not explicitly differentiate this tool from sibling tools like issue_get_comments or issue_get_url, so it is clear but lacks explicit sibling differentiation.

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

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

The description provides no guidance on when to use this tool versus alternatives. It does not mention exclusions, prerequisites, or alternative tools for related resources such as comments or links. The only usage hint ('use only when needed') appears in the schema for include_description, not in the description itself.

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

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

The readOnlyHint annotation covers the safety profile, but the description adds no behavioral context. It does not disclose whether the tool returns attachment metadata/URLs or file content, which is a critical behavior given the existence of issue_download_attachment. The description merely rephrases the schema parameter.

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, focused sentence with no filler. It front-loads the action and resource, making it easy to parse quickly.

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 one well-documented parameter and an output schema, so the description need not explain return values. However, it omits the important distinction between listing attachment metadata and downloading content, which is a gap in contextual completeness for selecting the right sibling tool.

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

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

Schema coverage is 100%, and the issue_id parameter has a clear description. The tool description adds nothing beyond 'by its id', so it meets the baseline but does not enrich the parameter semantics.

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?

Description clearly states the action ('Get'), the resource ('attachments of a Yandex Tracker issue'), and the scope ('by its id'). This distinguishes it from sibling tools like issue_get_comments and issue_download_attachment, 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?

The implied usage is clear: use this when you need an issue's attachments. However, it fails to explicitly mention the relationship with issue_download_attachment (which likely downloads actual content) or provide any 'when not to use' guidance, leaving potential ambiguity.

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 explains that results are paginated with a 'next_cursor', how to fetch subsequent pages, and what a null cursor means. This goes beyond the readOnlyHint annotation by revealing the response shape and pagination behavior, without contradicting the annotation.

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

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

Two sentences: the first packs the core purpose and content categories, the second explains pagination clearly. No verbose or redundant language; each clause earns its place.

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

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

Given the presence of an output schema and readOnlyHint annotation, the description adequately covers the tool's behavior. It explains pagination, the kinds of changes included, and the stopping condition, making it sufficient for an agent to invoke correctly without additional context.

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

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

All five parameters are fully documented in the schema (100% coverage), so the description adds little about individual parameters. However, it reinforces the cursor-based pagination semantics by explaining the next_cursor/cursor relationship, which complements the schema's cursor 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 uses a specific verb ('Get') and resource ('change history of a Yandex Tracker issue by its id'), and enumerates the content (status transitions, field edits, comment changes, triggers). This clearly distinguishes it from sibling tools like issue_get_comments or issue_get_transitions.

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 reading an issue's audit trail and provides detailed pagination guidance (how to use next_cursor and cursor, when to stop). It does not explicitly state when to use this tool instead of alternative read tools, but the content list makes the use case 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?

The description adds no behavioral context beyond the readOnlyHint annotation. It does not mention pagination, return format, or error behavior. Since annotations already declare the operation safe, the description provides minimal additional 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 sentence that front-loads the action and resource, with no extraneous words. It is 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?

For a simple read-only tool with one parameter and an output schema, the description is adequate to convey the tool's purpose. It doesn't cover edge cases like absent checklist items, but the output schema and annotations cover most operational context, so this is acceptable.

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 already fully documents the single parameter with a clear format example ('SOMEPROJECT-1'). The description's 'by its id' adds no new meaning, so the description does not enhance parameter understanding beyond the schema.

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

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

The description uses the specific verb 'Get' followed by the resource 'checklist items of a Yandex Tracker issue' and identifies the input by 'its id'. This clearly states the tool's function and distinguishes it from sibling issue_get_* tools such as issue_get_comments and issue_get_links.

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 checklist items for a specific issue are needed, but it does not explicitly state when to prefer this tool over alternatives or mention any exclusions. Given the sibling tools for various issue aspects, more explicit guidance would improve this dimension.

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

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

The annotations already declare readOnlyHint=true, aligning with the 'Get' semantics. The description adds no additional behavioral context beyond the operation itself, such as ordering, pagination, or filtering behavior. With annotations covering the safety profile, this is acceptable but not enriched.

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 zero filler. Every word contributes to understanding the tool's purpose and input.

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

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

For a simple read-only tool with one parameter and an output schema, the description is sufficient. It clearly states the operation and the key input. It lacks extra guidance like handling of empty results or pagination, but the output schema likely covers the return structure, so this is not a critical gap.

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

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

The input schema fully describes the only parameter (issue_id) with format guidance. The description's 'by its id' adds no new meaning, as the schema already provides the 'SOMEPROJECT-1' format. Since schema coverage is 100%, the baseline of 3 is appropriate.

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

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

The description uses a specific verb ('Get'), a clear resource ('comments of a Yandex Tracker issue'), and a retrieval key ('by its id'). It distinguishes this tool from siblings like issue_get_changelog, issue_get_worklogs, and issue_get_attachments, which target different issue sub-resources.

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 indicates when to use the tool: to retrieve comments for a specific issue. It does not explicitly list exclusions or alternative tools, but the context is clear enough that an agent can infer when this is the appropriate choice among the many sibling tools.

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