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

Annotations are absent, so the description carries the full burden. It usefully discloses the default placement behavior (append to end when no positioning args are given), but omits idempotency (what happens if the task is already in the project), auth requirements, and failure modes.

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 core action and followed by the key default behavior. Nothing wasted.

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 association tool with no annotations and no output schema, the description covers the main action and default placement, but leaves idempotency, error conditions, and permission needs 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?

Schema description coverage is 100%, so the schema already documents all five parameters including the mutual-exclusion rule. The description adds only the tie between 'positioning arguments' and the default end-of-project behavior, which is minimal added value over 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 a specific verb and relationship: adding an existing task to a project. It is clearly distinguishable from siblings like asana_remove_project_from_task and asana_add_tag_to_task, though it does not explicitly name those alternatives.

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 describes what happens with positioning arguments but gives no guidance on when to use this tool versus asana_update_task or asana_create_task, nor any prerequisites such as needing an existing task and project.

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 does not disclose whether adding an already-present tag is idempotent, what permissions or scopes are required, or whether the operation is reversible — meaningful gaps for a mutation tool.

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

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

A single, front-loaded sentence with zero waste. It is appropriately sized, though the brevity comes at the cost of omitting useful context rather than being efficiently dense.

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

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

For a mutation tool with no annotations, no output schema, and no behavioral detail, the description leaves the agent without the context needed to call it confidently. It covers only the bare identity of the operation.

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 both parameters (task_gid, tag_gid), so the schema already explains them fully. Per the baseline rule for high coverage with no additional param meaning in the description, a 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 verb ('Add') and resource ('a tag to a task'), which is enough to distinguish it from the sibling asana_remove_tag_from_task. It does not, however, explicitly name alternatives or scope, so it falls short of a 5.

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

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

There is no guidance on when to use this tool versus alternatives like asana_create_tag_for_workspace, asana_get_tags_for_task, or asana_remove_tag_from_task, and no prerequisites (e.g. needing an existing tag GID) are stated. The agent must infer all of this from the tool 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 provided, the description carries the full burden of behavioral disclosure. It only says 'Set dependencies' without explaining whether this replaces or adds to existing dependencies, what happens on error, or if special permissions are required. This is a minimal mutation description with zero behavioral 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 short sentence with no fluff, but it is under-specified. It essentially restates the tool name with minimal added value. While concise, it lacks the detail expected for a tool description, so it is not well-optimized for usefulness.

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?

This is a mutation tool with no annotations and no output schema. The description fails to explain return values, idempotency, whether dependencies are appended or replaced, or how it relates to sibling tools. For a simple but consequential operation, this is severely 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?

The input schema has 100% coverage, describing both task_id and dependencies array. The description adds no additional meaning beyond the schema, such as relationship semantics or edge cases. Baseline 3 is appropriate given the schema completeness.

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 'Set' and resource 'dependencies for a task', making the specific action unambiguous. However, it does not explicitly differentiate from the sibling tool asana_add_task_dependents, though the term 'dependencies' helps indicate direction.

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 like asana_add_task_dependents or asana_update_task. There are no preconditions, exclusions, or context about when this action is 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 carries full burden for behavioral disclosure. It explains the direction of dependencies but uses 'Set' which could imply replacing all dependents rather than adding to existing ones (the tool name says 'add'). No side effects, mutability, or return behavior are disclosed, which is a significant gap 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, front-loaded sentence with no filler. Every word contributes to explaining the operation, making it highly concise and well-structured for quick parsing.

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

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

Given the tool has no annotations and no output schema, the description should provide more context about behavior, such as whether it appends or replaces dependents, and what the successful response looks like. The description only covers the bare purpose, leaving critical usage details 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?

Schema description coverage is 100%, and the schema already explains both parameters clearly. The description's parenthetical 'tasks that depend on this task' is redundant with the schema's own wording, so it adds no additional semantic value beyond what the schema provides.

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 uses a specific verb ('Set') and resource ('dependents for a task'), with a parenthetical clarifying that the dependents are tasks that depend on this task. This direction disambiguates it from the sibling 'asana_add_task_dependencies', which sets the opposite dependency direction.

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 explicit guidance is given on when to use this tool versus alternatives like asana_add_task_dependencies. The description implies a use case but does not state prerequisites, exclusions, or relational context, leaving the agent to infer when this is the appropriate choice.

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 behavioral burden, and it is a bare one-liner. It does not disclose permission/auth requirements, whether the caller becomes a project member, side effects, or what happens if name collides. For a mutation tool with zero annotation coverage this is a substantial 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?

