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

The description adds valuable context beyond annotations: it clarifies that activation applies to archived projects (a prerequisite state) and mentions the return value ('Confirmation of activation'). Annotations already indicate this is a non-destructive, idempotent, open-world mutation (readOnlyHint=false, destructiveHint=false, idempotentHint=true, openWorldHint=true), but the description provides useful operational 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 perfectly structured and concise: one clear purpose sentence, followed by a brief Args section with only the essential parameter, and a Returns statement. Every sentence earns its place with no wasted words, and the most important information (what the tool does) 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 single-parameter mutation tool with comprehensive annotations but no output schema, the description is nearly complete. It covers the purpose, parameter, and return value. The main gap is lack of detail about what 'Confirmation of activation' contains, but given the annotations provide safety context and the tool is relatively simple, this is a minor omission.

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's Args section repeats the parameter information already fully covered in the input schema (100% schema description coverage). It adds no additional meaning beyond what the schema provides about 'id_project'. With complete 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 clearly states the specific action ('Activate (unarchive)') and resource ('a previously archived Worksection project'), distinguishing it from siblings like 'worksection_archive_project' (which performs the opposite action) and 'worksection_create_project' (which creates new projects). The parenthetical '(unarchive)' provides helpful clarification of the operation's effect.

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 this is for 'previously archived' projects, providing clear context about when to use it. However, it doesn't explicitly mention when NOT to use it or name specific alternatives (though the sibling list includes related tools like 'worksection_archive_project' and 'worksection_update_project').

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

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

Annotations already provide key behavioral hints: readOnlyHint=false (write operation), destructiveHint=false (non-destructive), idempotentHint=true (safe to retry), and openWorldHint=true (handles new data). The description adds minimal context beyond this—it specifies the action is 'Add' and mentions a confirmation return, but does not detail error cases, rate limits, or permission requirements. With annotations covering core traits, the description adds some value but lacks rich behavioral disclosure.

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

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

The description is appropriately sized and front-loaded, with the core purpose in the first sentence. The Args and Returns sections are structured but slightly redundant with the schema. Every sentence contributes, though the parameter details could be trimmed since they're covered in the schema, keeping it 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 moderate complexity (a write operation with 2 parameters), annotations provide good coverage of behavioral traits, and the schema fully describes inputs. However, there is no output schema, and the description only vaguely mentions 'Confirmation' without detailing response format or error handling. For a mutation tool, this leaves gaps in understanding outcomes, making it adequate but incomplete.

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 (id_project and members) fully documented in the schema. The description repeats the parameter names and adds that members are 'comma-separated email addresses,' which is already stated in the schema. It provides no additional meaning, syntax examples, or constraints beyond what the schema offers, meeting 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 specific action ('Add one or more members') and resource ('to a Worksection project team'), using a precise verb. It distinguishes this tool from sibling tools like worksection_get_members (which retrieves members) and worksection_create_project (which creates projects), establishing a unique purpose.

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

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

The description provides no guidance on when to use this tool versus alternatives. It does not mention prerequisites (e.g., project must exist, members must be valid users), exclusions, or comparisons to sibling tools like worksection_update_project (which might handle member updates differently). Usage is implied but not explicitly defined.

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 provide key behavioral traits (readOnlyHint=false, destructiveHint=false, idempotentHint=true, openWorldHint=true), so the description's burden is lower. It adds context by clarifying that archiving means 'closing' a project, which is useful beyond annotations. However, it doesn't disclose additional aspects like permissions needed, rate limits, or what 'confirmation' entails, leaving some gaps.

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

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

The description is front-loaded with the core action and resource, followed by structured Args and Returns sections. It's efficient with minimal waste, though the Args section redundantly repeats schema info. Every sentence serves a purpose, but slight verbosity in parameter documentation reduces perfect score.

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 one parameter with full schema coverage and annotations covering safety and idempotency, the description is adequate but incomplete. It lacks output details (no schema), doesn't explain archival effects (e.g., if reversible), and misses usage context. For a mutation tool, more behavioral context would improve completeness.

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

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

