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

Annotations declare readOnlyHint=false and destructiveHint=false, and the description is consistent with that ('Изменяет задачу' — it modifies the issue). Beyond the annotations it adds a genuine behavioral requirement not encoded anywhere else: the pre-call confirmation step for text, assignee and deadline. It still says nothing about error behavior or whether additions are reversible.

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

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

Two short sentences, front-loaded with the action and followed immediately by the constraint. Every clause earns its place with no filler.

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

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

An output schema exists, so return values need not be explained, and the safety profile is covered by annotations. The description covers the mutation nature and the confirmation workflow, leaving only minor gaps such as the undocumented required issue_id and deadline_type semantics.

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

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

Schema description coverage is 0% across 6 parameters, so the description carries the burden, and it names only three (text, assignee, deadline) — and only in the context of user confirmation rather than semantics. The required issue_id, plus checked and deadline_type, remain completely undocumented in both schema and description.

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

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

The description states a specific verb and resource ('Добавить пункт чек-листа' = add a checklist item) and the name cleanly separates it from siblings like update_checklist_item and delete_checklist_item. It does not, however, explicitly contrast itself with those siblings or note that the parent issue must already exist.

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

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

It gives one concrete usage rule — show the text, assignee and deadline to the user before invoking — which is real guidance for a mutating tool. But there is no when-to-use/when-not-to-use statement relative to update_checklist_item or the checklist read tools, so routing guidance is only implied by the name.

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

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

Annotations already declare readOnlyHint=false and destructiveHint=false, so the write nature is known. The description adds a genuinely non-obvious behavioral requirement — display the comment text for user confirmation before calling — which is context the annotations do not provide.

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

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

Two short sentences, with the action stated first and the mutation warning immediately after. No filler, no redundancy — every clause earns its place.

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

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

An output schema exists, so return values need not be described, and the annotations cover the read/write profile. The gap is the summonees parameter plus the absence of any note on comment visibility or who may comment, leaving a simple tool slightly under-specified.

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

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

Schema description coverage is 0%, so the description must carry the parameter burden, and it only implicitly covers issue_id and text. The summonees parameter (users to mention/notify) is entirely undocumented in both description and schema, and its semantics are not inferable from the name alone.

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

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

The description gives a specific verb and resource ('Добавить комментарий к задаче'), which is enough to tell it apart from list_comments or create_issue by action type. It does not, however, explicitly name a sibling or scope boundary the way a top-scoring description would.

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

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

It supplies one concrete precondition — show the text to the user before invoking, since it mutates Tracker data. There is no guidance on when to choose this over alternatives (e.g., update_issue, add_worklog) or any exclusion conditions, so usage is only partially covered.

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

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

Annotations already declare readOnlyHint=false and destructiveHint=false, so the mutation nature is partly covered; the description reinforces this ('Изменяет данные в Трекере') and adds a confirm-with-user step, which is genuine extra context. It does not say whether the worklog is reversible, what permissions are needed, or how the change affects existing time reports, so it stays at an adequate-but-thin level.

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

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

Two short sentences with no filler: the action comes first, the safety/confirmation instruction second. Nothing is repeated from the schema or annotations.

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

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

An output schema exists, so return values need not be described. For a mutating four-parameter tool with no schema documentation, the description covers the action and the confirmation step but omits duration/date formats, the meaning of issue_id, and any pointer to the sibling worklog tools.

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

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

Schema description coverage is 0%, so the description carries the burden, and it names three of the four fields (duration, start date, comment) in the confirmation instruction. However, issue_id goes unmentioned and no format guidance is given for duration (e.g. '2h 30m') or start (timezone/date format), leaving a real gap.

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

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

The description states a specific verb and resource ('Списать время на задачу' – log time to an issue), which clearly separates it from read-oriented siblings like list_worklogs or get_issue_time_report. It stops short of naming the update_worklog/delete_worklog alternatives, so sibling differentiation is implied rather than 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?

It gives one invocation-time instruction (show duration, start date, and comment to the user before calling), which is useful, but offers no guidance on when to use this tool versus update_worklog, delete_worklog, or the time-report tools. There is no when-not-to-use condition and no routing signal for the agent.

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

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

Annotations already declare readOnlyHint=false and destructiveHint=false; the description reinforces the mutation («Изменяет данные в Трекере») and, more valuably, adds a confirmation-with-user requirement that annotations do not convey. This extra behavioral context is genuinely helpful, though no permission or side-effect details are given.

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

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

Two compact sentences, front-loaded with the action verb, with no filler. Every clause carries information—the mutation warning and the confirmation requirement.

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

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

An output schema exists, so return values need not be described. Still, for a 7-parameter mutation tool with 0% schema coverage, the description documents only 2 parameters and omits guidance on priority, assignee, issue_type, and the free-form fields object.

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

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