A single front-loaded sentence with zero filler. It is as short as it can be while still stating the action and scope, though the brevity borders on under-specification.

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 8 parameters, no annotations, and no output schema, the description should at minimum note the workspace-vs-team requirement or the creation's side effects. It mentions the two scopes only in passing and omits any behavioral or prerequisite context, leaving the agent to derive everything from the 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 description coverage is 100%, so every field (including the color enum values, default_view, privacy_setting, opt_fields) is fully documented in the schema itself. The description adds nothing beyond it, which is the baseline 3 when the schema does the lifting.

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 gives a specific verb+resource ('Create a new project') and names the two container scopes (workspace or team), so the operation is unambiguous. It does not differentiate itself from siblings like asana_get_project or asana_search_projects, but the create verb is inherently distinct, so this is clear rather than exceptional.

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 alternatives such as asana_search_projects (to find existing projects before creating) or when a team GID is mandatory. The only hint that 'team' is required for organization workspaces lives in the schema, not the description.

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 must carry the full burden of behavioral disclosure. It only says that a status update is created, but does not mention required permissions, the effect on existing project statuses, whether the operation is reversible, or what the response contains. This is a significant gap 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 sentence that is front-loaded with the action ('Create') and the resource ('status update for a project'). It contains no redundancy or unnecessary words, making it highly concise and well-structured.

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 six parameters and no output schema, the description offers only the barest functional statement. It lacks usage context, behavioral details, and return value information, leaving the agent under-informed about the tool's broader implications and expected response.

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

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

The input schema has 100% description coverage, so all six parameters are already well-documented. The tool description adds no additional parameter semantics beyond what the schema provides, 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 uses a specific verb ('Create') and a clear resource ('status update for a project'), making the tool's purpose explicit. It distinguishes this tool from sibling tools like asana_get_project_status and asana_delete_project_status, which are distinctly different operations.

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, no mention of prerequisites, and no exclusion criteria. It simply states the function without any contextual advice, leaving the agent to infer usage from the tool 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 bears full responsibility for behavioral disclosure. It only states the basic action without mentioning prerequisites (e.g., parent task must exist), failure modes, permissions, or any side effects. The description adds no context beyond what is obvious from the tool name.

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 purpose. It is efficient with no filler, but it is so minimal that it may leave out useful details 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?

The tool has 7 parameters, no output schema, and no annotations. The description explains only the core operation, leaving the agent without guidance on response format, parameter specifics (e.g., how assignee 'me' works), or edge cases. For a tool of this complexity, the description is insufficient.

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%, and the description adds no parameter-specific semantics beyond the schema. Baseline for high schema coverage is 3, and the description does not improve or detract from this.

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 uses a specific verb ('Create') and resource ('subtask for an existing task'), clearly distinguishing it from sibling tools like create_task or set_parent_for_task. It is unambiguous about the operation performed.

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 such as asana_create_task or asana_set_parent_for_task. The description does not mention any prerequisites, validations, or scenarios 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 carries the full behavioral burden yet discloses nothing beyond the bare action. It is silent on permission requirements, duplicate-name behavior, idempotency, and what the call returns, all of which matter for a write 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?

A single front-loaded sentence with zero redundancy — the core action is stated immediately. It is efficient, though the extreme terseness contributes to its other gaps.

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 input schema is well documented at 100% coverage and there is no output schema to explain, so the structured data carries the parameter detail. However, for a mutation tool with no annotations, the description is too thin on behavioral context to be fully complete.

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

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

Schema description coverage is 100%, so the schema fully documents name, color, notes, followers, opt_fields, and workspace_gid. The description adds no extra meaning beyond the schema, 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?

States a specific verb and resource ('Create a new tag') plus the scoping context ('in a workspace'), which distinguishes it from tag-mutating siblings like asana_update_tag and asana_delete_tag. It does not, however, explicitly contrast with the related read tools such as asana_get_tags_for_workspace.

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 no guidance on when to use this tool versus alternatives such as asana_add_tag_to_task or asana_get_tag. There are no stated prerequisites (e.g., needing workspace membership) and no exclusions.

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

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

