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

With no annotations provided, the description carries the full burden of behavioral disclosure. It states the action but doesn't cover critical aspects like required permissions, whether the operation is idempotent, what happens if the user is already a watcher, error conditions, or the response format. This leaves significant gaps for an agent to understand 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 front-loaded with the core purpose in the first sentence, followed by a clear parameter list. Every sentence earns its place by providing essential information without redundancy, making it appropriately sized 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, no output schema, and low schema description coverage, the description is incomplete. It lacks details on behavioral traits, error handling, and return values, which are crucial for an agent to use the tool effectively in context with its siblings.

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 lists the parameters with brief explanations ('Work package ID' and 'User ID to add as watcher'), which adds some meaning beyond the schema's basic types. However, with 0% schema description coverage, it doesn't fully compensate by detailing format constraints, valid ranges, or examples, leaving the semantics somewhat vague.

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 'Add' and the resource 'a user as a watcher to a work package', making the purpose specific and understandable. However, it doesn't explicitly differentiate from its sibling 'remove_watcher', which is a clear alternative, though the naming implies the opposite action.

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 'remove_watcher' or other work package management tools. It lacks context about prerequisites, such as user permissions or work package state, and doesn't mention any exclusions or when-not-to-use scenarios.

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

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

With no annotations provided, the description carries full burden for behavioral disclosure. It states the action ('Add a comment') which implies a write operation, but doesn't disclose permission requirements, whether comments are editable/deletable, rate limits, or what happens on success/failure. The description provides minimal behavioral context beyond the basic 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 efficiently structured with a clear purpose statement followed by parameter explanations. Every sentence serves a purpose, and there's no redundant information. The formatting with 'Args:' section helps readability. It could be slightly more front-loaded with key behavioral 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 write operation tool with 3 parameters, no annotations, and no output schema, the description is insufficient. It doesn't explain what the tool returns, error conditions, authentication requirements, or how the comment integrates with the work package system. The agent lacks crucial context for proper invocation and error handling.

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 provides meaningful semantic context for all three parameters beyond what the schema offers (0% coverage). It clarifies that 'comment' accepts 'markdown format' and that 'internal' has a 'default: False' value, which adds crucial usage information not present in the bare schema. However, it doesn't explain what 'internal' means in practical terms.

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

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

The description clearly states the action ('Add a comment') and target resource ('to a work package'), making the purpose immediately understandable. It distinguishes from siblings like 'update_comment' by focusing on creation rather than modification. However, it doesn't specify if this creates a new comment thread or adds to an existing one, preventing 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_comment' or how it relates to other comment-related operations. There's no mention of prerequisites, constraints, or typical use cases beyond the basic action. 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 it's a creation operation but doesn't cover permissions needed, whether it's idempotent, error conditions, or what happens on success (e.g., returns a relation ID). The lag parameter hint for 'precedes/follows' adds some context, but overall behavioral traits are minimally described.

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

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

The description is appropriately sized and front-loaded with the core purpose in the first sentence. The parameter explanations are structured clearly in a list format, with no redundant or wasted sentences. Every element earns its place by adding necessary 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 no annotations and no output schema, the description is moderately complete. It covers the purpose and parameters well but lacks behavioral details (e.g., response format, error handling) and usage context. For a mutation tool with 4 parameters, it should provide more guidance on outcomes and constraints to be fully complete.

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

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

Schema description coverage is 0%, so the description must fully compensate. It successfully adds meaning beyond the schema by explaining each parameter: 'from_id' as source work package ID, 'to_id' as target work package ID, 'relation_type' with enumerated values, and 'lag' as optional days for specific relation types. This provides complete parameter semantics not present 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 verb ('Create') and resource ('relation between two work packages'), making the purpose immediately understandable. It distinguishes from siblings like 'delete_relation' and 'get_relation' by specifying creation. However, it doesn't explicitly differentiate from other creation tools like 'create_work_package' in terms of resource type.

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., existing work packages), exclusions, or comparisons with siblings like 'set_parent_work_package' or 'list_work_package_relations'. Usage is implied only through the action described.

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 it correctly identifies this as a creation operation, it doesn't mention permission requirements, whether the creation is reversible, what happens on failure, or any rate limits. For a mutation tool with zero annotation coverage, this represents significant gaps in behavioral understanding.

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

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

