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

With no annotations provided, the description carries the full burden of behavioral disclosure. It states the tool adds a worklog but doesn't cover critical aspects like required permissions, whether it's a write operation (implied but not explicit), potential side effects (e.g., updating issue time estimates), error conditions, or response format. This leaves significant gaps for a mutation tool.

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

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

The description is a single, clear sentence that directly states the tool's purpose without unnecessary words. It's front-loaded and efficiently communicates the core function, 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?

For a mutation tool with 5 parameters, 0% schema coverage, no annotations, and no output schema, the description is insufficient. It lacks details on behavior, parameters, usage context, and expected outcomes, leaving too many unknowns for effective tool invocation by an agent.

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

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

Schema description coverage is 0%, so the schema provides no parameter descriptions. The description adds no parameter semantics beyond implying 'issueKey' and 'timeSpent' are involved. It doesn't explain what 'timeSpent' format entails, the purpose of 'comment' or 'visibility', or how 'started' relates to the worklog, failing to compensate for the coverage 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 clearly states the action ('add a worklog entry') and resource ('to an issue'), which is specific and unambiguous. However, it doesn't explicitly differentiate from sibling tools like 'jira_update_worklog' or 'jira_delete_worklog', which would require mentioning creation vs. modification/deletion of worklogs.

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

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

The description provides no guidance on when to use this tool versus alternatives. It doesn't mention prerequisites (e.g., needing an existing issue), compare to siblings like 'jira_update_worklog' for editing worklogs, or specify scenarios where adding a worklog is appropriate versus other time-tracking methods.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It states 'creates' which implies a write operation, but provides no information about authentication requirements, rate limits, side effects, error conditions, or what happens upon successful creation. This is inadequate for a mutation tool with 14 parameters.

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

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

The description is extremely concise at just 7 words. It's front-loaded with the core action and contains no unnecessary words. While it may be too brief for adequate functionality description, it earns full marks for conciseness.

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

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

Given the complexity (14 parameters, no annotations, no output schema, 0% schema description coverage), the description is completely inadequate. It doesn't explain what the tool returns, how to handle errors, what permissions are needed, or provide any context about the parameters. For a creation tool in a complex system like JIRA, this leaves the agent with insufficient 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?

The schema has 0% description coverage, meaning none of the 14 parameters have documentation in the schema. The description adds no semantic information about any parameters beyond the generic 'specified parameters' phrase. For a complex tool with many parameters including arrays, objects, and specific patterns, this is a critical 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 clearly states the verb ('creates') and resource ('new JIRA issue'), making the purpose immediately understandable. It distinguishes from siblings like 'jira_update_issue' by specifying creation rather than modification. However, it doesn't explicitly differentiate from other potential creation tools that might exist in a broader context.

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

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

The description provides no guidance on when to use this tool versus alternatives. It doesn't mention prerequisites, when to choose this over other issue management tools, or any contextual constraints. The agent must infer usage from the tool name alone.

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

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

With no annotations provided, the description carries full burden for behavioral disclosure. While 'Delete' implies a destructive mutation, the description doesn't specify whether this requires special permissions, if deletions are permanent/reversible, what happens to associated data, or any rate limits/constraints. For a destructive operation with zero annotation coverage, this represents a significant transparency gap.

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

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

The description is a single, efficient sentence that states the core functionality without unnecessary words. It's appropriately sized for a simple operation and front-loads the essential information, making it easy for an agent 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?

For a destructive mutation tool with no annotations, 2 required parameters (0% schema coverage), and no output schema, the description is inadequate. It should explain parameter meanings, permissions required, consequences of deletion, and what to expect upon success/failure. The current description leaves too many critical questions unanswered for safe and effective tool 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%, meaning neither parameter has documentation in the schema. The description provides no information about what 'issueKey' or 'worklogId' represent, their format requirements, or where to obtain these values. For a tool with 2 required parameters and no schema documentation, the description fails to compensate for this 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 clearly states the action ('Delete') and target resource ('a worklog entry from an issue'), making the purpose immediately understandable. However, it doesn't explicitly differentiate from sibling tools like 'jira_update_worklog' or 'jira_get_worklogs', which would require more specific language about the destructive nature of this operation versus those alternatives.

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

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