Schema description coverage is 100%, with the parameter 'id_project' fully documented in the schema as 'Project ID to archive'. The description repeats this exactly in the Args section, adding no extra meaning beyond the schema. Baseline score of 3 applies 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 action ('Archive (close)') and resource ('a Worksection project'), making the purpose unambiguous. However, it doesn't explicitly differentiate from sibling tools like 'worksection_update_project' or 'worksection_complete_task' which might also affect project status, 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?

No guidance is provided on when to use this tool versus alternatives. For example, it doesn't mention when to archive versus update, complete, or activate a project, or if there are prerequisites like project status. 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?

Annotations cover key traits (readOnlyHint=false, destructiveHint=false, idempotentHint=true, openWorldHint=true), so the description's burden is lower. It adds minimal context by implying a state change to 'done', but doesn't detail behavioral aspects like error conditions (e.g., invalid ID), side effects (e.g., notifications), or confirmation specifics. No contradiction with annotations.

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

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

The description is brief and front-loaded with the core action ('Mark a task as completed'), followed by minimal parameter and return info. It avoids unnecessary elaboration, though the 'Args' and 'Returns' sections are somewhat redundant given the schema and could be integrated more seamlessly.

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 (mutation with one parameter), annotations provide safety and idempotency info, but no output schema exists. The description covers the basic action and parameter, but lacks details on return values (beyond 'Confirmation'), error handling, or integration with sibling tools, leaving 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?

Schema description coverage is 100%, with the parameter 'id_task' fully documented in the schema as 'Task ID to complete'. The description repeats this without adding extra meaning (e.g., format examples, sourcing instructions). With high schema coverage, the baseline is 3, and the description doesn't enhance beyond that.

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 ('Mark a task as completed') and resource ('Worksection Task'), making the purpose immediately understandable. It distinguishes from siblings like 'worksection_reopen_task' by specifying completion, though it doesn't explicitly contrast with all related tools like 'worksection_update_task'.

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., task must exist, user must have permissions), exclusions (e.g., cannot complete already completed tasks), or compare with siblings like 'worksection_update_task' which might also handle status changes.

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

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

Annotations already indicate this is a non-readonly, non-destructive, non-idempotent operation with open-world semantics. The description adds minimal behavioral context beyond this—it mentions the return format ('Created project data with ID') but doesn't cover error conditions, rate limits, authentication requirements, or side effects. With annotations providing the safety profile, this earns a baseline score.

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

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

The description is front-loaded with the core purpose in the first sentence. The parameter list is organized but could be more concise—some details (like date formats) are redundant with the schema. Overall, it's efficient with minimal 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 (8 parameters, creation operation) and lack of output schema, the description is adequate but not complete. It covers the basic purpose and parameters but lacks usage context, error handling, or detailed return value explanation. Annotations help, but more behavioral detail would improve completeness.

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

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

Schema description coverage is 100%, so the schema fully documents all parameters. The description lists parameters but adds no additional meaning beyond what's in the schema (e.g., format details like 'YYYY-MM-DD' are already in schema patterns). It 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 explicitly states the verb ('Create') and resource ('new project in Worksection'), making the purpose immediately clear. It distinguishes this tool from sibling tools like 'worksection_update_project' or 'worksection_get_projects' by specifying it's for creation rather than modification or retrieval.

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., required permissions), when not to use it (e.g., for updating existing projects), or refer to sibling tools like 'worksection_update_project' for modifications.

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

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

Annotations already indicate this is a non-destructive, non-idempotent, open-world write operation (readOnlyHint: false, destructiveHint: false, idempotentHint: false, openWorldHint: true). The description adds minimal behavioral context beyond this, mentioning the return format ('Created task data with ID') but not addressing permissions, rate limits, or error conditions.

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 a parameter list and return note. It's appropriately sized for a tool with 12 parameters, though the parameter list is somewhat redundant given the schema coverage, making it slightly verbose.

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 (12 parameters, write operation) and lack of output schema, the description provides adequate context by listing parameters and specifying the return format. However, it could be more complete by addressing authentication needs or error handling, though annotations cover basic behavioral traits.

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 all parameters thoroughly. The description repeats parameter details in a structured list but adds little semantic value beyond what's in the schema, such as clarifying priority scale (0=lowest, 10=highest) or date formats, which are already covered.

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 task') and resource ('in a Worksection project'), distinguishing it from sibling tools like worksection_update_task or worksection_complete_task. It precisely defines the tool's purpose without being tautological.

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 creating tasks but doesn't explicitly state when to use this tool versus alternatives like worksection_update_task or worksection_create_project. It provides no guidance on prerequisites, exclusions, or specific scenarios where this tool is preferred over others.

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

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