The description is well-structured with a clear purpose statement followed by organized parameter documentation. While efficient, the parameter documentation section is somewhat lengthy but necessary given the parameter count. Every sentence adds value, with no redundant information.

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

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

Given the complexity (8 parameters, mutation operation) and lack of both annotations and output schema, the description does a good job with parameters but leaves gaps in behavioral context. It adequately documents what to provide but doesn't fully explain what happens during execution or what to expect in return. For a creation tool, this is minimally adequate but could be more complete.

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

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

The description provides excellent parameter semantics beyond the 0% schema coverage. For all 8 parameters, it explains what each represents (e.g., 'Work package title (required)', 'Type ID (default: 1 for Task)', 'Whether to send notifications (default: True)'), including required/optional status, defaults, and format guidance like 'markdown format'. This fully compensates for the lack of schema descriptions.

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

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

The description clearly states the specific action ('Create a new work package') and resource ('in a project'), distinguishing it from sibling tools like update_work_package or delete_work_package. It provides a complete verb+resource+context statement that leaves no ambiguity about the tool's function.

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_work_package or set_parent_work_package. It doesn't mention prerequisites, dependencies, or typical usage scenarios. The only contextual information is the project context, but no comparative guidance is offered.

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

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

With no annotations, the description carries full burden but only states the basic action. It doesn't disclose critical behavioral traits such as permissions required, whether deletion is permanent/reversible, side effects (e.g., impact on linked work packages), or error handling. This is inadequate 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 front-loaded with the core purpose, followed by a concise parameter explanation. Every sentence earns its place with no wasted words, 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 the tool's destructive nature, lack of annotations, no output schema, and minimal parameter coverage, the description is incomplete. It fails to address key aspects like return values, error cases, or behavioral nuances, leaving significant gaps 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?

The description adds essential meaning beyond the schema, which has 0% coverage. It explains that 'relation_id' is the 'Relation ID to delete', clarifying the parameter's purpose. Since there's only one parameter, this is sufficient to compensate for the lack of schema descriptions, though it could note format constraints (e.g., integer ID).

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 target ('a relation between work packages'), which is specific and distinguishes it from other deletion tools like delete_work_package. However, it doesn't explicitly differentiate from remove_watcher or other relation-manipulation tools like create_relation, keeping it from 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?

No guidance is provided on when to use this tool versus alternatives. It doesn't mention prerequisites (e.g., needing an existing relation), exclusions, or compare it to siblings like delete_work_package or remove_watcher, leaving the agent to infer usage context.

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

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

With no annotations provided, the description carries full burden for behavioral disclosure. It states the deletion is 'permanent', which is valuable context beyond the tool name. However, it doesn't mention required permissions, whether deletion can be undone, what happens to associated data, or error conditions—critical gaps 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 and well-structured: a clear purpose statement followed by parameter documentation. Every sentence earns its place—the first establishes the action, the second explains the parameter. No wasted words or redundancy.

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

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

For a destructive tool with no annotations and no output schema, the description is incomplete. It doesn't cover permissions, side effects, success/error responses, or recovery options. While concise, it lacks the depth needed for safe operation of a permanent deletion tool.

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

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

The description adds meaningful context for the single parameter: 'work_package_id: Work package ID to delete'. With 0% schema description coverage, this compensates by clarifying what the parameter represents. However, it doesn't specify format constraints (e.g., integer range) or where to find the ID, leaving some ambiguity.

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 ('permanently delete') and target resource ('a work package'), distinguishing it from sibling tools like 'delete_relation' or 'remove_watcher'. It uses precise language that leaves no ambiguity about the tool's function.

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 it's clear this deletes work packages, there's no mention of prerequisites (e.g., checking dependencies first), consequences, or when to choose other deletion-related tools like 'delete_relation'. The description assumes the user already knows when deletion is appropriate.

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 states the tool retrieves details (implying read-only), but doesn't disclose behavioral traits like authentication needs, rate limits, error conditions, or what 'details' includes. For a read 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 appropriately sized with two sentences: a purpose statement and a parameter list. It's front-loaded with the core purpose. However, the parameter section could be more integrated, and there's slight redundancy in stating 'Activity ID' (which is in the schema title).

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

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