The description provides no guidance on when to use this tool versus alternatives like 'jira_update_worklog' for modifying worklogs or 'jira_get_worklogs' for viewing them. There's no mention of prerequisites, permissions required, or scenarios where deletion is appropriate versus modification, leaving the agent with insufficient context for proper tool selection.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It states the tool retrieves issues but lacks details on permissions required, rate limits, pagination behavior, or response format. This is a significant gap for a tool that likely interacts with an external API and returns data.

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, efficient sentence that directly states the tool's function without any fluff or redundancy. It's front-loaded with the core 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?

Given the complexity of JIRA API interactions and the lack of annotations and output schema, the description is incomplete. It doesn't cover behavioral aspects like authentication needs, error handling, or what the return data looks like (e.g., issue fields included), leaving gaps for effective tool use.

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

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

The input schema has 0 parameters with 100% coverage, so no parameter documentation is needed. The description appropriately doesn't discuss parameters, and the baseline for this scenario is 4, as it avoids unnecessary repetition while being complete for a parameterless tool.

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

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

The description clearly states the action ('retrieves') and resource ('all JIRA issues assigned to the current user'), making the purpose immediately understandable. However, it doesn't explicitly differentiate from sibling tools like 'jira_get_issue' (which gets a specific issue) or 'search_jira_issues' (which allows broader filtering), missing full sibling distinction.

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

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

The description provides no guidance on when to use this tool versus alternatives. It doesn't mention when this is appropriate (e.g., for personal task tracking) versus when to use 'search_jira_issues' for more complex queries or 'jira_get_issue' for specific issues, leaving the agent to infer usage context.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It states the tool retrieves data ('Get'), implying a read-only operation, but lacks details on permissions, rate limits, pagination (implied by parameters like 'startAt' and 'maxResults'), or error handling, which are critical for a tool with 12 parameters.

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

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

The description is a single, efficient sentence that front-loads the core purpose and key filtering options without unnecessary words. Every part earns its place, 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?

Given the high complexity (12 parameters, no annotations, no output schema), the description is incomplete. It lacks behavioral context, detailed parameter guidance, and output information, making it inadequate for an agent to use the tool effectively without additional inference or trial-and-error.

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 mentions filtering by 'type, project, and name', which covers only 3 of the 12 parameters, leaving others like 'startAt', 'maxResults', 'expand', and 'filterId' unexplained. This partial coverage is insufficient for such a complex parameter set.

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

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

The description clearly states the tool's purpose with a specific verb ('Get') and resource ('all accessible JIRA boards'), and mentions filtering capabilities. It distinguishes itself from siblings like 'jira_get_projects' or 'jira_get_sprints' by focusing on boards, though it doesn't explicitly contrast with them.

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

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

No guidance is provided on when to use this tool versus alternatives. The description mentions filtering but doesn't specify scenarios, prerequisites, or exclusions, leaving the agent to infer usage from the tool name and context alone.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It states what the tool does but lacks details on authentication requirements, rate limits, error handling, or response format. For a tool that likely requires user context, this is insufficient, though it doesn't contradict any 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, clear sentence that directly states the tool's purpose without any fluff. It is front-loaded and efficiently communicates the core function, making it highly concise and well-structured.

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

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

Given the tool has 0 parameters, no annotations, and no output schema, the description is minimally adequate by stating what it retrieves. However, it lacks details on the return value structure or behavioral aspects, leaving gaps for an agent to understand full usage. It meets the basic requirement but could be more informative.

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

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

The input schema has 0 parameters with 100% coverage, so no parameter documentation is needed. The description appropriately doesn't discuss parameters, earning a baseline of 4 for not adding unnecessary information. It doesn't reach 5 as it could have mentioned implicit context like authentication.

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

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

The description clearly states the verb 'Get' and the resource 'current user profile information and permissions', making the purpose specific and understandable. It distinguishes from siblings like jira_get_assigned_issues or jira_get_projects by focusing on user-specific data. However, it doesn't explicitly contrast with all siblings, keeping it at 4 instead of 5.

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

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

The description provides no guidance on when to use this tool versus alternatives. It doesn't mention scenarios like checking user permissions before performing actions with other tools (e.g., jira_create_issue) or prerequisites. This lack of context leaves the agent without usage direction.

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

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

