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

The description adds value beyond the destructiveHint annotation by clarifying that tasks are hidden, not deleted, and can be retrieved with showHidden: true. This nuance helps the agent understand the permanence and reversibility of the action. It does not contradict the annotation; rather, it provides helpful detail about the state change.

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 concise sentences: the first states the core action, the second explains the side effect and recovery method. Every word earns its place, and the most important information is front-loaded.

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

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

Given the simple operation and the presence of a destructiveHint annotation, the description covers the essential behavior: tasks disappear from the list but remain retrievable via showHidden. There is no output schema, but the description sufficiently explains the outcome for an agent to understand the tool's effect. Minor additional detail about the return value would be nice, but it's not critical.

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 already fully documents the tasklist parameter, including its default value and how to obtain the ID from list-tasklists. The description adds no additional semantics for the parameter; it only references the task list indirectly. With 100% schema coverage, a baseline of 3 is appropriate.

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

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

The description clearly states the tool hides completed tasks in a task list, using a specific verb (非表示) and a specific resource (タスクリスト). It distinguishes itself from siblings by explaining that hidden tasks can still be retrieved with showHidden: true, a behavior not mentioned in other tools. This makes the purpose unambiguous and differentiates it from list-tasks or complete-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 for use: it hides completed tasks from the list and describes the retrieval mechanism. It does not explicitly name alternatives or when-not-to-use conditions, but the operation is unique among siblings, so no exclusions are needed. The context is clear enough for an agent to decide when to invoke it.

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

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

With no annotations, the description carries the full burden of behavioral disclosure. It discloses the core behavior (setting true/false toggles completion) but says nothing about side effects, idempotency, auth requirements, rate limits, or what happens to the task record beyond the completed field. For a mutation tool 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 a single, efficient sentence that front-loads the primary action and includes the toggling nuance. No waste words, appropriately concise for a simple tool. It loses a point for not having any structured breakdown or bullet points that could aid readability, but it's still highly 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?

The tool is simple but has no output schema, no annotations, and a brief description. Missing context includes what happens when the task doesn't exist, whether the operation is idempotent, and whether any additional effects occur (e.g., timestamps, notifications). An agent has enough to make a basic call but not to handle edge cases or understand the full outcome.

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 all three parameters are documented with descriptions in the schema itself. The description adds only a redundant explanation of the 'completed' parameter's behavior, already present in the schema. Since the schema carries the full parameter meaning, a baseline of 3 applies.

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 states a specific verb and resource: 'make task complete', and clarifies that setting completed to false reverts it. This clearly distinguishes it from other task operations like update-task, though it doesn't explicitly name the sibling alternative. The purpose is unmistakable.

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

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

No guidance is provided on when to use this tool versus alternatives like update-task or clear-completed-tasks. The behavior is implied (toggle completion), but there is no explicit 'use this when you only need to change completion status' or 'for other task fields use update-task'. The agent must infer the usage context.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It mentions that specifying 'parent' creates a subtask, but this behavior is already documented in the input schema. It does not disclose other relevant traits such as the write nature of the operation, potential side effects, or default tasklist behavior beyond the schema. The description adds minimal value beyond what the schema already states.

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 a single sentence that front-loads the core action and immediate behavioral nuance. There is no fluff, repetition, or unnecessary elaboration, making it highly 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?

For a tool with 6 parameters and no annotations or output schema, the description is minimal but not critically insufficient. It states the core function and subtask behavior, while relying on the schema for parameter details. However, it does not provide broader workflow guidance (e.g., how to obtain a tasklist ID) or clarify return behavior, leaving some gaps for an agent evaluating usage 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 100% parameter description coverage, so the baseline is 3. The description only references 'parent' indirectly and adds no semantic detail beyond the schema's own parameter descriptions. It does not clarify relationships between parameters or provide examples, but the schema already handles this adequately.

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

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

The description clearly states the action ('タスクを作成する' - create a task) and identifies the key distinction that specifying 'parent' makes it a subtask. This unambiguously separates it from sibling tools like create-tasklist, which creates a task list instead.

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

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

The description implies usage for creating a task but does not explicitly contrast with alternatives or provide when-not-to-use guidance. No exclusions, prerequisites, or references to related tools (e.g., list-tasklists) are given, so the usage context is only inferred from the purpose.

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 only states the creation action without detailing side effects, permissions, or error handling. There is no indication of return behavior or other traits.

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 a single, concise sentence that directly states the action. It is efficient and front-loaded, though it lacks any additional structure or context beyond 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?

