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

Annotations already indicate this is a non-destructive, non-read-only, non-idempotent operation. The description adds valuable context about what gets created (new tasks with specific attributes) and the confirmation message format, though it doesn't mention 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?

Well-structured with clear sections (purpose, usage, Args, Returns, Examples) and front-loaded information. The examples are helpful but somewhat lengthy; every sentence earns its place by providing concrete guidance.

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, 0% schema description coverage, and presence of an output schema, the description provides complete context. It explains what the tool does, how to use parameters, what to expect in return, and includes multiple examples covering common use cases.

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

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

With 0% schema description coverage, the description fully compensates by explaining all parameter semantics through examples and the Args/Returns sections. It clarifies what each optional field means (project, priority, due date, tags) and provides concrete usage examples that add meaning beyond the bare schema.

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

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

The description clearly states the specific action ('Create a new task in Taskwarrior') and resource ('task'), distinguishing it from siblings like modify, delete, or list. It explicitly identifies what the tool does beyond just the name.

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

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

The description provides implied usage guidance ('Use this tool to add new tasks') and mentions optional attributes, but doesn't explicitly state when to use this vs alternatives like taskwarrior_modify or taskwarrior_annotate. No clear 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 provide key behavioral information: readOnlyHint=false (mutation), destructiveHint=false (non-destructive). The description adds that this adds notes/comments/context, which aligns with annotations. However, it doesn't disclose additional behavioral traits like whether annotations are editable, if there are rate limits, or authentication requirements beyond what annotations cover.

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 purpose statement, usage guidance, args/returns sections, and an example. It's appropriately sized at 4 sentences plus structured elements. Some redundancy exists (e.g., 'Add an annotation' then 'add notes'), but overall it's efficient and front-loaded with the core purpose.

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

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

Given a mutation tool with annotations covering safety (non-destructive, non-readonly), an output schema exists (returns confirmation message), and the description provides adequate parameter context, the description is reasonably complete. It could improve by mentioning sibling relationships more explicitly, but it covers the essential context for this tool's complexity.

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

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

Schema description coverage is 0%, but the description compensates by explaining that 'params' contains 'task_id and annotation text' and provides an example. However, it doesn't fully explain parameter semantics beyond what the example shows, such as format constraints for task_id or annotation length limits mentioned in the schema. Baseline 3 is appropriate given partial compensation.

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: 'Add an annotation (note) to a task' with the verb 'add' and resource 'task'. It distinguishes from siblings like 'taskwarrior_modify' by focusing specifically on annotations rather than general task updates. However, it doesn't explicitly contrast with all siblings, keeping it at 4 rather than 5.

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

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

The description provides implied usage guidance: 'Use this tool to add notes, comments, or additional context to a task.' This suggests when to use it but doesn't explicitly state when NOT to use it or name alternatives like 'taskwarrior_modify' for other task modifications. The guidance is helpful but not comprehensive.

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 idempotentHint=true (safe to retry) and destructiveHint=false (non-destructive), which the description doesn't contradict. The description adds useful context about what the tool does (marks as done) and provides examples, but doesn't mention potential side effects like timestamp updates or status changes beyond completion. 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?

Well-structured with clear sections (description, usage, args, returns, examples). Every sentence adds value: the first states the purpose, the second provides usage guidelines, and the rest clarify parameters and outputs with minimal waste. Front-loaded with the core action.

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

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

Given the tool's moderate complexity (single parameter, idempotent operation) and the presence of an output schema (returns confirmation message), the description is complete. It covers purpose, usage, parameters with examples, and return expectations, aligning well with annotations and sibling tools.

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

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

Schema description coverage is 0%, but the description compensates by explaining the parameter in the Args section ('CompleteTaskInput containing the task_id to complete') and providing examples with both numeric IDs and UUIDs. However, it doesn't add detailed semantics beyond what the schema's property name and examples imply, keeping it at baseline level.

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 identifies the resource ('task'), distinguishing it from siblings like taskwarrior_delete (remove) or taskwarrior_modify (edit). 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?