Given the tool's simplicity (1 parameter) but lack of annotations and output schema, the description is incomplete. It doesn't explain what 'details' are returned, potential errors, or how this fits into the broader context of sibling tools. For a tool with no structured support, more descriptive 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 0%, so the description must compensate. It adds minimal semantics by specifying 'activity_id: Activity ID', but doesn't explain what an activity ID is, its format, or where to find it. This provides some value beyond the bare schema but doesn't fully compensate for the coverage gap, warranting a baseline 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 tool's purpose with 'Get details of a specific activity', which includes a verb ('Get') and resource ('activity'). It distinguishes from siblings like 'get_work_package_activities' (which likely lists multiple activities) by specifying retrieval of a single activity. However, it doesn't explicitly contrast with all siblings, so it's not a perfect 5.

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

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

The description provides no guidance on when to use this tool versus alternatives. It doesn't mention when to use it over 'get_work_package' or 'get_work_package_activities', nor does it specify prerequisites or exclusions. The only implied usage is needing an activity ID, but this is covered in parameters.

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 this is a 'Get' operation, implying read-only behavior, but doesn't address permissions, rate limits, pagination, or error handling. For a tool with zero annotation coverage, this leaves significant gaps in understanding how it behaves 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 appropriately sized and front-loaded: the first sentence states the core purpose clearly, and the 'Args' section efficiently documents the parameter without redundancy. Every sentence earns its place, 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 tool's low complexity (1 parameter, no output schema, no annotations), the description is minimally complete. It covers the purpose and parameter semantics adequately but lacks usage guidelines and behavioral details. For a read operation with simple inputs, this is acceptable but leaves room for improvement in guiding the agent.

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

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

The description adds meaningful context for the single parameter: 'project_id: Project identifier or ID' clarifies that this is a string identifier for a project. With 0% schema description coverage (schema only has title 'Project Id'), the description fully compensates by explaining the parameter's purpose, earning a high score despite the low baseline.

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

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

The description clearly states the tool's purpose: 'Get list of users who can be assigned to work packages in a project.' It specifies the verb ('Get'), resource ('list of users'), and context ('in a project'). However, it doesn't explicitly differentiate from siblings like 'get_project' or 'get_work_package', which might also return user-related data, so it doesn't reach the highest clarity level.

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, exclusions, or compare to sibling tools like 'get_project' or 'list_work_packages' that might overlap in functionality. The agent must infer usage from the purpose alone, which is insufficient for optimal 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 this is a 'Get' operation, implying it's likely read-only, but doesn't confirm this or describe other traits like authentication needs, rate limits, error handling, or what the return format looks like. For a tool with zero annotation coverage, this leaves significant gaps in understanding its 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 front-loaded with the core purpose in the first sentence, followed by a brief parameter explanation. It avoids unnecessary words and is appropriately sized for a simple tool, with every sentence adding value. The structure is clear 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?

Given the tool's low complexity (one parameter, no nested objects) and lack of annotations or output schema, the description is minimally adequate. It covers the basic purpose and parameter meaning but misses behavioral details like return values or error conditions. For a read operation, this is acceptable but not comprehensive.

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

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

The description adds meaningful context for the single parameter 'project_id' by explaining it as a 'Project identifier or ID', which clarifies its purpose beyond the schema's basic 'string' type. With 0% schema description coverage and only one parameter, this compensation is effective, though it doesn't detail format constraints (e.g., numeric vs. string IDs).

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 'detailed information about a project', making the purpose understandable. It distinguishes this tool from siblings like 'list_projects' (which lists multiple projects) and 'update_project' (which modifies projects). However, it doesn't specify what 'detailed information' includes, 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 when to choose 'get_project' over 'list_projects' for viewing project data, nor does it specify prerequisites like needing a project ID. Usage context is implied but not explicitly stated.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It states this is a 'Get' operation, implying read-only behavior, but doesn't disclose any other traits like authentication requirements, rate limits, error conditions, or what 'details' include. For a tool with zero annotation coverage, this leaves significant gaps in understanding its 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 appropriately concise with two sentences and an Args section. The first sentence clearly states the purpose, and the second provides parameter information without unnecessary elaboration. However, the structure could be improved by integrating the Args into the main description flow rather than as a separate section.

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

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