For a simple create tool with one parameter and no output schema, the description is minimally sufficient but omits behavioral details like return value or error conditions. Given the low complexity, it is adequate but not comprehensive.

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

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

The input schema fully documents the single 'title' parameter with 100% coverage. The description adds no additional meaning beyond what the schema provides, so baseline of 3 is appropriate.

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

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

The description states a specific action (create) on a specific resource (task list) in Japanese, clearly distinguishing it from sibling tools like create-task which operate on tasks. The purpose is 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 no guidance on when to use this tool versus alternatives such as update-tasklist or create-task. It simply states the action without any contextual usage 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?

The annotations already declare destructiveHint=true. The description adds '取り消せない' (cannot be undone), which is useful but not substantially broader than the annotation. No additional behavioral details are disclosed, such as cascading deletes or permission requirements.

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

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

The description is compact—two sentences, both reasonably informative. The 'cannot be undone' warning is a valuable addition and the text is appropriately front-loaded. It loses one point because the core phrase largely mirrors the tool name and title.

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

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

For a simple, destructive task with full schema coverage and no output schema, the description is sufficient. It states the operation and warns of irreversibility. It could be more complete by mentioning when to prefer clear-completed-tasks for bulk deletion, but this not essential for basic invocation.

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

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

The schema has 100% parameter descriptions, including where to obtain task and tasklist IDs and the '@default' value for tasklist. The description does not add any parameter-specific meaning, so the baseline score of 3 is appropriate.

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

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

The description clearly states the tool deletes a task using a specific verb and resource, and the warning '取り消せない' reinforces the intent. It is distinguished from delete-tasklist and clear-completed-tasks by the explicit 'task' resource, though it doesn't further describe scope or side effects.

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

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

No guidance is provided on when to use this tool versus alternatives like clear-completed-tasks or delete-task-list. The description merely states the action, leaving the agent to infer appropriate usage from the name and schema.

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

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

Annotations already declare destructiveHint=true, and the description adds critical behavioral context: cascading deletion of all tasks and irreversibility ('取り消せない'). This goes beyond the annotation and is essential for an agent to assess the safety of the operation.

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

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

Two short, high-value sentences. The primary action and its most important side effects are front-loaded. No filler or redundancy.

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

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

For a simple delete operation with a single parameter, all necessary context is provided: what is deleted, what else is deleted, and irreversibility. The destructive annotation and schema fully cover the remaining needs. No missing information.

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 covers 100% of parameter descriptions ('削除するタスクリストの ID'), so the tool description adds no additional meaning beyond what the schema already provides. Baseline 3 is appropriate.

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

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

The description states a clear verb ('削除する' = delete) and resource ('タスクリスト' = tasklist), and explicitly notes that all contained tasks are also deleted, distinguishing it from sibling delete-task. The purpose is unmistakable.

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?

While it doesn't explicitly name alternative tools, it clearly warns that all tasks within the tasklist are deleted and that the action cannot be undone. This implicitly tells an agent not to use this tool if they only want to delete a single task or if they need to preserve tasks, providing effective usage context.

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

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

Annotations include readOnlyHint=true, which covers the safety profile. The description adds nothing beyond that—no mention of error handling, permissions, or return value. For a simple read operation, this is adequate but adds minimal value beyond the annotation.

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 a single, focused sentence that immediately states the action and resource. There is zero wasted text and the core purpose is front-loaded.

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

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

For a simple read tool with complete schema documentation and a readOnly annotation, the description is sufficient. It does not mention return format, but no output schema exists, and the behavior is straightforward. A slightly richer note on what the response contains would improve it, but nothing critical is missing.

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%—both parameters are fully documented in the schema, including how to obtain IDs from list-tasks and list-tasklists. The description adds no parameter-level information beyond what the schema already provides, so the baseline of 3 applies.

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 states a clear verb-resource pair: 'get details of one task.' It is unambiguous and distinguishes from list-tasks (which presumably retrieves multiple tasks) and tasklist operations. However, it does not explicitly differentiate from sibling get-tasklist, though the resource type makes that obvious.

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

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