Schema description coverage is 0% with 7 parameters, so the schema provides no semantics. The description names only «название» and «очередь» (summary and queue), leaving fields, assignee, priority, issue_type, and description completely undocumented in both places.

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

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

«Создать задачу» states a specific verb and resource, immediately distinguishing it from siblings like update_issue, get_issue, and search_issues. It is clear and unambiguous, though it does not explicitly name or contrast against an alternative tool.

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

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

The sentence «перед вызовом подтвердите название и очередь с пользователем» gives a concrete pre-call condition, which is useful guidance. However, it offers no when-to-use/when-not guidance relative to alternatives such as update_issue, so usage is only partially covered.

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, so the safety profile is covered structurally. The description adds value beyond that by stating the change is irreversible and affects the parent issue, and by requiring user confirmation — a workflow constraint the annotations do not express. It still omits any permission or rate-limit 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?

Two short sentences with zero filler: the action is front-loaded and the irreversibility/confirmation warning follows. Every clause earns its place.

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

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

An output schema exists so return values need no explanation, and the annotations cover destructiveness. What is missing is the parent/child relationship between issue_id and checklist_item_id, which an agent needs to call the tool correctly. The description is adequate but leaves that identifiable gap.

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

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

Schema description coverage is 0% for two required parameters, so the description carries the full burden. It refers obliquely to the checklist item identifier ('подтвердите идентификатор пункта') but never explains issue_id or the relationship between the two IDs, leaving half the parameters unexplained.

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

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

The description states a specific verb+resource ('Удалить один пункт чек-листа' — delete one checklist item), which is clearly distinguishable from the add_/update_checklist_item siblings. It stops short of naming an alternative or clarifying where the item lives, so it is clear but not maximally differentiated.

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

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

It gives one actionable precondition — confirm the item ID with the user before deleting — which is genuine usage guidance for a destructive operation. However, it names no alternatives (e.g. update_checklist_item) and states no when-not-to-use condition, so the routing guidance is only implied.

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

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

Annotations already declare destructiveHint=true and readOnlyHint=false. The description adds useful context beyond that by stating the change is irreversible and that user confirmation of both identifiers is required before proceeding, though it omits permission or error-handling 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 two tight sentences with no filler. The core action is front-loaded, and the destructive warning plus confirmation requirement follow 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?

For a simple two-parameter deletion tool, the description covers the action, its irreversibility, and the need for user confirmation, while annotations supply the safety profile and an output schema exists. It could still mention authorization requirements or post-deletion state, so it falls just short of 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 0%, so the description must compensate. It partially does by mapping the two identifiers to a user-facing "task" (issue_id) and "record ID" (worklog_id) and requiring confirmation, but it adds no format details or constraints for either parameter.

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

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

The description states a specific verb and resource: "Удалить запись трудозатрат" (Delete a worklog entry). This operation is naturally distinguished from sibling tools like add_worklog, update_worklog, and list_worklogs without needing to name them.

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

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

It provides one clear usage rule — confirm the issue and worklog ID with the user before deleting — which is valuable for a destructive operation. However, it does not explicitly state when to use this versus update_worklog or how to recover from an erroneous deletion.

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

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

Annotations already declare readOnlyHint=false and destructiveHint=true, so the write/destructive nature is covered. The description adds one genuinely new behavioral fact beyond annotations: 'Изменяет данные в Трекере; подтвердите целевой переход с пользователем' establishes a human-confirmation requirement. It says nothing about irreversible state changes, permissions, or whether 'fields' accompanies the transition.

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

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

Two short sentences, mutation fact and confirmation guardrail front-loaded, no filler. It is appropriately sized; the only cost is that the brevity comes at the expense of the missing detail noted above.

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

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

For a destructive mutation on an issue tracker, an agent still lacks where transition_id comes from (list_transitions), whether the transition may require fields, and what permissions are needed. An output schema exists, so return values need not be described, but the preconditions and parameter sourcing are not covered.

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

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

Schema description coverage is 0% across 3 parameters, so the schema provides no meaning for issue_id, transition_id, or fields, and the description does not compensate. 'Целевой переход' loosely maps to transition_id and confirms it is the destination status, but issue_id and especially the opaque 'fields' object are left entirely unexplained.

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

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

The description gives a specific verb + resource: 'Выполнить переход статуса задачи' (execute an issue status transition). An agent knows exactly what mutation is performed. It does not distinguish itself from the sibling list_transitions, which is the natural companion tool for obtaining the transition to execute.

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

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

