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. 'Add issues to a cycle' implies a mutation operation but reveals nothing about permissions required, whether this is idempotent, what happens if issues already exist in the cycle, error conditions, or response format. This is a significant gap for a mutation tool.

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

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

The description is a single, efficient sentence with zero wasted words. It's front-loaded with the core action and resource, making it immediately scannable and understandable without unnecessary elaboration.

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

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

For a mutation tool with no annotations and no output schema, the description is inadequate. It doesn't explain what happens after adding issues, potential side effects, error handling, or relationship to sibling tools. The agent would need to guess about important behavioral aspects.

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

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

Schema description coverage is 100%, so all parameters are documented in the schema. The description adds no additional parameter information beyond what's already in the schema (cycle_id, issues array, project_id). This meets the baseline expectation when schema coverage is complete.

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') and resource ('issues to a cycle'), making the purpose immediately understandable. It doesn't distinguish from siblings like 'add_module_issues' or 'transfer_cycle_issues', but the verb+resource combination is specific enough for basic understanding.

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 'add_module_issues' or 'transfer_cycle_issues'. It doesn't mention prerequisites, constraints, or appropriate contexts for usage, leaving the agent with minimal contextual 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. It correctly identifies this as a write operation ('Add'), but doesn't mention permission requirements, rate limits, or what happens on success/failure. The description adds some context about parameter requirements but lacks comprehensive behavioral traits.

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 perfectly sized with two focused sentences. The first sentence states the core purpose, and the second provides crucial usage guidance. Every word earns its place with zero redundancy or unnecessary elaboration.

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 write operation with no annotations and no output schema, the description does well by covering the core purpose and providing important usage guidance about parameter requirements. However, it doesn't address what the tool returns or potential side effects, leaving some gaps in completeness for a mutation tool.

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

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

Schema description coverage is 100%, so the schema already documents all three parameters thoroughly. The description adds minimal value by mentioning that project_id and issue_id are UUID parameters, but doesn't provide additional semantic context beyond what's in the schema. This meets the baseline for high schema coverage.

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

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

The description clearly states the specific action ('Add a comment') and target resource ('to a specific issue'), distinguishing it from sibling tools like get_issue_comments (which retrieves comments) or update_issue (which modifies the issue itself). The verb+resource combination is precise and unambiguous.

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

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

The description explicitly provides when-to-use guidance by naming an alternative tool (get_issue_using_readable_identifier) for cases where the user has readable identifiers instead of UUIDs. It also implies this tool should be used when you already have the UUID parameters, creating clear contextual boundaries.

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

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

No annotations are provided, so the description carries the full burden. It states the tool 'adds' and 'assigns', implying a mutation, but lacks critical behavioral details: it does not specify permissions required, whether issues can be added multiple times, error handling (e.g., invalid UUIDs), or the effect on existing module-issue relationships. This is inadequate for a mutation tool with zero annotation coverage.

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

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

The description is extremely concise with two short sentences that directly state the tool's purpose. It is front-loaded and wastes no words, making it easy to parse quickly without unnecessary elaboration.

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

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

For a mutation tool with no annotations and no output schema, the description is incomplete. It lacks behavioral context (e.g., side effects, error cases), usage guidelines, and details on return values. While the schema covers parameters well, the overall context for safe and effective use is insufficient, especially given the complexity of modifying data relationships.

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

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

Schema description coverage is 100%, with clear parameter descriptions in the schema (e.g., 'Array of issue UUIDs'). The description adds no additional meaning beyond the schema, such as format examples or constraints. With high schema coverage, the baseline score of 3 is appropriate, as the description does not compensate but also does not detract.

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 issues to a module') and the resource ('module'), which is specific and actionable. It distinguishes from siblings like 'delete_module_issue' or 'list_module_issues' by focusing on addition, but does not explicitly differentiate from similar tools like 'add_cycle_issues' beyond the resource name.

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

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

The description provides no guidance on when to use this tool versus alternatives. It does not mention prerequisites (e.g., existing module/issues), exclusions, or compare to siblings like 'add_cycle_issues' or 'create_issue', leaving the agent to infer usage from 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 full burden for behavioral disclosure. It states this is a creation operation but doesn't mention permissions required, whether it's idempotent, what happens on conflicts, or what the response looks like. 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 a single, efficient sentence that states the core purpose without unnecessary words. It's appropriately sized and front-loaded with the essential information.

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

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

For a creation tool with no annotations and no output schema, the description is insufficient. It doesn't explain what a 'cycle' represents in this context, what happens after creation, error conditions, or relationship to sibling tools. The 100% schema coverage helps with parameters but doesn't compensate for missing behavioral and contextual 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?

Schema description coverage is 100%, so the schema already documents both parameters thoroughly. The description adds no additional parameter semantics beyond what's in the schema, meeting the baseline expectation but not providing extra value.

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

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

The description clearly states the action ('Create') and resource ('new cycle in a project'), making the purpose immediately understandable. However, it doesn't differentiate from sibling tools like 'update_cycle' or 'list_cycles' beyond the basic verb, missing explicit 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 like 'update_cycle' or 'list_cycles', nor does it mention prerequisites or context for creation. It simply states what the tool does without usage context.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It only says 'Create an issue' and mentions the project_id requirement. It doesn't disclose that issue_data contains many server-managed fields (created_at, created_by, updated_at, etc.) that likely shouldn't be set by the client, nor does it mention any side effects, validation, or response behavior. The nested issue_data schema has a rich description for estimate_hours but the tool description itself adds no 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?

Two sentences, front-loaded with the core action and then a practical tip. It is concise and readable, though the second sentence could be slightly more explicit about the parameter 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?

For a create tool with a large nested issue_data object and no output schema, the description is thin. It doesn't explain what issue_data should contain, which fields are required (name, description_html are required in the schema but not mentioned), or what the response will be. The get_projects tip is helpful but doesn't compensate for the missing guidance on the main payload.

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 50%: project_id has a description, and issue_data has a description for estimate_hours, but the rest of the nested properties are undocumented. The description adds value by explaining how to obtain project_id via get_projects, but it doesn't clarify the semantics of issue_data as a whole or which fields are client-settable vs server-managed. With 50% coverage, the description partially compensates but leaves 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 states a clear verb and resource ('Create an issue') and identifies the required project_id parameter. It doesn't explicitly distinguish from sibling tools like update_issue, but the verb 'create' plus the schema makes the primary purpose clear.

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

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

The description gives a concrete usage hint: if you have a readable project identifier, use get_projects to resolve it to a project_id. This is useful routing guidance, though it doesn't explicitly say when not to use the tool or mention alternatives for creating other resources.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. While 'create' implies a mutation, it doesn't specify whether this requires admin permissions, what happens on failure, or if it's idempotent. It also doesn't describe the return value or any side effects, which is critical for a creation tool with no output schema.

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

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

The description is a single, clear sentence with no wasted words. It's front-loaded with the core action and resource, making it easy to parse quickly. Every part of the sentence contributes directly to understanding the tool's purpose.

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

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

For a creation tool with no annotations and no output schema, the description is insufficient. It doesn't cover behavioral aspects like permissions, error handling, or return values, and it ignores the complexity of the nested 'issue_type_data' parameter. Given the context signals, more detail is needed to guide effective tool 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 50%, with only 'project_id' having a description. The tool description adds no parameter details beyond what's in the schema, failing to explain the complex 'issue_type_data' object or its required fields like 'name' and 'description'. However, since there are only 2 parameters and the schema provides some structure, it meets the baseline for minimal viability.

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

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

The description clearly states the action ('create') and resource ('new issue type in a project'), making the purpose understandable. It distinguishes from siblings like 'create_issue' or 'create_label' by specifying the resource type. However, it doesn't explicitly differentiate from 'update_issue_type' or 'delete_issue_type' in the same domain.

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 'update_issue_type' or 'list_issue_types'. It doesn't mention prerequisites, such as needing an existing project, or constraints, like permissions required for creation. This leaves the agent with minimal context for tool selection.

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

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

With no annotations provided, the description carries full burden for behavioral disclosure. It states 'Create' which implies a write/mutation operation, but doesn't disclose any behavioral traits: no information about permissions required, whether the operation is idempotent, what happens on duplicate names, rate limits, or what the response contains. For a creation tool with zero annotation coverage, this leaves critical gaps for the agent.

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 purpose without unnecessary words. It's appropriately sized for a basic creation tool and front-loads the essential information. Every word earns its place with no redundancy or fluff.

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

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

Given this is a mutation tool with no annotations, 2 parameters (one being a complex nested object with 15 properties), 50% schema description coverage, and no output schema, the description is inadequate. It doesn't explain what constitutes a valid label, what fields are mandatory beyond schema requirements, how the creation affects the system, or what to expect in return. The agent lacks sufficient context to use this tool 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 50% (only 'project_id' has a description), so the description must compensate but adds no parameter information. It mentions 'label' and 'project' which align with the two parameters ('project_id' and 'label_data'), but provides no details about what fields in 'label_data' are required or optional, what 'color' format to use, or how 'parent' relates to hierarchy. The description adds minimal value beyond what's inferable from parameter names.

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

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