The description adds valuable behavioral context beyond what annotations provide. While annotations already declare this as a safe, read-only operation (readOnlyHint=true, destructiveHint=false, idempotentHint=true), the description warns about performance implications ('This may return a large dataset') and provides practical guidance on managing data volume. This enhances the agent's understanding of real-world usage considerations.

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 structured and concise. It begins with the core purpose, provides parameter details in a clear Args section, specifies return values, and ends with important performance notes. Every sentence earns its place, with zero wasted words, and critical information is front-loaded appropriately.

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 read-only list operation with comprehensive annotations and full schema coverage, this description is complete. It covers purpose, parameters, returns, and important behavioral considerations (performance). The absence of an output schema is compensated by the clear return value description. No additional context is needed for this tool's complexity level.

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 already fully documents both parameters. The description's Args section essentially repeats what's in the schema without adding significant semantic context. The baseline score of 3 is appropriate since the schema does the heavy lifting, though the description doesn't add meaningful value beyond the structured data.

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 specific verb ('Get') and resource ('all tasks across all projects'), distinguishing it from sibling tools like worksection_get_tasks (likely project-specific) and worksection_search_tasks (search-focused). It explicitly mentions the scope 'across all projects' which differentiates it from more targeted 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 explicit guidance on when to use alternatives: 'Use filter="active" or get tasks per project for better performance.' It directly addresses performance concerns and suggests specific sibling tools (implied by 'get tasks per project') as better alternatives for certain use cases, making the when/when-not guidance clear and actionable.

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

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

Annotations already cover read-only, non-destructive, idempotent, and open-world hints. The description adds valuable context by specifying the return format ('List of comments with author, text, date, and optionally file attachments'), which is not captured in annotations. It doesn't contradict annotations.

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

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

The description is front-loaded with the core purpose, followed by structured Args and Returns sections. Every sentence adds value: the first states the action, and the subsequent lines clarify parameters and output. 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?

Given the tool's low complexity, rich annotations (covering safety and behavior), and 100% schema coverage, the description is mostly complete. It lacks an output schema but describes the return format. Minor gaps include no pagination details or error handling, but overall it's sufficient.

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

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

Schema description coverage is 100%, so the schema fully documents both parameters. The description repeats the parameter information without adding meaning beyond the schema, such as example values or edge cases. Baseline 3 is appropriate given 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 ('Get all comments') and resource ('for a specific Worksection task'), distinguishing it from sibling tools like worksection_get_task or worksection_post_comment. It precisely defines the scope of retrieval.

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

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

The description implies usage when comments for a task are needed, but provides no explicit guidance on when to use this tool versus alternatives like worksection_get_task (which might include comments) or worksection_search_tasks. No exclusions 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?

Annotations already indicate read-only, non-destructive, idempotent, and open-world behavior. The description adds value by specifying the return format (list with id, email, name, online status, role), which isn't covered by annotations. No contradictions exist.

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 with zero waste: the first states the purpose, the second details the return format. It's front-loaded and efficiently structured, with every sentence adding 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 simple read-only tool with no parameters and comprehensive annotations, the description is nearly complete. It covers purpose and output format, though it could slightly improve by mentioning any limitations (e.g., pagination, sorting) to reach a perfect score.

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 parameters and 100% schema description coverage, the baseline is 4. The description appropriately omits parameter details since none exist, focusing instead on the tool's purpose and output.

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 members') and resource ('Worksection account'), distinguishing it from sibling tools that focus on projects, tasks, comments, or tags. It provides a complete picture of 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 implies usage for retrieving member information, but lacks explicit guidance on when to use this versus alternatives (e.g., for user lookup vs. project-specific member tools like worksection_add_project_members). No exclusions 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?

