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

No annotations are provided, so the description carries the full burden. It states this is an 'Add' operation, implying a mutation, but doesn't disclose behavioral traits like required permissions, whether dependencies are unique or can be duplicated, what happens on conflicts, or if there are rate limits. The description adds minimal context beyond the basic action.

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

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

The description is appropriately sized and front-loaded: the first sentence states the core purpose, followed by a clarifying sentence on dependencies, and then specific usage guidance. Every sentence earns its place with 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 no annotations, no output schema, and 0% schema description coverage for a mutation tool with 3 parameters (including a nested object), the description is incomplete. It covers the basic action and parameter usage context but lacks details on behavioral traits, parameter specifics, and return values, leaving significant gaps for an agent to use it correctly.

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

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

Schema description coverage is 0%, so the description must compensate. It explains the semantics of 'taskId' vs. no 'taskId', which clarifies the optional parameter's role. However, it doesn't describe the 'dependency' object's fields (name, description, url, version) or 'requestId', leaving key parameters undocumented. The description adds some value but doesn't fully compensate for the coverage gap.

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

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

The description clearly states the action ('Add a dependency') and the target resources ('to a request or task'), with specific examples of what dependencies can be ('libraries, tools, or other requirements'). However, it doesn't explicitly differentiate from sibling tools like 'add_note' or 'add_subtasks' beyond the different resource type.

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

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

The description provides clear context on when to use this tool: 'If 'taskId' is provided, the dependency will be added to that specific task. Otherwise, it will be added to the request.' This gives explicit guidance on parameter usage, though it doesn't mention when not to use it or name specific alternatives among siblings.

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

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

With no annotations provided, the description carries full burden but lacks critical behavioral details. It mentions notes are displayed in task progress and can be referenced, but doesn't cover permissions, rate limits, whether notes are editable/deletable, or what happens on success/failure. This is inadequate 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 appropriately concise with two sentences that avoid redundancy. The first sentence states the purpose, and the second provides context about display and reference, though it could be more front-loaded with key details.

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

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

For a mutation tool with 3 parameters, 0% schema coverage, no annotations, and no output schema, the description is incomplete. It lacks details on parameters, behavioral traits, error handling, and output, leaving significant gaps for an AI agent to use it correctly.

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

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

Schema description coverage is 0%, so the description must compensate but adds no parameter-specific information. It doesn't explain what 'requestId', 'title', or 'content' represent, their formats, or constraints. The mention of 'important information about the project' vaguely relates to 'content' but is insufficient.

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

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

The description clearly states the action ('Add a note') and target resource ('to a request'), specifying that notes contain project information like user preferences or guidelines. It distinguishes from siblings like 'delete_note' and 'update_note' by focusing on creation, but could be more explicit 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 provides no guidance on when to use this tool versus alternatives such as 'update_note' or 'add_tasks_to_request', nor does it mention prerequisites like needing an existing request. It only implies usage through context about note content and display.

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 that this is a write operation ('Add'), mentions the outcome ('A progress table will be displayed showing the updated task with its subtasks'), and explains the relationship between subtasks and tasks ('All subtasks must be completed before a task can be marked as done'). However, it lacks details on permissions, error conditions, or whether this operation is idempotent, which are important 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 appropriately sized with four sentences that are front-loaded: the first sentence states the purpose and parameters, the second explains subtasks, the third adds context about task completion, and the fourth describes the output. There's minimal waste, though the second sentence could be slightly more concise.

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

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

Given the complexity (a mutation tool with 3 parameters, no annotations, and no output schema), the description is moderately complete. It covers the purpose, parameters at a high level, behavioral context (subtask-task relationship and output display), but lacks details on parameter formats, error handling, and exact return values. For a tool that modifies data without annotations, this leaves gaps in operational understanding.

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

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

Schema description coverage is 0%, so the description must compensate. It lists the required parameters ('requestId', 'taskId', and 'subtasks array') and explains that subtasks have 'title' and 'description' fields, which adds meaning beyond the schema. However, it doesn't clarify what 'requestId' and 'taskId' represent (e.g., their format or how to obtain them), leaving key parameters partially undocumented.

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

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

