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

The annotations already indicate a write operation (readOnlyHint=false), and the description adds useful context by specifying the return value (id and title) and the default behavior for listId (default list). It also provides the due date format. No contradictions with annotations.

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

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

The description is well-structured with clear sections for Args, Returns, and Examples. Each section is concise and directly useful, with no filler or redundant 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 return value since there is no output schema, provides parameter explanations and examples, and handles a moderate number of parameters. It lacks error-handling or edge-case details, but for a simple creation tool it is sufficiently 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 schema covers all parameters with descriptions (100% coverage), but the description enhances this with examples for each parameter, clarifies the ISO format for due, and notes the default for listId. This adds practical meaning beyond the raw 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 that it adds a new to-do to Google Tasks ('Google Tasks에 새 할 일을 추가합니다'), using a specific verb and resource. This distinguishes the tool from sibling operations like listing, updating, completing, or deleting tasks.

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

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

The description provides examples of when to use the tool (e.g., adding a task with optional note or due date), but does not explicitly mention alternatives or when not to use it. Sibling tool names are listed in context, but the description itself offers no comparative guidance.

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

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

Annotations already cover readOnlyHint=false, idempotentHint=true, and destructiveHint=false, so the description doesn't need to restate those. It adds context that the id must come from tasks_list, which is useful, but it doesn't describe the return value or behavior on invalid ids. Given the annotation coverage, this is adequate but not exceptional.

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 organized with a main statement, usage note, args list, and examples, making it easy to scan. However, the Args section largely duplicates schema descriptions, slightly lengthening the text without adding new information.

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

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

For a simple 'complete a task' tool, the description covers purpose, prerequisites, parameters, and invocation examples. It does not detail error handling or return values, but given the simplicity and the presence of annotations, these are not critical gaps.

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

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

Schema already describes both parameters (id and listId) with 100% coverage, so the baseline is 3. The description adds value by specifying that id comes from tasks_list and providing concrete examples mapping natural language to parameter values, which helps the agent construct calls correctly.

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 function: 'Google Tasks의 할 일을 완료 처리합니다' (complete a Google Tasks todo). It distinguishes itself from siblings like tasks_add/delete/update/uncomplete by focusing on the completion action, and the examples reinforce the specific use case.

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

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

It provides an explicit prerequisite: use the id from tasks_list, which guides the agent on the required workflow. The examples show when the tool should be selected (e.g., '여권 확인 완료했어'), offering clear context for invocation. It doesn't explicitly mention alternatives like tasks_uncomplete, but the workflow is clear enough for a simple tool.

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 include destructiveHint=true. The description adds '영구 삭제' (permanently delete) and '되돌릴 수 없습니다' (irreversible), providing context beyond the annotation about the severity of the action. No contradiction with annotations.

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

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

The description is compact and well-structured: a clear two-sentence introduction, a concise parameter list, and a practical example. Every sentence earns its place, with no unnecessary 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?

For a simple deletion tool with no output schema, the description covers the purpose, parameters, and an example workflow. It is sufficient for an agent to select and invoke the tool, though the optional listId could be explained in more depth.

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% for both id and listId, so the baseline is 3. The description repeats the parameter descriptions from the schema without adding new semantic details, though the example illustrates usage. It does not fully compensate for any 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 'Google Tasks에서 할 일을 영구 삭제합니다' (permanently deletes a task) and '되돌릴 수 없습니다' (cannot be undone), using a specific verb and resource. It distinguishes itself from sibling tools like tasks_update and tasks_complete by focusing on deletion.

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 example workflow 'tasks_list()로 id 확인 -> tasks_delete({id: "..."})' provides clear context on when to use the tool (after listing tasks to obtain the ID). However, it does not explicitly discuss alternatives or when not to use it, but the destructive nature is highlighted.

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?

Beyond the readOnlyHint and idempotentHint annotations, the description adds valuable context: it returns both completed and uncompleted items, and includes counts (total, pending). This gives the agent a clear expectation of the response structure.

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 reasonably concise, front-loaded with the main purpose, and well-structured with Returns and Examples sections. The examples are useful, though the misguidance about filtering adds some noise.

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 list tool, the description covers the return fields and gives examples. However, the complete omission of the filter parameter from the description creates a significant information gap, even though the schema documents it. Without mentioning filtering, the agent may not know the tool can filter directly.

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%, but the description does not mention the filter parameter at all. Worse, the example '완료 안 된 것만 보여줘' suggests calling tasks_list() with no arguments and filtering afterwards, which contradicts the schema's filter capability. This is misleading and fails to add meaning beyond the schema.

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

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

The description states 'Google Tasks의 모든 할 일을 조회합니다' (retrieves all Google Tasks), specifying the exact verb and resource. It clearly differentiates from sibling mutation tools (add, complete, delete, update) by focusing on retrieval.

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

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

Provides concrete examples mapping user intents like '할 일 목록 보여줘' to tasks_list(), which is good practical guidance. However, it doesn't explicitly state when to use this over alternatives, though the read-only nature and examples make it clear enough.

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=false, destructiveHint=false, and idempotentHint=true, covering the safety profile. The description adds the specific state change but no extra behavioral details (e.g., permissions, error conditions). With annotation coverage, this is adequate.

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, front-loaded sentence, but it includes an Args section that duplicates the schema. Slight redundancy, but overall concise and well-organized.

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

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

For a simple state-change tool with robust annotations and full schema coverage, the description is adequate. It doesn't explain return values, but no output schema exists, and the idempotent hint covers repeated calls. A minor gap is the lack of guidance on when listId 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?

Schema coverage is 100% with descriptions for both parameters, and the description repeats the same information. It adds no additional meaning beyond the schema, so the baseline 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 tool reverts completed tasks to incomplete status, with a specific verb ('되돌립니다') and resource ('할 일'). It is distinct from siblings like tasks_complete and tasks_delete, 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 implies its usage for completed tasks that need to be undone, but it does not explicitly state when to use it versus alternatives or provide exclusions. The purpose makes the primary use case evident, but no direct guidance is 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 indicate readOnlyHint=false, idempotentHint=true, and destructiveHint=false, covering the safety profile. The description adds no additional behavioral details (e.g., overwrite semantics, clearing fields, or effects on completed tasks). It merely restates the fields and examples, so it adds minimal value beyond annotations.

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

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

The description is well-structured with a clear purpose sentence, an Args list, and examples. Every section serves a purpose; there is no redundancy or filler. The examples are concise and directly demonstrate usage.

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 update operation with no output schema, the description provides sufficient context for basic use: which fields can be updated and example invocations. However, it lacks edge-case guidance (e.g., how to clear a field, whether listId is needed for default list, or behavior on invalid IDs), which would improve completeness.

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

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

The schema descriptions cover 100% of parameters, but the description adds clarity by explicitly marking optional parameters ('선택') and providing example argument values (e.g., 'id: "..."', 'notes: "새 메모"'). This helps the agent understand how to map natural-language requests to parameters, going beyond the raw 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 it modifies Google Tasks task titles, notes, and due dates, using the verb '수정합니다' (edits). This distinguishes it from sibling tools like tasks_add (create), tasks_complete/uncomplete (status changes), tasks_delete, and tasks_list.

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?

Examples provide concrete usage scenarios ('add a memo', 'change the title') and natural-language mappings, conveying when to call this tool. However, it does not explicitly contrast with siblings such as tasks_complete or tasks_delete, so the when-not-to-use guidance is implicit rather than explicit.

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