Given the tool's simplicity (1 parameter, no output schema, no annotations), the description is incomplete. It doesn't explain what 'details' are returned, how to handle errors, or provide any context about relations in the system. For a tool with no annotations and no output schema, the description should do more to compensate for these gaps.

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

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

The description adds minimal parameter semantics beyond the schema. It mentions 'relation_id: Relation ID', which matches the schema's property name and title, but provides no additional context about what a relation ID is, its format, or where to obtain it. With 0% schema description coverage, the description doesn't adequately compensate for the lack of schema documentation.

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

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

The description clearly states the tool's purpose with 'Get details of a specific relation', providing a specific verb ('Get') and resource ('relation'). It distinguishes from siblings like 'create_relation' or 'delete_relation' by focusing on retrieval rather than mutation. However, it doesn't explicitly differentiate from other getter tools like 'get_work_package' or 'get_project' beyond the resource type.

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

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

The description provides no guidance on when to use this tool versus alternatives. It doesn't mention when to use 'get_relation' instead of 'list_work_package_relations' or 'get_work_package', nor does it specify prerequisites like needing a valid relation_id. The usage is implied 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 lacks behavioral details. It doesn't disclose whether this is a read-only operation, what permissions are required, error handling, or response format. 'Get detailed information' is vague about what 'detailed' entails.

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

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

The description is appropriately concise with two sentences: one stating the purpose and another listing the parameter. It's front-loaded with the main function, though the parameter section could be integrated more smoothly.

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 (a read operation with no annotations or output schema), the description is incomplete. It doesn't explain what 'detailed information' includes, potential errors, or how this fits with sibling tools like 'get_work_package_activities', leaving significant gaps for an agent.

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

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

The description adds minimal semantics beyond the input schema, which has 0% coverage. It specifies that 'work_package_id' is a 'Work package ID', but this is redundant with the schema's title. No format, constraints, or examples are provided, leaving gaps in understanding.

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

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

The description clearly states the tool's purpose with a specific verb ('Get') and resource ('detailed information about a work package'), distinguishing it from siblings like 'list_work_packages' or 'get_work_package_activities'. However, it doesn't explicitly differentiate from 'get_work_package_schema', which might cause some 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 provides no guidance on when to use this tool versus alternatives like 'list_work_packages' for multiple packages or 'get_work_package_schema' for schema details. It only states what the tool does, without 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. It mentions pagination behavior (page and page_size with defaults), which is useful, but lacks details on permissions, rate limits, error handling, or what 'retrieve all' entails (e.g., if it includes deleted comments). For a read operation with zero annotation coverage, this leaves significant gaps in behavioral understanding.

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 front-loaded with the core purpose in the first sentence, followed by a structured Args section that efficiently documents parameters. Every sentence earns its place with no redundant or vague language, making it appropriately sized and well-organized.

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 3 parameters, no annotations, and no output schema, the description is moderately complete. It covers the purpose and parameters adequately but lacks behavioral details (e.g., response format, error cases) and usage guidelines. For a tool with this complexity, it meets minimum viability but has clear gaps 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 0%, so the description must compensate. It provides clear semantics for all three parameters: work_package_id specifies the target, page and page_size control pagination with defaults. This adds meaningful context beyond the bare schema, though it doesn't explain format constraints (e.g., integer ranges) or usage nuances.

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 'retrieve' and the resource 'activities and comments for a work package', making the purpose specific and understandable. It doesn't explicitly distinguish from siblings like 'get_activity' or 'get_work_package', but the focus on 'all activities and comments' provides some 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 like 'get_activity' (which might retrieve a single activity) or 'get_work_package' (which might retrieve work package details without activities). There's no mention of prerequisites, context, or exclusions for usage.

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 tool retrieves a schema but doesn't describe what the schema contains, format (e.g., JSON structure), error conditions, authentication needs, or rate limits. For a read operation with zero annotation coverage, this leaves significant gaps in understanding how the tool behaves.

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

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

The description is appropriately sized and front-loaded: the first sentence states the purpose clearly, followed by a brief Args section. There's no wasted text, and the structure helps the agent quickly grasp key information. However, the Args section could be integrated more seamlessly, slightly affecting flow.

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 (2 parameters, no annotations, no output schema), the description is incomplete. It doesn't explain what the schema output looks like, potential errors, or how type_id affects results. For a tool that likely returns structured data critical for other operations (e.g., create_work_package), more context is needed to use it effectively.

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

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