Usage is only implied: it instructs the agent to confirm the target transition with the user before acting, which is a useful workflow guardrail. However, it never states when to prefer this over list_transitions (to discover valid transitions) or update_issue (to change fields without a status change). No alternatives or exclusions are named.

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

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

readOnlyHint=true already tells the agent this is a safe read. The description adds one genuinely useful behavioral detail, that returned items carry their identifiers (which is what the update/delete siblings need), but says nothing about permissions or ordering/limits on the returned items.

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

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

A single front-loaded sentence with no filler; the resource comes first and the clarifying detail about identifiers is appended efficiently.

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

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

An output schema exists, so return values need not be described, and this is a simple one-parameter read. Still, the description offers no routing guidance against get_checklist_report and no clarification of the issue_id format, so it is only minimally complete.

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

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

Schema description coverage is 0% and the single parameter issue_id carries no schema documentation. The description implies the argument is an issue ('чек-листа задачи') but never clarifies whether it expects a numeric ID or a key such as 'PROJ-123', leaving a real ambiguity unaddressed.

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

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

States a specific verb and resource: retrieving the checklist items of an issue, plus the detail that their identifiers are included. It does not explicitly differentiate itself from the sibling get_checklist_report, so an agent must infer which one to reach for from the name alone.

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

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

There is no statement of when to use this tool versus get_checklist_report or the add/update/delete_checklist_item siblings. The only implied context is that it is a read operation on an existing issue's checklist.

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 tells the agent this is a safe read, so the description carries a lower burden. It adds that the output is an aggregate report (progress, overdue, per-assignee), but says nothing about permissions, scope limits, or how an absent as_of is interpreted.

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

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

Two short sentences, no padding, with the report scope front-loaded before the parameter note. Efficient for a two-parameter tool.

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

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

An output schema exists, so return values need no further explanation, and the description still summarizes them. With only one non-obvious parameter (as_of format given) this is nearly complete, the main gap being no guidance on when to prefer it over get_checklist.

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

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

Schema description coverage is 0%, so the description must compensate. It documents the format of as_of (YYYY-MM-DD) but not what a null as_of means (schema default null, presumably 'now'), and issue_id is left unexplained.

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

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

States a specific verb (analyze) and resource (checklist) and enumerates the report contents: progress, open and overdue items, per-assignee breakdown. This implicitly distinguishes it from the sibling get_checklist (raw list), though it never names that sibling or the distinction explicitly.

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

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

Usage is only implied by the described output — an agent can infer you call this when you want aggregated checklist status rather than raw items. There is no explicit when-to-use/when-not and no mention of alternatives such as get_checklist or get_issue_time_report.

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?

readOnlyHint=true already covers the safety profile, and the description adds the useful detail that the result is derived from the caller's token rather than an id. It says nothing about failure modes (e.g., invalid/expired token) or whether permissions affect the result.

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

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

A single front-loaded sentence with zero redundancy. Every word contributes to identifying the resource and its scope.

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

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

With an output schema present and no parameters, the description need not explain return values or inputs. The only meaningful gap is the absence of any hint about token-related failure conditions, which is minor for a simple identity read.

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

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

The tool takes zero parameters, so the schema carries no semantics to compensate for and the description correctly implies no input is required. Baseline 4 applies for a no-argument tool.

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

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

The description states a specific verb and resource ('get the user') scoped to the current Tracker token, which clearly separates it from a general user lookup. It does not, however, explicitly contrast itself with siblings like get_user or list_users, so the differentiation must be inferred.

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

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

There is no guidance on when to pick this over get_user, list_users, or search_users. The token-scoped phrasing implies 'use when you want the authenticated identity', but that inference is left entirely to the agent.

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?

readOnlyHint=true already establishes the safe read profile, so the description's only added signal is that results include field schemas and types. It says nothing about scope (global vs. per-queue), pagination, or auth requirements, but with annotations the bar is lower.

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 compact sentence that leads with the action and immediately qualifies the payload. No filler or redundant restatement of the tool name.

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

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

With zero parameters and an output schema present, the description need not explain return values; mentioning schemas and types is a useful preview. The only real gap is the absence of any scoping or usage context relative to sibling metadata tools.

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

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

The tool takes zero parameters, so there is nothing for the description to compensate for. Baseline 4 applies; the description appropriately makes no attempt to describe nonexistent inputs.

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

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

The description states a specific verb and resource ('Получить все глобальные поля задач') and adds what is returned ('вместе со схемами и типами'). It is clearly a distinct retrieval tool, but it does not differentiate itself from near-siblings like get_queue_fields 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?

There is no statement of when to use this tool versus the many other field/metadata getters in the sibling list. Usage is only implied by the resource name, with no exclusions or prerequisites given.

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

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