The description clearly states the action ('Create') and resource ('new label in a project'), making the purpose immediately understandable. It distinguishes this tool from sibling tools like 'list_labels' or 'update_label' by specifying creation rather than retrieval or modification. However, it doesn't specify what a 'label' is in this context or differentiate from other creation tools like 'create_issue' or 'create_state'.

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 project), when not to use it (e.g., for updating existing labels), or refer to sibling tools like 'list_labels' for checking existing labels or 'update_label' for modifications. 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 'Create' implies a write/mutation operation, the description doesn't address permissions required, whether the operation is idempotent, what happens on failure, or what the response contains. For a creation tool with zero annotation coverage, this is a significant gap.

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

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

The description is a single, efficient sentence with zero wasted words. It's appropriately sized for a simple creation tool and front-loads the essential information 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 creation tool with no annotations, no output schema, and complex nested input structure (module_data with 28 properties), the description is inadequate. It doesn't explain what a 'module' represents in this context, what fields are mandatory beyond 'name', or what the tool returns upon success.

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 50%, with only 'project_id' having a description. The tool description adds no parameter information beyond what's in the schema. However, with 2 parameters total and one already documented in the schema, the baseline of 3 is appropriate since the schema does some heavy lifting.

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

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

The description clearly states the action ('Create') and resource ('new module in a project'), providing specific verb+resource information. However, it doesn't differentiate this tool from sibling tools like 'create_cycle' or 'create_project', which follow the same pattern but target different resources.

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

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

The description provides no guidance on when to use this tool versus alternatives. There's no mention of prerequisites, when-not-to-use scenarios, or comparison with sibling tools like 'update_module' or 'list_modules' that might be relevant in different contexts.

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

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

No annotations are provided, so the description carries the full burden. 'Create' implies a persistent mutation, but the description does not disclose permissions, side effects, validation failures, or reversibility. Some of this is covered in the schema, but the description itself adds no 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?

The description is a single efficient sentence with no wasted words and the action is front-loaded. It is arguably too minimal for a mutation tool with no annotations, but it is concise and readable.

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 100% schema coverage and required parameters documented, an agent can construct a valid call. However, there is no output schema, no behavioral disclosure, and no usage guidance, so the description alone is not complete and relies heavily on the schema for meaningful 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 coverage is 100%, so the baseline applies; the description adds no parameter-level detail. The schema already documents name, identifier, docs_view, and project_manager, including the active-member constraint and the get_workspace_members hint, so no additional parameter meaning is required from the description.

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

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

The description identifies a specific verb and resource ('create' + 'project'), making the core action unambiguous and distinguishing it from read-only siblings like get_projects and other create_* tools. It does not add scope or key fields, but the resource is clear enough for selection.

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 guidance, no exclusions, and no mention of alternatives such as get_projects or get_project_summary. The agent is left to infer usage from the tool name and schema.

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. While 'Create' implies a write/mutation operation, the description doesn't address permissions needed, whether this is idempotent, what happens on conflicts, or what the response contains. For a creation tool with complex nested parameters, 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 a single, efficient sentence that gets straight to the point with zero wasted words. It's appropriately sized for a tool with a clear primary function, though this conciseness comes at the cost of missing important contextual information.

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

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

For a creation tool with complex nested parameters (state_data has 18 properties) and no annotations or output schema, the description is inadequate. It doesn't explain what a 'state' represents in this system, what fields are required versus optional, or what the tool returns. The agent would struggle to use this effectively without 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?

The description mentions 'project' and 'state' which align with the two parameters (project_id and state_data), but adds no semantic details beyond what's in the schema. With 50% schema description coverage (only project_id has a description), the description doesn't compensate for the undocumented state_data properties. The baseline is 3 since the description at least hints at the parameter purposes.

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

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

The description clearly states the action ('Create') and resource ('new state in a project'), making the purpose immediately understandable. However, it doesn't differentiate this tool from other creation tools like create_cycle, create_issue, or create_project, which all follow the same pattern of creating resources within projects.

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. There's no mention of prerequisites, when this is appropriate versus other state-related tools (like update_state or list_states), 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, the description carries the behavioral burden and does well by disclosing the non-obvious consequence of omitting rich_filters: the view saves but shows every work item. It also reveals the permission requirement. It does not mention return format or side effects, but for a create operation this is a reasonably transparent disclosure.

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

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

Two sentences, front-loaded with the core action, then the role requirementкие and the most important behavioral caveat. Every sentence earns its place with no redundancy or filler.

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

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

For a no-annotation tool with a nested object input and no output schema, the description covers the critical filter behavior and role prerequisite, but it does not say what the response will contain or which fields are required beyond what the schema already shows. The schema is rich, but the description alone is not fully complete for an agent.

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

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

Schema description coverage is 50%, so the description should compensate, but it mostly repeats what the rich_filters property already states in the schema. It does not add meaning for other key fields such as name, access, or query. The rich_filters caveat is useful, but the description adds limited parameter semantics beyond the schema.

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

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

The description opens with 'Create a saved view in a project,' a specific verb and resource that immediately distinguishes this from sibling tools like create_issue, create_cycle, or update_view. It also adds the role requirement, which narrows scope further. There is no ambiguity about what the tool does.

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

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

The description clearly states a precondition ('Requires project Admin or Member role') and gives an important usage directive about passing rich_filters to make the view open filtered. It does not explicitly mention alternatives or when-not-to-use, but the context is clear enough for an agent to decide when this tool applies.

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. While 'Create' implies a write operation, it doesn't address permission requirements, whether the operation is idempotent, potential side effects, error conditions, or response format. This is inadequate for a mutation tool with zero annotation coverage.

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

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

The description is a single, efficient sentence that communicates the core purpose without any wasted words. It's appropriately sized for a simple creation operation and gets straight to the point with no unnecessary elaboration.

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

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

For a mutation tool with no annotations and no output schema, the description is insufficient. It doesn't explain what happens after creation, potential constraints, error handling, or relationship to sibling tools. The agent would need to guess about behavioral aspects and output format, creating significant gaps in understanding.

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

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

Schema description coverage is 100%, so the schema already documents all three parameters thoroughly. The description adds no additional parameter information beyond what's in the schema, which is acceptable but not exceptional. The baseline score of 3 reflects adequate but minimal value addition.

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

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

The description clearly states the action ('Create') and resource ('new worklog for an issue'), making the purpose immediately understandable. However, it doesn't differentiate this tool from sibling tools like 'update_worklog' or 'delete_worklog', which would require explicit comparison to achieve a perfect score.

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 'update_worklog' or 'delete_worklog'. It also doesn't mention prerequisites, dependencies, or contextual constraints, leaving the agent with insufficient information for optimal 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. 'Delete a cycle' implies a destructive mutation, but it doesn't specify whether this is reversible, what permissions are required, what happens to associated data (like issues in the cycle), or any rate limits. 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 maximally concise at just three words. While this represents under-specification rather than ideal conciseness, according to the scoring framework, 'Process' received a 2 for conciseness as under-specification. 'Delete a cycle' is similarly brief but more meaningful than 'Process', earning the highest score for efficiency with zero wasted words.

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

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

For a destructive mutation tool with no annotations and no output schema, the description is incomplete. It doesn't address critical context like what 'cycle' means in this system, whether deletion cascades to related resources, what confirmation or validation occurs, or what the response contains. The agent lacks sufficient information to use this tool safely and 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?

The schema has 100% description coverage, with both parameters ('cycle_id' and 'project_id') clearly documented as UUID identifiers. The description adds no additional parameter information beyond what the schema already provides. According to scoring rules, when schema_description_coverage is high (>80%), the baseline is 3 even with no param info in the description.

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

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

The description 'Delete a cycle' is a tautology that merely restates the tool name without adding specificity. It doesn't clarify what a 'cycle' represents in this context or how this deletion differs from similar operations like 'delete_cycle_issue' or 'delete_module'. The description lacks the verb+resource specificity needed for clear differentiation.

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

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

The description provides no guidance on when to use this tool versus alternatives. It doesn't mention prerequisites, dependencies, or when-not-to-use scenarios. With siblings like 'delete_cycle_issue' and 'delete_module' available, the absence of any comparative context leaves the agent guessing about appropriate usage contexts.

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 'Remove an issue from a cycle,' implying a destructive mutation, but lacks details on permissions required, whether the issue is deleted entirely or just unlinked, error handling, or side effects. This is inadequate for a mutation tool with zero annotation coverage.

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

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

The description is a single, efficient sentence with no wasted words, making it easy to parse. It's front-loaded with the core action, though it could benefit from additional context for 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?