With no annotations provided, the description carries the full burden of disclosing behavioral traits. However, it only states the basic action and omits any context such as whether authentication is required, what the response contains, or side effects (e.g., task appears in project timeline). It adds no value beyond the schema.

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, direct sentence with zero wasted words. It is front-loaded and immediately states the action and object, making it optimally concise for quick parsing.

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 has 11 parameters, no output schema, and no annotations, yet the description is only one sentence. It fails to convey expected return values, error conditions, or important behavioral nuances (e.g., that project_id is required despite being listed among optional-looking properties). For a create operation with this complexity, the description is insufficiently 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%, so the schema already documents all 11 parameters in detail, including the complex html_notes restrictions and custom_fields format. The description adds no parameter-level meaning, but the baseline of 3 is appropriate because the schema does the heavy lifting.

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 'Create a new task in a project' uses a specific verb ('Create') and resource ('task in a project'), clearly distinguishing it from sibling tools like asana_create_subtask and asana_update_task. It unambiguously states the tool's primary action.

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 like asana_create_subtask or asana_update_task. It does not mention any exclusions, prerequisites, or contextual clues, leaving the agent to infer usage solely 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?

With no annotations provided, the description carries the full burden for behavioral disclosure. It states the required input but does not mention whether this is a write operation requiring permissions, whether the action is reversible, what the response contains, or any side effects. This is insufficient 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, focused sentence that directly states the action and a key requirement. No wasted words, and it is perfectly sized 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?

The tool has no output schema and no annotations, so the description should explain return values or at least the effect of the action. It doesn't mention what the response will be, any prerequisites (e.g., authentication), or additional behavior. Given its simplicity, it is not fully complete for an agent to understand the full context of invoking this 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 input schema already provides detailed descriptions for all four parameters (100% coverage), so the baseline is 3. The description adds value by clarifying the relationship between text and html_text ('Either text or html_text is required'), which is a semantic constraint not enforced by the schema's required fields. This goes beyond mere repetition.

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 uses a specific verb ('Create') and resource ('a comment or story on a task'), clearly distinguishing it from sibling tools like asana_create_task (creates a task) and asana_get_task_stories (retrieves stories). The parenthetical about required input adds clarity 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 implies the use case: when you need to add a comment or story to a task. However, it does not explicitly state when not to use it or mention alternatives among the sibling tools. The requirement that text or html_text be provided gives a functional constraint but 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?

With no annotations, the description carries the burden of indicating the destructive nature. It explicitly says 'Delete', which conveys the core behavior, but it does not disclose permanence, side effects, or required permissions. Minimal but acceptable.

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, clear, and concise sentence. Every word earns its place with no redundant information.

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

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

For a simple delete operation with one parameter and no output schema, the description is functionally adequate but lacks any context about irreversibility, errors, or expected behavior after deletion. It meets minimum viability but doesn't enrich the agent's understanding.

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

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

Schema description coverage is 100%, and the parameter 'project_status_gid' is clearly described as 'The project status GID to delete'. The description adds no extra semantic detail beyond the schema, 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 'Delete a project status update' uses a specific verb and resource, clearly distinguishing it from sibling tools like get and create project status. It leaves no ambiguity about the tool's function.

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 about when to use this tool versus alternatives. There is no mention of prerequisites, scenarios for deletion, or warnings about irreversible actions.

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 must carry the full behavioral burden. It states only that a tag is deleted, but does not disclose whether the deletion is permanent, what permissions are required, whether it cascades to tasks, or what the response looks like. For a destructive operation, this is a minimal disclosure (score 2).

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, but it is so minimal that it fails to provide necessary context for a destructive tool. Conciseness is not the issue; the content is under-specified. A score of 3 reflects that it is structurally clean but substantively thin.

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 this is a destructive delete operation with no annotations and no output schema, the description should provide at least basic behavioral context (e.g., permanence, permissions). It instead offers only a tautological restatement. This leaves significant gaps for an agent to call the tool safely and correctly.

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

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

Schema description coverage is 100% for the single required parameter 'tag_gid', which already documents it as the globally unique identifier. The description adds no additional meaning, syntax, or constraints beyond what the schema provides. The baseline for high schema coverage is 3.

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 'Delete a tag' is a direct restatement of the tool name 'asana_delete_tag', adding no new information. It does not distinguish this tool from sibling delete operations such as asana_delete_task or asana_delete_project_status. This matches the rubric's definition of tautology (score 2).

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, nor does it mention prerequisites or exclusions. There is no implied usage context beyond the tool name itself. This is 'no guidance' (score 2).

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 behavioral burden, and it does deliver the single most important trait: permanent, irreversible deletion. It remains silent on other consequential behaviors an agent would want before calling it — whether subtasks, stories, or tag associations are cascade-deleted, what permissions are required, and what the response contains.

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 with zero filler; the core action is front-loaded and the destructive warning follows immediately. Nothing could be removed without losing 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 destructive, irreversible operation with no annotations and no output schema, the definition covers the essential warning but omits cascade effects, permission prerequisites, and error behavior. An agent can call it correctly, but cannot fully predict the consequences of doing so.

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?