readOnlyHint=true already tells the agent this is a safe read, so the description carries a lower burden, but it adds nothing behavioral on top: no note on the optional fields selection, error behavior for a missing/invalid key, or any auth requirement. The only added context is the key format example.

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

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

A single sentence with no filler, front-loaded with the verb and resource, and the example is the one piece of extra information that 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?

An output schema exists so return values need not be described, but for a tool with an undocumented optional 'fields' parameter and many sibling read tools, the description is too thin: no field-selection guidance and no differentiation from search_issues.

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

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

Schema description coverage is 0%, so the description must compensate. It loosely covers issue_id via the TEST-123 key example, but the 'fields' parameter — which controls which issue fields are returned — is completely undocumented in both schema and description.

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

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

States a specific verb and resource ('Получить задачу Яндекс Трекера') and constrains retrieval to a key lookup with a concrete example (TEST-123). This distinguishes it from search_issues, but it never names that sibling or otherwise positions itself among the many get_* 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 'по ключу' plus the TEST-123 example implies usage (use when you already know the issue key), which is useful routing information. However, there is no explicit when-to-use vs search_issues or when-not guidance, and nothing about required permissions.

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 covered. The description adds the report's dimensions (plan/fact/deviation/employee/day) and the accepted date format, which is useful context, but says nothing about what happens when the optional dates are omitted or which effort categories are included.

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

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

Two compact sentences that lead with the tool's purpose and follow with the one non-obvious parameter convention. No filler, though the language of the description does not match the English tool/parameter names, which costs a little clarity.

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

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

An output schema exists, so return details need not be repeated. Still, for a three-parameter report tool with zero schema coverage, the definition omits issue_id semantics and the behavior of the optional date range, leaving gaps an agent must guess at.

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

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

Schema description coverage is 0%, so the schema gives no meaning for any of the three parameters. The description does clarify the date format (YYYY-MM-DD) for date_from/date_to, which is more than the schema provides, but leaves issue_id unexplained and never states that both dates are optional or what their omission means.

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

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

States a specific verb and resource: analyze the time/effort ('трудозатраты') of a single issue, plus what the report contains (plan, fact, deviation, breakdown by employee and day). It is clearly distinguishable from a system-wide time report, but it never names the sibling get_time_report or explains the scope difference explicitly.

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

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

There is no when-to-use guidance, no mention of the alternative (get_time_report) and no stated prerequisites such as needing worklogs to exist. The only operational hint is the date format, which is not usage guidance.

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

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

readOnlyHint=true already tells the agent this is a safe read, so the description is not carrying the safety burden. It adds only that the result includes keys ("их ключи"), a small amount of extra context, and says nothing about caching, stability, or permissions. Adequate but thin given the annotations already cover the safety profile.

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

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

A single short sentence with no filler, front-loading the verb and resource immediately. Nothing in it is redundant with the title or schema, and every word earns its place.

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

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

For a 0-parameter reference-data lookup with an output schema that documents the return shape, the description is nearly sufficient. The only missing element is a pointer to the workflow context (e.g., that these keys feed create_issue/update_issue), which would make it fully self-contained.

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

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

The tool takes zero parameters, so there is nothing for the description to disambiguate; the baseline for a 0-param schema is 4. No parameter behavior is misrepresented or omitted.

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

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

The description states a specific verb and resource ("get valid issue types and their keys"), making the retrieval target unambiguous. It does not explicitly distinguish itself from sibling lookups like get_statuses, get_priorities, or get_resolutions, but the resource noun is distinct enough that an agent can route correctly.

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

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

There is no guidance on when to call this versus alternatives, no mention of prerequisites, and no hint that these values are needed before create_issue or update_issue. The word "valid" faintly implies reference-data lookup, but nothing 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=true annotation already tells the agent this is a safe, non-mutating lookup, so the description carries a lower burden. It adds no further behavioral detail (e.g., that values are static/enumerable reference data), so it neither contradicts nor enriches 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?

A single short sentence with the resource front-loaded and zero filler. Every word contributes to identifying what the tool returns.

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

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

With an output schema present, the description need not describe return values, and it appropriately names what comes back (priority levels and keys). Combined with the readOnly annotation and zero-param schema, it is nearly complete; only the relationship to sibling lookup tools is unstated.

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

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

The tool takes zero parameters, which is the baseline-4 case. The description correctly implies no input is required, and there is no parameter documentation gap to compensate for.

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

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

States a specific verb ('Получить') and resource ('уровни приоритета и ключи'), and even names the downstream purpose (creating or changing tasks). It does not explicitly differentiate itself from reference-data siblings like get_statuses, get_issue_types or get_resolutions, so it stops short of a 5.

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

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

The phrase 'для создания или изменения задач' implies the tool is used to fetch valid priority keys before create/update calls, which is useful implied context. There is no explicit when-not guidance and no named alternative among the many sibling reference-data 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?