The description clearly states the action ('Add subtasks') and target resource ('to an existing task'), making the purpose immediately understandable. It distinguishes this tool from siblings like 'add_tasks_to_request' (which adds tasks to requests) and 'add_dependency' (which adds dependencies between tasks). However, it doesn't specify what type of tasks/subtasks these are (e.g., project management tasks), leaving some context implicit.

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 'Add subtasks to an existing task' and mentioning that 'All subtasks must be completed before a task can be marked as done,' which suggests this should be used when breaking down tasks into smaller units. However, it doesn't explicitly state when to use this versus alternatives like 'plan_task' (which might also involve subtask planning) or 'update_task' (which might modify existing subtasks), nor does it mention prerequisites like needing an existing task ID.

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 that 'A progress table will be displayed' as an outcome, which adds some context. However, it lacks critical details: whether this is a mutation (implied but not stated), what permissions are needed, if tasks are appended or replace existing ones, or error handling for invalid requestIds.

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 that are front-loaded: the first states the core purpose, the second adds context about task structure, and the third describes an outcome. No wasted words, though it could be slightly more structured for clarity.

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

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

Given the complexity (2 parameters with nested objects, 0% schema coverage, no annotations, no output schema), the description is incomplete. It lacks details on return values (beyond mentioning a progress table), error conditions, side effects, or how this tool fits into the broader workflow with 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%, so the description must compensate. It mentions 'tasks can include subtasks and dependencies', which clarifies the structure of the 'tasks' array parameter beyond the schema. However, it doesn't explain 'requestId' (e.g., format or source) or provide examples, leaving gaps in parameter 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 action ('Add new tasks') and target resource ('to an existing request'), making the purpose evident. However, it doesn't explicitly differentiate this from similar sibling tools like 'add_subtasks' or 'update_task', which would be needed for a perfect score.

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

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

The description mentions 'extending a request with additional tasks' but provides no explicit guidance on when to use this tool versus alternatives like 'add_subtasks' (for adding subtasks to existing tasks) or 'update_task' (for modifying existing tasks). No prerequisites or exclusions are stated.

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

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

With no annotations provided, the description carries full burden but lacks critical behavioral details. It mentions archiving moves requests to a separate file, but doesn't specify if this is reversible, what permissions are needed, whether it's destructive to original data, or what happens on failure. 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 well-structured with three sentences: purpose, parameter logic, and rationale. Each sentence adds value without redundancy, though the third sentence slightly rephrases the first, making it slightly less than perfectly concise.

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

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

Given no annotations, no output schema, and a single parameter with full schema coverage, the description covers basic purpose and parameter logic adequately. However, for a mutation tool that likely changes system state, it should provide more behavioral context like reversibility or error handling to be fully complete.

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

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

The description adds meaningful context beyond the schema's 100% coverage by explaining the conditional logic: if requestIds is provided, only those are archived; if not, all completed requests are archived. This clarifies the parameter's semantic impact, though it doesn't add format or validation details.

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 archives completed requests to keep the active tasks file clean, specifying the verb (archive) and resource (completed requests). It distinguishes from siblings like list_requests or restore_archived_request by focusing on archiving, though it doesn't explicitly contrast with them.

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 wanting to clean the active tasks file by moving completed work to archive storage. It doesn't provide explicit when-not-to-use guidance or name alternatives like list_archived_requests for checking archives, leaving usage context somewhat inferred rather than clearly 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?

With no annotations provided, the description carries full burden but offers minimal behavioral insight. It states the action is 'Delete', implying a destructive mutation, but doesn't disclose critical details like whether deletion is permanent, requires specific permissions, or has side effects (e.g., affecting request status). This leaves significant gaps for a tool that alters 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 highly concise and front-loaded, with two sentences that directly state the purpose and parameters without any fluff. Every word serves a functional role, making it efficient for an agent to parse quickly.

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

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

Given the tool's complexity (a destructive operation with 2 parameters), lack of annotations, and no output schema, the description is incomplete. It fails to address behavioral risks, parameter details, or expected outcomes, leaving the agent with insufficient information to use the tool safely and effectively.

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

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

Schema description coverage is 0%, so the description must compensate but only partially does. It names the parameters ('requestId' and 'noteId') and indicates they identify the note to delete, adding basic context. However, it doesn't explain what these IDs represent, their format, or where to obtain them, leaving the schema's undocumented parameters inadequately clarified.

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 ('Delete') and target resource ('a note from a request'), making the purpose immediately understandable. It distinguishes itself from siblings like 'update_note' or 'add_note' by specifying deletion. However, it doesn't explicitly differentiate from other deletion tools like 'delete_subtask' or 'delete_task', which keeps it from a perfect score.

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

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

The description provides no guidance on when to use this tool versus alternatives. It doesn't mention prerequisites (e.g., note must exist), exclusions, or compare with siblings like 'update_note' for modification instead of deletion. The agent must infer usage from context alone.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It clearly indicates this is a destructive operation ('Delete'), mentions the constraint about uncompleted subtasks, and describes the visual feedback ('A progress table will be displayed'). However, it doesn't cover important aspects like authentication requirements, error conditions, or whether the deletion is permanent/reversible.

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

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

