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

Annotations are absent, so the description must disclose behavioral traits. It only states the action ('Create a task') but provides no details on side effects, permissions, reversibility, or error behavior. For a mutation tool with no annotation coverage, this is insufficient.

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 single sentence is free of fluff and front-loads the purpose, but it is too sparse—it carries only the verb+resource and no additional value. It is not over-concise to the point of obscuring purpose, but it under-delivers on 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?

With 5 parameters, no annotations, and an output schema not referenced, a one-sentence description is grossly incomplete. An agent cannot determine required parameter formats, return values, or any special behaviors. This falls far short of being complete for a task-creation 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 for the 5 parameters. It mentions none of the parameters (title, when, notes, tags, project_id), leaving their purpose and formatting entirely undefined.

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 'Create' and the resource 'task', specifying it through Things' AppleScript interface. This distinguishes it from sibling tools like get_todos, update_todo, and search_todos 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?

No guidance on when to use this tool versus alternatives. There are update_todo and update_checklist siblings, but the description does not mention conditions or prerequisites, leaving the agent to infer 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?

No annotations are provided, so the description carries the full burden of behavioral disclosure. It only states the purpose and the use of AppleScript API, but does not explicitly indicate read-only behavior, potential permissions, side effects, or any operational constraints. For a tool with no annotations, this falls short of adequate 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 a single, concise sentence that immediately identifies the action and resource. It contains no filler or redundant details, making it optimally front-loaded and 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?

For a simple no-parameter getter with an output schema, the description provides sufficient context: it names the resource and the underlying API. The output schema covers return values, and the absence of parameters eliminates misuse risk. It could mention read-only semantics, but that is implicit and not critical given the tool's simplicity.

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

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

The tool has zero parameters, and the schema has 100% coverage (an empty object). With no parameters to explain, the description adds no additional semantics, which is appropriate. The baseline of 4 applies because there is nothing to document 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 clearly states the verb 'Get' and the resource 'Anytime tasks', which distinguishes it from sibling tools like get_today and get_upcoming by the specific task scope. However, it does not explicitly contrast itself with those alternatives, relying on the resource name to imply 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 implies the tool is for retrieving Anytime tasks, making its usage context obvious from the name and resource. However, it provides no explicit guidance on when to choose this over sibling tools, nor any exclusions or conditions. Since it is a zero-parameter getter, the ambiguity is low but still present.

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 disclosing behavioral traits. It only mentions that the tool uses 'Things' official AppleScript API', which gives implementation context but does not state whether the operation is read-only, whether it has side effects, or any rate limits or access requirements. Since it's a 'get' operation, it's likely safe, but this is not explicitly 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 a single, concise sentence with no filler. It front-loads the core action ('Get Inbox tasks') and adds the implementation detail (AppleScript API) efficiently. Every word earns its place.

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 zero-parameter getter with an output schema present, the description is largely sufficient. It clearly identifies the resource and the underlying API. It could benefit from a brief note on what 'Inbox' represents, but the output schema likely covers return format, so the description is complete enough for a simple 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 tool has zero parameters, and the schema trivially reflects that (100% coverage). Per the baseline for 0-parameter tools, a score of 4 is appropriate. The description does not need to explain parameter semantics, and it does not attempt to, which is fine given there are none.

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 ('Get') and resource ('Inbox tasks'), and mentions the API used. It distinguishes from siblings like get_today and get_upcoming by naming the specific resource. However, it doesn't explicitly differentiate from other 'get_*' tools beyond the resource name, which is sufficient but not deeply explanatory.

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 get_today or get_upcoming. There is no mention of typical scenarios, prerequisites, or exclusions. An agent would have to infer from the name that it retrieves inbox tasks, but no explicit usage context 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?

No annotations are provided, so the description carries the full burden. The word 'List' implies a read-only operation, but it does not explicitly state that it has no side effects, requires no permissions, or is safe to call. A more transparent phrasing like 'This read-only operation returns...' would improve this.

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 with no wasted words. It communicates the action, scope, and a key output feature in minimal space, which is ideal 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?

For a zero-parameter list tool with an output schema available, the description is sufficient. It tells the agent what the tool does and the key detail of stable IDs. No additional information (pagination, errors, etc.) is needed given the simple nature and existing 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?

There are zero parameters, and the schema coverage is 100% (empty object). With zero parameters, the baseline is 4, and the description adds value by stating the output includes stable IDs, giving the agent useful expectations without needing to inspect the output schema.

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

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

The description clearly states the verb 'List', the resource 'all Things projects', and adds a specific output detail (stable IDs). It is unambiguous and distinguishes itself from sibling tools like get_todos or get_inbox by naming the exact 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?