readOnlyHint=true already covers the safety profile, and the description adds the conditional behavior that include_local_fields=true also returns local fields. It does not mention permissions, ordering, or rate limits, so with annotations covering safety this is a modest addition.

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

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

Two short sentences with no waste; the core purpose is front-loaded before the conditional parameter behavior. It is terse to the point of omitting useful context, but sizing is appropriate.

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

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

Return values need not be described because an output schema exists, and the read-only annotation covers safety. However, with 0% schema coverage the description should do more to document queue_id and disambiguate from get_global_fields.

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

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

Schema description coverage is 0%, so the schema itself documents nothing. The description compensates for include_local_fields by explaining its effect (also returns local fields), but leaves queue_id entirely unexplained and gives no format hints.

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

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

The description states a specific verb+resource ('Получить поля очереди' / get queue fields) and clarifies the scope with the conditional inclusion of local fields. It does not explicitly distinguish itself from the sibling get_global_fields, so the queue-vs-global contrast is left implicit.

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

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

It says what the tool returns but gives no guidance on when to prefer it over get_global_fields or other field-listing siblings, and states no prerequisites or exclusions. Usage context must be inferred.

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 establishes this is a safe, non-mutating read, so the description carries a lower burden. It adds the 'available for closing' filter semantics, which is useful, but says nothing about whether results are context/queue-dependent or how they are ordered. Adequate 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?

A single short sentence with the scope qualifier front-loaded and no filler; it is appropriately sized for a parameterless lookup. It is terse to the point of omitting any routing or usage guidance, which slightly limits its 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?

An output schema exists, so return values need not be explained, and with no parameters the description has little else to cover. Still, in a sibling set crowded with get_* metadata tools, it does not help the agent choose this one over list_transitions or get_statuses.

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

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

The tool takes zero parameters, so the baseline of 4 applies; there is no parameter semantics for the description to clarify. The 100% schema coverage and empty property set mean nothing is missing on this axis.

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

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

The description states a specific verb and resource ('Получить доступные резолюции') and adds scope ('для закрытия задач'), so the agent knows this returns the set of resolutions valid for closing an issue. It is clear but does not explicitly distinguish itself from metadata siblings like get_statuses, get_priorities, 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 phrase 'для закрытия задач' implies the usage context (fetching resolutions when closing an issue), which is more than nothing. However, there is no explicit when-to-use clause, no mention of pairing with execute_transition, and no exclusions relative to the other lookup 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?

Annotations already declare readOnlyHint=true, so the safe-read profile is covered. The description adds one useful behavioral nuance: these are organization-level configured statuses, not per-issue status values. Beyond that it says nothing about caching, completeness of the returned set, or authorization scope.

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

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

A single front-loaded sentence that names verb, resource, and scope with zero filler. Nothing is redundant or deferred.

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, an output schema that documents the return shape, and annotations covering the read-only profile, the definition is nearly self-sufficient. The only shortfall is the absence of routing guidance among the several sibling configuration-listing tools.

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

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

The tool takes zero parameters, which is the baseline-4 case: there is no parameter meaning the description needs to supply. It correctly implies a full org-wide enumeration with no filtering options.

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

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

States a specific verb and resource: 'Получить статусы задач' (get task statuses), narrowed by scope to those 'настроенные в организации' (configured in the organization). This is clearly distinct from issue-level operations, but it does not differentiate itself from near-identical sibling configuration lookups such as get_priorities, get_resolutions, 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 gives no when-to-use context, no prerequisites, and no mention of the closely related configuration-listing siblings. An agent must infer from the name alone that this is the status-config lookup versus get_priorities/get_resolutions.

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 safety is covered. The description adds the date input format (YYYY-MM-DD), which is genuinely useful, but says nothing about rate limiting, the meaning of max_issues/concurrency, or whether results are paginated or truncated.

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

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

Two tight sentences with the report scope front-loaded and the date-format constraint appended. No filler, though the format note could be folded into the main sentence.

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

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

An output schema exists, so return values need not be described, but for a 5-parameter tool with zero schema description coverage the description should explain the query parameter and the tuning parameters. It also omits the relationship to get_issue_time_report, leaving the agent under-equipped to choose correctly.

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

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

Schema description coverage is 0% across 5 parameters, and the description only clarifies the date format for date_from/date_to. The required 'query' parameter's syntax and the roles of max_issues (default 50) and concurrency (default 5) are unexplained anywhere.

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?