The description is extremely efficient with three focused sentences: the core action, a critical constraint, and the visual feedback. Each sentence earns its place by providing essential information without any redundant or unnecessary content.

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 operation with no annotations, no output schema, and 3 undocumented parameters, the description is insufficiently complete. While it covers the basic action and a key constraint, it lacks crucial information about error handling, permissions, the nature of the deletion, and what the 'progress table' actually contains.

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 3 undocumented parameters, the description adds minimal value beyond naming the parameters. It lists the three required IDs but provides no context about their format, where to obtain them, or their relationships. The description doesn't compensate for the complete lack of schema documentation.

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

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

The description clearly states the specific action ('Delete a subtask from a task'), identifies the resource ('subtask'), and distinguishes it from sibling tools like 'delete_task' by specifying it operates on subtasks rather than entire tasks. This provides precise differentiation within the toolset.

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 ('Only uncompleted subtasks can be deleted'), which helps the agent understand a key constraint. However, it doesn't explicitly mention when NOT to use it (e.g., for completed subtasks) or name specific alternatives like 'update_subtask' for modifying instead of deleting.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It describes key behavioral traits: the deletion action (implying mutation), the constraint that only uncompleted tasks can be deleted, and that a progress table will be displayed after deletion. However, it lacks details on permissions, error handling, or what happens if deletion fails, leaving 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 appropriately concise with two sentences that cover key points: the action with constraints and the post-deletion behavior. It's front-loaded with the main purpose, and each sentence adds value without redundancy. However, the second sentence could be more integrated with the first for better flow.

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

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

Given the complexity of a deletion tool with no annotations, 0% schema coverage, and no output schema, the description is incomplete. It misses critical details: parameter meanings, error cases, permissions, and the format of the progress table. While it covers the basic action and constraint, it doesn't provide enough context for reliable agent use in this environment.

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

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

The input schema has 0% description coverage, so the description must compensate for undocumented parameters. It mentions 'a specific task from a request,' which hints at the need for requestId and taskId, but doesn't explain their semantics, formats, or sources. For example, it doesn't clarify if these are IDs from 'list_requests' or 'get_next_task.' The description adds minimal value beyond the schema's structure.

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 ('Delete') and resource ('a specific task from a request'), making the purpose understandable. It distinguishes from siblings like 'update_task' or 'mark_task_done' by specifying deletion, though it doesn't explicitly contrast with all alternatives. The description avoids tautology by adding operational details beyond just restating 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 some usage context by stating 'Only uncompleted tasks can be deleted,' which implies when to use it (for uncompleted tasks) and when not to use it (for completed tasks). However, it doesn't explicitly name alternatives like 'update_task' for modifying tasks or clarify prerequisites such as needing valid request/task IDs. The guidance is implied rather than 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?

With no annotations provided, the description carries full burden and does well by disclosing key behavioral traits: it creates a file output (write operation), explains path resolution logic (directory vs. full path, relative paths), and describes auto-generation rules for filenames. It doesn't mention error conditions, permissions needed, or rate limits, but covers substantial 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 well-structured and front-loaded with the core purpose in the first sentence. Each subsequent sentence adds specific value: what gets saved, parameter explanations, and path handling rules. There's zero wasted text, and the bullet points enhance readability without verbosity.

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

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

For a tool with 4 parameters, no annotations, and no output schema, the description provides strong coverage of inputs, behavior, and output format options. It lacks details on error cases, exact file naming conventions (beyond extension), and what the exported content structurally contains, but it's largely complete for practical use given the 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 50% (2 of 4 parameters have descriptions). The description compensates effectively by explaining all parameters: it clarifies 'format' options, distinguishes 'outputPath' usage (directory vs. file), explains 'filename' auto-generation, and implies 'requestId' is required (though not explicitly stated). This adds meaningful context beyond the schema's limited 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 tool's purpose with specific verbs ('Export', 'saves') and resources ('current status of all tasks in a request', 'tasks, subtasks, dependencies, and notes'), distinguishing it from sibling tools that focus on individual operations like add/delete/update tasks or notes. It explicitly identifies what gets exported and to what format.

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 save task status for reference. However, it doesn't explicitly state when NOT to use it or name specific alternatives among the sibling tools (e.g., list_requests for overview vs. this for detailed export), though the context implies it's for archival/reference purposes rather than real-time querying.

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 and does so effectively. It discloses key behavioral traits: progress table display with each response, state-dependent outcomes (pending task vs. all_tasks_done), and critical workflow constraints (user approval requirements after task completion). It doesn't cover rate limits or error handling, but provides substantial 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 appropriately front-loaded with core functionality, but contains some redundancy (repeating approval requirements) and could be more streamlined. The bullet points help structure but add length. Most sentences earn their place, but some phrasing could be tighter.

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 (stateful workflow with user interactions) and absence of both annotations and output schema, the description provides substantial context about behavior, outcomes, and integration with sibling tools. It doesn't describe the progress table format or error cases, but covers the essential workflow comprehensively.

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% with 1 parameter, so the description must compensate. It explains that 'requestId' identifies which request's tasks to process, adding meaningful context beyond the bare schema. However, it doesn't specify format or constraints for the requestId value.

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

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