Only one parameter exists and the schema documents it fully ('The task ID to delete'), so the schema already carries the semantics. The description adds nothing about the ID's format or accepted sources (GID vs. name), making this a baseline case where the schema does the heavy lifting.

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?

States a specific verb and resource ('Delete a task'), which cleanly distinguishes it from the many read/create/update siblings sharing the asana_ prefix. It does not, however, explicitly differentiate itself from other delete siblings such as asana_delete_tag or asana_delete_project_status beyond the resource noun.

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 versus alternatives (e.g. removing a task from a project with asana_remove_project_from_task instead of deleting it outright) and no stated prerequisites or permission requirements. The irreversibility note hints at caution but is not framed as usage 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?

With no annotations provided, the description carries the full burden for behavioral disclosure. It does disclose the 25-task maximum limit, which is a key constraint, but it omits any details about error behavior, permissions, or return format. This is a modest disclosure that avoids contradictions.

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 core purpose and key limit. No filler or redundant content exists.

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

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

Given the tool's relative simplicity (2 params, no output schema), the description adequately covers the essential use case. It notes the batch aspect and max limit, but lacks any detail about response shape or error cases, which would be expected in a fully complete context. Still, it is sufficient for a straightforward GET operation.

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?

Because schema description coverage is 100%, the schema already fully documents both parameters (task_ids and opt_fields). The description adds little beyond the schema, only hinting at 'detailed information' which is not a strong supplement. 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 action ('Get'), the resource ('tasks'), and the specific qualifier ('by their GIDs', 'multiple', 'maximum 25 tasks'). This distinguishes it from single-task retrieval (asana_get_task) and search 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 retrieving multiple tasks by GID, which is a clear context. However, it does not explicitly contrast with alternatives like asana_get_task or mention when not to use it, so there is slight room for improvement.

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 says 'Get detailed information' without explaining what 'detailed' includes, whether pagination or field selection is supported (though opt_fields exists), or what the response structure looks like. The tool is read-only in intent, but that is implied rather than explicit.

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 is efficient and front-loaded, stating the core action and resource. It avoids redundancy and verbosity. However, its brevity borders on under-specification, which is a completeness issue rather than a conciseness one, so the structure itself is fine.

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 there are no annotations, no output schema, and a relatively simple tool, the description should still provide more context about what information is returned and when to use it. The vague phrase 'detailed information' does not tell the agent what to expect, and there is no comparison to sibling tools. The description is minimally viable but lacks 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 input schema covers both parameters (project_id and opt_fields) with descriptions, so schematically the meaning is clear. The description adds no additional semantics beyond the schema; it merely restates that a specific project is retrieved, which maps to project_id. Since schema coverage is 100%, 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 the tool's purpose: to retrieve detailed information about a specific project. The verb 'Get' and resource 'project' are specific, and the mention of 'a specific project' aligns with the required project_id parameter. However, it does not explicitly distinguish itself from sibling tools like asana_search_projects or asana_get_project_status.

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 it is for retrieving a project by ID, nor does it suggest when to use search_projects or other get/list tools. There is no mention of exclusions or prerequisites.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It only says 'Get sections in a project' and does not state whether the operation is read-only, how results are returned, or any pagination or limitations. This adds little beyond the tool's name.

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, front-loaded with the key information. There is no filler or unnecessary detail, making it highly efficient.

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

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

For a simple read operation with complete parameter schema, the description is minimally adequate. However, without an output schema or annotations, it would benefit from stating the return type (e.g., 'list of sections') or any relevant caveats. It is not incomplete but leaves some ambiguities.

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

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