Names a specific verb (build a summary report) and resource (Tracker tasks) and enumerates the breakdown dimensions: employees, tasks, queues, days. An agent understands the output shape. However, it never distinguishes itself from the sibling get_issue_time_report, which an agent must disambiguate on its own.

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 'from a Tracker query' implies the tool is query-driven aggregation, but there is no explicit when-to-use, when-not-to-use, or named alternative. The most likely confusion, get_time_report vs get_issue_time_report, is left entirely unresolved.

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 declares the safety profile, so the bar is lower, but the description adds nothing behavioral beyond the purpose line: no permissions/scope requirements, no not-found behavior, no rate-limit or scoping notes. The one extra fact (login OR UID) is really parameter semantics, not behavior.

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

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

A single front-loaded sentence with zero filler, correctly leading with the action and resource. It is terse to the point of omitting useful qualifiers, but nothing in it is wasted.

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

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

An output schema exists, so return values need not be described, and the tool is a simple single-parameter read. However, the description is written in Russian while the tool surface, schema, and sibling names are English, and it omits any scoping or failure-mode context, leaving it only minimally adequate.

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

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

Schema description coverage is 0% and the sole parameter "user_id" is titled only "User Id", so the description must compensate. It does partially, by disclosing that the value may be either a login or a UID, which is genuinely beyond the schema — but it gives no format, case-sensitivity, or ambiguity-resolution guidance.

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

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

States a specific verb and resource ("Получить пользователя организации" = get an organization user) plus the lookup keys (login or UID). This is enough to distinguish it from get_current_user (self) and list_users/search_users, though it does not name those siblings explicitly.

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

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

No when-to-use, when-not-to-use, or alternative routing is given. An agent cannot tell from the description whether to reach for this, search_users, or list_users when it only has partial identity information; the choice is left to inference from the parameter.

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?

readOnlyHint=true already tells the agent this is a safe read, and the description adds nothing further: no ordering, no pagination, no visibility/permission behavior, no comment-count limits. The description carries only what the annotation plus name already convey.

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

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

It is a single short sentence with no wasted words, but this is under-specification rather than effective conciseness; there is no front-loaded scoping detail to anchor the agent.

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

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

An output schema exists so return values need not be described, but for a list endpoint with one undocumented parameter and no pagination or ordering guidance, the definition leaves notable gaps an agent would need filled.

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

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

Schema description coverage is 0% for the single required issue_id parameter, so the description must compensate and it does so only weakly — 'задачи' hints that the id refers to an issue, but no format (key vs. numeric id) is given.

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

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

The description states a specific verb and resource (retrieve the comments of a task), which is unambiguous even in its terse Russian form. It does not, however, differentiate itself from the sibling add_comment or indicate scope (all comments vs. filtered/paginated).

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

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

There is no indication of when to use this tool versus alternatives such as add_comment or get_issue, nor any prerequisites or exclusions. The agent must infer usage entirely from the tool name.

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

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

readOnlyHint=true already tells the agent this is a safe read. The description adds nothing further – no pagination behavior, no note on how 'available' is determined, no volume or rate context. With annotations carrying the safety profile, this one-liner contributes essentially no extra behavioral context.

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

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

A single front-loaded sentence with no wasted words, but the brevity is under-specification rather than discipline – there is simply nothing else provided.

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

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

An output schema exists so return values need not be described, but for a paginated list tool the description omits pagination semantics and any usage context. What remains is too thin for an agent to call it confidently with correct paging.

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

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

Schema description coverage is 0% for both parameters, so the description carries the full burden for explaining page and per_page. It mentions neither pagination nor any default, leaving both parameters semantically undocumented.

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 clear verb and resource ('Получить доступные очереди' – get available queues), so an agent knows it lists queues. It does not distinguish itself from any sibling or clarify what 'доступные' (available) means in scope terms, but the core purpose is unambiguous.

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

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

There is no statement of when to use this tool versus alternatives (e.g., get_queue_fields, which also concerns queues), nor any prerequisite or scope guidance. The agent must infer usage entirely from the name.

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

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

readOnlyHint=true is consistent with a listing tool, so the description does not contradict the annotations. It adds no behavioral detail beyond that — no note that results are scoped to one issue, that transitions may be permission-filtered, or that the output is a candidate set rather than a mutation.

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

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

A single short sentence with no filler and the resource front-loaded. It is efficient, though terseness here reflects missing content rather than disciplined editing.

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

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

The tool is simple (one param, output schema present, read-only), so the description is minimally sufficient for invocation. It omits the workflow relationship with execute_transition, which is the main contextual gap for an agent deciding what to do with the returned transitions.

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

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

Schema description coverage is 0% for the single required issue_id parameter, so the description carries the full burden and does not meet it. 'для задачи' only loosely implies the parameter identifies an issue; no format, source, or identifier convention is given.

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

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