The description clearly states the tool's purpose with specific verbs ('return the next pending task') and resource ('given a requestId'), distinguishing it from siblings like 'list_requests' or 'open_task_details'. It explicitly defines what constitutes a 'next task' (not done yet) versus completion state.

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

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

The description provides explicit when-to-use guidance, including prerequisites (need 'requestId'), when not to use (after 'mark_task_done' without user approval), and alternatives for completion scenarios ('add_tasks_to_request' or 'plan_task'). It directly addresses sibling tool interactions with clear sequencing rules.

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 that this is a read operation ('Get', 'view') and specifies the scope ('global prompts settings applied to all tasks'), which is useful behavioral context. However, it lacks details on permissions, rate limits, or response format, leaving gaps 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 front-loaded and efficient: the first sentence clearly states the purpose and key fields, and the second sentence adds useful context about global application. Both sentences earn their place without redundancy or fluff, making it appropriately sized for a simple 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 tool's low complexity (0 parameters, no output schema, no annotations), the description is reasonably complete for basic understanding. It explains what the tool retrieves and its scope. However, without annotations or output schema, it could benefit from more detail on return format or error conditions, leaving some contextual gaps.

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

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

The input schema has 0 parameters with 100% coverage, so no parameter documentation is needed. The description appropriately focuses on the tool's purpose and output semantics (e.g., 'including instructions, taskPrefix, and taskSuffix settings'), adding value beyond the empty schema. Baseline for 0 parameters is 4.

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

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

The description clearly states the tool's purpose: 'Get the current prompts configuration' with specific fields (instructions, taskPrefix, taskSuffix). It distinguishes from siblings like 'set_prompts' and 'update_prompts' by focusing on retrieval rather than modification. However, it doesn't explicitly contrast with 'remove_prompts' or other prompt-related tools.

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

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

The description implies usage context by stating it 'helps you view the current global prompts settings that are applied to all tasks,' suggesting it's for configuration inspection. However, it doesn't provide explicit guidance on when to use this versus alternatives like 'set_prompts' or 'update_prompts,' 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?

With no annotations provided, the description carries full burden for behavioral disclosure. It mentions 'overview of all archived requests with their metadata and completion information' which gives some output context, but lacks critical details like pagination behavior, rate limits, authentication requirements, or whether this is a read-only operation (implied but not stated).

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 that each add value. The first sentence states the core functionality with key capabilities, and the second adds context about what information is returned. No wasted words, though it could be slightly more 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 list/read tool with 100% schema coverage but no annotations and no output schema, the description is minimally adequate. It covers the basic purpose and output content but lacks important behavioral context (pagination, limits, side effects) that would be needed for robust agent usage.

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

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

Schema description coverage is 100%, so the schema already fully documents both parameters. The description mentions 'optional search and filtering capabilities' which aligns with the schema but adds no additional semantic context beyond what the parameter descriptions provide.

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: 'List archived requests' (verb+resource) and mentions 'with optional search and filtering capabilities' which adds specificity. However, it doesn't explicitly differentiate from its sibling 'list_requests' (which presumably lists non-archived requests), missing full sibling differentiation.

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

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

The description provides no guidance on when to use this tool versus alternatives. It doesn't mention the sibling 'list_requests' or explain when archived vs. active requests should be listed, nor does it provide any context about 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 mentions that the tool lists requests with 'basic information and summary of tasks,' which implies a read-only operation, but it doesn't specify details like pagination, sorting, filtering, rate limits, or authentication requirements. For a tool with zero annotation coverage, this leaves significant gaps in understanding its behavior.

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

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

The description is concise and front-loaded, consisting of two sentences that directly state the tool's purpose and utility. Every sentence earns its place by clarifying the action and scope. However, it could be slightly more structured by explicitly mentioning the lack of parameters or output details, but 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 (simple list operation with 0 parameters), no annotations, and no output schema, the description is moderately complete. It explains what the tool does but lacks details on behavioral aspects like return format, error handling, or system constraints. For a tool with no structured data support, this is adequate but leaves room for improvement in providing more context.

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

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