Given the complexity of a destructive mutation tool with no annotations and no output schema, the description is incomplete. It lacks information on behavioral traits, return values, error conditions, and differentiation from siblings, leaving significant gaps for an AI agent to understand and invoke the tool correctly.

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

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

Schema description coverage is 100%, with all three parameters (cycle_id, issue_id, project_id) documented in the schema. The description doesn't add any meaning beyond what the schema provides, such as explaining relationships between parameters or usage nuances. Baseline 3 is appropriate when the schema does the heavy lifting.

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 ('Remove') and resource ('an issue from a cycle'), making the purpose understandable. However, it doesn't differentiate from sibling tools like 'delete_module_issue' or 'delete_cycle', which also involve deletion operations in similar contexts, missing explicit 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?

No guidance is provided on when to use this tool versus alternatives. For example, it doesn't clarify if this is for removing a single issue from a cycle while preserving the issue elsewhere, or if there are prerequisites like the issue being in the cycle first. Sibling tools like 'delete_cycle' or 'delete_module_issue' exist without context on their differences.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. While 'Delete' implies a destructive mutation, the description doesn't specify whether this action is reversible, what permissions are required, what happens to associated issues or data, or any rate limits. It lacks critical context for a destructive operation.

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

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

The description is extremely concise with a single sentence ('Delete an issue type'), which is front-loaded and wastes no words. For a simple tool name like 'delete_issue_type', this minimalism is efficient, though it may sacrifice 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?

Given the complexity of a destructive deletion tool with no annotations and no output schema, the description is inadequate. It doesn't cover behavioral aspects like irreversibility, permissions, or effects on related data, nor does it explain return values or error conditions. The high schema coverage helps with parameters, but overall context is lacking.

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 100% description coverage, with clear documentation for both parameters (project_id and type_id as UUID identifiers). The description adds no additional meaning beyond what the schema provides, such as explaining the relationship between project and issue type or validation rules. With high schema coverage, the baseline score of 3 is appropriate.

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

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

The description 'Delete an issue type' clearly states the verb (delete) and resource (issue type), making the basic purpose understandable. However, it doesn't differentiate this tool from other deletion tools in the sibling list (like delete_cycle, delete_label, delete_module, etc.), nor does it specify what constitutes an 'issue type' in this 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 (e.g., needing to identify the issue type first using get_issue_type or list_issue_types), consequences of deletion, or when not to use it (e.g., if the issue type is in use). The sibling tools include create_issue_type and update_issue_type, but no comparison is made.

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. 'Delete a label' implies a destructive mutation, but it doesn't disclose behavioral traits like whether deletion is permanent, requires specific permissions, affects related issues or cycles, or has rate limits. For a destructive tool with zero annotation coverage, this is a significant gap.

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

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

Extremely concise with zero waste—'Delete a label' is a single, front-loaded sentence that directly states the purpose. Every word earns its place, though this conciseness comes at the cost of detail.

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 destructive tool with no annotations and no output schema. The description lacks context on consequences, permissions, or return values. Given the complexity of deletion operations and rich sibling tools, more information is needed to guide safe and correct 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 100%, with clear descriptions for both parameters (label_id and project_id as UUID identifiers). The description adds no additional meaning beyond the schema, which already documents the parameters adequately. Baseline 3 is appropriate when schema does the heavy lifting.

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

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

The description 'Delete a label' clearly states the verb (delete) and resource (label), but it's vague about scope and doesn't differentiate from sibling tools like delete_cycle, delete_module, or delete_state. It doesn't specify whether this is a soft or hard deletion, or what happens to associated 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?

No guidance on when to use this tool versus alternatives. There's no mention of prerequisites (e.g., needing to retrieve label_id first), consequences of deletion, or when not to use it. Sibling tools include create_label, get_label, update_label, and list_labels, but no comparison is provided.

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

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

No annotations are provided, so the description carries full burden for behavioral disclosure. 'Delete a module' implies a destructive operation but provides no information about permissions required, whether deletion is permanent or reversible, what happens to associated data (like module issues), rate limits, or error conditions. This is inadequate for a destructive tool with zero annotation coverage.

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

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

The description is extremely concise at just three words with no wasted language. It's front-loaded with the core action, though this brevity comes at the cost of completeness. Every word earns its place in conveying the basic purpose.

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

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

For a destructive deletion tool with no annotations and no output schema, the description is severely incomplete. It doesn't address critical context like what 'delete' means operationally, dependencies, permissions, or consequences. Given the complexity of deletion operations and the rich sibling tool ecosystem, this minimal description leaves too many questions unanswered.

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

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

Schema description coverage is 100%, with both parameters (module_id and project_id) clearly documented in the schema as UUID identifiers. The description adds no parameter information beyond what the schema provides, which is acceptable given the high schema coverage. The baseline score of 3 reflects adequate but minimal value addition.

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

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

The description 'Delete a module' is a tautology that merely restates the tool name without adding specificity. It doesn't distinguish this from sibling deletion tools like delete_cycle, delete_issue_type, delete_label, delete_module_issue, delete_state, or delete_worklog. The verb+resource is clear but lacks differentiation from similar tools.

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

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

No guidance is provided about when to use this tool versus alternatives. With multiple deletion tools in the sibling list (delete_cycle, delete_issue_type, delete_label, delete_module_issue, delete_state, delete_worklog), the description offers no context about prerequisites, consequences, or appropriate scenarios for module deletion versus other deletion 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 full burden but only states the action without disclosing behavioral traits. It doesn't mention whether this operation is reversible, requires specific permissions, has side effects (e.g., affecting issue status), or returns any confirmation. For a deletion tool, this is a significant gap in transparency.

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

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

The description is extremely concise with two short sentences that directly state the action. It's front-loaded with the primary purpose and avoids any unnecessary words, making it efficient and easy to parse.

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

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

Given the tool's complexity (a deletion operation with 3 parameters), lack of annotations, and no output schema, the description is incomplete. It doesn't cover behavioral aspects, error handling, or return values, leaving significant gaps for an AI agent to understand how to use it correctly in 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 100%, so the schema already documents all three parameters (project_id, module_id, issue_id) as UUID identifiers. The description adds no additional meaning beyond what's in the schema, such as relationships between parameters or format details, meeting the baseline for high schema coverage.

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

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

The description clearly states the action ('Remove an issue from a module') and the resource ('issue'), making the purpose understandable. However, it doesn't explicitly differentiate from sibling tools like 'delete_cycle_issue' or 'list_module_issues', which would require more specific context about module-issue relationships.

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 'delete_cycle_issue' or 'update_issue', nor does it mention prerequisites such as needing existing project, module, and issue IDs. It lacks context about typical workflows or error conditions.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. 'Delete a state' implies a destructive, irreversible mutation, but it doesn't specify consequences (e.g., what happens to associated data), permissions required, error conditions, or confirmation behavior. For a destructive tool with zero annotation coverage, this is a significant gap in transparency.

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

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

The description is a single, efficient sentence with zero waste. It is front-loaded and directly conveys the core action without unnecessary elaboration, 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 this is a destructive mutation tool with no annotations and no output schema, the description is incomplete. It lacks critical context such as what a 'state' is, deletion consequences, success/error responses, or any behavioral nuances. The high schema coverage doesn't compensate for these gaps in a tool that performs irreversible actions.

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 100% description coverage, with clear documentation for both parameters (project_id and state_id as UUID identifiers). The description adds no parameter semantics beyond what's in the schema, so it meets the baseline of 3 where the schema does the heavy lifting. No additional value is provided.

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

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

The description 'Delete a state' clearly states the action (delete) and resource (state), making the purpose immediately understandable. It distinguishes from siblings like 'get_state' or 'create_state' by specifying deletion. However, it doesn't specify what a 'state' represents in this context (e.g., workflow state, project state), which prevents a perfect score.

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 state), exclusions (e.g., cannot delete default states), or sibling tools like 'update_state' or 'list_states' that might be relevant alternatives. The agent must infer usage from the 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 the full burden of behavioral disclosure. It does reveal the permission requirement and that the operation is a deletion, but it does not state whether deletion is permanent, cascading, or what response is returned. The permission detail adds useful context beyond the bare verb.

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 first states the core action, and the second adds a critical permission constraint. There is no filler or repetition, and the most important information is front-loaded.

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

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

For a simple deletion tool with two required parameters, the description covers the action, the parameters, and the authorization rule. Since there is no output schema, the absence of explicit return-value details is a minor gap, but the tool is still callable safely with the information given.

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

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

Schema description coverage is 100%, so the input schema already documents project_id and view_id. The description merely restates that these are uuid parameters, adding no semantic meaning beyond what the schema provides. Baseline 3 is appropriate.

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

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

The description starts with a specific verb and resource: 'Delete a saved view.' This uniquely identifies the operation among siblings like get_view, create_view, and update_view. No ambiguity remains about what the tool does.

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

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