The schema description coverage is 100%, with both parameters already described in the input schema. The description does not add any additional meaning about parameters, 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 states the action ('Get') and the resource ('sections in a project'), which is specific and distinguishes it from sibling tools like asana_get_project and asana_get_project_status. However, it is a minimal restatement and does not explicitly elaborate on scope or differentiate further.

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 any context, prerequisites, or exclusions, and there is no reference to sibling tools or alternative approaches.

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 disclosure. It only states the read action itself and provides no information about authentication, required permissions, return format, or any side effects. This is minimal and leaves the agent to infer the behavior from the tool name.

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, short sentence that is front-loaded and free of filler. However, it is so brief that it omits necessary context, though this is more a completeness issue than a conciseness issue.

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 get tool with two well-documented parameters, the description still lacks important context: it does not explain what is returned, that it requires a project status GID, or how it differs from the plural listing tool. With no output schema and no annotations, the description is insufficient to fully guide an agent.

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 both parameters (opt_fields and project_status_gid), so the schema already documents their meaning. The description adds no additional parameter context, earning the baseline score of 3.

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 'Get a project status update' states the action and resource clearly enough, but it is vague and does not specify that it fetches a single status by GID. It could easily apply to the sibling tool asana_get_project_statuses, so it fails to distinguish between them.

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

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

No guidance is provided on when to use this tool versus alternatives. The description does not mention that this tool retrieves a specific project status by GID, nor does it contrast with listing or creating statuses.

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 action without mentioning pagination behavior, return format, ordering, or potential errors, which is a meaningful gap for a tool with offset/limit parameters.

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 with no filler. It clearly conveys the core action and resource without any unnecessary words, making it easy 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?

With no output schema and no annotations, the description must provide more context but does not. It fails to explain the response shape, pagination semantics despite having limit/offset parameters, or what constitutes a 'status update,' leaving the agent under-informed.

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 all four parameters, so the schema fully documents them. The description adds no additional semantic value beyond what the schema already provides, thus 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 it retrieves all status updates for a project, with a specific verb and resource. The word 'all' distinguishes it from the sibling tool asana_get_project_status (singular), making it clear this is for the full 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?

No guidance is given on when to use this tool versus alternatives such as asana_get_project_status or asana_get_task_stories. There is no mention of prerequisites, exclusions, or context where this endpoint is preferred.

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 disclose behavioral traits. The 'Get' verb implies a read-only operation, but the description does not add details such as whether the count includes subtasks, whether it reflects a snapshot, or any response structure. It is minimally transparent beyond the name itself.

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 communicates the core function. It is front-loaded with the verb and resource, and there is no wasted wording.

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 lack of an output schema and annotations, the description should clarify the return value format (e.g., a bare integer vs. an object with a count field). It also does not mention how opt_fields might affect the response. The description is too terse to fully prepare an agent to consume the tool's output reliably.

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

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

Schema description coverage is 100%, so the baseline is 3. The description does not add any parameter semantics beyond what the schema already provides. It neither clarifies project_id nor opt_fields, so it adds no extra value over the structured fields.

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 'Get the number of tasks in a project' uses a specific verb+resource and clearly identifies the operation. It distinguishes this tool from siblings like asana_get_project (which fetches project details) and asana_get_multiple_tasks_by_gid (which lists tasks). The scope is well-defined.

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. There are no exclusions or mentions of related sibling tools. The description only states what it does, not the context or use cases, leaving the agent without explicit decision support.

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. 'Get' correctly implies a read-only operation, but the description discloses nothing about returned fields, permission requirements, or error behavior when the tag_gid is invalid.

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 short sentence, front-loaded with the verb and resource. Efficient and waste-free, though it is arguably under-specified rather than optimally 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 simple two-parameter getter with no output schema, the description should at least hint at what 'detailed information' includes or how opt_fields affects the response. It is minimally viable but leaves return-shape context unstated.

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 both tag_gid and opt_fields are already documented in the schema. The description adds no extra syntax or format meaning beyond that, which is the baseline-3 case.

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?

States a specific verb+resource ('Get detailed information about a specific tag'), which is clear on its own. However, it does not distinguish itself from sibling retrieval tools like asana_get_tags_for_task or asana_get_tags_for_workspace, leaving the agent to infer the by-GID vs by-collection distinction.

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

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

No when-to-use guidance, no mention of when to prefer this over the sibling tag-listing tools, and no prerequisites stated. The agent gets no routing help.

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 doesn't disclose pagination behavior (despite limit/offset params), return format, or auth requirements for what is a read 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?