Explicitly states when to use this tool ('when a task has been finished and should be marked as done'), providing clear context. It distinguishes from alternatives by focusing on completion rather than deletion, modification, or other states (e.g., taskwarrior_start/stop for active 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 indicate destructiveHint=true and idempotentHint=true, but the description adds valuable context beyond this: it clarifies that deletion is reversible via 'undo' (important behavioral trait) and that tasks are 'marked as deleted' rather than permanently erased. This enhances understanding 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 well-structured and front-loaded with the core purpose, followed by usage notes, parameter explanation, and an example. Every sentence adds value without redundancy, making it efficient and easy to parse for an AI agent.

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 (destructive operation with recovery), rich annotations (e.g., destructiveHint, idempotentHint), and the presence of an output schema (implied by 'Returns: Confirmation message'), the description is complete. It covers purpose, usage, behavioral nuances, and parameters adequately without needing to detail return values.

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

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

Schema description coverage is 0%, but the description compensates by explaining the parameter in the 'Args' section and providing an example ('task_id="5"'). However, it doesn't add deep semantic meaning beyond what's implied by the schema (e.g., format details or constraints), so it meets the baseline for adequate but not exceptional 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 ('Delete a task from Taskwarrior') and distinguishes it from siblings like 'taskwarrior_complete' or 'taskwarrior_modify' by specifying it's for removal rather than status changes or edits. 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 ('to remove a task') and mentions recovery via 'undo', which implicitly references the sibling 'taskwarrior_undo'. However, it doesn't explicitly state when not to use it (e.g., vs. 'taskwarrior_complete' for marking done) or name alternatives, keeping it from a perfect score.

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

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

The annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false, indicating safe, repeatable read operations. The description adds useful context beyond this: it specifies the tool returns 'detailed information' and supports multiple output formats (markdown/JSON), which clarifies behavioral traits not covered by 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 well-structured and appropriately sized, with a clear purpose statement, usage guideline, parameter explanation, and examples. Each sentence adds value, and it's front-loaded with key information. Minor room for improvement in brevity, but overall 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 (single-task retrieval), rich annotations (covering safety and idempotency), and the presence of an output schema (implied by 'Returns' statement), the description is mostly complete. It explains the purpose, usage, parameters, and output formats adequately, though it could benefit from more explicit sibling tool differentiation.

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

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

The schema description coverage is 0%, but the description compensates by explaining the 'params' input containing 'task_id' and 'response_format', with examples for usage. It adds meaning beyond the bare schema, such as clarifying that 'task_id' can be an ID or UUID and describing the output format options. However, it doesn't fully detail all parameter nuances, so it meets the baseline for partial compensation.

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 detailed information about a specific task' and 'view all attributes and annotations of a single task.' This specifies the verb ('get/view') and resource ('task'), but doesn't explicitly differentiate it from sibling tools like 'taskwarrior_list' or 'taskwarrior_summary' beyond focusing on a single 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?

The description provides clear context: 'Use this tool to view all attributes and annotations of a single task.' This implies usage for detailed, individual task retrieval rather than listing or summarizing multiple tasks. However, it doesn't explicitly state when not to use it or name alternatives like 'taskwarrior_list' for multiple 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, and idempotentHint=true, indicating safe, non-destructive read operations. The description adds valuable context beyond annotations: it mentions support for 'powerful querying' with Taskwarrior filter expressions and describes the return format options (markdown or JSON). 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 well-structured with a purpose statement, usage guidelines, parameter summary, and examples. It's appropriately sized for a tool with multiple parameters and examples. However, the 'Args' and 'Returns' sections are somewhat redundant given the detailed 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?

Given the tool's complexity (filtering capabilities), rich input schema with full coverage, annotations covering safety, and an output schema (implied by response_format), the description is complete. It explains the tool's purpose, provides usage examples, and clarifies output formatting, leaving no significant gaps for agent understanding.

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

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

The input schema has 100% description coverage (all parameters are well-documented with descriptions, defaults, and constraints), so the baseline is 3. The description's 'Args' section repeats the parameter name but adds minimal value beyond the schema. The examples provide helpful semantic context for filter usage, but this doesn't significantly elevate the score above baseline.

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

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

The description clearly states the tool's purpose with specific verbs ('list tasks', 'view tasks', 'search for specific tasks', 'get an overview') and identifies the resource ('from Taskwarrior'). It distinguishes this tool from siblings like taskwarrior_add, taskwarrior_complete, etc., by focusing on listing/filtering rather than creating or modifying 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 provides clear context for when to use this tool ('to view tasks, search for specific tasks, or get an overview of pending work'), including specific examples like listing pending tasks or tasks for a project. However, it doesn't explicitly state when NOT to use it or name alternatives among siblings (e.g., taskwarrior_summary for aggregated views).

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

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

Annotations indicate readOnlyHint=false (mutation), idempotentHint=true (safe to retry), and destructiveHint=false (non-destructive). The description adds value by specifying that it modifies 'existing' tasks and provides examples of behavioral details like using empty strings to remove values (e.g., due='') and how to handle tags without prefixes. It does not contradict annotations and enriches the context beyond them.

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, usage guidelines, args/returns sections, and multiple examples. Each sentence earns its place by providing essential information without redundancy, and it is 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?

Given the tool's complexity (mutation with multiple attributes), low schema coverage (0%), and presence of an output schema (returns confirmation message), the description is complete. It covers purpose, usage, parameters with examples, and behavioral details, leaving output specifics to the schema. No gaps are evident 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?

Schema description coverage is 0%, so the description carries full burden. It compensates by listing key parameters (task_id, description, project, priority, due, add_tags) in the description and examples, explaining semantics like 'use empty string to remove' for project and due, and priority values (H, M, L). This adds significant meaning beyond the bare schema.

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

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

The description clearly states the verb ('Modify') and resource ('an existing task's attributes'), distinguishing it from siblings like taskwarrior_add (create), taskwarrior_delete (remove), or taskwarrior_complete (mark as done). It specifies what can be updated (description, project, priority, due date, or tags), making the purpose specific and differentiated.

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 'Use this tool to update...' and lists specific attributes, providing clear context for when to use it. However, it does not mention when not to use it or name alternatives (e.g., taskwarrior_delete for removal, taskwarrior_annotate for adding notes), so it lacks explicit exclusions or sibling comparisons.

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=false, covering safety and idempotency. The description adds value by mentioning the return format options and that it includes task counts, which are behavioral details beyond annotations. However, it doesn't elaborate on potential limitations like pagination 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 clear sections (purpose, usage, args, returns, examples) and front-loaded with the core function. Each sentence adds value, but the 'Args' and 'Returns' sections could be slightly more concise by integrating information, and the example is somewhat redundant with the args explanation.

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 with enum), rich annotations covering safety and behavior, and the presence of an output schema (implied by 'Returns' reference), the description is complete enough. It explains the tool's purpose, usage, parameters, and output format adequately without needing to duplicate structured data.

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

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

With 0% schema description coverage, the schema provides no parameter documentation. The description compensates by explaining the 'response_format' parameter in the Args and Examples sections, specifying the two enum values and their purposes. This adds meaningful semantics, though it doesn't fully detail the 'params' wrapper structure beyond referencing ListProjectsInput.

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 ('List all projects') and resource ('in Taskwarrior'), distinguishing it from sibling tools like taskwarrior_list (general listing) or taskwarrior_tags (different resource). The first sentence directly communicates the tool's function 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 provides clear context for when to use this tool ('to see all projects and the number of tasks in each'), which implicitly differentiates it from other listing tools. However, it doesn't explicitly state when NOT to use it or name specific alternatives among the siblings, preventing a perfect score.

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

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

Annotations cover key traits (readOnlyHint=false, idempotentHint=true, destructiveHint=false), so the description adds value by explaining the 'active' state effect. However, it doesn't disclose additional behaviors like error conditions, permissions needed, or how it interacts with other tools (e.g., if starting an already active task). 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?

Well-structured with clear sections (description, args, returns, examples) and front-loaded purpose. Slightly verbose in the example section, but overall efficient with no redundant information.

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

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

Given the tool's moderate complexity (state change operation), annotations provide safety profile, and output schema exists (implied by 'Returns'), the description is reasonably complete. It covers purpose, parameter usage, and example, though could improve on error handling or sibling tool context.

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

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

Schema description coverage is 0%, but the description compensates by specifying the parameter as 'task_id to start' and providing an example. It adds meaning beyond the schema's minimal documentation, though it doesn't detail format constraints (e.g., UUID vs. numeric ID) or validation rules. Baseline adjusted upward due to compensation.

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 ('Start working on') and resource ('a task'), specifying that it adds the 'active' state to the task. However, it doesn't explicitly differentiate from siblings like 'taskwarrior_modify' or 'taskwarrior_annotate' which might also affect task states, 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?

It provides implied usage ('Use this tool to indicate you're actively working on a task'), but lacks explicit guidance on when to use this vs. alternatives like 'taskwarrior_modify' for state changes or 'taskwarrior_stop' for ending work. 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?

The description adds context beyond annotations: it clarifies that stopping indicates 'paused work,' which isn't covered by annotations like idempotentHint or destructiveHint. Annotations already indicate it's not read-only, not destructive, and idempotent, but the description usefully explains the behavioral intent. 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 well-structured and front-loaded with the core purpose, followed by sections for Args, Returns, and Examples. Each sentence adds value without redundancy, making it efficient and easy to scan.

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 (1 parameter, annotations provided, output schema exists), the description is fairly complete. It explains the purpose, usage, and parameters, and since an output schema exists, it doesn't need to detail return values. However, it could be more comprehensive on parameter details given the 0% schema coverage.

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

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

Schema description coverage is 0%, so the description must compensate. It mentions 'params: StopTaskInput containing the task_id to stop' and provides an example with 'task_id="5",' adding some meaning. However, it doesn't fully detail parameter semantics like format constraints or what 'task_id' entails beyond the schema's basic type, leaving gaps.

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

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

The description clearly states the tool's purpose with a specific verb ('Stop') and resource ('working on a task'), making it easy to understand. However, it doesn't explicitly differentiate from sibling tools like 'taskwarrior_start' or 'taskwarrior_pause' (if such a tool existed), which would require more specific context about what 'stop' means in this system.

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 guidance by stating 'Use this tool to indicate you've paused work on a task,' which suggests when to use it. However, it lacks explicit alternatives (e.g., when to use 'complete' or 'delete' instead) or exclusions, leaving some ambiguity compared to sibling tools.

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

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

Annotations already provide readOnlyHint=true, destructiveHint=false, idempotentHint=true, and openWorldHint=false, covering safety and idempotency. The description adds useful context beyond this: it specifies the scope ('pending tasks') and the types of statistics ('counts by project, priority, and urgency'), which helps the agent understand what data to expect. 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 well-structured and concise: three sentences that efficiently state the purpose, usage, and return value. Every sentence adds value without redundancy, and it's front-loaded with the core functionality. 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 (0 parameters, read-only, idempotent), rich annotations (covering safety and behavior), and the presence of an output schema (which handles return values), the description is complete enough. It adds necessary context about the summary's content (pending tasks, counts by categories) without needing to detail outputs or parameters.

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

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

The tool has 0 parameters, and schema description coverage is 100% (though empty). With no parameters, the baseline is 4, as there's nothing for the description to compensate for. The description appropriately doesn't discuss parameters, focusing instead on the tool's output and usage.

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 a summary of task statistics' and specifies it provides 'an overview of pending tasks, including counts by project, priority, and urgency.' This is specific (verb+resource+scope) and distinguishes it from siblings like taskwarrior_list (which likely lists individual tasks) or taskwarrior_projects (which likely lists projects). However, it doesn't explicitly contrast with all siblings, so it's not a perfect 5.

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

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

The description provides implied usage guidance: 'Use this tool to get an overview of pending tasks...' This suggests when to use it (for summary statistics rather than detailed lists). However, it doesn't explicitly state when NOT to use it or name specific alternatives (e.g., 'use taskwarrior_list for detailed task information'), which would be needed for a higher score.

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

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

Annotations already indicate this is a read-only, non-destructive, idempotent operation with a closed world. The description adds useful context about what information is returned (tags with usage counts) and provides an example, but does not disclose additional behavioral traits like 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 with clear sections (purpose, usage, args, returns, example) and avoids redundant information. Every sentence adds value, though the example could be slightly more informative about format differences.

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

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

Given the tool's low complexity (1 parameter), rich annotations covering safety and behavior, and the presence of an output schema, the description is sufficiently complete. It explains the tool's purpose, usage, parameter role, and return format, though it could briefly mention the output schema's existence for clarity.

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

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

With 0% schema description coverage for the single parameter, the description compensates by explaining the parameter's purpose ('response_format') in the Args and Returns sections, and provides an example showing its usage. However, it does not detail the specific effects of choosing 'markdown' vs 'json' formats beyond general descriptions.

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

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

The description clearly states the specific action ('List all tags') and resource ('used in Taskwarrior'), distinguishing it from sibling tools like taskwarrior_projects or taskwarrior_list. It explicitly mentions the output includes usage counts, which differentiates it from a simple tag listing.

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 ('to see all tags and how many tasks use each tag'), but does not explicitly mention when not to use it or name specific alternatives among siblings. The example reinforces the primary use case without comparative guidance.

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

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

The description adds valuable behavioral context beyond annotations: it specifies that it only undoes the 'most recent change' and provides an example of usage. Annotations already cover the safety profile (destructiveHint=false, readOnlyHint=false), but the description enhances understanding of the tool's specific scope and limitations.

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 clear sections (purpose, usage, args, returns, examples) and wastes no words. Every sentence adds value, though the 'Args' and 'Returns' sections could be slightly more detailed given the simple nature of this 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?

For a simple undo operation with good annotations and an output schema, the description is nearly complete. It explains what the tool does, when to use it, parameter requirements, and provides an example. The only minor gap is not explicitly stating what constitutes a 'change' or potential limitations beyond the most recent one.

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

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

With 0% schema description coverage and only one parameter (params of type UndoInput with no properties), the description compensates well by stating 'no parameters needed' in the Args section. This clarifies what might otherwise be confusing about an empty parameter object, though it doesn't explain why the parameter structure exists.

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 ('undo') and target resource ('last Taskwarrior operation'), distinguishing it from siblings like taskwarrior_modify or taskwarrior_delete. It provides a precise verb+resource combination that leaves no ambiguity about what the tool does.

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

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

The description explicitly states when to use this tool ('to revert the most recent change to tasks') and implies when not to use it (only for the last operation, not for selective undo). While it doesn't name specific alternatives, the context of sibling tools makes it clear this is for reversal operations.

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