The description clearly states the precondition for use: only the view's owner or a project Admin may delete it. This gives an agent actionable context about who can invoke the tool, though it doesn't explicitly contrast with update_view or list_project_views.

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. 'Delete a worklog' implies a destructive mutation, but it doesn't disclose behavioral traits like whether deletion is permanent, requires specific permissions, affects related data (e.g., time tracking), or what happens on success/failure. For a destructive tool with zero annotation coverage, this is a significant gap in transparency.

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

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

The description is extremely concise at three words, with zero wasted text. However, it's under-specified rather than efficiently informative—it lacks necessary context for a destructive operation, which slightly reduces its effectiveness despite the brevity.

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 this is a destructive mutation tool with no annotations and no output schema, the description is incomplete. It doesn't cover behavioral aspects (e.g., permanence, permissions), usage context, or what to expect upon deletion. The high schema coverage helps with parameters, but overall, the description fails to provide adequate context for safe and correct use.

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

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

Schema description coverage is 100%, with all three parameters (project_id, issue_id, worklog_id) clearly documented as UUID identifiers. The description adds no parameter semantics beyond what the schema provides, but since the schema does the heavy lifting, the baseline score of 3 is appropriate.

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

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

The description 'Delete a worklog' clearly states the verb (delete) and resource (worklog), but it's overly simplistic and doesn't distinguish from sibling tools like 'delete_cycle', 'delete_label', or 'delete_module'. It specifies the action but lacks any nuance about what a worklog represents in this 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?

No guidance is provided on when to use this tool versus alternatives. The description doesn't mention prerequisites (e.g., needing to identify the worklog first via 'get_issue_worklogs'), nor does it clarify if this is reversible or has side effects. It's a bare statement with no contextual usage information.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It states 'Get details' which implies a read-only operation, but doesn't specify if authentication is required, rate limits apply, what happens on invalid IDs, or the response format. This is inadequate for a tool with no annotation coverage.

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

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

The description is a single, front-loaded sentence with zero wasted words. It directly states the tool's purpose without unnecessary elaboration, making it highly efficient and easy to parse.

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

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

Given no annotations, no output schema, and a read operation with two required parameters, the description is incomplete. It doesn't explain what 'details' are returned, error conditions, or behavioral traits, leaving significant gaps for the agent to operate 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 100%, with clear descriptions for both 'cycle_id' and 'project_id' parameters. The description adds no additional parameter semantics beyond what the schema provides, so it meets the baseline of 3 for high schema coverage without compensating value.

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

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

The description 'Get details of a specific cycle' clearly states the verb ('Get') and resource ('cycle'), making the purpose understandable. However, it lacks specificity about what 'details' include and doesn't differentiate from sibling tools like 'list_cycles' or 'get_cycle_issues', leaving room for ambiguity about scope.

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

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

The description provides no guidance on when to use this tool versus alternatives. With siblings like 'list_cycles' (for multiple cycles) and 'get_cycle_issues' (for cycle-related issues), there's no indication of context, prerequisites, or exclusions, leaving the agent to infer usage from tool names 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 this is a read operation ('Get'), which implies non-destructive behavior, but doesn't mention potential limitations like pagination, rate limits, authentication requirements, or error conditions. It provides basic context but lacks comprehensive behavioral details.

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

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

The description is efficiently structured in two sentences: the first states the core purpose, the second provides crucial usage guidance. Every sentence adds value with zero wasted words, making it easy to parse and understand 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 tool's moderate complexity (2 required parameters, no output schema, no annotations), the description is reasonably complete. It covers purpose, parameter types, and alternative usage scenarios. However, it doesn't describe the return format (e.g., comment structure, ordering) or potential limitations, leaving some gaps for a read operation.

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

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

Schema description coverage is 100%, so the schema already fully documents both parameters (project_id and issue_id as UUIDs). The description adds minimal value by repeating that parameters are UUIDs and mentioning the alternative tool for readable identifiers, but doesn't provide additional semantic context beyond what's in the schema.

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

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

The description clearly states the specific action ('Get all comments') and resource ('for a specific issue'), distinguishing it from sibling tools like add_issue_comment (which creates comments) or get_issue_worklogs (which retrieves worklogs). It precisely defines the tool's function without ambiguity.

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

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

The description explicitly provides when to use this tool (to get comments for a specific issue) and when to use an alternative (get_issue_using_readable_identifier if you have a readable identifier instead of UUIDs). This offers clear guidance on tool selection and prerequisites.

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

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

No annotations are provided, so the description carries full burden. It implies a read operation ('Get'), but doesn't disclose behavioral traits like whether it's safe, idempotent, requires authentication, or has rate limits. For a tool with no annotations, this is a significant gap in transparency.

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

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

The description is a single, efficient sentence with no wasted words. It's appropriately sized for a simple tool, though it could be more informative. The structure is front-loaded but lacks depth, earning a high score for conciseness but not perfect due to under-specification.

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

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

Given no annotations, no output schema, and a simple tool with 2 parameters, the description is incomplete. It doesn't explain what 'details' are returned, error conditions, or how it fits into the broader context of issue management. This leaves gaps for an agent to understand full tool behavior.

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

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

Schema description coverage is 100%, so the schema fully documents both parameters (project_id and type_id). The description adds no meaning beyond what the schema provides, as it doesn't explain parameter relationships or usage. Baseline 3 is appropriate when schema does the heavy lifting.

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 'Get details of a specific issue type' clearly states the action (get) and resource (issue type), but it's vague about what 'details' include and doesn't differentiate from siblings like 'list_issue_types' or 'get_issue_using_readable_identifier'. It provides basic purpose but lacks specificity about scope or output.

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, context, or exclusions, such as needing a project_id and type_id versus using list_issue_types for browsing. This leaves the agent without direction on 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 simply says 'Get a specific issue' but does not state that this is a read-only operation, mention authentication requirements, or describe any side effects, rate limits, or return behavior beyond the action itself.

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

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

Two sentences suffice: the first states the purpose and the second unpacks the identifier format with a concrete example. No filler, and the key information is front-loaded.

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

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

For a straightforward get-by-identifier tool with two simple, fully documented parameters, the description covers what an agent needs to call it correctly. It lacks details about response shape, but the absence of an output schema makes that less critical. A mention of what happens when the issue does not exist would strengthen it.

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

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

Schema coverage is 100% because both parameters already have descriptions that include the exact same FIRST-123 example. The description restates this mapping rather than adding new semantic information, so it earns the baseline score of 3.

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

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

The description opens with a clear verb and resource: 'Get a specific issue using its readable identifier.' It also clarifies the identifier format with concrete examples ('FIRST-123', 'ABC-123'), making the tool's purpose unambiguous and distinct from list_project_issues, which fetches multiple issues.

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

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

The description provides no guidance on when to use this tool versus alternatives such as list_project_issues or get_issue_comments. It never states what conditions warrant this tool or mentions any exclusions, leaving the agent to 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 the full burden of behavioral disclosure. It states a read operation ('Get') but doesn't cover aspects like authentication needs, rate limits, pagination, or response format. This is inadequate for a tool with potential complexity in data retrieval.

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 zero waste—it directly states the tool's function without unnecessary details. It's appropriately sized and front-loaded 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?

Given no annotations and no output schema, the description is incomplete. It doesn't explain what 'worklogs' entail, how results are returned, or any behavioral traits, making it insufficient for an agent to use the tool effectively in a complex environment.

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

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

Schema description coverage is 100%, so the schema fully documents the two parameters (issue_id and project_id). The description adds no additional meaning beyond implying these are required for fetching worklogs, meeting the baseline for high schema coverage.

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

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

The description clearly states the action ('Get') and resource ('all worklogs for a specific issue'), making the purpose understandable. However, it doesn't differentiate from sibling tools like 'get_total_worklogs' or 'get_issue_comments', which could cause confusion in selection.

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

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

The description provides no guidance on when to use this tool versus alternatives, such as 'get_total_worklogs' for aggregated data or 'get_issue_comments' for related issue details. It lacks context on prerequisites or exclusions, leaving usage ambiguous.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It states 'Get details' which implies a read-only operation, but doesn't clarify if it's safe, what permissions are required, how errors are handled, or what the return format looks like. For a tool with zero annotation coverage, this leaves significant gaps in understanding its behavior beyond the basic action.

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

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

The description is a single, efficient sentence: 'Get details of a specific label.' It's front-loaded with the core action and resource, with no wasted words or unnecessary elaboration. Every part of the sentence earns its place by conveying the essential purpose without redundancy.

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

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

Given the tool's complexity (a read operation with 2 required parameters), lack of annotations, and no output schema, the description is incomplete. It doesn't explain what 'details' are returned, error conditions, or how it fits into the broader context of sibling tools like 'list_labels'. For a tool without structured behavioral or output information, more descriptive context is needed 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?