With no annotations provided, the description carries full burden for behavioral disclosure. While 'retrieves' implies a read-only operation, it doesn't specify authentication requirements, rate limits, error conditions, or what 'detailed information' includes (e.g., fields returned, format). This leaves significant gaps for a tool that likely interacts with an external API.

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, efficient sentence that gets straight to the point with no wasted words. It's appropriately sized for a simple retrieval tool and front-loads the core functionality.

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

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

For a tool with no annotations, no output schema, and minimal parameter documentation, the description is insufficient. It doesn't explain what 'detailed information' includes, how results are structured, or any behavioral constraints. Given the complexity of JIRA issues and the lack of structured documentation, this leaves too many unknowns for effective tool use.

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

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

The description mentions 'a specific JIRA issue' which implies the issueKey parameter identifies which issue to retrieve, but doesn't explain the parameter's format or semantics beyond what the schema's pattern already provides. With 0% schema description coverage, the description adds minimal value over the bare schema.

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

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

The description clearly states the action ('retrieves detailed information') and target resource ('a specific JIRA issue'), making the purpose immediately understandable. It distinguishes this tool from siblings like jira_create_issue (creation) and jira_update_issue (modification), though it doesn't explicitly differentiate from jira_get_issue_comments which retrieves only comments.

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

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

The description provides no guidance on when to use this tool versus alternatives like jira_get_assigned_issues (for user-specific issues) or search_jira_issues (for broader queries). It simply states what the tool does without context about appropriate use cases or prerequisites.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It mentions 'configurable quantity and filtering options,' which hints at customization but doesn't describe what the tool returns (e.g., comment objects, pagination, error handling), authentication needs, rate limits, or side effects. For a read operation with 6 parameters, this leaves significant gaps in understanding how the tool behaves beyond basic functionality.

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, efficient sentence that front-loads the core purpose ('retrieves comments for a specific JIRA issue') and adds useful context ('with configurable quantity and filtering options'). There is no wasted verbiage or redundancy, making it highly concise and well-structured for quick comprehension.

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 complexity (6 parameters, nested object, no output schema, and no annotations), the description is incomplete. It doesn't explain return values, error conditions, or behavioral details like pagination or authentication. For a tool with rich filtering options and no structured output documentation, this leaves the agent with insufficient context to use it effectively beyond basic invocation.

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

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

Schema description coverage is 0%, so the description must compensate. It mentions 'configurable quantity and filtering options,' which loosely maps to parameters like maxComments, authorFilter, and dateRange, but doesn't explain what each parameter does, their formats, or constraints. With 6 parameters (including a nested object), this adds minimal value beyond the schema, failing to clarify semantics like what 'includeInternal' means or how 'orderBy' affects results.

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

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

The description clearly states the verb ('retrieves') and resource ('comments for a specific JIRA issue'), making the purpose immediately understandable. It distinguishes from siblings like jira_get_issue (which gets issue details) and jira_get_worklogs (which gets worklogs). However, it doesn't explicitly contrast with jira_get_assigned_issues or search_jira_issues, which are about issues rather than comments.

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

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

The description provides no guidance on when to use this tool versus alternatives. It doesn't mention prerequisites (e.g., needing an issue key), nor does it differentiate from potential overlapping tools like jira_get_issue (which might include comments) or search_jira_issues (which might search comments). Usage is implied by the purpose but not explicitly stated.

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

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

With no annotations provided, the description carries full burden for behavioral disclosure. It states the tool retrieves projects with filtering/search, but lacks critical details such as authentication requirements, rate limits, pagination behavior (implied by 'maxResults' and 'startAt' but not explained), or what 'accessible' means in terms of permissions. This leaves significant gaps for a tool with 9 parameters.

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

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

