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

With no annotations provided, the description carries full burden. It discloses the mutation behavior ('Updates the task's status') and timestamp setting, but lacks details on permissions, side effects, error conditions, or response format, leaving significant gaps for a mutation tool.

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

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

The description is efficiently structured in two sentences: the first states purpose and prerequisites, the second details behavioral effects. Every sentence adds value with zero waste, making it front-loaded and appropriately sized.

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 but lacks crucial context like error handling, permissions, return values, or how it differs from sibling tools, leaving the agent under-informed.

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 adds no additional meaning beyond implying both IDs are required, matching the schema. Baseline 3 is appropriate when schema does the heavy lifting.

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

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

The description clearly states the specific action ('Mark a task as completed') and resource ('task'), distinguishing it from siblings like 'update_task' or 'delete_task' by focusing on completion status changes rather than general updates or deletions.

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_task' for partial updates or 'delete_task' for removal. It mentions required parameters but offers no context about appropriate 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?

With no annotations provided, the description carries full burden for behavioral disclosure. It mentions the creation action and return of details, but doesn't address permissions needed, whether this is idempotent, rate limits, error conditions, or what format the 'created project details' will be in. 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 appropriately sized with three concise sentences that each serve a purpose: stating the action, listing optional parameters, and describing the return. It's front-loaded with the core purpose. Minor improvement could be made by combining the second and third sentences for even tighter 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?

For a creation tool with 5 parameters, 100% schema coverage, but no annotations and no output schema, the description does an adequate job. It covers the basic action and parameters but lacks depth on behavioral aspects like error handling, authentication needs, or response format details that would be helpful given the mutation nature of the tool.

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

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

Schema description coverage is 100%, so the schema already fully documents all 5 parameters. The description adds minimal value by listing the optional parameters (color, view mode, kind, sort order) but doesn't provide additional semantic context beyond what's in the schema descriptions. 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 ('Create a new project'), target resource ('in Dida365'), and distinguishes it from siblings like 'update_project_by_projectID' or 'get_projects'. It uses a precise verb+resource combination 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 implied usage by stating 'Requires at least a project name', which suggests this is the primary tool for creating projects. However, it doesn't explicitly state when to use this versus alternatives like 'update_project_by_projectID' or provide any exclusion criteria or prerequisites beyond the name requirement.

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 creates a new task and returns details, but lacks information about authentication requirements, rate limits, error conditions, or whether the operation is idempotent. 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 appropriately sized with two sentences that efficiently convey the core functionality and requirements. It's front-loaded with the main purpose, though the parameter listing could be slightly more concise. Every sentence serves a purpose without obvious 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 this is a mutation tool with no annotations and no output schema, the description is moderately complete but has gaps. It covers the basic purpose and parameters but lacks details about authentication, error handling, and the structure of returned task details. The absence of output schema means the description should ideally explain return values more thoroughly.

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 5 parameters thoroughly. The description lists the parameters ('title, project ID, content, due date and priority') but doesn't add meaningful semantic context beyond what's in the schema descriptions. Baseline 3 is appropriate when schema does the heavy lifting.

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

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

The description clearly states the action ('Create a new task') and resource ('in Dida365'), specifying it will be created under a project. It distinguishes from siblings like 'create_project' by focusing on tasks, but doesn't explicitly differentiate from 'update_task' or other task-related tools beyond the creation aspect.

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 with specific details and mentions required parameters, but doesn't provide explicit guidance on when to use this versus alternatives like 'update_task' or 'complete_task'. It states 'Requires at least title and projectId', which gives some context but lacks comprehensive when/when-not instructions.

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. It discloses key behavioral traits: the operation is permanent, it cascades to delete all tasks within the project, and it returns a success message. However, it doesn't cover permissions, error conditions, or confirmation requirements.

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

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

Two sentences with zero waste: first states the action and consequences, second states the return. Front-loaded with the core purpose, appropriately sized for a single-parameter destructive operation.

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

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

For a destructive tool with no annotations and no output schema, the description covers the permanence and cascade effect adequately but lacks details on permissions, error handling, or what the success message contains. 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 100%, so the schema already documents the projectId parameter fully. The description doesn't add any meaning beyond what the schema provides, such as format examples or ID sourcing. Baseline 3 is appropriate when schema does the heavy lifting.

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

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

The description clearly states the specific action ('permanently delete'), the resource ('a project'), and the method ('by its ID'). It distinguishes from siblings like delete_task by specifying it deletes projects, not 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 needing to delete a project and its tasks, but doesn't explicitly state when to use this vs. alternatives like update_project_by_projectID or warn against accidental deletion. It mentions the cascade effect on tasks, which provides some context.

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

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

With no annotations provided, the description carries the full burden. It discloses key behavioral traits: the operation is permanent (destructive), requires confirmation via two IDs, and returns a success message. However, it lacks details on permissions, error handling, or side effects (e.g., impact on related 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 action, uses two efficient sentences with zero waste, and each sentence adds necessary information (purpose, requirements, and outcome). It is appropriately sized for a simple deletion tool.

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

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

Given the complexity (destructive operation with no annotations and no output schema), the description is adequate but has gaps. It covers the purpose, requirements, and outcome, but lacks details on permissions, error cases, or what the success message contains, which could be important for a 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 schema description coverage is 100%, so the schema already documents both parameters fully. The description adds minimal value beyond the schema by implying the parameters are for confirmation, but does not provide additional syntax or format details. 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 ('permanently delete'), the resource ('a task'), and the context ('from a project'), distinguishing it from siblings like 'complete_task' or 'delete_project_by_projectID' which target different resources or 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?

It provides clear context by specifying that both task ID and project ID are required for confirmation, which implies when to use it (when deleting a specific task within a project). However, it does not explicitly state when not to use it or name alternatives like 'complete_task' for non-destructive actions.

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 the return format ('project metadata including name, color, view mode, kind and sort order'), which is helpful, but doesn't address important behavioral aspects like error conditions (e.g., what happens if projectId is invalid), authentication requirements, rate limits, or whether this is a read-only operation (though implied by 'Get').

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 one detailing the return format. It's front-loaded with the core function. While efficient, it could be slightly more structured by explicitly separating purpose from output 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 simple read operation with 1 parameter and no output schema, the description is adequate but has gaps. It explains what information is returned, which compensates for the missing output schema, but doesn't cover error handling or behavioral constraints. Given the low complexity, it's minimally viable 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?

Schema description coverage is 100%, with the single parameter 'projectId' fully documented in the schema. The description adds no additional parameter semantics beyond what's in the schema (e.g., format examples, validation rules). This meets the baseline of 3 when schema coverage is high.

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 project by its ID', making the purpose unambiguous. It distinguishes from siblings like get_projects (which lists multiple projects) and get_task_by_projectId_and_taskId (which retrieves tasks). However, it doesn't explicitly contrast with these siblings in the text.

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_projects (for listing all projects) or get_task_by_projectId_and_taskId (for retrieving tasks within a project). It simply states what the tool does without contextual usage instructions.

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 discloses this is a read operation ('Retrieve') and returns specific fields, but lacks details on permissions, rate limits, pagination, or error behavior. For a list tool with zero annotation coverage, this is adequate but has 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?

Two sentences, front-loaded with the core purpose, followed by return details and parameter note. Every sentence earns its place with no waste or redundancy. 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 0 parameters, no output schema, and no annotations, the description is reasonably complete for a simple list tool. It states what it does, what it returns, and that no parameters are needed. However, it could benefit from more behavioral context (e.g., ordering, limits) to be fully 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 input schema has 0 parameters with 100% coverage, so the schema fully documents this. The description adds value by explicitly stating 'No parameters required,' which clarifies usage beyond the empty schema. Baseline for 0 params is 4, and this meets that with clear confirmation.

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 verb ('Retrieve') and resource ('list of all projects in the Dida365 account'), and distinguishes it from siblings like get_project_by_projectId (singular) and get_tasks_by_projectId (tasks). It explicitly mentions what details are returned (ID, name, color, view mode, sort order).

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: use this to get all projects, not filtered or single projects. It implies alternatives like get_project_by_projectId for specific projects, but doesn't explicitly name them or state when-not-to-use scenarios. The 'No parameters required' note helps guide 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 details and lists return fields (title, content, status, due date, priority, subtasks), but doesn't cover aspects like error handling (e.g., what happens if IDs are invalid), authentication needs, rate limits, or whether it's a read-only operation. The description adds some value by specifying return fields, but gaps remain for a tool with no annotation coverage.

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

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

The description is concise and well-structured: the first sentence states the purpose and required inputs, and the second sentence details the return information. Both sentences earn their place by providing essential context without redundancy or fluff.

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

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

Given no annotations, no output schema, and 2 parameters with full schema coverage, the description is moderately complete. It covers the purpose, inputs, and return fields, but lacks behavioral details (e.g., error handling, auth) and doesn't fully compensate for the absence of annotations. It's adequate for a simple retrieval tool 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 100%, with both parameters ('projectId' and 'taskId') clearly documented in the schema as required string IDs. The description adds minimal value beyond the schema by reiterating the need for both IDs but doesn't provide additional context like ID formats or examples. Baseline 3 is appropriate when the schema does the heavy lifting.

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

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

The description clearly states the tool's purpose: 'Retrieve a specific task's details by providing both the project ID and task ID.' It specifies the verb ('retrieve'), resource ('task's details'), and required identifiers. However, it doesn't explicitly differentiate from sibling tools like 'get_tasks_by_projectId' (which likely retrieves multiple tasks) or 'get_project_by_projectId' (which retrieves project details).

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

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

The description implies usage by stating 'by providing both the project ID and task ID,' suggesting it's for retrieving a single, specific task. However, it doesn't provide explicit guidance on when to use this tool versus alternatives like 'get_tasks_by_projectId' (for multiple tasks) or 'get_project_by_projectId' (for project 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?

No annotations are provided, so the description carries the full burden of behavioral disclosure. It states the tool returns 'a list of tasks with their basic information,' which hints at read-only behavior and output format, but lacks details on permissions, rate limits, pagination, error handling, or what 'basic information' entails. For a tool with no annotations, this leaves significant gaps in understanding its operational 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 concise and front-loaded, with two sentences that directly state the tool's purpose and utility. There is no wasted text, and each sentence adds value: the first defines the action, and the second provides usage context. However, it could be slightly more structured by explicitly separating purpose from guidelines.

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 (single parameter, no output schema, no annotations), the description is minimally adequate. It covers the basic purpose and hints at output, but lacks details on behavioral traits, error cases, or integration with sibling tools. Without annotations or output schema, more context on return values and operational limits would improve completeness for effective agent use.

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

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

The input schema has 100% description coverage, with the single parameter 'projectId' documented as 'The ID of the project whose tasks you want to list (required).' The description adds no additional semantic context beyond what the schema provides, such as format examples or constraints. With high schema coverage, the baseline score of 3 is appropriate, as the description does not compensate but also does not detract.

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

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

The description clearly states the tool's purpose: 'Get all tasks belonging to a specific project by project ID.' It specifies the verb ('Get'), resource ('tasks'), and scope ('belonging to a specific project'), but does not explicitly differentiate it from sibling tools like 'get_task_by_projectId_and_taskId' (which gets a single task) or 'get_projects' (which gets projects, not 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 context with 'Useful for viewing all tasks in a project,' suggesting it's for bulk task viewing within a project. However, it does not provide explicit guidance on when to use this tool versus alternatives like 'get_task_by_projectId_and_taskId' (for a single task) or 'complete_task' (for task completion), nor does it mention any exclusions or prerequisites.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It states that it 'Returns updated project details', which adds some context about output. However, it doesn't disclose critical behavioral traits such as permission requirements, whether changes are reversible, error handling, or side effects. For a mutation tool with zero annotation coverage, this is a significant gap.

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

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

The description is concise and front-loaded, with two sentences that efficiently convey the core functionality and return value. Every sentence earns its place, though it could be slightly more structured by separating prerequisites from actions. 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?

Given the complexity of a mutation tool with no annotations and no output schema, the description is incomplete. It lacks details on error conditions, authentication needs, rate limits, or what the 'updated project details' output entails. The description doesn't compensate for the absence of structured data, leaving gaps in understanding the tool's behavior.

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

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

Schema description coverage is 100%, so the schema already documents all parameters thoroughly. The description lists modifiable fields (name, color, view mode, kind, sort order), which aligns with the schema but doesn't add meaningful semantics beyond what's in the schema descriptions. The baseline score of 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 project's properties'), making the purpose evident. It specifies what can be modified (name, color, view mode, kind, sort order), which helps distinguish it from sibling tools like 'update_task'. However, it doesn't explicitly differentiate from other update operations beyond listing modifiable fields.

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

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

The description mentions 'Requires project ID', which is a prerequisite but not a usage guideline. It doesn't provide guidance on when to use this tool versus alternatives like 'update_task' or 'create_project', nor does it specify scenarios where this tool is appropriate or inappropriate. No explicit when/when-not/alternatives 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?

No annotations are provided, so the description carries full burden. It discloses that the tool modifies properties and returns updated details, but lacks critical behavioral traits: it doesn't mention authentication needs, rate limits, whether updates are partial or overwrite all fields, error handling, or side effects. For a mutation tool with zero annotation coverage, this is a significant gap in transparency.

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

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

The description is appropriately sized with three sentences: first states purpose and updatable fields, second specifies required parameter, third describes return value. It's front-loaded with key information and avoids redundancy, though it could be slightly more structured (e.g., bullet points for fields). Every sentence adds value, making 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 complexity (mutation tool with 6 parameters), no annotations, and no output schema, the description is incomplete. It lacks details on authentication, error cases, partial updates, and return format specifics. While it covers basic purpose and parameters, for a tool that modifies data, more behavioral and contextual information is needed to be fully helpful to 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%, so the schema fully documents all 6 parameters (e.g., taskId as required, priority as 0-5, status as 0/1). The description adds minimal value beyond the schema by listing updatable fields (title, content, etc.) and noting taskId is required, but doesn't provide additional syntax, constraints, or examples. Baseline 3 is appropriate when the schema does the heavy lifting.

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

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

The description clearly states the verb ('Modify') and resource ('existing task's properties'), specifying what fields can be updated (title, content, due date, priority, status). It distinguishes from sibling tools like 'create_task' (creation vs. modification) and 'delete_task' (deletion vs. update), though not explicitly named. The purpose is specific but could more directly contrast with 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 implies usage by stating 'At least taskId is required,' which suggests prerequisites, but does not explicitly say when to use this tool versus alternatives like 'complete_task' (which might update status) or 'update_project_by_projectID' (for project-level changes). No explicit when-not-to-use guidance or named alternatives are provided, leaving usage context somewhat inferred.

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