The input schema has 100% description coverage, with clear documentation for both parameters ('label_id' and 'project_id'). The description adds no additional meaning beyond what the schema provides, such as explaining parameter relationships or usage examples. According to the rules, with high schema coverage (>80%), the baseline score is 3, which is appropriate here.

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 'Get details of a specific label' clearly states the verb ('Get') and resource ('label'), making the purpose understandable. However, it lacks specificity about what 'details' include and doesn't differentiate from sibling tools like 'list_labels' or 'create_label' beyond the basic action. It's not tautological but remains somewhat vague.

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 sibling tools like 'list_labels' for listing all labels or 'create_label' for creating new ones, nor does it specify prerequisites such as needing a project context. Usage is implied only by the tool name and description, with no explicit context or exclusions.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It states it 'gets details' but doesn't clarify what details are returned, whether it's a read-only operation, if it requires specific permissions, or how errors are handled. For a tool with no annotation coverage, this leaves significant gaps in understanding its behavior and constraints.

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 without unnecessary words. It avoids redundancy and wastes no space, making it easy to parse quickly. Every word earns its place in conveying the essential action.

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

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

Given the tool's low complexity (2 required parameters, no output schema, no annotations), the description is minimally adequate but incomplete. It covers the basic purpose but lacks behavioral details, usage context, and output information. For a simple read operation, it's functional but could be more helpful by adding context like return format or error cases.

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

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

Schema description coverage is 100%, with both parameters ('module_id' and 'project_id') clearly documented in the schema as UUID identifiers. The description adds no additional semantic context beyond what the schema provides, such as explaining why both IDs are required or how they relate. Baseline 3 is appropriate since the schema does the heavy lifting.

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 ('details of a specific module'), making the purpose immediately understandable. It distinguishes from sibling tools like 'list_modules' by specifying retrieval of a single module rather than listing multiple. However, it doesn't explicitly contrast with other 'get_' tools like 'get_cycle' or 'get_state', which follow similar patterns.

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 sibling tools like 'list_modules' for browsing modules or 'get_projects' for related data, nor does it specify prerequisites such as needing both project and module IDs. Usage is implied by the name and parameters but not explicitly stated.

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

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

With no annotations provided, the description carries the full burden, and it delivers: it discloses that this is a read operation returning raw file content, that unpublished projects yield 404s, and that there is no path-listing capability. This gives the agent accurate expectations about side effects and failure modes.

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?

Three sentences, each earning its place: what the tool returns, how to get the index, and the key constraints and navigation behavior. The most important information is front-loaded.

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

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

For a simple read-only tool with two parameters and no output schema, the description covers the action, return format, failure case, and page-discovery approach. Nothing essential for invoking the tool correctly is missing.

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

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

Schema description coverage is 100%, so the input schema already documents both path and project_id. The description adds a small amount of usage context ('Omit path to get the site's index') but mostly repeats what the schema says, so the baseline of 3 is appropriate.

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

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

The opening phrase 'Read a page of a project's published docs site' names a specific verb, resource, and scope. It also clarifies the return type (raw HTML file) and distinguishes this docs-reading tool from the many issue/module/project tools 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 explicitly states when the tool works ('Only projects with docs_view enabled and a published build'), when it fails (returns a 404), and how to navigate ('follow the links in the index'). It also tells the agent how to request the site index by omitting path. No alternative docs tool exists, so no sibling routing is needed.

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

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

No annotations are provided, so the description carries the burden of behavioral disclosure. 'Get' and 'current user' convey a read-only, user-scoped listing, but the description does not mention ordering, pagination, response shape, or whether any implicit filtering occurs. This is adequate for a simple list operation, but notable details remain implicit.

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 entire description is one short, front-loaded sentence with no filler words. Every word adds information about what the tool does and for whom.

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

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

For a zero-parameter listing operation, the invocation is fully specified: call it with no arguments to retrieve the current user's projects. The lack of an output schema is a minor gap, but the expected type of result is reasonably self-evident from the tool's purpose.

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

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

The tool has zero parameters, and the schema coverage is 100% by construction, so there are no parameter semantics for the description to clarify. This meets the baseline for a no-parameter tool, and the description does not need to add anything further.

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 ('Get'), resource ('projects'), and scope ('for the current user'), making the tool's purpose immediately clear. It is easily distinguished from siblings like create_project or get_project_summary, since it targets all projects for the current user rather than creating or summarizing 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 when to use the tool: whenever an agent needs all projects visible to the current user. However, it does not explicitly state when not to use it or mention alternatives such as get_project_summary, so the routing guidance is left largely to inference.

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

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

With no annotations, the description carries the full burden, but 'get a project's counts' unambiguously indicates a read-only aggregation and 'cheaper than listing each' discloses a performance characteristic. It does not explicitly state side-effect-freeness or error behavior, but for a tool whose name and verb imply retrieval, this is adequate and adds value beyond the schema.

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

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

The description is four concise sentences. The purpose is front-loaded, followed by a cost rationale, a parameter note, and a resolution path. There is no redundant restating of schema fields, and every sentence earns its place.

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

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

For a single-parameter, read-only summary tool, the description covers the core purpose, when to use it, and how to obtain the necessary ID. It does not describe the exact return format, but it enumerates the counted entities, giving the agent enough context to interpret results. Minor gaps like error conditions or response structure are acceptable given the tool's simplicity.

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

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

Schema coverage is 100%, giving full parameter documentation, so baseline is 3. The description adds meaningful guidance on how to resolve a readable identifier to the required project_id via get_projects, which goes beyond the schema's simple type description and directly helps the agent prepare the 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 uses a specific verb ('get a project's counts') and enumerates the exact resources (work items, modules, cycles, states, members, pages, labels, intakes), making it clearly distinct from the many list/get siblings. It is not a tautology and immediately differentiates the tool as an aggregate summary rather than a detailed listing 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 phrase 'Cheaper than listing each' explicitly states when to choose this tool over fetching individual lists, implying a when-not for detailed data needs. It also gives a concrete prerequisite step: if you only have a readable identifier, use get_projects to obtain the required project_id. This is direct, actionable guidance with an alternative 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?

With no annotations provided, the description carries full burden but only states it 'gets details' without disclosing behavioral traits like read-only nature (implied by 'get'), error handling, authentication needs, or rate limits. It's minimal and doesn't add meaningful context beyond the basic action.

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

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

The description is a single, clear sentence with zero waste—'Get details of a specific state' is front-loaded and appropriately sized for its purpose, earning its place efficiently without unnecessary elaboration.

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

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

Given no annotations, no output schema, and a simple read operation with two parameters, the description is incomplete. It doesn't explain what 'details' includes, potential errors, or how it fits into the broader context of sibling tools, leaving gaps for an AI agent to infer 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 100%, with both parameters ('project_id' and 'state_id') well-documented in the schema as UUID identifiers. The description adds no additional meaning beyond what the schema provides, so it meets the baseline of 3 for high schema coverage without extra value.

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

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

The description 'Get details of a specific state' clearly states the verb ('Get') and resource ('state'), but it's vague about what 'details' entails and doesn't differentiate from sibling tools like 'list_states' or 'get_cycle'. It's functional but lacks specificity about scope or content of the returned details.

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

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

No guidance is provided on when to use this tool versus alternatives like 'list_states' (for listing all states) or other 'get_' tools. The description implies it's for retrieving a single state by ID, but there's no explicit comparison or context for selection among siblings.

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 a read operation ('Get'), implying it's non-destructive, but doesn't cover aspects like authentication needs, rate limits, error handling, or what the return format might be (e.g., time units, aggregation method). This is insufficient for a tool with zero annotation coverage.

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

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

The description is a single, efficient sentence that directly states the tool's purpose without any wasted words. It's appropriately sized and front-loaded, 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?

Given the complexity of a data retrieval tool with no annotations and no output schema, the description is incomplete. It doesn't explain what 'total logged time' entails (e.g., summed worklogs, time range, units) or the return structure, leaving gaps that could hinder correct tool invocation by an AI agent.

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

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

The input schema has 100% description coverage, with the 'project_id' parameter well-documented as a UUID. The description adds no additional parameter details beyond what the schema provides, such as format examples or constraints. Given the high schema coverage, a baseline score of 3 is appropriate as the description doesn't compensate but doesn't detract either.

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 ('total logged time for a project'), making the purpose specific and understandable. However, it doesn't differentiate from sibling tools like 'get_issue_worklogs' or 'get_projects', which could also involve retrieving work-related data, so it misses full sibling differentiation.

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

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

The description provides no guidance on when to use this tool versus alternatives. It doesn't mention prerequisites, context, or exclusions, such as whether it aggregates data from other tools or if it's for summary purposes only. This 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?

There are no annotations, so the description carries the full burden of behavioral disclosure. It only restates that the tool gets information; it does not describe what fields are returned, whether authentication is required, or any other runtime behavior. 'Get' implies a read operation, but no meaningful behavioral context is provided.

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

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