There is no explicit guidance on when to use this tool versus alternatives (e.g., 'when you need to fetch projects' or 'use get_todos for tasks'). The context of the sibling list implies it, but no direct or indirect usage suggestion is present.

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 only mentions the API used and the action, but does not indicate whether the operation is read-only, what side effects exist, or what the return payload contains beyond 'Someday tasks'. This is a basic getter, but the lack of any side-effect or safety hint leaves the agent without important 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 a single, concise sentence with no fluff. It is front-loaded with the action and resource, and every word adds value. It is appropriately short for a tool with no parameters.

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 an output schema, the description does not disclose any operational details such as read-only nature, performance considerations, or any prerequisites. Without annotations, an agent cannot tell if this is safe to call in any context or if it requires certain permissions. The description is minimal and leaves the agent with unanswered questions about when and how to use it.

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?

There are no parameters (schema is empty, coverage 100%), and the baseline for 0 params is 4. The description adds a bit of meaning by specifying the resource ('Someday tasks'), which helps interpret the output schema. No further compensation is needed.

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 ('Get') and the resource ('Someday tasks'), naming the specific list from Things. It is distinguishable from sibling tools by the explicit 'Someday' qualifier, though it does not elaborate on what 'Someday' means or how it differs from 'Anytime' or 'Upcoming'.

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?

There is no guidance on when to use this tool versus its siblings (e.g., get_today, get_anytime). The description only states what it does, leaving the agent to infer the appropriate context based on the tool name. No when-not-to-use or alternative routing is 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 behavioral burden. It does add value by specifying 'directly applied' — implying inheritance or project-level tags are excluded — which is a meaningful scoping detail. However, it does not disclose return ordering, pagination, or how a tag is matched (by name or ID), leaving important behavior unexplained.

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?

A single efficient sentence with no filler. It front-loads the action and the distinguishing scope ('directly applied'). It cannot be trimmed further, though the brevity comes at the cost of the behavioral and parameter detail penalized elsewhere.

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?

While an output schema exists and covers the return shape, there are no annotations, 0% schema description coverage, and no sibling differentiation. For a single-parameter tool the definition is minimal but leaves the tag format and the distinction from search_todos unresolved, so an agent would still need to guess at correct 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?

Schema description coverage is 0%, so the description must compensate, but it does not. The sole parameter 'tag' is a bare string whose format (name vs. ID, exact vs. partial match) is never clarified anywhere. The description merely restates what the schema already shows, adding nothing about how to properly populate the tag parameter.

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 (get) and resource (tasks with a directly applied tag), which distinguishes it from general list tools like get_todos and get_inbox. The function is clear enough that an agent can separate it from most siblings based on the tag concept alone.

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 given on when to use this tool versus alternatives such as search_todos (which likely also filters by tag) or the other get_* list tools. The phrasing 'directly applied tag' hints at a scope distinction from inherited tags, but no explicit when-to-use or when-not-to-use conditions are provided.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It only mentions that it uses Things' AppleScript API, giving a hint about implementation but not about side effects, required permissions, or return format. The tool is likely read-only, but this is not explicitly 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?

A single, front-loaded sentence that conveys the essential purpose without any fluff. Perfectly concise for the tool's simplicity.

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 zero parameters and an output schema, the description is adequate but sparse. It does not mention prerequisites (e.g., Things app must be running) or any limitations. For a simple getter, this is minimally sufficient but leaves some context unaddressed.

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

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

The tool has zero parameters, so the baseline for this dimension is 4 per the rubric. The description does not add parameter-specific meaning, but none is needed since the schema is empty.

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: 'Get Today tasks'. It clearly identifies what the tool does. While it doesn't explicitly differentiate from sibling tools like get_inbox or get_upcoming, the resource 'Today' is distinct enough that 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. It does not mention that this is for Today's tasks only, nor does it suggest other tools for different lists. The user must infer usage from the name 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 full burden of behavioral disclosure. It only says 'Get', implying read-only, but does not disclose behaviors like error handling for invalid project IDs, ordering of tasks, pagination, or whether subtasks are included. For a read operation, this is a notable gap given zero annotation support.

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?