A single terse sentence that is front-loaded and waste-free. It is efficient, though perhaps overly terse given the tool's capability.

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 read tool with no annotations and no output schema, the description should explain return shape (list of tag objects), pagination, and relation to siblings. It provides none of this, leaving significant 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 coverage is 100%, so the schema fully documents all four parameters including limit, offset, task_gid, and opt_fields. The description adds no parameter detail beyond what the schema 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?

States a clear verb+resource: retrieving tags for a specific task. It's distinguishable from siblings like asana_get_tasks_for_tag (reverse direction) and asana_get_tags_for_workspace (different scope), but the description doesn't explicitly differentiate these.

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 when-to-use guidance, no mention of alternatives like asana_get_tasks_for_tag for the reverse lookup, and no prerequisites stated.

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

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

No annotations are provided, so the description carries the full burden of behavioral transparency. However, it only restates the tool name without adding context about pagination, read-only nature, or any potential side effects. The schema mentions limit/offset, but the description itself does not elaborate on behavior.

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

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

The description is a single, concise sentence: 'Get tags in a workspace.' It contains no wasteful words and is directly front-loaded with the core action and resource, making it easy 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?

The description provides the essential purpose but lacks detail on return values and pagination behavior, especially since there is no output schema. It is adequate for a simple GET endpoint but incomplete for an agent to understand full behavior without relying on external knowledge.

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 each parameter having a description in the input schema. The tool description adds no additional parameter semantics, but the schema already provides sufficient detail, 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 what the tool does: 'Get tags in a workspace.' It uses a specific verb ('Get'), a specific resource ('tags'), and a scope ('in a workspace'), distinguishing it from sibling tools like asana_get_tasks_for_tag (which retrieves tasks) and asana_get_project.

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

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

The description implies usage through its resource name but does not explicitly state when to use this tool over alternatives. There are no exclusions or mentions of alternative tools, so usage guidance is minimal but not absent.

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 states the tool retrieves information, implying read-only behavior, but does not disclose permissions, response format, potential errors, or side effects. The description is too minimal to provide meaningful transparency beyond what the tool name already implies.

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, tightly worded sentence that directly states the tool's purpose without any filler. It is front-loaded and efficient, earning its place in the description.

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

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

For a simple read tool with a well-covered schema, the description is minimally adequate. However, since there is no output schema to clarify return values, the vague 'detailed information' leaves some ambiguity. The lack of usage guidance and behavioral context (no annotations) slightly reduces completeness, but the low complexity of the tool makes this a borderline 3.

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 100% of parameters with descriptions for both task_id and opt_fields. The description adds no additional meaning beyond the schema, so the baseline score of 3 applies. The parameter meanings are clear solely from 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 'Get detailed information about a specific task' clearly identifies the action (get) and the resource (specific task), distinguishing it from siblings like asana_search_tasks (searching) and asana_get_multiple_tasks_by_gid (multiple tasks). The phrase 'specific task' aligns with the singular task_id parameter.

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 explicit guidance on when to use this tool versus alternatives. It does not mention that this should be used when you have a known task ID, nor does it suggest alternatives like search for finding tasks. Usage context is only implied by the word 'specific'.

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 says 'get' which implies a read-only operation, but does not mention pagination, return format, rate limits, or any side effects. The description adds no behavioral context beyond the verb.

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 wasted words. It is appropriately sized, though it is essentially a restatement of the tool's name and could have been enriched without losing conciseness.

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 has no annotations and no output schema, so the description should compensate by explaining return types, pagination behavior, or typical usage. It does none of this, leaving the agent with minimal context beyond the schema's parameter definitions.

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 five parameters are already documented in the schema. The description adds no additional meaning beyond the schema, which matches the baseline score of 3 for high coverage.

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

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

The description clearly states 'Get tasks for a specific tag' with a specific verb and resource. However, it does not distinguish this tool from siblings like asana_search_tasks, which could also retrieve tasks by tag, so it misses the top score.

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

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

No guidance is provided on when to use this tool versus alternatives such as asana_search_tasks or asana_get_multiple_tasks_by_gid. There is no context about use cases, prerequisites, or exclusions.

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

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

With no annotations provided, the description is the only source of behavioral info. It implies a read-only operation ('Get') but does not disclose details like permissions required, pagination, ordering, or the structure of returned stories. This falls short of the burden placed on descriptions when annotations are absent.

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 of nine words, directly stating the tool's purpose without any filler. It 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?

While the description is clear, it is minimal. It lacks any usage guidance, exclusions, or behavioral context beyond the basic action, and there is no output schema to clarify return values. For a tool with no annotations, this is inadequate.

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

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