The description is a single, front-loaded sentence with no filler or repetition. Every word contributes to the meaning, making it an appropriately concise definition.

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 no-parameter getter, the description is enough to invoke the tool, but with no output schema it omits what the returned 'information' actually contains. An agent can call it, but it does not know the shape or scope of the response in advance.

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

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

The tool has zero parameters and schema coverage is trivially 100%, so there is no parameter ambiguity. The description reinforces the semantic expectation that the user is derived from the current context rather than passed as an argument, which is useful.

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's information', so an agent can tell what the tool does. However, it does not distinguish itself from sibling tools like get_workspace_members, so it misses the differentiation that would earn 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 'current user' implies when to use this tool: whenever the authenticated user's own profile is needed. It gives no explicit guidance on when not to use it or which sibling alternative might be more appropriate, leaving usage to inference.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It only restates that the tool requests two UUID parameters and says 'Get', which implies read-only behavior, but it does not disclose return format, error behavior, or any other operational characteristics.

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 sentences with no fluff. The core purpose is front-loaded, and the alternative-tool guidance is the only additional context, making it tightly scoped and efficient.

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

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

The tool is low-complexity and the schema fully covers parameters, but there is no output schema and the description does not state what the tool returns or what happens when the view is not found. This is a noticeable gap given that no annotations compensate for it.

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

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

Schema description coverage is 100%, with both view_id and project_id already documented as UUID identifiers. The description adds no semantic value beyond repeating that the parameters are UUIDs, so it meets the baseline but does not exceed it.

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

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

The description starts with a specific verb and resource: 'Get a specific saved view.' This clearly identifies what the tool does and, alongside the sibling list_project_views, distinguishes a single-resource fetch from list operations.

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

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

The description gives explicit routing guidance: 'If you do not have the view_id, use the list_project_views tool to find it.' This directly tells the agent when to use an alternative tool, making the selection logic unambiguous.

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 are absent, so the description must convey behavioral traits. It only states 'get', implying a read operation, but fails to disclose any side effects, permission requirements, pagination, ordering, or return format. This is a minimal disclosure for a tool that could benefit from clarifying the workspace context.

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

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

The description is a single concise sentence with no extraneous words. The action is front-loaded, 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 simple tool with no output schema, the description is adequate but not thorough. It explains what it does but leaves out context on what 'current workspace' means, what data members include, or how the result is returned. The absence of an output schema means the description should ideally specify the return shape, which is missing.

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

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

With zero parameters, the schema coverage is trivially 100%. The baseline for 0 params is 4, and the description adds nothing about parameters because none exist. This is appropriate; no compensation is needed.

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 ('get'), resource ('members'), and scope ('current workspace'), making it unambiguous. No sibling tool provides a member list, so it is clearly distinguished from 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 offers no guidance on when to use this tool versus others, nor does it mention prerequisites or exclusions. It simply states the action without 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 the full burden of behavioral disclosure. It states the action ('Get all issues') but lacks critical details: it doesn't specify whether this is a read-only operation (implied by 'Get' but not explicit), describe pagination or limits for 'all issues', mention authentication requirements, indicate rate limits, or explain the return format (e.g., list structure, error handling). For a tool with no annotations, 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 a single, efficient sentence that front-loads the core action ('Get all issues') and context ('for a specific cycle'). There is zero waste or redundancy, making it easy to parse quickly. It appropriately sized for a simple retrieval tool, with every word earning its place.

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

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

Given the tool's complexity (a read operation with 2 required parameters), lack of annotations, and no output schema, the description is incomplete. It doesn't address behavioral aspects like safety (read-only vs. mutating), return format, error conditions, or usage context. While the schema covers parameters well, the description fails to compensate for missing annotations and output details, leaving the agent with insufficient guidance for reliable 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 100%, with both parameters (cycle_id and project_id) clearly documented in the schema as UUID identifiers. The description adds no additional parameter semantics beyond implying that 'cycle_id' specifies the cycle and 'project_id' specifies the containing project, which is already covered by the schema. Since the schema does the heavy lifting, the baseline score of 3 is appropriate, with no extra value from the description.

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

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

The description clearly states the verb ('Get') and resource ('all issues for a specific cycle'), making the purpose immediately understandable. It distinguishes from siblings like 'list_cycles' (which lists cycles) and 'list_module_issues' (which lists issues for modules), though it doesn't explicitly contrast with 'get_issue_using_readable_identifier' (which retrieves a single issue). The description is specific but could be more precise about differentiation from similar 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 provides no guidance on when to use this tool versus alternatives. It doesn't mention prerequisites (e.g., needing a valid cycle_id and project_id), contrast with sibling tools like 'get_issue_using_readable_identifier' (for single issues) or 'list_module_issues' (for module-specific issues), or specify use cases (e.g., bulk retrieval vs. filtered searches). Usage is implied by the name and description 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 but only states the basic action. It doesn't disclose behavioral traits such as whether this is a read-only operation, if it requires authentication, how results are returned (e.g., pagination), or error handling, leaving significant gaps.

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

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

The description is a single, efficient sentence with no wasted words. It's front-loaded with the core purpose, making it easy to parse quickly without unnecessary elaboration.

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

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

Given no annotations and no output schema, the description is incomplete. It doesn't explain what 'cycles' are in this context, the format of returned data, or potential limitations, which is inadequate for a tool that likely returns a list of items.

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

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

Schema description coverage is 100%, so the schema fully documents the 'project_id' parameter. The description adds no additional meaning beyond implying the parameter is required, which is already clear from the schema. This meets the baseline for high coverage.

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

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

The description clearly states the verb ('Get') and resource ('all cycles for a specific project'), making the purpose understandable. However, it doesn't explicitly differentiate from sibling tools like 'get_cycle' (singular) or 'list_cycle_issues', which might cause confusion about scope.

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

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

The description provides no guidance on when to use this tool versus alternatives like 'get_cycle' (for a single cycle) or 'list_cycle_issues' (for issues within cycles). It lacks context about prerequisites or typical use cases, offering minimal usage direction.

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

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

No annotations are provided, so the description carries the full burden. It states it's a read operation ('Get'), but doesn't disclose behavioral traits like whether it requires authentication, returns paginated results, includes archived issue types, or provides error handling for invalid project IDs.

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 zero wasted words. It's front-loaded with the core action and resource, making it easy to scan and understand 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 no annotations and no output schema, the description is incomplete. It doesn't explain what the tool returns (e.g., a list of issue type objects, their structure, or possible empty results), which is critical for a read operation with no structured output documentation.

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

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

Schema description coverage is 100%, with the parameter 'project_id' fully documented in the schema as 'The uuid identifier of the project to get issue types for'. The description adds no additional meaning beyond implying the parameter is required, so it meets the baseline of 3.

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

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

The description clearly states the verb 'Get' and the resource 'all issue types for a specific project', making the purpose understandable. It distinguishes from siblings like 'get_issue_type' (singular) and 'create_issue_type', but doesn't explicitly differentiate from other list tools like 'list_labels' or 'list_states' beyond the resource name.

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 a valid project_id), compare to other list tools, or indicate when not to use it (e.g., for a single issue type use 'get_issue_type').

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It states 'Get all labels' but doesn't clarify if this is a read-only operation, what permissions are required, whether it returns paginated results, or what the output format looks like. For a list operation with zero annotation coverage, this is a significant gap in transparency.

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

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

The description is a single, efficient sentence that front-loads the core action ('Get all labels') and context ('for a specific project'). There is zero waste or redundancy, making it appropriately concise for a simple list operation.

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

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

Given the lack of annotations and output schema, the description is incomplete. It doesn't explain behavioral aspects like read-only nature, permissions, or output format, which are crucial for an agent to use the tool correctly. For a tool with no structured safety or output information, the description should provide more 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?

The schema description coverage is 100%, with the single parameter 'project_id' well-documented in the schema as 'The uuid identifier of the project to get labels for'. The description adds no additional semantic context beyond implying the parameter's purpose, so it meets the baseline for high schema coverage without compensating value.

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

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

The description clearly states the verb ('Get') and resource ('labels') with scope ('for a specific project'), making the purpose evident. However, it doesn't explicitly differentiate from sibling tools like 'get_label' (singular) or 'create_label', leaving some ambiguity about when to use this versus 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 'get_label' (singular) or 'create_label'. It mentions the context ('for a specific project') but lacks explicit when-to-use or when-not-to-use instructions, leaving the agent to infer usage from the 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 but only states the basic action. It doesn't disclose behavioral traits like whether this is a read-only operation (implied by 'Get'), pagination, rate limits, authentication needs, or what 'all issues' entails (e.g., status filters). This leaves significant gaps for a tool with potential complexity.

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 zero waste. 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 no annotations and no output schema, the description is minimally adequate but incomplete. It covers the basic purpose but lacks details on behavior, output format, or error handling, which are important for a tool that likely returns a list of 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 100%, with clear parameter descriptions in the schema itself. The description adds no additional meaning beyond implying 'module_id' and 'project_id' are needed, which is already covered. Baseline 3 is appropriate as the schema does the heavy lifting.

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 'issues for a specific module', making the purpose understandable. It distinguishes from siblings like 'list_cycle_issues' by specifying 'module' scope, though it doesn't explicitly differentiate from 'get_issue_using_readable_identifier' or 'get_issue_comments' which have different purposes.

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

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