Annotations already declare readOnlyHint=true, destructiveHint=false, idempotentHint=true, and openWorldHint=true, covering safety and idempotency. The description adds minimal behavioral context beyond this, such as specifying that it returns 'detailed information' and listing example data types (name, status, dates, etc.), but does not disclose rate limits, authentication needs, or error conditions.

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. The 'Args' and 'Returns' sections are clear but slightly verbose; every sentence earns its place by providing necessary details without redundancy, though it could be more concise by integrating the parameter explanations more seamlessly.

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 parameters, no nested objects), rich annotations (covering safety and idempotency), and 100% schema coverage, the description is mostly complete. It lacks an output schema, but the 'Returns' section adequately summarizes the response. It could improve by mentioning error cases or authentication requirements, but it suffices for this simple 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%, with both parameters (id_project and extra) fully described in the schema. The description adds slight value by clarifying that 'extra' provides 'additional data' and listing the comma-separated options, but this mostly repeats schema information. 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 clearly states the verb ('Get detailed information') and resource ('about a specific Worksection project'), making the purpose explicit. It distinguishes from sibling tools like 'worksection_get_projects' (plural) by specifying retrieval of a single project by ID, and from 'worksection_get_project_folders' by focusing on project details rather than folders.

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

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

The description implies usage context by stating 'by its ID', suggesting this tool is for retrieving details of a known project. However, it does not explicitly state when to use this vs. alternatives like 'worksection_get_projects' (for listing projects) or 'worksection_get_task' (for task details), nor does it mention prerequisites or exclusions.

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

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

Annotations already cover key behaviors (read-only, non-destructive, idempotent, open-world), so the description adds minimal value by specifying the return format ('List of folders with id and name'). It doesn't disclose additional traits like pagination, error handling, or authentication needs, but doesn't contradict annotations either.

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 action and resource, followed by a concise note on returns. Both sentences earn their place by providing essential information without redundancy, making it efficient and well-structured.

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

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

Given the tool's simplicity (0 parameters, no output schema) and rich annotations, the description is mostly complete. It covers purpose and return format, but could improve by clarifying scope relative to siblings or adding usage context, though not critical for this low-complexity 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?

With 0 parameters and 100% schema description coverage, the baseline is high. The description doesn't need to explain parameters, and it correctly notes there are no inputs, so it adequately compensates by focusing on the output.

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 project folders (groups) in the Worksection account'), making the purpose specific. However, it doesn't explicitly differentiate from sibling tools like 'worksection_get_projects' or 'worksection_get_tasks', which could 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?

No guidance is provided on when to use this tool versus alternatives. With siblings like 'worksection_get_projects' and 'worksection_get_tasks', the description lacks context about whether this is for high-level folder navigation or specific project details, 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?

Annotations already declare readOnlyHint=true, destructiveHint=false, idempotentHint=true, and openWorldHint=true, covering safety and idempotency. The description adds context about optional filtering and extra data inclusion, which is useful behavioral detail beyond annotations. No contradiction with annotations.

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

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

The description is front-loaded with the core purpose, followed by Args and Returns sections. It's appropriately sized with no wasted sentences, though the Args section slightly repeats schema info.

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 (list operation), rich annotations, and 100% schema coverage, the description is mostly complete. It lacks output schema but describes return values. Could improve by mentioning pagination or limits, but adequate for 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 both parameters well-documented in the schema. The description's Args section repeats schema info but adds minimal extra meaning (e.g., listing specific extra options). 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 'List' and resource 'all projects in the Worksection account' with optional filtering. It distinguishes from sibling tools like worksection_get_project (singular) and worksection_get_project_folders by specifying it returns all projects, not just one or folders.

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 listing projects with optional status filtering, but doesn't explicitly state when to use this vs. alternatives like worksection_get_project (for a single project) or worksection_search_tasks (for task-specific queries). No explicit exclusions or prerequisites are provided.

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

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

Annotations already indicate read-only, non-destructive, idempotent, and open-world behavior, so the description does not need to repeat these. It adds valuable context by specifying that it returns 'List of tags with id and name', which clarifies the output format beyond annotations. No contradictions with annotations are present.

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

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

The description is front-loaded with the core purpose in the first sentence, followed by concise 'Args' and 'Returns' sections that add necessary details without waste. Every sentence earns its place by clarifying usage and output, making it efficient and well-structured.

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

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

Given the tool's low complexity (one optional parameter), rich annotations (covering safety and behavior), and no output schema, the description is mostly complete. It explains the purpose, parameter usage, and return format. However, it could improve by mentioning pagination or rate limits, though annotations hint at open-world 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?