States a specific verb and resource ('get available status transitions for an issue'), which is clearly distinguishable in intent from utilities like get_statuses. However, it never names its natural sibling execute_transition, which performs the transition this tool enumerates, so the agent must infer the pairing.

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

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

There is no when-to-use, when-not-to-use, or prerequisite guidance. The only routing signal is the verb 'get' versus 'execute' in the sibling name, which the description does not reinforce or explain.

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?

readOnlyHint=true already declares this is a safe read, so the description's burden is reduced, but it adds essentially nothing beyond that: no mention of permissions/scope needed, pagination limits, ordering, or rate limits. The only behavioral hint, 'страницу', is already implied by the schema's page/per_page fields.

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

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

A single front-loaded sentence with no filler or redundancy. It is efficient, though its brevity contributes to the missing guidance elsewhere rather than being a virtue in itself.

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

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

An output schema exists, so return values need not be described, and the operation is simple. Still, with 0% schema coverage and several user-related siblings, the description leaves the agent without enough to choose this tool confidently over search_users.

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

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

Schema description coverage is 0%, so the description must carry parameter meaning, but it only vaguely gestures at paging ('страницу') and never mentions per_page, defaults, or bounds. Both parameters are effectively undocumented in either place.

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

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

States a specific verb and resource ('Получить страницу пользователей организации') and signals pagination via 'страницу'. It does not differentiate itself from the sibling search_users or get_user, so an agent cannot tell from the description alone which user-listing tool to pick.

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

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

There is no when-to-use guidance, no prerequisites, and no mention of the alternatives (search_users, get_user, get_current_user). The agent must infer that this is the unfiltered org-wide listing and that search_users handles filtered queries.

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?

readOnlyHint=true already covers the safety profile, and the description goes further by disclosing autopagination and a hard result cap of 500 records — behavior an agent cannot see in the schema. It stops short of saying whether the 'limit' parameter can override or lift that cap.

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

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

Two short sentences, the core purpose front-loaded, with the pagination/cap caveat second. Nothing is wasted or repeated from the schema.

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

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

An output schema exists, so return-field documentation is unnecessary, and the description covers the key behavioral caveat (auto-pagination, 500-record max). The remaining gap is the undefined relationship between the 'limit' parameter and the stated ceiling.

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

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

Schema description coverage is 0%, so the description carries the burden; it clarifies that issue_id identifies the task (задачи) and that the result set is bounded at 500, which relates to the defaulted 'limit' param. However it never explains the 'limit' parameter itself or how the 500 ceiling interacts with 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?

States a specific verb ('Получить') and resource ('записи трудозатрат задачи'), so an agent immediately knows this lists worklog entries for one issue. It does not differentiate itself from adjacent siblings such as get_issue_time_report or get_time_report, which also return time-tracking 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?

There is no guidance on when to choose this over get_issue_time_report, get_time_report, or the add/update/delete_worklog siblings. Usage is only inferable from the tool name and the notion of retrieving records.

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 a safe read operation. The description adds no behavioral context beyond that—no pagination behavior, rate limits, authentication needs, or result characteristics. It neither contradicts nor enriches 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 single sentence is concise but severely under-specified for a 4-parameter search tool. It is not padded, but it omits necessary information rather than earning its brevity through completeness.

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

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

An output schema exists so return values need not be explained. However, the description is far too sparse for a search tool with 4 parameters at 0% schema coverage and no usage guidance. It leaves the agent without critical invocation details.

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

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

Schema description coverage is 0% for all four parameters. The description mentions 'query language' but does not explain the query syntax, nor does it clarify what 'page', 'per_page', or 'fields' control. It fails to compensate for the complete lack of parameter documentation.

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

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

States a specific verb ('Найти') and resource ('задачи') plus the query language context, so the agent can tell it searches issues. It does not explicitly differentiate from sibling search tools like search_users, but the resource is clear.

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

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

Provides no when-to-use guidance, no alternatives, and no exclusions. The agent must infer that this is for searching issues rather than fetching a specific issue via get_issue or listing via other 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?

Annotations already declare readOnlyHint=true, so the read-only safety profile is covered. The description adds one genuine behavioral trait beyond that — a scan ceiling of 1000 users, which signals results may be truncated — but says nothing about pagination, ordering, or what happens when the cap is hit. With annotations doing part of the work, a 3 fits.

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

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

Two short sentences, no padding. The searchable-field list comes first, then the scanning constraint — front-loaded and free of 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?

An output schema exists, so return values need not be explained, and annotations cover read-only safety. However, with 0% schema coverage the description leaves the 'limit' parameter and its interaction with the 1000-user scan cap unexplained, so the definition is not quite self-sufficient for correct invocation.

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

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