The input schema has 0 parameters with 100% coverage, meaning there are no parameters to document. The description doesn't add parameter-specific information, which is appropriate here. Since the baseline for 0 parameters is 4, this score reflects that the description doesn't need to compensate for any schema gaps, and it aligns well with the lack of parameters.

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: 'List all requests with their basic information and summary of tasks.' It uses specific verbs ('list') and resources ('requests'), and mentions the scope ('all requests in the system'). However, it doesn't explicitly differentiate from sibling tools like 'get_next_task' or 'request_planning', which also involve request-related operations, so it doesn't reach the highest score.

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

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

The description provides minimal guidance: it says this tool 'provides a quick overview of all requests,' implying it's for summary purposes. However, it doesn't specify when to use this tool versus alternatives (e.g., 'get_next_task' for a specific task or 'request_planning' for planning-related actions), nor does it mention any prerequisites or exclusions. This lack of explicit context limits its usefulness for an agent.

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

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

No annotations are provided, so the description carries the full burden. It mentions that 'A progress table will be displayed showing the updated status of all tasks and subtasks', which adds some behavioral context about output. However, it lacks details on permissions, side effects (e.g., if this is irreversible), or error handling, which are important 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 appropriately sized with three sentences. The first sentence states the purpose and parameters, the second describes the output, and the third provides a prerequisite. It is front-loaded with the core action, though the third sentence could be more integrated.

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, 0% schema coverage, no output schema, and 3 parameters for a mutation tool, the description is incomplete. It mentions output behavior but lacks details on return values, error conditions, or dependencies, leaving gaps for an AI agent to understand full usage.

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

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

Schema description coverage is 0%, so the description must compensate. It lists the parameters ('requestId', 'taskId', 'subtaskId') but does not explain their meaning, format, or relationships. This adds minimal value beyond the schema, which already specifies the required parameters without 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 action ('Mark a subtask as done') and specifies the required parameters ('requestId', 'taskId', 'subtaskId'), which distinguishes it from siblings like 'mark_task_done' or 'update_subtask'. However, it does not explicitly differentiate from all siblings, such as 'delete_subtask', which also operates on subtasks.

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 'All subtasks must be completed before a task can be marked as done', which suggests a prerequisite but does not explicitly say when to use this tool versus alternatives like 'mark_task_done' or 'update_subtask'. No exclusions or clear 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?

With no annotations provided, the description carries the full burden of behavioral disclosure. It effectively describes key behaviors: it's a mutation operation (implied by 'mark as done'), triggers a progress table display, and enforces a workflow pause until user approval. It doesn't cover potential side effects like task status changes in related systems or error conditions, but provides substantial 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 front-loaded with the core purpose but becomes verbose with workflow instructions that might be better placed elsewhere. The three sentences vary in focus: first states the action, second describes an output behavior, third gives procedural constraints. While all content is relevant, the structure mixes operational details with core tool description.

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

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

For a mutation tool with no annotations and no output schema, the description does well by explaining the action, parameters, immediate visual feedback (progress table), and critical workflow constraints. It misses details about return values, error handling, and the exact nature of the 'progress table', but provides sufficient context for basic safe usage given the 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?

With 0% schema description coverage for 3 parameters, the description partially compensates by mentioning all parameters ('requestId', 'taskId', 'completedDetails') and indicating which are required vs. optional. However, it doesn't explain what these parameters represent (e.g., format of IDs, content of completedDetails) or provide examples, leaving significant semantic 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 action ('Mark a given task as done') and the resource ('task'), making the purpose immediately understandable. However, it doesn't explicitly differentiate from sibling tools like 'mark_subtask_done' or 'update_task' which might have overlapping functionality, preventing a perfect score.

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

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