One sentence, no redundancy, and the key fact (project ID) is front-loaded. Every word adds value, and there is no extraneous 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 tool with one required parameter and an output schema (so return format is defined elsewhere), the description covers the core purpose and parameter role. However, it lacks usage alternatives and behavioral nuances that would make it fully self-sufficient for an agent. Given the simplicity, a 3 is appropriate.

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 provides no description for project_uuid (0% coverage). The description adds that the parameter is 'its Things ID', clarifying the nature of the identifier, which the schema alone does not convey. However, it does not specify format, length, or any constraints beyond being a string, so the semantic enrichment is minimal.

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 ('Get') on a specific resource ('a project's tasks') and identifies the key qualifier ('by its Things ID'). This clearly distinguishes it from sibling tools like get_inbox (non-project tasks) and search_todos (generic search), so an agent can select it correctly.

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: when you have a project ID and need its tasks. However, it does not explicitly mention alternatives or prerequisites (e.g., 'obtain the ID via get_projects' or 'use search_todos for filtered results'). The usage context is implied rather than 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 responsibility for behavioral disclosure. It only mentions the AppleScript API, which is a technical note but not behavioral. It does not state that this is a read-only operation, nor does it mention any side effects, permissions, or return behavior. Minimal disclosure for a simple getter.

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 states the action, resource, and API. It is front-loaded and contains no fluff. This is an ideal length 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 that the tool has no parameters and an output schema exists, the description is mostly sufficient. However, it does not clarify how 'Upcoming' differs from sibling tools like get_today or get_anytime, which could cause confusion. But given the naming convention and the fact that the output schema will clarify the return format, this is a minor gap. A 4 feels appropriate.

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

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

The tool has zero parameters, and schema coverage is effectively 100% (empty schema). Per the baseline for 0 parameters, a score of 4 is appropriate since there is nothing to explain beyond what the schema already states. The description adds no parameter info, but none is needed.

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 ('Get') and the resource ('Upcoming tasks') with a specific API. It does not explicitly differentiate from sibling tools like get_today or get_anytime, but the name and resource are specific enough. Slight deduction for lack of explicit 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?

No guidance on when to use this tool versus alternatives. It simply states what it does without mentioning context, prerequisites, or exclusions. An agent would have to infer usage from the resource name 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?

No annotations are provided, so the description carries the full burden. It discloses that search operates 'without direct database access' but fails to describe result ordering, pagination, case sensitivity, or that it is read-only. This is a significant gap for a search 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, front-loaded sentence that efficiently communicates the purpose. The phrase 'without direct database access' is vague and adds little value, but overall the structure is clean.

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 one-parameter schema and presence of an output schema, the description covers the basics but omits practical details like result limits, scope (e.g., user's own todos), or any behavioral nuances. It is minimally sufficient but leaves room for misinterpretation.

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 explain the 'query' parameter. It indicates the query targets titles and notes, adding some meaning, but does not clarify match semantics (partial, case-insensitive, etc.). Partial compensation, but not enough.

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 ('Search') and resource ('task titles and notes'), making the core function clear. It does not explicitly differentiate from siblings like get_todos, but the search intent is distinct enough from listing 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 for searching, but does not state when to prefer this over get_todos or other listing tools, nor does it provide exclusions or context about alternatives. Guidance is solely implicit.

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 does mention the need for THINGS_AUTH_TOKEN, which is useful, but it never describes side effects, idempotency, or that the operation likely replaces the entire checklist via the default 'replace' mode. The behavior is largely opaque.

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, so it is not verbose, but it is not appropriately sized because it omits critical information. The phrase 'documented URL scheme' is vague and adds little value, while the auth requirement could be placed elsewhere. It is under-specified rather than efficiently 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?

For a tool with three parameters, no annotations, and an output schema, this description is far too sparse. It fails to explain how to form the checklist_items, what the mode parameter does, what the output schema contains, or any behavioral expectations. An agent has almost no guidance for correct 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?

Schema description coverage is 0%, so the description must compensate by explaining the parameters. It does not mention id, mode, or checklist_items at all, nor clarify the meaning of the 'mode' default or the array structure. The agent receives no additional semantic information beyond what the schema types alone convey.

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 verb ('change') and a resource ('checklist'), so the basic purpose is clear. However, it does not explain what 'change' entails (add, remove, reorder, replace?) and does not distinguish it from sibling tools like update_todo, making the exact scope ambiguous.

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 given on when to use this tool versus alternatives. It mentions a 'documented URL scheme' and an auth token, but these are implementation details, not usage context. There is no indication of prerequisites beyond the token or situations where another tool would be more appropriate.

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 must carry the burden of behavioral disclosure. It mentions only the special detach behavior for project_id, but does not explain whether fields are partially updated, whether null values clear fields, or what the return value is. The mutation semantics are implied by 'Edit' but not elaborated, leaving agents uncertain about side effects.

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 with zero waste. The core purpose is front-loaded, and the special-case instruction is placed directly after. It is appropriately sized for the information provided, though it could be expanded without becoming verbose.

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 7 parameters, 1 required, and an output schema, this description is under-specified. It fails to explain update semantics (partial vs. full), the effect of null defaults, or how the tool differs from update_checklist. An agent would need to infer too much to call the tool correctly across all parameter combinations.

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 is the only source of parameter meaning. It enhances project_id with the special detach semantics, but other parameters (tags, when, notes, title, status) are left to inference from their names. No guidance is given on whether they are overwritten or how null interacts with them, which is insufficient for a 7-parameter tool.

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 and resource ('Edit a task') and implies an update operation, distinguishing it from read tools like get_todos and creation tools like add_todo. However, it does not explicitly contrast with update_checklist or specify the full scope of editable fields, leaving some 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 offers a specific usage hint (pass project_id='' to detach) but provides no general guidance on when to use this tool versus alternatives like add_todo or update_checklist. It does not state that this tool is for modifying existing tasks or when other tools are more appropriate.

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