No guidance is provided on when to use this tool vs alternatives. The description only states what it does, without mentioning that it is the correct choice for fetching a single task by ID or that list-tasks is for retrieving multiple tasks. No exclusions or alternative references.

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 readOnlyHint annotation already indicates this is a safe read operation. The description adds no additional behavioral context—no mention of what data is returned, error scenarios, or limitations. It simply restates the purpose without enriching the agent's understanding beyond the annotation.

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 a single sentence with no extraneous content. It is concise and front-loaded, conveying the core purpose directly.

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

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

For a simple read-only tool with one optional parameter and no output schema, the description is adequate but minimal. It does not mention what information is returned or provide any additional context, but given the simplicity and the schema covering the parameter, it does not feel critically incomplete.

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

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

Schema description coverage is 100% for the sole parameter 'tasklist', which includes default value and how to obtain IDs. The description itself adds no parameter-specific information, so the baseline of 3 applies.

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 (取得 / retrieve) and the resource (タスクリスト / task list), specifying it is for a given task list. While it does not explicitly distinguish from siblings like list-tasklists, the singular 'specified' implies fetching one item, which is reasonably clear in context.

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

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

The description provides no guidance on when to use this tool versus alternatives. It does not mention that list-tasklists should be used when the user needs an overview or that get-tasklist is for a single known list. No exclusions or context are given.

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

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

Annotations already declare readOnlyHint=true, so safety is covered. The description adds behavioral context beyond the annotation: it scopes to the authenticated account's tasklists and indicates that the returned IDs are meant to be passed on to other tools. This tells the agent the output is a set of tasklists with IDs, which is useful for chaining. No additional risk or side-effect info is needed given the read-only nature.

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

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

Two short sentences, front-loaded with the main function (list tasklists) and immediately followed by the practical usage hint about tasklist IDs. Every word earns its place; no redundancy or fluff. The structure is exemplary.

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

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