The schema description coverage is 100%, with the parameter 'type' fully documented in the schema as an enum for 'project' or 'task'. The description adds minimal value by restating this as 'project' for project tags, 'task' for task tags, and noting it defaults to both, but does not provide additional semantics beyond 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 available tags (labels/statuses) for projects or tasks', making the purpose specific and actionable. It distinguishes itself from siblings like worksection_set_task_tags (which sets tags) and worksection_get_projects/tasks (which retrieve projects/tasks, not tags), avoiding redundancy.

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

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

The description provides clear context by specifying that it retrieves tags for 'projects or tasks', and the optional 'type' parameter allows filtering. However, it does not explicitly state when to use this tool versus alternatives (e.g., no mention of using worksection_get_project or worksection_get_task for tag info within those resources), so it lacks explicit exclusions or named alternatives.

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

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

Annotations already provide readOnlyHint=true, destructiveHint=false, idempotentHint=true, and openWorldHint=true, covering safety and idempotency. The description adds context about what details are returned (description, subtasks, files, relations) and mentions the 'extra' parameter for additional data, which provides useful behavioral information beyond annotations.

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

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

The description is efficiently structured with a clear purpose statement, parameter explanations, and return value summary in just three sentences. Every sentence adds value without redundancy, and it's appropriately front-loaded with the core functionality.

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

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

For a read-only tool with comprehensive annotations and good schema coverage, the description provides adequate context. It explains what details are returned and parameter usage. The main gap is no output schema, but the description partially compensates by listing return elements. Slightly more detail on response structure would make it 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?

With 100% schema description coverage, the schema already documents both parameters. The description adds marginal value by listing examples of what 'extra' can include ('text', 'html', 'files', etc.) and clarifying that id_task is for a 'specific task', but doesn't provide format details or constraints beyond the schema.

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

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

The description clearly states the verb 'Get' and resource 'detailed information about a specific task', distinguishing it from siblings like worksection_get_all_tasks (list) and worksection_get_tasks (likely filtered list). It specifies retrieving details for a specific task rather than multiple tasks.

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

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

The description implies usage when detailed information about a specific task is needed, but doesn't explicitly state when to use this vs. alternatives like worksection_get_tasks or worksection_search_tasks. It provides clear context (specific task details) but lacks explicit exclusions or named alternatives.

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

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

Annotations already declare readOnlyHint=true, destructiveHint=false, idempotentHint=true, and openWorldHint=true, covering safety and idempotency. The description adds valuable context about what 'full details' means through the 'extra' parameter explanation, which clarifies behavioral aspects of data retrieval beyond what annotations provide.

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

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

The description is well-structured with a clear purpose statement followed by parameter details and return information. It's appropriately sized for a 3-parameter tool, though the parameter explanations could be more integrated rather than listed separately. Every sentence adds value 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 moderate complexity, rich annotations covering safety and behavior, and no output schema, the description is mostly complete. It explains the purpose, parameters, and return format adequately. However, it lacks explicit guidance on error handling or pagination, which could be relevant for a list 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?

With 100% schema description coverage, the input schema already documents all parameters thoroughly. The description repeats the parameter explanations verbatim without adding new semantic context, such as format examples for 'id_project' or practical use cases for 'extra' options. It meets the baseline but doesn't enhance 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 specific action ('Get all tasks') and resource ('for a specific Worksection project'), distinguishing it from siblings like worksection_get_all_tasks (no project filter) and worksection_get_task (single task). 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 implies usage context by specifying 'for a specific Worksection project,' but doesn't explicitly state when to use this tool versus alternatives like worksection_search_tasks or worksection_get_all_tasks. No guidance on prerequisites or exclusions is provided, leaving the agent to infer appropriate usage 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?

Annotations already indicate this is a non-readOnly, non-destructive, non-idempotent, open-world operation. The description adds useful context about the optional 'todo' parameter creating checkboxes and the default email behavior, which aren't covered by annotations. However, it doesn't disclose rate limits, authentication needs, or error conditions beyond what annotations provide.

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

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