The description adds no semantic information about parameters beyond the schema. The schema already fully documents task_id and opt_fields with clear descriptions, so 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 uses the specific verb 'Get' with clear objects 'comments and stories' and scope 'for a specific task'. This distinguishes it from sibling tools like asana_get_task (which retrieves the task itself) and asana_create_task_story (which creates a story).

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 about when to use this tool versus alternatives. It merely states its function without mentioning exclusions or alternative tools for related operations, such as asana_get_task for task details.

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 action without mentioning authentication, pagination, response shape, or side effects. This is a significant gap for an agent deciding whether to call the 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 with no unnecessary words. It is fully 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 list operation with one optional parameter, the description covers the basic purpose but lacks usage guidance and return-value context. Without an output schema, the agent may not know the structure of the response, making the description incomplete for a safe 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 only parameter opt_fields is fully described in the schema, so the description adds no additional meaning. Schema description coverage is 100%, warranting a baseline score of 3.

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 uses the action verb 'List' and clearly identifies 'workspaces' as the resource, which distinguishes it from sibling tools that operate on tasks, projects, and users. This is a specific and unambiguous purpose.

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 for when to use this tool versus alternatives such as asana_get_tags_for_workspace or asana_get_users_in_workspace. There is no mention of prerequisites, when not to use it, or how it fits into a workflow.

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, and it does disclose the key non-obvious behavior: the task survives removal and only the project association is lost. However, it omits idempotency, required permissions, and what happens if the task is not in the project.

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, no waste, with the core action front-loaded and the critical non-destructive clarification immediately after.

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 two-parameter mutation with no output schema and no annotations, the description conveys the essential outcome (association removed, task retained). It is nearly complete but leaves error cases and permission requirements 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?

Schema description coverage is 100% and both parameters are fully documented in the schema, so the description adds no param-level detail beyond it. Baseline 3 applies when the schema does the heavy lifting.

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?

States a specific verb and resource: 'Remove a task from a project.' The second sentence explicitly distinguishes this from asana_delete_task by clarifying the task continues to exist, which is the exact disambiguation an agent needs among these siblings.

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?

Usage is only implied: an agent can infer this is the operation for un-associating a task from a project (counterpart to asana_add_project_to_task), but the description never states when to use it, when not to, or names any alternative 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?

With no annotations, the description carries the full behavioral burden but offers only a bare operation statement. It omits whether the tag is deleted, permissions required, reversibility, side effects, or response format—critical 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 single sentence is front-loaded and free of waste, but it is extremely terse and adds no structure or supplementary detail beyond the tool name.

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

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

For a mutation tool with no annotations and no output schema, the description is inadequate. It lacks behavioral context, return information, and any guidance that would help an agent use it correctly in 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% description coverage for both parameters, so the schema already documents them fully. The description adds no additional parameter meaning, making the baseline of 3 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 verb (remove) and resource (tag from a task), making the purpose unambiguous. However, it does not differentiate from siblings like asana_delete_tag or asana_add_tag_to_task, so it falls short of a 5.

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

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

The description provides no guidance on when to use this tool versus alternatives, nor any prerequisites or exclusions. It merely states the action without context, so an agent gets no help in tool selection.

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 fails to mention that name_pattern is a regular expression, how archived projects are handled, or that the tool returns a list of matching projects. The behavior is under-specified.

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 one concise sentence, front-loaded with the action and resource. No extraneous 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?