No guidance on when to use this tool versus alternatives like 'get_issue_using_readable_identifier' (for single issues) or 'list_cycle_issues' (for cycle-specific issues). The description implies usage for module-related issues but lacks explicit context or exclusions.

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

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

With no annotations provided, the description carries full burden for behavioral disclosure. It states what the tool does but reveals nothing about permissions required, pagination behavior, error conditions, rate limits, or response format. For a read operation in a system with many mutation tools, 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 a single, efficient sentence that states the core purpose without unnecessary words. It's appropriately sized for a simple retrieval tool and front-loads the essential information ('Get all modules for a specific project').

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 and no output schema, the description is insufficiently complete. It doesn't address what 'modules' are in this context, what data they contain, whether the list is filtered/paginated, or what authentication/authorization is required. Given the rich sibling toolset with many mutation operations, more context is needed.

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

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

Schema description coverage is 100% with the single parameter 'project_id' fully documented in the schema. The description adds no additional parameter semantics beyond what's already in the schema (e.g., doesn't clarify what constitutes a valid project_id or how modules relate to projects). This meets the baseline for high schema coverage.

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

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

The description clearly states the action ('Get all modules') and target resource ('for a specific project'), providing a specific verb+resource combination. However, it doesn't distinguish this from sibling tools like 'get_module' (singular) or 'list_module_issues', missing explicit differentiation that would warrant a score 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 like 'get_module' (singular retrieval) or 'list_module_issues' (related but different resource). There's no mention of prerequisites, exclusions, or contextual factors, leaving usage decisions entirely to inference from the tool name alone.

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

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

No annotations are provided, so the description carries full responsibility for behavioral disclosure. It states 'Get all issues' but does not mention pagination, rate limits, error handling, or any side effects (though it is read-only by nature). There is no explicit statement about the return format or potential large result sets.

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

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

The description is two concise sentences. The primary purpose is front-loaded, and the additional guidance on parameter resolution is relevant and succinct. No wasted words.

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

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

For a simple list operation with one parameter and no output schema, the description covers the essential steps: what it returns and how to get the parameter. However, it does not mention pagination or result limits, which are common for listing tools, leaving a potential gap for large projects.

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 fully describes the parameter (project_id as uuid). The description adds value by suggesting a method to resolve a readable identifier to a uuid via get_projects, which goes beyond the schema and helps the agent obtain a correct value.

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

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

The description clearly states the action ('Get all issues') and the resource ('for a specific project'), which distinguishes it from siblings like list_issue_types or get_issue. The mention of 'all issues' implies a collection operation, making the purpose unambiguous.

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

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

The description provides context on how to obtain the required project_id via get_projects, but does not explicitly state when to use this tool versus alternatives like get_issue_using_readable_identifier or create_issue. It implies a listing use case but lacks explicit exclusion or comparison guidance.

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

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

No annotations are provided, so the description must carry the behavioral burden. The verb 'Get' clearly signals a read-only list operation and the view definition adds useful domain context. However, it does not disclose permissions, rate limits, or behavior for invalid/missing project_id, which leaves some ambiguity for a no-annotation 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?

Three short sentences, each contributing useful information: what the tool does, what a view is, and how to resolve the required parameter. There is no filler or repetition of schema details.

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

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

For a single-parameter list tool with no output schema, the description covers the essential context: purpose, domain definition, required input, and a fallback for obtaining that input. It does not describe the exact return shape or ordering, but 'Get all saved views' plus the view definition is sufficient for an agent 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?

The schema already documents project_id as a required UUID string with 100% coverage, so the baseline is 3. The description adds meaningful value by explicitly stating the parameter is a uuid and explaining how to obtain project_id from a readable identifier using get_projects.

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 names a specific verb and resource: 'Get all saved views for a project.' It also defines what a view is, and the word 'all' distinguishes it from the sibling get_view tool, which is about a single view. Purpose is unmistakable.

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 clear context: use this tool to retrieve all saved views for a project. It also provides a practical decision rule for obtaining project_id when only a readable identifier is available, pointing to get_projects. It stops short of explicitly stating when not to use it or naming alternatives like get_view, so it does not reach the top score.

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 a read operation ('Get') but lacks details on permissions, rate limits, pagination, or response format. This is inadequate for a tool that likely returns a list, as it doesn't prepare the agent for handling multiple states.

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 zero wasted words. It's front-loaded with the core action and resource, making it easy to parse quickly without unnecessary elaboration.

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 a list operation with no annotations and no output schema, the description is insufficient. It doesn't explain what 'states' are in this context, how results are returned (e.g., array format), or any error conditions, leaving the agent underprepared for 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 100%, with the parameter 'project_id' fully documented in the schema. The description adds no additional meaning beyond implying the tool fetches states scoped to a project, which is already inferred from the schema. This meets the baseline for high schema coverage.

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

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

The description clearly states the verb 'Get' and the resource 'all states for a specific project', making the purpose unambiguous. However, it doesn't explicitly differentiate from sibling tools like 'get_state' (singular) or 'list_cycles', which might also retrieve related project 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 provides no guidance on when to use this tool versus alternatives. It doesn't mention prerequisites (e.g., needing a valid project_id), exclusions, or comparisons to similar tools like 'get_state' or 'list_cycles', leaving the agent without contextual usage cues.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. 'Transfer' implies a mutation that moves issues between cycles, but it doesn't specify whether this is destructive (e.g., removes from source), requires permissions, handles errors, or affects issue states. This leaves significant gaps in understanding the tool's behavior.

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

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

The description is a single, efficient sentence that front-loads the core action without unnecessary words. Every part earns its place by directly stating the tool's 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 complexity of a mutation tool with no annotations and no output schema, the description is incomplete. It lacks details on behavioral traits (e.g., side effects, error handling) and return values, leaving the agent with insufficient context to use the tool effectively beyond basic parameter passing.

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

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

Schema description coverage is 100%, with clear parameter descriptions in the schema (e.g., 'uuid identifier of the source cycle'). The tool description adds no additional meaning beyond implying a source-target relationship, so it meets the baseline of 3 where the schema does the heavy lifting.

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 ('transfer') and resource ('issues from one cycle to another'), making the tool's purpose immediately understandable. However, it doesn't explicitly differentiate from sibling tools like 'add_cycle_issues' or 'list_cycle_issues', which could involve similar resources but different operations.

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

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

The description provides no guidance on when to use this tool versus alternatives. With siblings like 'add_cycle_issues' (which might add issues to a cycle) and 'list_cycle_issues' (which lists them), there's no indication of context, prerequisites, or exclusions for choosing this transfer operation.

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

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

No annotations are provided, so the description carries full burden. 'Update an existing cycle' implies a mutation operation but doesn't disclose behavioral traits like required permissions, whether updates are partial or complete, if changes are reversible, rate limits, or what happens on success/failure. For a mutation tool with zero annotation coverage, this leaves critical gaps.

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

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

The description is a single, efficient sentence with zero waste. It's appropriately sized for a basic tool definition, though it could be more informative. The structure is front-loaded with the core action, but lacks supporting details that would enhance utility.

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 (mutation tool with 3 required parameters, nested objects, no output schema, and no annotations), the description is incomplete. It doesn't explain what fields can be updated, the update behavior, or expected outcomes. For a tool that modifies data, this minimal description leaves too much undefined for safe and effective use.

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

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

Schema description coverage is 100%, with all parameters documented in the schema. The description adds no additional meaning beyond the schema's parameter details. According to guidelines, when schema coverage is high (>80%), the baseline score is 3 even with no param info in the description.

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

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

The description 'Update an existing cycle' states the verb ('update') and resource ('cycle'), but is vague about what specifically gets updated. It doesn't differentiate from sibling tools like 'update_issue' or 'update_module' beyond the resource name. The purpose is clear at a basic level but lacks specificity about the update scope.

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

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

No guidance is provided about when to use this tool versus alternatives. The description doesn't mention prerequisites (e.g., needing an existing cycle ID), when not to use it (e.g., for creating new cycles), or how it differs from related tools like 'create_cycle' or 'delete_cycle'. The agent must infer usage from the name alone.

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

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

No annotations are present, so the description carries the full burden of behavioral disclosure. It implies mutation via 'Update' and states ID requirements, but says nothing about permissions, partial-update semantics, read-only fields, response shape, or side effects. For a mutating write tool, this is a significant gap.

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

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