The description is front-loaded with the core purpose in the first sentence, followed by a structured Args/Returns section that efficiently covers key details without redundancy. Every sentence adds value, and there's no wasted verbiage 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 mutation tool with no output schema, the description adequately covers the action, parameters, and return mention ('Created comment data'), but lacks details on response format, error handling, or side effects. Given the annotations provide safety context and schema covers parameters well, it's mostly complete but could benefit from more behavioral disclosure.

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 parameters thoroughly. The description adds minimal value by briefly explaining the 'todo' parameter's effect (creates checkboxes) and the default for 'email_user_from', but doesn't provide additional syntax, format details, or constraints beyond 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 Worksection task'), distinguishing it from sibling tools like worksection_get_comments (which retrieves comments) and worksection_complete_task (which modifies task status). 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 implies usage context (when you need to add a comment to a task) but provides no explicit guidance on when to use this tool versus alternatives like worksection_update_task (which might also allow commenting) or prerequisites. It mentions the default behavior for email_user_from but doesn't specify when to override 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?

The description adds minimal behavioral context beyond annotations. Annotations already indicate this is a mutation (readOnlyHint: false), non-destructive (destructiveHint: false), idempotent (idempotentHint: true), and open-world (openWorldHint: true). The description only states it reopens tasks and returns confirmation, without adding details about permissions needed, rate limits, or what 'confirmation' 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 sized with two sentences: one stating the purpose and one documenting parameters/return. However, the parameter documentation is redundant with the schema, and the structure could be more front-loaded by integrating parameter information more efficiently.

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

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

Given the tool's moderate complexity (state-changing operation), rich annotations, and complete schema coverage, the description is minimally adequate. However, with no output schema, the description should provide more detail about what 'Confirmation' contains (e.g., success status, updated task object, error details). The current description leaves return values underspecified.

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 input schema already fully documents the single parameter (id_task). The description repeats the parameter documentation verbatim ('Task ID to reopen'), adding no additional semantic meaning beyond what's in the schema. 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 specific action ('Reopen') and target resource ('a previously completed task'), distinguishing it from sibling tools like worksection_complete_task (which does the opposite) and worksection_update_task (which modifies task properties). 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 provides clear context for when to use this tool ('previously completed task'), but doesn't explicitly mention when NOT to use it or name specific alternatives. It implies usage for reversing task completion status, but lacks explicit exclusions like using it on already-open tasks.

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

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

Annotations already provide readOnlyHint=true, destructiveHint=false, idempotentHint=true, and openWorldHint=true, covering safety and behavior aspects. The description adds value by specifying it returns a list of matching tasks and mentions optional filtering, but doesn't disclose additional behavioral traits like rate limits, authentication needs, or pagination. With annotations present, the bar is lower, and the description adds some useful context without contradicting annotations.

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

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

The description is appropriately sized with a clear opening sentence followed by a structured Args section. It avoids unnecessary verbosity, and each sentence serves a purpose, such as explaining the tool's function and detailing parameters. However, the Args section could be more integrated into the flow rather than listed separately, slightly affecting structure.

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

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

Given the tool's complexity (7 optional parameters, no output schema), the description is reasonably complete. It covers the purpose, parameters, and return type. With annotations providing safety and behavioral hints, and schema coverage at 100%, the description adequately supports agent usage. It could improve by addressing sibling differentiation or output details, but it meets most contextual needs 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 all parameters well-documented in the input schema. The description's Args section repeats much of this information (e.g., filter for 'active', date formats as YYYY-MM-DD), adding minimal extra meaning. It does clarify that 'text' searches in both title and description, which slightly enhances understanding, but overall, the schema carries the heavy lifting, justifying a 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 clearly states the tool searches for tasks across the account using various criteria, which is a specific verb+resource combination. It distinguishes from siblings like worksection_get_all_tasks by mentioning filtering capabilities, though not explicitly naming alternatives. The purpose is well-defined but could be more precise about 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 implies usage through the mention of 'various criteria' and parameter explanations, suggesting when to apply filters. However, it lacks explicit guidance on when to choose this tool over siblings like worksection_get_all_tasks or worksection_get_tasks, and provides no exclusions or prerequisites. Usage is contextually implied but not clearly articulated.

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 cover key behavioral traits (non-readOnly, non-destructive, idempotent, openWorld), so the description's burden is lower. It adds minimal context by specifying the return ('Confirmation') but doesn't elaborate on side effects, error conditions, or how tags interact with existing ones. No contradiction with annotations exists.

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

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