The description is a single, efficient sentence that front-loads the core purpose ('Get all accessible JIRA projects') and adds key capabilities ('with filtering and search capabilities'). There is no wasted verbiage, making it appropriately concise for the tool's complexity.

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 (9 parameters, no annotations, no output schema), the description is incomplete. It lacks necessary context such as authentication needs, rate limits, pagination details, error handling, and what 'accessible' entails. Without annotations or output schema, the description should provide more behavioral and operational guidance to be fully helpful.

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 by explaining parameters. It only vaguely mentions 'filtering and search capabilities' without detailing what parameters exist or their purposes (e.g., 'expand' for additional data, 'typeKey' for project types). This fails to add meaningful semantics beyond the bare schema, leaving most parameters 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 clearly states the verb ('Get') and resource ('JIRA projects') with scope ('all accessible'), which provides a specific purpose. However, it doesn't explicitly differentiate from sibling tools like 'jira_get_boards' or 'jira_get_sprints' that also retrieve JIRA data, missing full sibling distinction.

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 mentions 'filtering and search capabilities' which implies usage for retrieving projects with specific criteria, but it provides no explicit guidance on when to use this tool versus alternatives like 'jira_get_boards' for board-related data or 'search_jira_issues' for issue searches. No when-not-to-use or prerequisite information is included.

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

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

No annotations are provided, so the description carries full burden. It mentions filtering by state, which is useful, but fails to disclose critical behaviors: pagination details (implied by startAt/maxResults but not explained), whether it returns partial/full sprint data, rate limits, authentication needs, or error conditions. For a read operation with 4 parameters, this is insufficient.

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

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

The description is a single, efficient sentence that front-loads the core purpose. Every word earns its place—no redundancy or fluff. It's appropriately sized for a straightforward retrieval 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 4 parameters with 0% schema coverage, no annotations, and no output schema, the description is incomplete. It doesn't explain return values (sprint structure), pagination behavior, error handling, or dependencies. For a tool with filtering and pagination, more context is needed to use it effectively.

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 mentions filtering by state (mapping to the 'state' parameter) and implies board targeting (mapping to 'boardId'), but doesn't explain the other two parameters (startAt, maxResults) or provide format/constraint details. It adds some meaning but leaves significant gaps.

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

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

The description clearly states the verb 'Get' and resource 'all sprints for a specific JIRA board', which is specific and actionable. It distinguishes from siblings like 'jira_get_boards' by focusing on sprints rather than boards, but doesn't explicitly differentiate from other sprint-related tools (none exist in the sibling list).

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

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

The description provides no guidance on when to use this tool versus alternatives. It doesn't mention prerequisites (e.g., needing board access), exclusions, or relationships to sibling tools like 'jira_get_boards' (which might be needed first to obtain board IDs). Usage context is implied but not explicit.

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

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

With no annotations provided, the description carries full burden but offers minimal behavioral insight. It implies a read-only operation ('Get') but doesn't disclose pagination behavior (via startAt/maxResults), authentication needs, rate limits, error conditions, or return format. For a tool with 5 parameters and no output schema, this is inadequate.

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, efficient sentence with no wasted words. It's front-loaded with the core purpose, making it easy to parse quickly, though this brevity contributes to gaps in other dimensions.

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 5 parameters, 0% schema coverage, no annotations, and no output schema, the description is incomplete. It covers the basic action but misses critical details like parameter meanings, behavioral traits, and output structure, which are essential for effective tool use in this context.

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

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

Schema description coverage is 0%, so the description must compensate but adds no parameter information. It mentions 'specific issue' which hints at the 'issueKey' parameter, but ignores the other 4 parameters (startAt, maxResults, startedAfter, startedBefore) that control pagination and date filtering, leaving them 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 clearly states the verb ('Get') and resource ('all worklog entries for a specific issue'), making the purpose unambiguous. However, it doesn't explicitly differentiate from sibling tools like 'jira_get_issue' or 'jira_get_issue_comments' which also retrieve issue-related data, missing an opportunity for full sibling distinction.

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

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

The description provides no guidance on when to use this tool versus alternatives. It doesn't mention prerequisites (e.g., needing issue access), compare to siblings like 'jira_get_issue' (which might include worklogs), or specify use cases like time tracking analysis, leaving the agent with minimal context for selection.

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

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

No annotations are provided, so the description carries full burden. It mentions 'Updates' which implies mutation, but lacks critical behavioral details: required permissions, whether changes are reversible, error handling, or response format. The mention of 'worklog entries' hints at additional functionality but doesn't explain how it interacts with sibling tools like jira_add_worklog.

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-loaded with core purpose. Efficiently lists three capability areas without redundancy. Could be slightly improved by structuring into bullet points for clarity, but overall well-sized with zero waste.

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?