The description is too brief for a tool with no output schema and no annotations. It doesn't explain the return format or any filtering details beyond the schema-visible parameters, leaving the agent uncertain about expected response.

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 each parameter described, so the description does not need to add parameter semantics. The description aligns with the name_pattern field but adds no new information 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 tool searches for projects in Asana using name pattern matching. It uses a specific verb ('search') and resource ('projects'), distinguishing it from project retrieval by GID (asana_get_project) and task search (asana_search_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 no explicit guidance on when to use this tool versus alternatives. There is no mention of alternatives, prerequisites, or exclusions; usage is only implied by the search semantics.

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 burden of disclosing behavioral traits. The verb 'search' implies a read-only operation, but the description does not mention pagination, result limits, return format, or any side effects. This is a significant gap for a tool with 55 parameters and no output schema.

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 efficiently conveys the core purpose. However, it lacks any structural elements (e.g., bullet points or usage notes) that might help navigate a tool with a very large parameter set.

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

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

Given the tool's complexity (55 parameters, nested objects, no output schema, no annotations), the description is far from complete. It does not explain what results are returned, how pagination works, or any usage caveats. The schema covers parameter definitions, but the description does not help the agent understand the overall behavior or expected output.

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

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

Schema description coverage is 100%, so the baseline is 3. The description adds no parameter-specific meaning beyond the phrase 'advanced filtering options,' which is already evident from the extensive parameter list. It neither compensates for missing schema details nor adds context beyond what the schema provides.

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 uses a specific verb ('search'), a clear resource ('tasks'), and a scoping context ('in a workspace'). It distinguishes from sibling tools like asana_search_projects (which searches projects) and asana_get_multiple_tasks_by_gid (which retrieves tasks by known IDs) by emphasizing the search/filtering nature.

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 prefer this tool over alternatives, nor any exclusions or prerequisites. It only states the generic action of searching tasks with filters, leaving the agent to infer appropriate use cases from the parameter list.

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 does mention the positioning behavior, which is beyond the name, but it omits side effects (e.g., removal from old parent), prerequisites, or auth requirements. For a mutation tool, this is only a partial disclosure.

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 efficiently conveys the core action and the additional positioning behavior.

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 is too brief for a mutation tool with no annotations and no output schema. It does not state what the tool returns, potential errors, or prerequisites. The positioning detail is helpful but does not make the description 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 coverage is low (33%) and the description does not compensate. It mentions 'position' and 'parent' but does not explain how to use insert_after/insert_before or null values. The schema provides some details, but the description adds no parameter-level meaning.

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 uses a specific verb ('Set') and clearly identifies the resource ('parent of a task') plus the additional behavior of positioning the subtask among siblings. This distinguishes it from related tools like create_subtask or update_task, which handle different operations.

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 re-parenting tasks and controlling their order, but it does not explicitly state when to use this versus alternatives or provide exclusions. The usage context is inferred rather than explicitly guided.

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 must carry the full behavioral burden. It lacks details about required permissions, reversibility, partial-update semantics (e.g., whether omitted fields are cleared or left unchanged), or response behavior 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, front-loaded sentence with no wasted words. It is appropriately sized for the amount of information it conveys.

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

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

For a mutation tool with five parameters, no annotations, and no output schema, the description is far too sparse. It fails to cover what fields can be updated, return behavior, or any operational constraints, leaving significant gaps for an agent to invoke it correctly.

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

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

Schema description coverage is 100%, so the schema fully documents all five parameters and their types. The description adds no additional meaning beyond what the schema already provides, making a baseline 3 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 gives a clear verb+resource ("Update an existing tag"), which is enough to distinguish it from asana_delete_tag, asana_get_tag, and asana_create_tag_for_workspace. However, it doesn't specify which tag fields can be updated or the scope of the operation, leaving the purpose at a vague minimum-viable level.

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 single sentence implies the tool modifies an existing tag but offers no guidance on when to use it versus siblings like asana_create_tag_for_workspace or asana_add_tag_to_task. No prerequisites, exclusions, or alternative routing are mentioned.

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

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

No annotations are provided, so the description carries the full behavioral burden for an 11-parameter mutation tool. It says nothing about partial-update semantics, permission requirements, side effects, reversibility, or what happens to omitted fields, leaving the agent with almost no behavioral 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 single sentence is front-loaded and contains no filler, but for a tool with 11 parameters and mutation semantics it is under-specified rather than appropriately concise. It omits information that would help an agent invoke the tool correctly.

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

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

Given the tool's complexity (11 parameters, nested custom_fields, no annotations, no output schema), the description is far too thin. It does not explain update scope, partial versus full replacement, permissions, or return behavior, so it is not complete enough for reliable 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 100%, and the schema itself gives detailed parameter descriptions (including the allowed HTML tag list for html_notes and custom_fields mapping behavior). The description adds no parameter meaning beyond 'details', so the 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 the verb 'Update' and the resource 'task', so the core action is identifiable. However, 'details' is vague and it gives no indication of how it differs from related mutation siblings like asana_set_parent_for_task or asana_add_project_to_task, so it stops short of full sibling differentiation.

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

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

There is no when-to-use guidance, no conditions for choosing this over asana_create_task or the specialized task-mutation siblings, and no mention of prerequisites such as required workspace/project permissions. The description merely restates the operation.

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