The description adds minimal semantics beyond the input schema: it explains that project_id is a 'Project identifier or ID' and type_id is 'Optional type ID to get type-specific schema.' With 0% schema description coverage, this partially compensates by clarifying parameter roles, but it doesn't provide format details (e.g., string format for project_id) or examples. The baseline is low due to poor schema coverage, so a 3 reflects marginal improvement.

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

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

The description clearly states the tool's purpose: 'Get the schema for creating/updating work packages.' It specifies the verb ('Get') and resource ('schema'), and distinguishes it from sibling tools like create_work_package or update_work_package by focusing on schema retrieval rather than data manipulation. However, it doesn't explicitly differentiate from other schema-related tools (none exist in siblings), so it's not a perfect 5.

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

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

The description provides no guidance on when to use this tool versus alternatives. It doesn't mention prerequisites (e.g., needing a valid project_id), scenarios where it's useful (e.g., before creating a work package), or exclusions. The agent must infer usage from the purpose alone, which is insufficient 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 full burden for behavioral disclosure. While it mentions 'accessible projects' (implying permission-based filtering) and 'optional filtering and pagination', it doesn't describe what 'accessible' means, what authentication is required, rate limits, error conditions, or what the return format looks like. For a list operation with zero annotation coverage, this leaves significant behavioral questions unanswered.

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 with a clear purpose statement followed by parameter documentation. Both sentences earn their place - the first establishes core functionality, the second provides essential parameter details. It's appropriately sized for a list operation with three parameters, though the parameter documentation could be slightly more concise.

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 provides adequate but incomplete coverage. The parameter documentation is good, but there's no information about return format, error handling, or authentication requirements. For a list operation that presumably returns structured data, the lack of output information is a notable gap, though the core functionality is reasonably clear.

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

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

The description provides explicit parameter documentation in the Args section, adding significant value beyond the schema which has 0% description coverage. It explains 'filters' as 'Optional JSON filter string', 'page' with default and meaning, and 'page_size' with default. This compensates well for the schema's lack of descriptions, though it doesn't provide examples of filter syntax or explain pagination behavior in detail.

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 ('List all accessible projects') and resource ('projects'), making the purpose immediately understandable. It distinguishes from siblings like 'get_project' by indicating it returns multiple items rather than a single one. However, it doesn't explicitly differentiate from 'list_work_packages' which might be confusing in this sibling 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. With multiple sibling tools like 'get_project' (single project) and 'list_work_packages' (different resource), there's no indication of when this list_projects tool is appropriate versus those other options. The description only states what it does, not when to choose it.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It states it 'gets' relations, implying a read-only operation, but doesn't specify permissions needed, rate limits, pagination, or what 'relations' entail (e.g., types, format). This leaves significant gaps for safe and effective use.

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 core purpose, followed by a simple parameter list. It avoids unnecessary words, though the 'Args:' section is somewhat redundant given the schema.

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

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

For a tool with no annotations, no output schema, and low schema coverage, the description is insufficient. It doesn't explain what 'relations' are, how results are returned, or error handling, leaving the agent with incomplete context 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?

The description adds minimal semantics by naming the parameter ('work_package_id') and indicating it's a required ID, but the schema already defines it as a required integer with a title. With 0% schema description coverage, this doesn't fully compensate—it lacks details like ID format or sourcing.

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 relations') and resource ('for a work package'), making the purpose understandable. However, it doesn't differentiate from sibling tools like 'get_relation' (singular) or 'create_relation', which could cause confusion about when to use each.

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_relation' (singular) or 'create_relation'. It mentions the required parameter but offers no context about prerequisites, typical use cases, 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. It mentions 'optional filtering and pagination,' which gives some behavioral context about the tool's capabilities. However, it lacks critical details such as whether this is a read-only operation (implied but not stated), what authentication is required, rate limits, error conditions, or the format of returned data. For a list tool with no annotations, this leaves significant gaps in understanding its 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 well-structured and front-loaded with the core purpose in the first sentence, followed by a bullet-point-like list of parameters. Every sentence earns its place by providing essential information without redundancy. It's appropriately sized for a tool with four parameters and no annotations.

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

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