Incomplete for a complex mutation tool with 9 parameters, nested objects, and no annotations or output schema. The description lacks details on permissions, error cases, return values, and parameter dependencies. Given the rich input schema and sibling tools, it should provide more context to guide proper usage.

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

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

Schema description coverage is 0%, so the description must compensate. It lists 'field changes, status transitions, and worklog entries' which partially maps to parameters like summary, description, priority, assignee, labels, components, and transition. However, it omits key parameters (issueKey, notifyUsers) and doesn't explain parameter interactions or semantics (e.g., how labels/operations work).

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

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

The description clearly states the action ('Updates') and resource ('an existing JIRA issue') with specific capabilities ('field changes, status transitions, and worklog entries'). It distinguishes from siblings like jira_create_issue (creates new) and jira_update_worklog (updates only worklogs), though it doesn't explicitly mention these distinctions.

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

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

No guidance on when to use this tool versus alternatives like jira_update_worklog or jira_create_issue. The description implies usage for updating existing issues but doesn't specify prerequisites (e.g., issue must exist) or exclusions (e.g., cannot create new issues).

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

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

With no annotations provided, the description carries full burden for behavioral disclosure. It states this is an update operation (implying mutation), but doesn't mention required permissions, whether changes are reversible, rate limits, or what happens to unspecified fields. For a mutation tool with zero annotation coverage, this leaves significant behavioral 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 extremely concise with a single clear sentence that front-loads the essential action. There's no wasted language or unnecessary elaboration, making it efficient for quick understanding.

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

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

For a mutation tool with 6 parameters (including nested objects), 0% schema description coverage, no annotations, and no output schema, the description is inadequate. It doesn't compensate for the missing structured information about behavior, parameters, or return values, leaving the agent with insufficient context for proper tool 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?

With 0% schema description coverage for all 6 parameters, the description provides no additional semantic context about what each parameter means or how they interact. It doesn't explain what 'worklogId' identifies, the format of 'timeSpent', what 'visibility' controls, or which fields are optional versus required beyond the schema's technical requirements.

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 resource ('an existing worklog entry'), making the purpose immediately understandable. It distinguishes this from sibling tools like 'jira_add_worklog' (create new) and 'jira_delete_worklog' (remove), but doesn't explicitly mention these distinctions in the description itself.

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

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

No guidance is provided on when to use this tool versus alternatives. The description doesn't mention prerequisites (e.g., needing an existing worklog), compare it to 'jira_add_worklog' for new entries, or specify appropriate contexts for updating versus other operations.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It mentions the tool 'supports both expert JQL and beginner-friendly filters,' which adds some context about flexibility. However, it lacks critical behavioral details such as whether this is a read-only operation, potential rate limits, authentication requirements, pagination behavior (implied by 'maxResults' but not explained), or what the output format looks like.

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 sized and front-loaded with the core purpose in the first clause. Both sentences earn their place by explaining the search methods and user expertise levels, with zero wasted words or redundancy.

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

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

Given the tool's complexity (7 parameters, no annotations, no output schema), the description is incomplete. It fails to explain parameter meanings, output structure, behavioral constraints, or differentiation from siblings. For a search tool with multiple input options and no structured guidance, this leaves significant gaps for an AI agent to understand and use it correctly.

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

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

Schema description coverage is 0%, so the description must compensate for all 7 parameters. The description only generically mentions 'JQL queries or helper parameters' without explaining what specific parameters are available (e.g., 'assignedToMe', 'project', 'status', 'text', 'maxResults', 'fields') or their semantics. This leaves most parameters undocumented and unclear in 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 the tool's purpose: 'Search JIRA issues using JQL queries or helper parameters.' It specifies the verb ('search'), resource ('JIRA issues'), and two search methods. However, it doesn't explicitly differentiate from sibling tools like 'jira_get_assigned_issues' or 'jira_get_issue', which are more specific retrieval tools.

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

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

The description implies usage context by mentioning 'expert JQL and beginner-friendly filters,' suggesting this tool is versatile for different user expertise levels. However, it provides no explicit guidance on when to use this versus alternatives like 'jira_get_assigned_issues' or 'jira_get_issue', nor does it mention prerequisites or exclusions.

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