The description is appropriately sized and front-loaded with the core purpose, followed by a structured 'Args' and 'Returns' section. However, the 'Args' section is redundant with the schema, slightly reducing efficiency, but overall it remains clear 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 the tool's moderate complexity (mutation with two parameters), rich annotations, and 100% schema coverage, the description is minimally adequate. It lacks output schema, so the 'Confirmation' return is vague, and it doesn't address potential conflicts or prerequisites, leaving some contextual gaps for 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?

Schema description coverage is 100%, with clear documentation of both parameters in the input schema. The description repeats this information in the 'Args' section without adding meaningful semantics beyond what's already structured, such as tag format examples 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 action ('Set tags') and resource ('on a Worksection task'), making the purpose immediately understandable. However, it doesn't explicitly differentiate from sibling tools like 'worksection_update_task' which might also handle tags, though the specificity of 'tags (labels/statuses)' helps somewhat.

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. With sibling tools like 'worksection_update_task' that might overlap in functionality, the description doesn't specify if this is the exclusive or preferred method for tag management, 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?

The description adds valuable behavioral context beyond annotations: 'Only provided fields will be updated' clarifies partial update behavior, which isn't covered by annotations. Annotations already indicate this is a non-destructive, idempotent mutation (readOnlyHint=false, destructiveHint=false, idempotentHint=true), so the description doesn't need to repeat safety aspects. It provides useful operational detail without contradictions.

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 details and return information. It's appropriately sized for a 6-parameter update tool. However, the Args section is somewhat redundant with the schema, slightly reducing efficiency.

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 an update tool with good annotations (covering safety and idempotency) and full parameter documentation in the schema, the description provides adequate context. It explains the partial update behavior and return value. The main gap is lack of output schema, but the description mentions 'Returns: Updated project data,' which helps somewhat.

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 all parameters. The description's Args section repeats parameter information but doesn't add meaningful semantics beyond what's in the schema (e.g., explaining relationships between parameters or edge cases). 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 ('Update an existing Worksection project') and resource ('Worksection project'), distinguishing it from sibling tools like worksection_create_project (creation) and worksection_get_project (retrieval). The verb 'update' is precise and differentiates this mutation operation from other project-related 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 implies usage context through 'Only provided fields will be updated,' suggesting partial updates are allowed. However, it doesn't explicitly state when to use this tool versus alternatives like worksection_archive_project or worksection_activate_project, nor does it mention prerequisites (e.g., needing an existing project ID). The guidance is present but incomplete.

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 cover key traits (readOnlyHint=false, destructiveHint=false, idempotentHint=true, openWorldHint=true), but the description adds valuable context: 'Only provided fields will be changed' clarifies partial update behavior, which isn't captured in annotations. It doesn't disclose rate limits, authentication needs, or error handling, but the added behavioral detail is helpful beyond the structured data.

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

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

The description is front-loaded with the core purpose ('Update an existing task. Only provided fields will be changed.'), but the 'Args' section is redundant with the schema, adding bulk without new value. It could be more concise by omitting the parameter list or integrating it more efficiently. The structure is clear but includes unnecessary repetition.

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

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

Given the tool's complexity (9 parameters, mutation operation) and rich annotations, the description is adequate but has gaps. It explains partial update behavior and lists parameters, but lacks output details (no schema provided), error scenarios, or permissions. With annotations covering safety and idempotency, it's minimally viable but could better address mutation-specific concerns like validation or side effects.

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 parameters thoroughly (e.g., 'id_task' as 'Task ID to update', 'priority' as 'New priority 0-10'). The description repeats this information in the 'Args' section without adding new meaning, such as format examples beyond YYYY-MM-DD for dates or units for 'max_time'/'max_money'. 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 ('Update') and resource ('existing task'), making the purpose unambiguous. It distinguishes from sibling tools like 'worksection_create_task' (creation vs. update) and 'worksection_complete_task' (completion vs. update), though it doesn't explicitly contrast with 'worksection_update_project' (task vs. project). The description is specific but could be slightly more differentiated from other update 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. It doesn't mention prerequisites (e.g., task must exist), contrast with sibling tools like 'worksection_set_task_tags' for tag-specific updates, or specify scenarios where this is appropriate (e.g., partial updates vs. full replacements). Usage is implied by the tool name 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.