Given the tool's moderate complexity (4 parameters, no annotations, no output schema), the description is partially complete. It covers the purpose and parameters adequately but lacks details on behavioral aspects like authentication, error handling, and return format. Without an output schema, the description should ideally hint at what data is returned, but it doesn't, leaving gaps in full contextual understanding.

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

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

The schema description coverage is 0%, so the description must compensate. It provides clear semantics for all four parameters: 'project_id' for filtering by project, 'filters' as a JSON filter string, and 'page'/'page_size' for pagination with defaults. This adds meaningful context beyond the schema's basic titles, though it doesn't detail the exact JSON structure for filters or validation rules.

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

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

The description clearly states the verb ('List') and resource ('work packages'), making the purpose immediately understandable. It distinguishes itself from sibling tools like 'get_work_package' by indicating it returns multiple items with filtering capabilities. However, it doesn't explicitly differentiate from other list tools like 'list_projects' or 'list_work_package_relations' 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 implies usage through the mention of 'optional filtering and pagination,' suggesting this tool is for retrieving multiple work packages rather than single items. However, it doesn't provide explicit guidance on when to use this versus alternatives like 'get_work_package' for single items or how filtering interacts with other parameters. No when-not-to-use scenarios or prerequisites are 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. It states the mutation action ('Remove') but doesn't describe permissions needed, whether the operation is reversible, what happens if the user isn't a watcher, or any rate limits. The description is minimal and lacks important behavioral context 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 efficiently structured with a clear purpose statement followed by parameter documentation. Both sentences earn their place by providing essential information. While slightly more context about behavior would be helpful, the existing text is appropriately sized and front-loaded with the core 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?

For a mutation tool with no annotations and no output schema, the description is incomplete. It covers the basic action and parameters but lacks crucial information about permissions, error conditions, return values, and how this operation relates to the broader watcher management context. 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?

The description explicitly documents both parameters with clear semantic meaning ('Work package ID' and 'User ID to remove from watchers'), adding significant value beyond the schema which has 0% description coverage. While it doesn't specify format constraints beyond what the schema provides (integer types), it clarifies what each ID represents in the context of the operation.

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 a user from work package watchers') and identifies the resource ('work package watchers'). It distinguishes from siblings like 'add_watcher' by specifying removal, but doesn't explicitly contrast with other watcher-related tools beyond the obvious verb difference.

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. While 'add_watcher' is clearly the opposite operation, there's no mention of prerequisites (e.g., user must be a current watcher), error conditions, or when removal might be inappropriate versus other modification 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. It discloses that the tool can both set and remove parents, mentions lock version requirements, and includes notification behavior. However, it doesn't cover important behavioral aspects like permissions needed, whether this is a destructive/mutative operation, error conditions, or what happens to child work packages when parent is removed.

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

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

The description is appropriately sized with a clear purpose statement followed by parameter explanations. Every sentence adds value, though the parameter section could be slightly more structured. It's front-loaded with the core functionality before parameter 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 mutation tool with no annotations and no output schema, the description does reasonably well on parameters but lacks important context. It doesn't explain what the tool returns, error conditions, or the full behavioral implications of parent removal. Given the complexity of parent-child relationships in work packages, more completeness would be beneficial.

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

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

With 0% schema description coverage, the description fully compensates by explaining all 4 parameters. It clarifies that parent_id accepts 'None to remove parent', explains lock_version must be 'get from work package first', and specifies notify's default value. This adds crucial semantic meaning beyond the bare schema.

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

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

The description clearly states the specific action ('Set or remove the parent') and resource ('work package'), distinguishing it from siblings like create_work_package or update_work_package which handle different operations. 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 implies usage for parent-child relationship management but doesn't explicitly state when to use this tool versus alternatives like update_work_package or create_relation. It mentions the need to 'get lock version from work package first' which provides some context, but lacks explicit when/when-not guidance compared to 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 mentions that 'lock_version' should be obtained from an activity first, hinting at concurrency control, but doesn't explain what happens on update (e.g., overwrites text, requires permissions, returns success/failure, or handles errors). 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 appropriately sized and front-loaded: the purpose is stated first, followed by a structured list of parameters with brief explanations. There's no wasted text, though it could be slightly more polished (e.g., using bullet points). Every sentence adds value.

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

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