Schema description coverage is 0%, so the description must carry the burden. It does explain what the required 'query' matches (login, email, display name, surname), which is real added meaning, but it never clarifies 'limit' (default 10) or how it relates to the stated 1000-user scan cap, leaving one of two parameters opaque.

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

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

States a specific verb (find) and resource (users) and enumerates the fields the query matches — login, email, display name, last name. It is clear what the tool does, but it never distinguishes itself from the sibling get_user or list_users tools, so an agent still has to guess where this fits.

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

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

There is no when-to-use guidance and no mention of alternatives: the description never says to prefer this over list_users or get_user, nor when it should be avoided. Usage is only obliquely implied by the list of searchable fields.

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

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

Annotations already declare readOnlyHint=false and destructiveHint=true, so mutation is covered. The description confirms the write and adds the user-confirmation guidance, which is genuinely useful. However, it never explains the destructiveHint=True implication (e.g. that assignee/deadline can be cleared or overwritten) or how the clear_* flags behave.

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

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

Two short sentences, front-loaded with the action and field list before the behavioral instruction. Nothing is padded, though the confirmation sentence could be integrated more tightly.

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

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

An output schema exists, so return values need not be explained, and annotations cover the safety profile. Still, for a 9-parameter mutation tool with 0% schema coverage, the description leaves the clear_* flags and deadline_type unexplained, which is a meaningful gap for correct invocation.

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

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

Schema description coverage is 0% across 9 parameters, so the description carries the full burden. It names only the four obvious fields (text, checked, assignee, deadline) and omits the non-obvious ones an agent would most likely get wrong: deadline_type, clear_assignee, and clear_deadline.

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

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

The description states a specific verb and resource ('Изменить один пункт чек-листа') and enumerates the editable fields (text, completion, assignee, deadline), so an agent can tell it apart from create/delete checklist siblings. It does not explicitly distinguish itself from update_issue, which it references only loosely ('Изменяет задачу').

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?

Adds one concrete behavioral guideline — show the changes to the user before calling — which implies a confirmation workflow, but it names no alternatives (e.g. update_issue vs this tool) and gives no when-not-to-use conditions. Usage is implied rather than spelled out.

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

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

Annotations already declare readOnlyHint=false and destructiveHint=true, so the mutation/destructive profile is known. The description corroborates this ('Изменяет данные в Трекере') and adds a genuinely useful behavioural note about user confirmation, but says nothing about which fields are mutable, reversibility, or permission requirements.

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

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

Two short sentences, front-loaded with the action and followed by the caution. Nothing is padded, though the second sentence mixes a behavioural fact with a workflow instruction.

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

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

An output schema exists, so return values need not be explained. But for a destructive update whose only payload is an undocumented free-form object, the description omits what can be updated and what constraints apply – a significant gap for an agent trying to call it correctly.

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

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

Schema description coverage is 0%, and 'fields' is a free-form nested object with additionalProperties=true, so the agent has no idea what keys or formats to supply. The description mentions 'поля' but never enumerates or illustrates them, leaving the critical parameter fully opaque.

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

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

The description states a specific verb+resource ('Обновить поля существующей задачи' – update fields of an existing issue), which an agent can distinguish from create_issue or execute_transition without opening the schema. It does not, however, explicitly name any sibling it contrasts with.

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

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

It gives one concrete operational guideline: show the changes to the user before invoking ('покажите изменения пользователю перед вызовом'). This is useful pre-call guidance but is about confirmation workflow, not about when to choose this tool over alternatives (e.g., execute_transition), so usage is only implied.

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

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

Annotations already declare readOnlyHint=false and destructiveHint=true, so the safety profile is partly covered; the description adds useful context that it modifies Tracker data and should be confirmed with the user. It still does not clarify whether omitted/nullable fields are left unchanged or reset, which is the key behavioral question for this mutation.

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

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

Two tight sentences with no filler, and the mutation warning is front-loaded right after the purpose statement. Nothing is wasted.

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

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

An output schema exists, so return values need no explanation, and the annotations cover the safety profile. For a 5-parameter mutation tool, however, the total absence of parameter semantics leaves an agent under-equipped 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?

With 0% schema description coverage and 5 parameters, the description carries the full burden but explains none of them. Issues like the nullable start/comment/duration fields and the meaning of issue_id/worklog_id are left entirely undocumented.

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

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

States a specific verb and resource ('Изменить запись трудозатрат' = change a worklog entry), which clearly separates it from add_worklog/delete_worklog/list_worklogs siblings by the update verb. It does not, however, explicitly name those siblings or the condition that selects this one.

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

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

The description implies usage (an update operation) and adds a procedural safeguard ('show the new values to the user before calling'), but gives no explicit when-to-use vs alternatives guidance or prerequisites such as permissions or required identifiers.

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