For a simple read-only list tool with pagination params already documented in the schema, the description is complete. It explains the purpose (getting IDs for other tools) and the scope (authenticated account's tasklists). The main omission is a description of the return format (e.g., fields of each tasklist), but the read-only hint and the explicit mention of tasklist IDs cover the essential expectations. Very close to complete.

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

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

Schema description coverage is 100% (both pageToken and maxResults have descriptions in Japanese). The description adds no parameter-specific detail, but that's unnecessary because the schema fully documents them. Baseline 3 applies because the schema does the heavy lifting; the description does not need to compensate.

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 states a specific verb (一覧する/list) and resource (タスクリスト/tasklists), and clarifies the account scope (認証中のアカウントが持つ). It also explains the purpose of the output (tasklist ID for other tools), which distinguishes it from siblings like get-tasklist (which fetches a single one) and create/update/delete operations. The purpose is 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 gives clear context on when to use this tool: to obtain tasklist IDs for other tools. It does not explicitly list exclusions or alternative tools, but the sibling list and the tasklist ID hint make it obvious this is the collection-list operation, not a single-get or mutation. The guidance is clear enough for an agent to know when to pick this over the others.

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

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

The annotation readOnlyHint already declares this a read-only operation, and the description adds a non-obvious behavioral nuance: API-completed tasks appear by default and can be hidden via clear-completed-tasks. This goes beyond the annotation and is highly relevant for correct invocation.

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 three short sentences, front-loaded with the core purpose and immediately followed by the key filtering and completion nuance. Every sentence earns its place, and there is no redundancy or filler.

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?

Despite having 11 parameters, all are fully documented in the schema, and the description covers the essential behavior and a crucial default that would otherwise be easy to miss. As a read-only list operation, it provides adequate context for correct usage without needing to explain return values (no output schema).

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 coverage is 100%, so the baseline is 3. The description adds value by summarizing that filtering is possible and by clarifying the default inclusion of completed tasks (related to showCompleted), but it does not elaborate on each parameter beyond what the schema already documents. This meets but does not exceed the 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 states a specific action ('list tasks') and the resource ('in a task list'), distinguishing it clearly from get-task (single task) and list-tasklists (listing task lists). It also mentions filtering capability, making the purpose unambiguous and immediately usable.

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 explicitly mentions that API-completed tasks are included by default and that clear-completed-tasks can hide them, guiding the agent toward an alternative tool for that specific need. While it doesn't exhaustively say when not to use other siblings, it provides useful context about the filtering and completion behavior.

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 bears full responsibility for behavioral disclosure. It does state the primary behavior ('変える' - change) and the three parameter-specific effects, which implies it is a write operation. However, it does not disclose potential side effects (e.g., removal from current list), reversibility, or permission requirements, leaving operational uncertainty.

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 a single, compact sentence that front-loads the core action and then explains each parameter's role in one line. Every word contributes to understanding, with no redundant or tangential 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?

The description covers the main functionality and parameter-driven behaviors, which is adequate given the tool's simplicity and full schema coverage. However, it omits details about default behavior when destinationTasklist is omitted, error conditions, and the return value, and since there is no output schema or annotations, these gaps could confuse an agent in edge 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?

The schema descriptions already cover each parameter's meaning at 100% coverage, but the description adds interpretive value by explicitly linking parameters to outcomes: 'parent' for subtasking, 'previous' for ordering, and 'destinationTasklist' for moving to another list. This contextualization goes beyond the raw schema descriptions.

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

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

The description states a specific action ('タスクの位置を変える' - change the position of a task) and lists three distinct movement mechanisms (subtask, reorder, move to another list). This clearly distinguishes it from siblings like update-task (field updates) and complete-task (status change), making the purpose unambiguous.

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

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

The description implies when to use this tool (whenever a task's position needs changing) but does not explicitly compare it to alternatives or state when not to use it. It lacks exclusions or prerequisites, so an agent would have to infer the use case from the action description 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, the description carries the disclosure burden. It reveals a key behavior: partial updates preserve unspecified fields. However, it omits other behavioral aspects such as error handling, authentication requirements, idempotency, or response format. The partial-update guarantee is valuable, but the description is not comprehensive for a tool with no annotation safety profile.

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 behavior and purpose, then the alternative. No filler or redundant information. Every word earns its place, making it highly efficient for an agent to parse.

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

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

For a tool with 6 parameters and no output schema, the description covers the essential behavioral contract (partial update) and the main usage exclusion (complete-task). Parameter-specific details are handled by the schema. The description is adequate for an agent to correctly invoke the tool without missing crucial 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 coverage is 100% – every parameter has a description. The tool description adds a global behavior (only specified fields change) but does not provide per-parameter meaning beyond what the schema already offers. Baseline 3 is appropriate since the schema carries the parameter 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 states a specific action ('部分更新' – partial update) on a specific resource (task) and immediately clarifies the partial-update semantics (only specified items change). It also distinguishes itself from the sibling tool complete-task, making its purpose 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 explicitly tells the agent when not to use this tool: '完了にするだけなら complete-task を使う' (if you only want to complete, use complete-task). It provides clear context for partial updates but does not enumerate other alternative tools (e.g., move-task, delete-task), though the partial-update scope makes those less likely to be confused.

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 for behavioral disclosure. It only states the action of renaming without mentioning side effects (e.g., impact on tasks, permission requirements, error behavior if the tasklist does not exist, or queuing/move semantics). This is a minimal disclosure 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 a single, concise sentence in Japanese that efficiently conveys the core purpose. It is appropriately front-loaded and contains no filler. However, it is so brief that it misses an opportunity to add contextual value, though it does not waste 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?

For a simple rename operation with full schema coverage and no output schema, the description is minimally adequate—it states the primary action. Yet it omits any mention of limitations (e.g., only the name changes, not other list properties) or prerequisites, which could be important for correct invocation. It does not introduce confusion, but it leaves room for richer context.

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

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

Schema description coverage is 100%, with both 'title' and 'tasklist' already documented clearly. The description adds no new parameter information beyond what the schema provides. Since the schema fully explains the parameters, the baseline of 3 is appropriate.

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

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

The description 'タスクリストの名前を変更する' clearly states a specific verb (change) and a resource (tasklist name), which distinguishes it from sibling tools like create-tasklist, delete-tasklist, and update-task. The title reinforces the exactly-scoped purpose, so an agent can correctly identify what the tool does without ambiguity.

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

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

The description provides no guidance on when to use this tool versus its siblings. It does not mention any conditions, exclusions, or alternatives, leaving the agent to infer that this is the right tool for renaming a tasklist. The only hint is the schema's tasklist description referencing list-tasklists, but that is not in the tool description itself.

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