Given the tool's complexity (a mutation with concurrency control), lack of annotations, and no output schema, the description is incomplete. It doesn't cover behavioral aspects like error handling, permissions, or what the tool returns. The parameter explanations are good, but overall context is lacking 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?

The schema description coverage is 0%, so the description must fully compensate. It does so by clearly explaining all three parameters: 'activity_id' identifies the comment, 'comment' is the new text in markdown format, and 'lock_version' is the current version to prevent conflicts. This adds crucial meaning beyond the bare schema.

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

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

The description clearly states the tool's purpose: 'Update an existing comment.' It specifies the verb ('update') and resource ('comment'), making it immediately understandable. However, it doesn't explicitly differentiate from sibling tools like 'create_comment' or 'get_activity', which would be needed for 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 comment), exclusions, or comparisons to siblings like 'create_comment' for new comments or 'get_activity' to retrieve lock versions. Usage is implied but not explicitly stated.

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

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

With no annotations provided, the description carries full burden for behavioral disclosure. It mentions 'lock_version' which implies optimistic concurrency control, adding some behavioral context. However, it doesn't describe what happens on update failure, whether partial updates are allowed, permission requirements, or response format. 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 well-structured with a clear purpose statement followed by parameter explanations. Each parameter explanation is brief and to the point. There's no wasted text, though the formatting with 'Args:' header and bullet-like structure could be slightly more polished.

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

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

For a mutation tool with 6 parameters, 0% schema coverage, no annotations, and no output schema, the description provides adequate parameter semantics but lacks behavioral context about permissions, error handling, and response format. It covers the 'what' but not the 'how' or 'what happens after'. Given the complexity, it's minimally viable but has clear gaps.

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

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

Schema description coverage is 0%, so the description must compensate. It provides semantic meaning for all 6 parameters beyond their titles, explaining what each represents (e.g., 'Current lock version (get from project first)', 'New project description in markdown'). This adds substantial value over the bare schema, though it doesn't explain nullability or default behaviors fully.

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 'update' and resource 'existing project', making the purpose unambiguous. It distinguishes from siblings like 'create_work_package' or 'list_projects' by focusing on modification rather than creation or listing. However, it doesn't explicitly differentiate from 'update_comment' or 'update_work_package' which are also update operations on 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 like 'update_work_package' or 'update_comment'. It mentions 'get from project first' for lock_version, which is a prerequisite hint but not explicit usage context. There's no mention of when-not-to-use scenarios or comparisons with sibling 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 the full burden of behavioral disclosure. It states this is an update operation (implying mutation) and mentions a lock_version mechanism for concurrency control, which is valuable context. However, it fails to disclose critical behavioral traits: whether this requires specific permissions, what happens on success/failure, if changes are reversible, rate limits, or error conditions. For a mutation tool with 8 parameters, this leaves 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 appropriately sized and well-structured: a clear purpose statement followed by a bullet-point-like parameter explanation. Every sentence earns its place by adding value. It could be slightly more front-loaded with usage context, but the structure efficiently conveys necessary information without waste.

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

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

Given the tool's complexity (mutation with 8 parameters, no annotations, no output schema), the description is partially complete. It excels at parameter semantics but lacks behavioral context, usage guidelines, and output information. For a mutation tool, this creates significant gaps in understanding how to use it safely and effectively, though the parameter explanations prevent it from being completely inadequate.

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 provides excellent parameter semantics beyond the input schema, which has 0% description coverage. It explains each parameter's purpose: work_package_id identifies the target, lock_version requires fetching first, subject is title, description uses markdown, status_id and priority_id are IDs, assignee_id uses 0 to unassign, and notify has a default. This fully compensates for the schema's lack of descriptions and adds crucial context like the unassign convention.

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

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

The description clearly states the tool's purpose: 'Update an existing work package.' This is a specific verb+resource combination that distinguishes it from siblings like 'create_work_package' and 'delete_work_package'. However, it doesn't explicitly differentiate from other update tools like 'update_comment' or 'update_project' 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 to fetch the work package first for lock_version), when not to use it, or how it differs from similar update operations on other resources. The only implicit guidance is the parameter list, which doesn't constitute explicit usage instructions.

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