The description provides explicit guidance on when to use this tool ('after you've completed [a task]') and when not to use alternatives ('DO NOT proceed to 'get_next_task' again until the user has explicitly approved'). It also mentions the workflow context and user approval requirement, offering comprehensive 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?

With no annotations provided, the description carries full burden for behavioral disclosure. It states this is for 'inspecting' information, which implies a read-only operation, but doesn't explicitly confirm this or address other behavioral aspects like authentication requirements, rate limits, error conditions, or what specific details are returned. The phrase 'at any point' suggests availability but doesn't clarify constraints.

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

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

The description is efficiently structured in two concise sentences. The first sentence directly states the action and required parameter, while the second provides usage context. Every word earns its place with no redundancy or fluff.

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

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

Given the tool has no annotations, no output schema, and 0% schema description coverage, the description is insufficiently complete. It adequately states the basic purpose but lacks crucial information about what details are returned, behavioral constraints, parameter semantics, and differentiation from sibling tools. For a read operation tool in a workflow system, more context is needed.

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

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

The schema has 0% description coverage, so the description must fully compensate. It mentions the 'taskId' parameter and that details are retrieved by it, but provides no additional semantic context about what a taskId is, its format, where to obtain it, or validation rules. This leaves significant gaps in parameter understanding beyond the basic schema type.

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 details') and resource ('specific task'), making the purpose evident. It specifies retrieving information by 'taskId' for inspection purposes. However, it doesn't explicitly differentiate from potential sibling tools like 'get_next_task' or 'list_requests' that might also provide task information.

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 'for inspecting task information at any point', suggesting this tool is for detailed examination rather than listing or workflow progression. However, it doesn't provide explicit guidance on when to use this versus alternatives like 'get_next_task' (which might return limited details) or 'list_requests' (which might provide summary information). No exclusions or clear alternatives are named.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It effectively describes key behaviors: it initiates a workflow, creates a Markdown file if 'outputPath' is provided, and explains the workflow's interactive nature (requiring user approval after each task). However, it doesn't mention potential side effects like file system changes or error handling, 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 purpose and required parameters, but it becomes verbose with an extensive workflow explanation (9 steps) that might be better suited for general documentation. While informative, some sentences (e.g., the detailed workflow steps) could be condensed without losing essential guidance, making it less concise than ideal.

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 (6 parameters, no annotations, no output schema), the description is largely complete. It covers the tool's role in a workflow, parameter semantics, and usage guidelines. However, it lacks details on return values (since no output schema exists) and doesn't address error conditions or validation rules, which are important for a tool with nested object 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?

With 0% schema description coverage, the description must compensate for the lack of parameter documentation. It adds significant meaning: it explains that 'originalRequest' and 'tasks' are required, 'splitDetails' is optional, 'dependencies' are project/task-specific, 'notes' are general guidelines, and 'outputPath' saves a Markdown file with absolute path recommendations. It also clarifies that tasks can include subtasks and dependencies. However, it doesn't detail the structure of 'tasks' objects beyond mentioning subtasks and dependencies.

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: 'Register a new user request and plan its associated tasks.' It specifies the verb 'register' and resource 'user request and tasks,' distinguishing it from siblings like 'add_tasks_to_request' (which adds to existing requests) or 'list_requests' (which only lists).

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 usage guidelines, detailing when to use this tool (to initiate a new workflow) versus alternatives (e.g., 'add_tasks_to_request' for adding tasks to existing requests). It outlines the entire workflow sequence, including when to use sibling tools like 'get_next_task' and 'mark_subtask_done,' and specifies prerequisites (must provide 'originalRequest' and '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?

With no annotations provided, the description carries the full burden of behavioral disclosure. It describes the conditional removal behavior based on 'fields', which is useful, but fails to address critical aspects: it doesn't specify if this is a destructive operation (implied by 'remove' but not explicit), what permissions are required, whether changes are reversible, or what happens on success/failure. 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 and front-loaded, with two sentences that directly address the core functionality without waste. The first sentence states the purpose, and the second explains the parameter-driven behavior, making it easy to scan and understand quickly. Every sentence earns its place by 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?

Given the tool's complexity (a mutation operation with conditional behavior), no annotations, no output schema, and low schema description coverage (0%), the description is incomplete. It covers the basic parameter logic but misses critical context: it doesn't explain the return value, error handling, side effects, or how this interacts with sibling tools like 'update_prompts'. For a tool that modifies configuration, this leaves too many unknowns for reliable 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 schema has 1 parameter with 0% description coverage, so the description must compensate. It effectively explains the semantics of the 'fields' parameter: if provided, only those specific fields are removed; if not, the entire configuration is removed. This adds clear meaning beyond the schema's enum values ('instructions', 'taskPrefix', 'taskSuffix'), though it doesn't detail what each field represents or the impact of removal.

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 'remove' and the resource 'prompts configuration or specific fields from it', making the purpose understandable. It distinguishes from siblings like 'get_prompts', 'set_prompts', and 'update_prompts' by focusing on deletion rather than retrieval, creation, or modification. However, it doesn't explicitly contrast with 'delete_task' or 'delete_subtask', which might cause minor confusion about scope.

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

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

The description implies usage through conditional logic based on the 'fields' parameter, suggesting when to use it for partial vs. full removal. However, it lacks explicit guidance on when to choose this tool over alternatives like 'update_prompts' for modifications or 'set_prompts' for replacement, and doesn't mention prerequisites or error conditions. This leaves some ambiguity in decision-making.

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 mentions the action 'moves the request from the archive back to active status', which implies a mutation but doesn't disclose behavioral traits like permissions needed, whether it's reversible, potential side effects (e.g., impact on dependencies), or response format. 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 two sentences, front-loaded with the core action ('Restore a specific archived request back to the active tasks file') and followed by a clarifying sentence. Every sentence earns its place by explaining the purpose and effect without redundancy or fluff, making it highly 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 has one parameter with full schema coverage but no annotations or output schema, the description is moderately complete. It explains what the tool does but lacks details on behavioral aspects (e.g., success/failure outcomes, error conditions) and doesn't leverage the sibling context to guide usage more precisely. For a mutation tool, this leaves room for improvement in 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 single parameter 'requestId' documented as 'The ID of the archived request to restore'. The description adds no additional parameter semantics beyond this, such as format examples or constraints. With high schema coverage, the baseline is 3, as the description doesn't compensate but also doesn't 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 verb 'restore' and resource 'archived request', specifying it moves the request 'back to active status'. It distinguishes from siblings like 'archive_completed_requests' and 'list_archived_requests' by focusing on restoration rather than archiving or listing. However, it doesn't explicitly contrast with 'list_requests' (which might show active requests) or other task management tools, keeping it from a perfect score.

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

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

The description implies usage when you need to 'continue working on' an archived request, suggesting it's for reactivation. However, it lacks explicit guidance on when to use this versus alternatives like creating new tasks or using other request tools, and doesn't mention prerequisites (e.g., the request must be archived first). This leaves some ambiguity in 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 of behavioral disclosure. It adds useful context: 'This replaces any existing prompts settings with the new values provided,' indicating a destructive overwrite behavior. However, it doesn't cover other important aspects like permissions needed, rate limits, error handling, or what happens if only some parameters are provided.

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

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

The description is appropriately sized and well-structured. It starts with a clear purpose statement, follows with a critical behavioral note, and then provides bullet-point explanations for each parameter. Every sentence earns its place with no wasted words, making it easy to scan and understand.

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 (mutating global configuration with 3 parameters), no annotations, and no output schema, the description is moderately complete. It covers the purpose, destructive behavior, and parameter meanings well, but lacks information about return values, error conditions, permissions, or how partial updates are handled, which would be helpful for a mutation tool.

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

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

The schema description coverage is 0%, so the description must compensate. It does so effectively by listing all three parameters ('instructions', 'taskPrefix', 'taskSuffix') and providing clear semantic explanations for each: 'General instructions or context shown at the top of each task', 'Text to prepend before each task description', and 'Text to append after each task description'. This adds significant value beyond the bare schema.

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

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

The description clearly states the tool's purpose: 'Set the global prompts configuration with instructions, taskPrefix, and/or taskSuffix.' It specifies the verb ('Set'), resource ('global prompts configuration'), and scope ('instructions, taskPrefix, and/or taskSuffix'), though it doesn't explicitly differentiate from sibling tools like 'update_prompts' or 'remove_prompts'.

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 'This replaces any existing prompts settings with the new values provided,' which suggests it should be used when replacing all prompts settings. However, it doesn't explicitly state when to use this tool versus alternatives like 'update_prompts' or 'remove_prompts,' nor does it provide clear 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. It mentions the tool updates an existing note, implying mutation, but lacks details on permissions, whether updates are reversible, error handling, or response format. This is inadequate for a mutation tool with zero annotation coverage.

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

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

The description is front-loaded with the core purpose in the first sentence, followed by parameter guidance. Both sentences earn their place by clarifying the action and inputs, with no wasted words. It's appropriately sized for a simple update 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 tool's complexity (mutation with 4 parameters), lack of annotations, and no output schema, the description is incomplete. It covers basic purpose and parameters but misses behavioral details like side effects, permissions, or return values, which are critical for safe 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 must compensate. It lists all four parameters ('requestId', 'noteId', 'title', 'content') and specifies required vs. optional, adding value beyond the bare schema. However, it doesn't explain parameter meanings (e.g., what 'requestId' refers to) or formats, 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 verb ('Update') and resource ('an existing note's title or content'), making the purpose evident. It distinguishes from siblings like 'add_note' (creation) and 'delete_note' (deletion), but doesn't explicitly differentiate from other update tools like 'update_subtask' or '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?

The description provides no guidance on when to use this tool versus alternatives. It doesn't mention prerequisites (e.g., needing an existing note), compare to siblings like 'add_note' or 'delete_note', or specify context for updates. Usage is implied but not explicitly stated.

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

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

No annotations are provided, so the description carries the full burden. It discloses the tool's behavior as a partial update operation, which implies mutation but doesn't specify permissions, side effects, or response format. It adds some context (e.g., fields that can be modified) but lacks details on error handling or constraints, leaving 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 front-loaded with the core purpose in the first sentence, followed by usage guidance. Both sentences are essential, with no redundant information, making it efficiently structured and appropriately sized for the tool's complexity.

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, 0% schema coverage, no output schema, and a mutation tool with 3 parameters, the description is incomplete. It covers the purpose and usage well but lacks behavioral details (e.g., permissions, side effects) and parameter specifics, making it adequate but with clear gaps for safe agent invocation.

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

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

With 0% schema description coverage and 3 parameters, the description compensates by listing the specific fields that can be updated ('instructions, taskPrefix, or taskSuffix'), providing meaningful semantics beyond the bare schema. However, it doesn't detail the format or constraints of these fields, so it doesn't fully cover all parameter aspects.

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 specific parts of the prompts configuration') and resource ('prompts configuration'), distinguishing it from sibling tools like 'set_prompts' (which likely replaces the entire object) and 'get_prompts' (which reads). It explicitly mentions the partial update nature versus full replacement.

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 this tool ('to modify individual fields... while keeping other settings unchanged') and implies when not to use it (e.g., use 'set_prompts' for full replacement or 'get_prompts' for reading). It clearly differentiates from alternatives like 'set_prompts' by specifying partial updates.

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 that a 'progress table will be displayed showing the updated task with its subtasks,' which adds some output context. However, it lacks details on permissions needed, whether updates are reversible, error conditions, or rate limits—critical for a mutation tool with zero annotation coverage.

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

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

The description is well-structured and front-loaded with the core purpose, followed by parameter guidance and behavioral notes. Each sentence adds value: the first defines the tool, the second lists parameters, the third gives a constraint, and the fourth describes output. It could be slightly more concise by integrating the parameter list more fluidly.

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

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

Given the complexity (a mutation tool with 5 parameters, no annotations, and no output schema), the description is moderately complete. It covers the basic action, parameters, a key constraint, and output behavior, but lacks details on error handling, authentication, or side effects, which are important for safe usage.

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

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

Schema description coverage is 0%, so the description must compensate. It lists all parameters ('requestId', 'taskId', 'subtaskId', 'title', 'description') and clarifies that 'title' and 'description' are optional, adding meaningful context beyond the bare schema. However, it doesn't explain the purpose or format of 'requestId', 'taskId', or 'subtaskId', leaving some ambiguity.

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

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

The description clearly states the action ('Update a subtask's title or description') and specifies the resource ('subtask'), making the purpose immediately understandable. It distinguishes this from sibling tools like 'update_task' by focusing specifically on subtasks, though it doesn't explicitly contrast with other update tools like 'update_note'.

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 some usage context by stating 'Only uncompleted subtasks can be updated,' which gives a conditional rule. However, it doesn't explicitly guide when to choose this tool over alternatives like 'update_task' or 'mark_subtask_done,' nor does it mention prerequisites or exclusions beyond completion status.

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 that updates are limited to uncompleted tasks and mentions a 'progress table will be displayed' as output behavior. However, it doesn't cover important aspects like whether this requires specific permissions, if changes are reversible, error handling, or rate limits. The description adds some behavioral context but leaves significant gaps.

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

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

The description is appropriately concise with two sentences. The first sentence clearly states the purpose and constraint, while the second describes output behavior. There's no unnecessary information, though it could be slightly more structured by separating constraints 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?

Given the tool's moderate complexity (mutation operation with 4 parameters), no annotations, and no output schema, the description is partially complete. It covers the update scope and a constraint but lacks details on parameter meanings, error conditions, permissions, and full output specification. The description provides a basic foundation but leaves important gaps for a mutation tool.

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

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

Schema description coverage is 0%, so the description must compensate. It mentions that 'title and/or description' can be updated, which maps to two of the four parameters. However, it doesn't explain the purpose of 'requestId' and 'taskId' (the required parameters) or provide any format/validation details. The description adds minimal value beyond what's implied by parameter names.

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

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

The description clearly states the tool's purpose: 'Update an existing task's title and/or description.' It specifies the verb (update) and resource (task) with the specific fields that can be modified. However, it doesn't explicitly differentiate from sibling tools like 'mark_task_done' or 'delete_task' beyond mentioning that only uncompleted tasks can be updated.

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: 'Only uncompleted tasks can be updated.' This establishes a key precondition. However, it doesn't explicitly mention when NOT to use it (e.g., for completed tasks) or name alternatives like 'delete_task' for removal or 'mark_task_done' for completion.

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