The description is brief and front-loaded, with the useful resolver guidance in the second sentence. The first sentence is somewhat redundant with the tool name, but there is no bloat or irrelevant detail.

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

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

This is a complex write operation with a large nested issue_data object, three required parameters, no output schema, and no annotations. The description only addresses ID resolution and leaves partial-vs-full update behavior, response contents, and permissions unclear, so an agent cannot invoke it with full confidence.

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 already describes all three top-level parameters and the nested issue_data object, so it does the heavy lifting. The description adds the uuid requirement and the readable-identifier resolution hint, but doesn't clarify how issue_data should be constructed or which nested fields are actually updatable.

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 clear verb and resource ('Update an issue') and identifies the required ID parameters, so an agent knows what the tool operates on. It doesn't enumerate which update fields are supported, so it's clear but not richly detailed.

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

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

Explicitly instructs the agent to use get_issue_using_readable_identifier first if only a readable identifier is available, which is valuable routing guidance. It stops short of explaining when not to use update_issue or contrasting it with create_issue and other issue tools.

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

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

With no annotations provided, the description carries full burden for behavioral disclosure. 'Update an existing issue type' implies a mutation operation but reveals nothing about permissions required, whether changes are reversible, rate limits, error conditions, or what happens when only partial fields are provided in issue_type_data. For a mutation tool with zero annotation coverage, 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 with zero wasted words. It's appropriately sized for a straightforward update operation and front-loads the essential information 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 mutation tool with no annotations and no output schema, the description is inadequate. It doesn't explain what constitutes a successful update, what gets returned (if anything), error handling, or behavioral nuances. The complexity of the nested issue_type_data object with 16 properties suggests this tool needs more contextual explanation than provided.

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

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

Schema description coverage is 100%, so the schema already documents all three parameters (project_id, type_id, issue_type_data) with their descriptions. The tool description adds no additional parameter information beyond what's in the schema, which is acceptable given the comprehensive schema coverage but doesn't provide extra value.

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

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

The description 'Update an existing issue type' clearly states the verb ('Update') and resource ('issue type'), making the purpose immediately understandable. However, it doesn't differentiate this tool from sibling update tools like update_issue, update_label, or update_state, which all follow the same 'update [resource]' pattern.

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. With multiple sibling update tools (update_issue, update_label, update_state, etc.), there's no indication of what distinguishes issue type updates from other resource updates, nor any prerequisites or contextual constraints mentioned.

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. 'Update an existing label' implies a mutation operation but doesn't specify required permissions, whether changes are reversible, error conditions, or what happens to unspecified fields. For a mutation tool with zero annotation coverage, this leaves critical behavioral aspects undocumented.

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 zero wasted words. It's appropriately sized for what it communicates and front-loads the essential action and resource.

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

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

For a mutation tool with 3 parameters, no annotations, and no output schema, the description is insufficient. It doesn't explain what fields can be updated, what the tool returns, error handling, or permissions required. The agent lacks critical context needed to use this tool 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 100%, so the schema fully documents all 3 parameters (project_id, label_id, label_data) and their nested properties. The description adds no parameter information beyond what's in the schema, which meets the baseline expectation when schema coverage is complete.

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 'Update an existing label' clearly states the action (update) and resource (label), but it's vague about what specifically gets updated. It doesn't distinguish this tool from other update tools like update_issue or update_cycle, nor does it mention the specific fields that can be modified.

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 (like needing an existing label), when not to use it, or how it differs from sibling tools like create_label or get_label. 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. It states this is an update operation, implying mutation, but doesn't mention permissions required, whether changes are reversible, error conditions, or what the response contains. For a mutation tool with zero annotation coverage, this leaves critical behavioral aspects unspecified.

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 three words: 'Update an existing module.' It's front-loaded with the core action and resource, with zero wasted words. Every word earns its place by conveying essential information.

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

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

Given this is a mutation tool with no annotations and no output schema, the description is incomplete. It doesn't explain what happens on success versus failure, what permissions are needed, or what data is returned. The input schema is well-documented, but the description doesn't compensate for the lack of behavioral and output 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 100%, with all parameters documented in the schema itself. The description doesn't add any parameter information beyond what the schema provides. According to scoring rules, when schema coverage is high (>80%), the baseline is 3 even with no param info in the description.

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

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

The description 'Update an existing module' clearly states the verb ('Update') and resource ('module'), making the basic purpose understandable. However, it lacks specificity about what aspects of a module can be updated and doesn't distinguish this tool from sibling update tools like update_cycle or update_issue, which follow the same pattern.

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. While siblings include create_module and delete_module, the description doesn't mention prerequisites like needing an existing module ID or when update might fail. There's also no comparison to other update tools in the sibling list.

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 responsibility for behavioral disclosure but offers none. It doesn't mention whether this is a safe operation, what permissions are required, whether it's idempotent, what happens on partial updates, or any side effects. The single phrase 'Update an existing state' provides zero behavioral context beyond the basic action implied by the name.

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 maximally concise at just three words. While severely under-specified, it contains zero wasted words and is front-loaded with the core action. This extreme brevity represents efficient communication, though at the cost of 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?

For a mutation tool with 3 required parameters (including a complex nested object), no annotations, and no output schema, the description is completely inadequate. It doesn't explain what a 'state' is, what fields are updatable, what the operation returns, or any behavioral characteristics. The agent would struggle to use this tool correctly based solely on the description.

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 100% schema description coverage, the schema fully documents all three parameters (project_id, state_id, state_data) and their nested properties. The description adds no parameter information beyond what's already in the structured schema, so it meets the baseline expectation but doesn't provide additional value through examples, constraints, or usage patterns.

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 'Update an existing state' is a tautology that merely restates the tool name 'update_state' without adding meaningful context. It specifies the verb 'update' and resource 'state' but lacks specificity about what a 'state' represents in this system or what aspects can be updated, making it only marginally better than just 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?

The description provides absolutely no guidance on when to use this tool versus alternatives. With sibling tools like 'create_state', 'delete_state', 'get_state', and 'list_states', there's no indication of prerequisites, appropriate contexts, or differentiation from related operations. This leaves the agent with no usage direction.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It only says 'Update a saved view' and restates that parameters are requested; it does not explain mutation semantics, whether the update is partial or full, what happens to unspecified fields, or any side effects. 'Update' implies mutation but adds no real 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?

The description is two sentences with no filler. The core operation is front-loaded, and the second sentence provides a single actionable routing instruction. Every sentence earns its place.

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

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

The schema is rich and fully documents the parameters, which covers much of the needed context. However, with no annotations and no output schema, the description leaves mutation semantics unstated, such as whether update is partial/full and how read-only fields are handled. This is a moderate gap rather than a fatal one.

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

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

Schema description coverage is 100%, and every parameter, including the nested view_data fields, is already described in the input schema. The description adds minimal extra meaning beyond calling out the uuid parameters and the view_id lookup pointer, so the baseline score of 3 is appropriate.

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

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

The description opens with the specific verb 'Update' and identifies the resource as 'a saved view', which clearly distinguishes it from sibling tools like create_view, get_view, delete_view, and list_project_views. There is no ambiguity about what resource the operation targets.

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 explicit routing guidance: 'If you do not have the view_id, use the list_project_views tool to find it.' It also signals that both project_id and view_id are needed for this operation, which helps the agent determine whether it has sufficient context before calling.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. 'Update an existing worklog' implies a mutation operation, but it doesn't disclose any behavioral traits such as required permissions, whether updates are partial or complete, what happens to unspecified fields, error conditions, or side effects. For a mutation tool with zero annotation coverage, this is a significant gap.

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

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

The description is extremely concise—a single sentence with no wasted words. It's front-loaded with the core action ('Update'), though it lacks detail. Every word earns its place, making it efficient despite being under-specified.

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 (4 required parameters, nested objects, no output schema, and no annotations), the description is incomplete. It doesn't address what the tool returns, error handling, or how it fits into the broader context of worklog management with siblings like 'create_worklog' and 'delete_worklog'. For a mutation tool with rich schema but no annotations or output schema, more guidance is needed.

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 description coverage is 100%, with all parameters well-documented in the input schema (e.g., 'issue_id' as 'The uuid identifier of the issue containing the worklog'). The description adds no meaning beyond what the schema provides—it doesn't explain parameter relationships, constraints, or usage examples. With high schema coverage, the baseline score of 3 is appropriate.

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

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

The description 'Update an existing worklog' clearly states the verb ('update') and resource ('worklog'), which is better than a tautology. However, it doesn't differentiate this tool from its sibling 'update_issue' or other update tools, nor does it specify what aspects of a worklog can be updated. It's a generic statement that could apply to any update operation.

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. There's no mention of prerequisites (e.g., needing an existing worklog), when not to use it (e.g., for creating vs. updating), or how it relates to sibling tools like 'create_worklog' or 'delete_worklog'. 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.