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

Annotations are absent, so the description carries the full burden of behavioral disclosure. It states only the basic status change from archived to active, but does not disclose any side effects, required permissions, reversibility, or impact on associated data. For a mutation operation, this is insufficient transparency.

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

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

The description is a single, focused sentence with no filler. It is front-loaded with the essential action and avoids any unnecessary details, 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?

For a simple operation with one parameter and no output schema, the description is minimally adequate. However, it omits details about return values, error conditions, or any special behaviors (e.g., what happens if the project is already active). Given the lack of annotations, this leaves some gaps, but the tool is simple enough that the description covers the core purpose.

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 single parameter project_id is fully described in the schema (100% coverage), including its type and constraints. The description adds no additional meaning or usage notes about the parameter, so the baseline of 3 applies.

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

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

The description clearly states the action: 'Restore an archived project to active status.' It specifies a verb, resource, and outcome, and implicitly contrasts with archive_project among siblings. An agent can immediately understand the tool's purpose without ambiguity.

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

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

No guidance is provided on when to use this tool versus alternatives. It does not mention any conditions, prerequisites, or cases where other tools (e.g., create_project, update_project) would be more appropriate. The description only states the function without contextual usage advice.

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 explaining behavior. It states that time is logged, but does not disclose whether a new entry is always created, what the response is, whether duplicate logs are allowed, or any permission requirements.

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

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

The description is a single, efficient sentence with no filler or repetition. It front-loads the core action, though it is so brief that it misses opportunities to add useful context.

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 mutating tool with 7 parameters, no annotations, and no output schema, this description is under-specified. It lacks guidance on return values, when to use alternatives, and expected side effects, leaving the agent to rely heavily on the schema and tool name.

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 already provides descriptions for all 7 parameters, including constraints, defaults, and optionality. The description adds only the phrase 'optionally money,' which is already reflected in the money parameter's null default. Baseline 3 is appropriate given high schema 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 states a clear action—logging time and optionally money—against a task, which maps directly to the tool name. It distinguishes itself from read-oriented siblings like get_costs by implying a write/insertion operation, though it does not explicitly call out sibling 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?

No guidance is provided on when to use add_costs versus update_costs or get_costs. An agent must infer that this creates a new cost entry and that update_costs would be used for modifying existing ones.

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 behavioral burden and does disclose the key side effect: existing tags are preserved. It does not cover duplicate handling, error conditions, or permissions, which leaves a moderate transparency 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?

A single sentence conveys the operation, object, and key behavioral differentiator with no filler. The essential additive semantics are front-loaded.

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

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

For a simple three-parameter tool with fully documented inputs and no output schema, this description is nearly sufficient: an agent knows the operation, the object, and that it is additive. It would be more complete with an explicit mention of replacing behavior/set_task_tags and duplicate-tag behavior, but nothing needed to make the call is missing.

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

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

Schema coverage is 100% and every parameter has a description (project_id, task_id, tags). The tool description adds no parameter-level meaning beyond reiterating that tags are added while existing ones remain, 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 uses a specific verb and object ('Add tags to a task') and adds a behavioral qualifier ('keeping the tags it already has') that clearly differentiates it from the sibling set_task_tags, which likely replaces tags. The action and scope are unambiguous.

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

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

The phrase 'keeping the tags it already has' signals this is the additive variant and implicitly distinguishes it from set_task_tags. However, it never explicitly names that alternative or states when to choose one over the other, so it stops short of full routing 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 full burden of behavioral disclosure. It states the action is reversible, which is important context, but it does not disclose potential side effects such as how archiving affects tasks, timers, or member access, nor does it mention any permission requirements. This is a moderate gap given the mutation nature of 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, efficient sentence that conveys both the primary action and the reversibility without any fluff or redundant wording. It is front-loaded with the core purpose and immediately useful for an agent.

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

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

For a simple tool with one parameter and no output schema, the description covers the essential information: what it does and that it is reversible. It does not explain edge cases like behavior with active subtasks or permissions, but for straightforward archiving this is sufficient. It slightly holds back from a 5 by not mentioning any prerequisites or broader impact.

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 provides full coverage (100%) for the single parameter `project_id` with its own description. The tool description adds no additional meaning about the parameter, but since an integer ID is self-explanatory and the schema already documents it, a baseline of 3 is appropriate.

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

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

The description clearly states the action: 'Close a project and move it to the archive.' It identifies a specific verb ('close') and resource ('project'), and the mention of reversibility with activate_project differentiates it from its sibling activate_project. The purpose is unambiguous and distinct from other project-related tools.

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

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

The description provides clear context for when to use this tool (to close and archive a project) and explicitly names the alternative for reversing the action (activate_project). While it does not list exclusions (e.g., when not to use it), the single clear scenario and the reverse-tool reference give an agent sufficient guidance for 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?

The description discloses important behavioral traits: it never returns token values, and it clarifies that an expired token is refreshed automatically if a refresh token is stored. This goes beyond the annotations (which are absent) and provides critical safety and operational context for an agent.

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

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

The description is concise and front-loaded: it states the core purpose in the first sentence, then adds clarifying details about token freshness and security. Every sentence earns its place, and there is no redundancy or fluff.

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

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

For a zero-parameter tool with no output schema, the description is complete. It explains what the tool reports, clarifies the distinction between stored credentials and token freshness, and explicitly states that token values are never returned. An agent has all the information needed to call it correctly and interpret the result.

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

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

The tool takes no parameters, and the schema description coverage is 100% (empty properties). The description adds value by explaining what the tool reports, which is more than the schema alone provides. Since there are no parameters, the baseline is 4, and the description fully compensates for any potential ambiguity.

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

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

The description clearly states the tool reports the active authentication mode and whether login credentials are stored, distinguishing it from other tools in the sibling list. It uses a specific verb ('report') and resource ('authentication mode', 'stored login credentials'), making its purpose unambiguous.

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

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

The description implies when to use this tool: when checking authentication status or credential storage. It does not explicitly name alternatives or exclusions, but the context of sibling tools (e.g., worksection_login, worksection_logout) makes the usage context clear. A brief mention of when not to use it would improve this dimension.

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 states the task is marked done and closed, but does not disclose whether the operation is reversible, whether it triggers notifications, requires permissions, or what the response contains. For a state-changing mutation, this is a significant gap.

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

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

The description is a single concise sentence that front-loads the action and outcome. It earns its place, though it could add a brief note about reversibility or side effects without becoming bloated.

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 thin. It tells the agent what the tool does but not what happens after completion, whether it can be undone, or how the response should be interpreted. The sibling reopen_task hints at reversibility but the description does not address it.

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

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

Schema description coverage is 100%, so the schema already documents both parameters. The description adds no parameter-specific meaning beyond what the schema provides, so 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 uses a specific verb ('Mark') and resource ('a task') and states the effect ('closing it in Worksection'). It clearly distinguishes from siblings like reopen_task, though it doesn't explicitly name that sibling.

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 completing tasks, and the sibling list includes reopen_task, which suggests the opposite operation. However, there is no explicit when-to-use guidance, prerequisites, or mention of when to prefer an alternative like update_task.

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 'Create' (implying a mutation) but does not disclose permission requirements, idempotency, duplicate handling, or any side effects. For a mutation tool with zero annotation support, this is a notable gap.

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

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

The description is a single, focused sentence with no wasted words. It front-loads the core action and then summarizes optional parameters efficiently. Every word contributes to understanding the tool's purpose.

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

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

For a simple create tool with full schema coverage, the description provides adequate high-level context. However, it does not mention what the response contains (e.g., created project ID) or address potential edge cases. While no output schema exists, a bit more context about expected return value or side effects would improve completeness.

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

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

Schema description coverage is 100%, so the baseline is 3. The description adds a slight grouping by mentioning 'manager, description and dates', which maps to some parameters, but it does not add any formatting or relationship details beyond the schema. It neither significantly enhances nor detracts from the schema's own explanations.

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

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

The description clearly states the verb 'Create' and the resource 'project', and it lists optional fields (manager, description, dates) that distinguish it from sibling tools like create_task and create_subtask. The purpose is immediately clear and unambiguous.

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

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

No guidance is given on when to use this tool versus alternatives such as update_project or archive_project. There are no prerequisites, exclusions, or contextual cues beyond the basic action, 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 provided, the burden is on the description to disclose behavior. 'Create' implies a write operation, but the description does not mention side effects, required permissions, idempotency, or whether the parent task is validated. The procedure is a black box, which 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 sentence with no waste, and it is front-loaded with the core action. It is concise and clear, though it could be slightly more informative without hurting 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?

Given this is a mutation tool with 7 parameters, no annotations, and no output schema, the description is too thin. It does not explain return values, error handling, or prerequisites like ensuring the parent task exists. An agent may need to guess at behavior beyond the basic 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 coverage is 100%, so all parameters are already described. The description adds no extra meaning beyond the hierarchy implied by 'under an existing task'. The baseline of 3 is appropriate since the schema carries the parameter documentation, but the description does not clarify parameter relationships beyond what the schema says.

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

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

The description clearly states the verb 'create' and the resource 'subtask' under an existing task, which is specific. However, it does not explicitly distinguish from similar tools like create_task or update_subtask, though the phrase 'under an existing task' provides some differentiation.

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

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

The description implies that the parent task must exist, but does not explicitly state when to use this tool versus create_task (e.g., when you need a child task) or when not to use it. No alternatives are mentioned, so usage context is only weakly implied.

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

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

With no annotations provided, the description carries the full burden of disclosing behavioral traits. It implies a write operation ('Create') but does not state whether authentication is required, whether the operation is reversible, what happens on validation failure, or what the return value looks like. For a mutation tool with zero annotation coverage, this is a significant gap.

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

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

The description is a single concise sentence that front-loads the action and resource. Every word adds value; there is no filler. It is appropriately sized for a tool whose parameters are already documented in the schema.

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

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

For a tool with 9 parameters, no output schema, and no annotations, this description is thin. It does not mention that project_id and title are required (though the schema does), nor does it note authentication needs, return behavior, or error handling. An agent has enough to guess the operation but not enough to anticipate important runtime outcomes.

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 parameter already has a meaningful description. The description adds only marginal context by naming 'assigned, dated and prioritised', which maps to assignee_email, due_date/start_date, and priority, but it does not clarify format, defaults, or relationships beyond the schema. The baseline of 3 is appropriate given 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 states a specific verb ('Create'), a resource ('task'), and a location ('in a project'), and it hints at optional attributes ('assigned, dated and prioritised'). This clearly differentiates it from the many get_* siblings and from update_task, though it does not explicitly name any alternative. It is clear and unambiguous about the core operation.

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 create_subtask or update_task. While the purpose is obvious, the description does not mention any preconditions (e.g., project existence, authentication) or situations where a sibling would be more appropriate. No exclusions or conditions are given, leaving the agent to infer usage context.

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

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

With no annotations provided, the description carries the full burden. It explicitly discloses that the tool returns content inline as base64 and refuses files larger than max_bytes instead of writing to disk, which conveys a non-persistent, read-only behavioral profile. It does not mention side effects beyond disk write avoidance, but this is meaningful behavioral context 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?

Two concise sentences with zero filler. The primary action and output format are front-loaded, followed by the limiting behavior. Every word adds value.

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, the description adequately explains the return format (base64) and the key constraint (max_bytes refusal). It does not detail error cases or auth requirements, but for a simple single-file fetch tool with only integer parameters, the essential information is present. The disk-free note also covers a common concern for download tools.

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

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

Schema coverage is 100% and each parameter already has a clear description. The tool description mentions max_bytes and its refusal behavior, but this directly mirrors the schema description, adding no new semantic information. The baseline of 3 applies 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 uses a specific verb ('Fetch'), a specific resource ('one attachment'), and the output format ('inline as base64'). It clearly distinguishes itself from siblings like upload_file and get_task_files by indicating it retrieves a single attachment's content rather than listing or uploading.

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 ('Fetch one attachment') but does not explicitly state when to use it versus alternatives, such as after calling get_task_files to obtain file_id. There are no exclusion rules or references to sibling tools, so the agent must infer the appropriate context.

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

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

No annotations are provided, so the description carries full responsibility. It only states the action and scope without disclosing behavioral details such as pagination, event types included, authentication requirements, or any limits. The minimal wording leaves the agent to infer read-only behavior from the verb 'List'.

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 redundancy. Every word contributes to the core purpose and scope.

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 straightforward list tool with three optional parameters and no output schema, the description is minimally sufficient but lacks behavioral context such as return format, event granularity, or pagination. Since no annotations exist, more detail would be helpful for agents to anticipate results.

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 clear description (date_to, date_from, project_id). The tool description adds only a general mention of 'date range' and 'account or project', which slightly reinforces but does not significantly extend the schema information. Baseline of 3 is appropriate.

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

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

The description clearly states a specific action ('List') on a distinct resource ('recent account or project activity events') with a date range scope. It differentiates from all sibling tools since no other tool appears to cover activity events.

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

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

The description provides clear context on when to use the tool (for account or project activity over a date range) but does not explicitly mention alternatives or exclusions. Given no direct sibling, the guidance is adequate though not exhaustive.

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?

There are no annotations, so the description carries the behavioral burden. It explicitly discloses a notable reliability quirk: 'Status and assignee filters are re-applied locally because the API's own filtering is unreliable for some combinations.' This is exactly the kind of behavioral context that prevents an agent from being surprised by inconsistent filtering. The read-only nature is only implied by 'List,' but the key caveat is covered.

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

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

The description is two sentences with no filler: the first states the core action and scope, and the second adds the critical filtering caveat. Every sentence earns its place.

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

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

For a tool with two optional, well-documented parameters and no output schema, the description adequately covers purpose, scope, and the one critical behavioral caveat. It does not explain output shape or pagination, but 'List tasks' gives a reasonable baseline expectation, making this a minor gap rather than a blocker.

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 parameters are already documented in the schema. The tool description's filter caveat largely restates the status parameter's own 'applied again locally' note and does not add meaningful new parameter-level semantics beyond that.

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–resource pair ('List tasks') and defines the scope precisely as 'across every project the account can see.' This clearly distinguishes it from siblings like get_task and get_tasks, which appear to be single-task or project-scoped, without needing to inspect their schemas.

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 cross-project scope implies when to use this tool: when an agent needs a global task listing across all visible projects. However, it never names alternatives or states when not to use it, such as pointing to get_tasks or search_tasks for narrower queries, so the usage guidance remains implied rather than explicit.

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 behavioral burden. It communicates a read-only action via 'List' and adds the non-obvious ordering guarantee 'oldest first.' It does not mention pagination, authentication, or error behavior, but these are minor for a simple read-only list.

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 eight-word sentence that front-loads the verb and resource. Every word adds meaning; there is no redundancy, filler, or unnecessary background.

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 low-complexity read-only list with fully documented parameters, the description covers the resource, scope, and ordering. No output schema exists, but 'list the comments' adequately signals the return; missing auth and error details are not critical for correct invocation.

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

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

The input schema already describes both parameters at 100% coverage, including that project_id identifies the task's project. The description adds no parameter-specific detail beyond 'on a task,' so the baseline score 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 ('List'), a concrete resource ('comments on a task'), and an ordering constraint ('oldest first'). It clearly differentiates from sibling tools like post_comment and update_comment, which mutate comments, and from get_task, which returns the task itself.

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 makes the tool's context clear: use it when you need the comments belonging to a task. It does not explicitly name alternatives or when-not conditions, but the read-only listing purpose is unambiguous and no sibling tool competes for the same job.

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 burden of behavioral disclosure. It discloses the purpose and scope (external contacts, registered in account), but does not mention potential side effects (none expected for a list) or any behavior like pagination, ordering, or data freshness. For a read-only list operation, this is adequate but could be richer.

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

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

The description is a single sentence with no fluff. It's front-loaded with the verb and resource, and is appropriately concise for a tool with no arguments.

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

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

Given the complexity is low (no params, no output schema, simple list operation), the description is mostly complete. It defines the resource clearly enough for an agent to know what it returns. However, it doesn't specify the return format or fields, which could be helpful but is not critical for calling 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?

The tool has zero parameters, and schema description coverage is 100%, so the schema provides all needed info. The description doesn't need to add parameter semantics, and with no params, the baseline is 4 per instructions. The description adds nothing about parameters, but it's not necessary.

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

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

The description states a clear verb ('List') and resource ('external contacts (clients)'), and notes the scope is 'registered in the account.' It distinguishes from sibling tools like get_members, which likely list team members, but it doesn't explicitly mention that distinction. It's clear but not fully differentiated from get_members.

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

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

The description implies usage when you need external contacts or clients, but it does not explicitly state when to use this vs. alternatives like get_members. It mentions 'registered in the account' which provides some context, but no exclusions or comparisons to siblings are given.

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

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

With no annotations provided, the description carries the full behavioral burden, but it only says 'List logged time and cost entries'. It does not disclose response shape, aggregation behavior, permission requirements, or any side effects, though as a read-only list it is not misleading.

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

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

The description is a single sentence with no filler. The core action and resource are front-loaded, and every part of the sentence earns its place.

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

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

For a simple read-only list tool with fully documented optional parameters, the description is minimally adequate. However, without an output schema or behavioral annotations, and without differentiation from similar report/summary siblings, it leaves some context 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 description coverage is 100%, so the schema already fully documents each parameter. The description adds a compressed summary of the optional scoping but does not add new meaning beyond the schema.

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

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

The description clearly states the action ('List') and the resource ('logged time and cost entries'), and identifies optional scoping dimensions. It does not explicitly differentiate from sibling tools like get_time_report or get_running_timers, so it falls short of full clarity.

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 that this tool is used to list filtered time/cost entries, but it gives no guidance on when to choose it over get_time_report or get_running_timers, and no exclusions or prerequisites 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 behavioral disclosure burden. The verb 'Find' clearly signals a non-mutating lookup, but it does not say what happens on no match, whether both parameters are accepted together, whether any permissions are needed, or what the response shape is.

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 no filler. It front-loads the action, target resource, and lookup criteria, making the core purpose immediately clear.

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 2-parameter read tool, the description provides the essential lookup contract, but it leaves relevant invocation details unclear: the schema lists both parameters as optional with null defaults, while the description implies at least one should be supplied, and there is no mention of no-match behavior or return format.

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 property descriptions already explain the parameters. The description's 'email or id' adds the relationship between the two parameters, but it does not materially go beyond what the schema already conveys.

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 ('Find'), a concrete resource ('account member'), and names the lookup keys ('email or id'). The singular 'one' hints at a distinction from siblings like get_members, but it does not explicitly differentiate among the related member 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 when to use the tool: when you need a single member and have an email or member id. It does not explicitly name alternatives such as get_members or get_project_members, nor does it state when not to use this 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 provided, the description carries the full burden of behavioral disclosure. The verb 'List' implies a read-only operation, which is a positive signal, but the description does not explicitly state that it is non-destructive, requires no special permissions, or has any other behavioral traits. Given the simplicity of the operation, this is adequate but not rich.

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 is front-loaded with the primary action and object. There is no filler or redundant information. Every word earns its place.

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

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

The tool has no output schema and no annotations, so the description must provide enough context for an agent to understand what the call returns. 'List the member groups' implies a list result but does not describe the structure, fields, or any pagination or error behavior. For a simple list tool this is acceptable but leaves some gaps.

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

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

The tool takes zero arguments, so the schema is trivially complete at 100% coverage. The description does not need to explain parameters, and it doesn't. According to the rubric, a zero-parameter tool warrants a baseline score of 4, and there is nothing that would reduce it.

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 lists member groups (teams) for the account. It uses a specific verb 'List' and resource 'member groups', and the account scope distinguishes it from project-specific siblings like get_project_groups. However, it doesn't explicitly differentiate from get_member or get_members, though the group/team focus is distinct.

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

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

The description provides no guidance on when to use this tool versus alternatives. It does not mention that this is for account-level teams or that project-level teams are handled by get_project_groups. An agent has to infer the appropriate usage from the name and sibling 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 provided, the description carries the full burden of behavioral disclosure. 'List' implies a read-only operation and the returned fields are named, but there is no mention of pagination, ordering, inactive-user handling, or authentication requirements. This is adequate but minimal for a simple zero-parameter listing 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 leads with the action and immediately specifies the resource and result fields. There is no filler, redundancy, or unnecessary detail.

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

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

For a zero-parameter list operation with no output schema, the description covers the essential information: what is listed and what fields are returned. It is probably sufficient for an agent to invoke correctly, though it could be more complete by noting whether the results include all account members or only active ones.

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

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

The tool takes zero parameters, and the input schema is an empty object with 100% schema description coverage. Since there are no parameters to explain, the description correctly spends its effort on output semantics and scope instead.

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 ('List'), the resource ('people in the account'), and the returned fields ('ids, emails and roles'). It is unambiguous and distinguishes itself from sibling project-scoped tools like get_project_members by specifying account scope, 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?

The description gives no guidance on when to prefer this tool over sibling tools such as get_member, get_project_members, or get_contacts. There are no stated exclusions or conditions, so an agent must infer the selection rule entirely from the tool name and the phrase 'in the account.'

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. It states the filter and ordering but does not explicitly state side-effect-free behavior or return format. However, 'List' implies read-only, and the description is not misleading. It adds some behavioral detail (open, overdue, sorted) beyond the 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?

A single, information-dense sentence with no filler. The key constraints are front-loaded.

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

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

For a simple list tool with one optional param and no output schema, the description is adequate. It doesn't explain the response format, but that is not required. It might benefit from noting it returns only open tasks, but it already does. It is complete enough for an agent to call 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 coverage is 100%, so the parameter project_id is already described. The tool description doesn't add param-specific details, but that's acceptable given the schema's high coverage. 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 uses a specific verb 'List' and a specific resource 'open tasks' with a clear condition (due date passed) and ordering (most overdue first). It clearly distinguishes from siblings like get_tasks or search_tasks by focusing on overdue and open 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 implies when to use it (when you need overdue tasks) but does not explicitly mention alternatives or exclusions. It provides clear context for its intended use.

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

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

With no annotations, the description must carry the burden of behavior. 'Fetch' implies a read-only operation and 'including its status and dates' hints at response contents, but it does not disclose error behavior, exact return shape, or the effect of include_extra. This is adequate but not richly transparent.

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 well-formed sentence that places the core purpose first and omits filler. Every phrase ('single', 'by id', 'status and dates') adds relevant 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 two-parameter read tool with full schema coverage, the description plus schema gives an agent enough to call it correctly. It lacks an explicit return structure, but no output schema exists and the inclusion of 'status and dates' supplies a reasonable expectation of the result.

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

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

Schema description coverage is 100%, so the schema already fully documents both project_id and include_extra. The description adds no parameter meaning beyond the schema, so it earns the baseline score.

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?

Description states a specific verb ('Fetch'), resource ('project'), and selection criterion ('by id'), and narrows the result contents to 'status and dates.' This clearly distinguishes it from plural siblings like get_projects and related project 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 phrase 'by id' makes the intended context clear: use when you have a specific project id and need a single record. It does not explicitly name alternatives or state when not to use it, but the singular scoping provides enough 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?

No annotations are provided, so the description must carry behavioral context. 'List' clearly implies a read-only operation, and the parenthetical adds semantic clarification. However, it does not disclose behavior around invalid project IDs, empty results, response format, or permissions, leaving some burden unmet.

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. It communicates the action, resource, and scope efficiently, and every word earns its place.

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

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

For a one-parameter, read-only listing tool with full schema coverage, the description is nearly complete. It states what is returned (task groups/folders) and the scope (project_id). Minor omissions like response shape or error behavior are acceptable given the tool's simplicity and lack of output schema.

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

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

Schema description coverage is 100% and project_id is already described as 'Project id.' with an exclusive minimum of 0. The description adds only the contextual tie that groups are 'configured inside a project,' which is mildly helpful but not significantly beyond the schema baseline.

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

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

The description uses a specific verb ('List') and resource ('task groups (folders) configured inside a project'). The parenthetical clarification and 'inside a project' scoping distinguish it from siblings like get_project or get_member_groups without requiring schema inspection.

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 usage context is implied: use this when you need the task groups/folders for a specific project, identified by project_id. However, it does not explicitly state when not to use it or point to alternatives (e.g., get_tasks for tasks within groups), so guidance is adequate but not robust.

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 burden. The verb 'List' clearly implies a read-only operation, but the description does not disclose output format, pagination, or whether the returned access list includes inherited or indirect access.

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

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

The description is a single concise sentence with no filler. It front-loads the action and the scope, making it easy for an agent to parse quickly.

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

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

For a one-parameter read-only list tool, this description is nearly sufficient: the agent knows what to pass (project_id) and what to expect conceptually (a list of people). Minor gaps remain around return structure and whether access includes groups or inherited roles.

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 single parameter project_id already has a clear description in the schema. The tool description only reinforces that a single project is being queried, without adding new constraints or value semantics.

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

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

The description states a specific verb ('List') and a specific resource ('people who have access to one project'). It clearly distinguishes this from sibling tools like get_members or get_member by anchoring the result to a single 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 phrase 'one project' implies when to use it, and the required project_id reinforces that. However, it does not explicitly mention alternatives or when not to use it, leaving sibling differentiation to inference.

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?

There are no annotations, so the description carries the full burden. It adds one useful behavioral detail—that results are scoped to the authenticated account's visibility—but it does not disclose default status filtering, pagination, ordering, or whether archived projects are included by default.

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 words. It is appropriately terse, though it is lean enough that additional context about defaults or alternatives would have made it more helpful.

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 listing tool with two optional parameters and full schema coverage, the description is minimally adequate. However, with no output schema and no annotations, it leaves response shape and default behavior unspecified, and it does not orient the agent among the many sibling project-related tools.

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

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

Schema description coverage is 100%, and both parameters have meaningful descriptions. The tool description adds no parameter-level detail, but since the schema already documents status and include_extra well, a 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 the verb 'List' and identifies the resource as 'projects visible to the authenticated account', making the collection-level read intent clear. It doesn't explicitly differentiate from get_project or get_project_members, but the plural 'projects' plus the visibility scope is enough for basic 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 guidance is given about when to choose this tool over alternatives such as get_project, get_project_members, or get_project_stats. The context is only implied by the verb 'list', and no exclusions or selection criteria are provided.

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

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

With no annotations, the description carries the burden of behavioral disclosure, and it does clarify that this is a counting/aggregation operation rather than one that returns raw tasks. However, it does not disclose whether subtasks are included, whether counts are grouped jointly or separately, or how the response is structured. It is adequate but not rich.

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 with no filler, and it front-loads the core action before specifying the grouping dimensions. Every word contributes meaning.

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 one-parameter, read-only aggregation tool with no output schema, the description adequately conveys the core call intent and what the agent gets back: counts by status and priority bucket. It could add minor detail about the exact response shape or status/priority values, but nothing essential for selecting and invoking the tool is missing.

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

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

The schema already fully documents the single project_id parameter with a description and an exclusive minimum constraint. The description adds only the contextual notion of 'a project's tasks', which maps naturally to project_id. Since schema coverage is 100%, 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 a specific verb ('Count') and resource ('a project's tasks'), and clearly specifies the grouping dimensions: status and priority bucket. This distinguishes it from sibling endpoints like get_tasks_by_status / get_tasks_by_priority, which are list-oriented rather than aggregation-oriented.

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 instead of alternatives such as get_tasks_by_status or get_tasks_by_priority. The description implies a summary use case, but it never states that an agent should choose this tool when only counts are needed rather than the underlying task 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?

No annotations are provided, so the description carries the behavioral burden. 'List every timer currently running' communicates a read-only, account-wide operation, but it does not disclose the return format, whether timer IDs are included, or any other operational detail. It is adequate but not rich.

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. Every word contributes meaning, and the core action plus scope are front-loaded.

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

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

For a zero-argument list operation, the description is largely complete: it names the operation, the resource, and the scope ('in the account'). The lack of an output schema is not addressed, so the exact shape of the returned timer list is unspecified, but this is a minor gap for such a simple tool.

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

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

The tool accepts zero parameters, so the description has no parameter details to provide. With no parameters and 100% schema description coverage, the baseline of 4 applies since there is nothing meaningful to add 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 uses a clear verb and resource: 'List every timer currently running in the account.' It uniquely identifies a specific read operation and distinguishes it from sibling timer-related tools like start_timer and stop_timer.

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

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

The description gives no guidance about when to choose this tool over alternatives such as get_time_report, start_timer, or stop_timer. There are no exclusions, conditions, or references to sibling tools, leaving the agent to infer the appropriate use case.

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

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

With no annotations, the description must carry the behavioral burden. It implies a read-only operation via 'List', but discloses nothing about pagination, ordering, permissions, error handling, or response format. This is minimal 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 unnecessary words. It is concise and appropriately sized for a simple list operation, though it is very sparse and could benefit from a bit more context.

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

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

For a list tool with no output schema and no annotations, the description is incomplete. It does not mention what the response contains, ordering, potential errors, or any constraints. An agent would lack critical information about what to expect from the call.

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 already provides full descriptions for both parameters (project_id and task_id) with 100% coverage. The description adds no additional meaning beyond what the schema states, so the baseline score of 3 applies.

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

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

The description clearly states the action 'List' and the resource 'subtasks of a task', making the purpose evident. It distinguishes from sibling tools like get_tasks by specifying subtasks, though it doesn't explicitly name alternatives or contrast 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 other list tools such as get_tasks or get_all_tasks. There is no mention of context, prerequisites, or conditions that would help an agent decide between siblings.

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

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

With no annotations, the description carries the full burden. It clearly indicates a read-only listing operation, which is useful, but it does not disclose return structure, ordering, or potential account-level context beyond the basic listing. This is adequate but minimal.

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 sentence that immediately states the action and resource. No filler or redundant detail.

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 no-argument listing tool, the description names the two things it returns (tag groups and tags) and the scope (account). It is largely complete, though it could additionally mention the relationship or grouping of tags, but that is not essential for invoking 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?

The tool has zero parameters and the schema confirms this with 100% coverage. The description has no parameter burden to bear, so a baseline near the top 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 ('List') with a clear resource ('tag groups and tags') and an explicit scope ('configured for the account'). This distinguishes it from siblings like get_task_tags, which likely target task-level tags.

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 such as get_task_tags or get_member_groups. The description states what it does but not the conditions or context that would lead an agent to prefer this 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?

No annotations are present, so the description carries the burden of explaining behavior. It transparently notes the optional inclusion of description text, files, and subtasks, but does not disclose auth requirements, error behavior, or default response shape. 'Fetch' implies read-only, yet this is not explicitly stated.

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

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

A single, efficient sentence states the main verb, resource, and optional extra fields. No filler or redundant information; the core behavior is front-loaded.

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

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

For a simple single-task fetch, the description is adequate, but it lacks guidance on how this tool relates to sibling tools like get_subtasks and get_task_files, especially when include_extra could overlap. With no output schema and no annotations, more context about the return value or default behavior would improve completeness.

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

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

Schema coverage is 100%, so the baseline is 3. The description adds little beyond the schema because it closely mirrors the include_extra parameter description ('description text, files and subtasks'). It does not provide additional syntactic or format context for the parameters.

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

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

The description clearly states a specific action ('Fetch one task') on a specific resource, which distinguishes it from get_tasks and similar list operations. However, it does not explicitly differentiate from sibling tools like get_subtasks or get_task_files, leaving some ambiguity about when to use this aggregate fetch versus those dedicated endpoints.

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 instead of alternatives. The phrase 'Fetch one task' implies a single-task lookup, but no exclusions or alternative tool references are provided, so an agent must infer usage from the name and schema alone.

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

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

With no annotations, the description carries the behavioral burden, and it does state what the operation returns (metadata only, not file contents). The read-only nature is implicit from 'List', and it does not hide mutation or side effects; only minor details like pagination or permission requirements are omitted.

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 no filler. Every word earns its place by specifying the action, scope, and output fields.

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 metadata-list tool, this is complete: the input schema covers parameters, and the description covers the absence of an output schema by naming the returned fields. Nothing an agent needs to invoke it correctly is missing.

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

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

Both parameters are already fully described in the schema (100% coverage), including the relationship between project and task. The description adds little beyond restating that the files are attached to a task, 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 begins with a specific verb (List) and a specific resource (files attached to a task), and it names the returned fields (ids, names, sizes). This makes its purpose unambiguous and distinguishes it from siblings like list_workspace_files and get_task.

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

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

It clearly implies the intended use case: retrieving the attachment metadata for a particular task. It does not explicitly name alternatives or state when not to use it, so it misses the top score, but the context is unambiguous.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It does indicate a read-only list operation and the available filter dimensions, but it omits details such as pagination behavior, ordering, or whether the response contains only summary fields or full task objects.

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 front-loads the resource and scope, then lists the two filter dimensions. There is no redundant or filler content.

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

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

For a simple three-parameter list tool with fully documented schema, this description is mostly complete: it states the project scope and the available filters. Some context is still missing—such as whether results are paginated, how returned tasks are ordered, and how this compares to related siblings—but the core invocation path is clear.

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 three parameters including the status enum and default values. The description merely restates the status and assignee filtering, adding no new semantic detail such as exact-match behavior for assignee_email or how null defaults are handled.

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 ('List') and resource ('tasks'), and clearly scopes the operation to 'inside one project' with optional status/assignee filters. This distinguishes it from project-agnostic siblings like get_all_tasks and get_tasks_by_priority, even though it does not name them explicitly.

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

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

The description implies the tool is for retrieving tasks from a single project, optionally filtered by status or assignee. However, it gives no explicit guidance about when to prefer this tool over alternatives such as get_all_tasks, get_tasks_by_status, or get_overdue_tasks, and it does not state any 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 behavioral disclosure. It only states the grouping action, but does not disclose the return format (e.g., whether it returns a map of buckets to task lists), whether it is read-only, or any limitations (e.g., handling of tasks without priority). This is minimal 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, concise sentence that communicates the core purpose without any extraneous detail. It is front-loaded and easily scannable.

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 is no output schema, the description should clarify the expected return structure, but it does not. It also omits any caveats about scope (e.g., whether all tasks are included) or behavior when no tasks exist. For a tool with one optional parameter and no annotations, this description leaves 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?

The schema description coverage is 100% for the single parameter project_id, which already explains its meaning ('Limit to one project; omit for the whole account.'). The tool description adds no additional information about the parameter, so it does not exceed the schema baseline.

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

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

The description clearly identifies the action (group tasks) and the grouping criterion (priority into high, normal, low). It implies retrieval of tasks and distinguishes from siblings like get_tasks_by_status (grouping by status) and get_tasks (flat list). The verb and resource are specific, though it doesn't explicitly say 'retrieve' but 'group' carries that meaning.

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 get_tasks, get_tasks_by_status, or search_tasks. The description does not mention any conditions, exclusions, or preferred contexts. An agent would have to infer usage from the name and schema.

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

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

With no annotations, the description carries the full burden of behavioral disclosure. It reveals that the tool groups tasks and includes counts, but it does not state whether tasks without a status are included, whether it is read-only, or any pagination or permission considerations. These gaps could lead an agent to assume broader or narrower behavior than actually exists.

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 states the core action and output composition with zero filler. It is front-loaded with the primary behavior and efficiently conveys the key information an agent needs.

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

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

The tool is simple with one optional parameter and no output schema, and the description gives a basic outline of the response (grouped tasks with counts). However, it omits important contextual details such as whether tasks with null status are included, whether grouping is based on a specific field, and does not reference the optional project_id behavior. This is adequate but leaves room for misinterpretation.

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

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

The input schema provides a full description for the only parameter (project_id: 'Limit to one project; omit for the whole account.'), so schema coverage is 100%. The description adds no additional parameter semantics, but per the rubric the baseline of 3 applies when the schema fully documents the parameter.

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

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

The description clearly states a specific action and resource: grouping tasks by status, with counts and tasks per group. This implicitly distinguishes it from siblings like get_tasks_by_priority or get_overdue_tasks, though it does not explicitly name an alternative. It is concise and specific enough for a capable agent to understand what the tool returns.

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 get_tasks, get_all_tasks, or get_tasks_by_priority. The description does not mention use cases, exclusions, or contrast with sibling tools, leaving the agent to infer the appropriate situation based only on the name.

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 behavioral burden. 'List' implies a read-only operation, but the description does not explicitly state that it is non-destructive, nor does it disclose any auth requirements, response format, or potential errors. For a simple getter this is adequate but minimal.

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 the meaning, and it is immediately clear what the tool does.

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 schema documentation, the description is sufficient. It does not describe the return format (since no output schema exists), but for a list of tag names this is unlikely to be necessary. It could be improved by adding a note about the response structure or confirming it is read-only, but overall it is adequate.

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

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

Schema description coverage is 100%, with both 'project_id' and 'task_id' already documented in the schema. The description adds no parameter-specific information beyond what the schema provides, so it meets the baseline but does not exceed it.

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 ('List') and the resource ('tag names currently applied to a task'). It distinguishes itself from the sibling 'get_tags' by specifying the scope as a particular task, so an agent can tell them apart without opening schemas.

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

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

The description implies usage when you need tags for a specific task, but it does not explicitly mention when to prefer this over alternatives like 'get_tags' (all tags) or 'set_task_tags' (modify tags). There is no explicit when-to-use or exclusion 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 behavioral burden. It discloses that the tool groups open and completed tasks by assignee and operates account-wide or by project. It does not mention read-only guarantees, response shape, or aggregation details, but for a simple read-style aggregation the provided behavior is reasonably clear.

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 sentence that states the core action, grouping dimension, statuses included, and scope. There is no filler or redundant restating of 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 one-optional-parameter read tool, the description covers the essential selection behavior and scope. Without an output schema, it does not describe the returned format, but the aggregation intent is clear enough for an agent to select and invoke the tool 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 coverage for the only parameter, project_id, is 100%, and the schema already explains it as limiting the view to one project. The description's phrase 'across the account or one project' reinforces the optionality, but it does not add meaning beyond the schema.

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

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

The description states a specific verb-resource pairing: 'Group open and completed tasks by assignee' and clearly scopes it 'across the account or one project.' It is clear but does not explicitly position itself against sibling tools like get_all_tasks or get_time_report, so it stops short of full differentiation.

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

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

The description implies when to use this tool: when an assignee-level overview of open and completed tasks is needed, optionally limited to one project. However, it gives no explicit guidance about when not to use it or how it compares to alternatives such as get_tasks_by_status, get_project_stats, or get_time_report.

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

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

With no annotations provided, the description carries the full burden. It discloses the aggregation and grouping behavior but omits details like read-only nature (though implied by 'get'), handling of empty results, pagination, or authentication requirements. It also doesn't clarify whether the default output includes entries (mitigated by the include_entries parameter).

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

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

The description is a single, front-loaded sentence that clearly states the action, resource, scope, and grouping. There is no wasted wording, and it is easy to scan.

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 six optional parameters and no output schema, the description is somewhat sparse. It doesn't explain parameter combinations (e.g., whether filters are mutually exclusive), the default behavior when no filters are provided, or the expected output structure beyond 'totalled per person'. The schema covers individual parameter meanings but not their interactions.

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 each parameter is already described (e.g., 'Inclusive start date', 'Limit to one project'). The description adds no additional parameter semantics beyond what the schema provides, aligning with the baseline 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 the verb 'summarise' and the resource 'logged time and money', with scope limited to an account, project, or task over a date range, and grouping per person. It distinguishes itself from sibling tools like get_costs (money only) and get_running_timers (active timers) by its aggregation focus.

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 obtaining aggregated time and money totals per person over a date range, which is clear context. However, it does not explicitly name alternatives or state when not to use this tool (e.g., if raw entries are needed without totals, or if only costs are needed).

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

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

With no annotations, the description must carry the behavioral disclosure burden. It does reveal a key behavior: 'Returns a status report instead of raising when the call fails,' which informs the agent about error handling. However, it does not explicitly state read-only safety or describe what the status report 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?

The description is two sentences, front-loaded with the primary purpose, and contains no filler. Every word contributes to understanding.

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

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

For a zero-parameter tool with no annotations and no output schema, the description explains the purpose and failure behavior, but it leaves the structure of the 'status report' unspecified. An agent knows why to call it but not exactly what to expect in the 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 tool has zero parameters, and the schema already indicates that. With no parameters there is nothing to clarify, so the baseline score of 4 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 a specific action (verify) and resource (configured credentials can reach Worksection API). It does not explicitly differentiate from siblings like auth_status or validate_configuration, but the connectivity focus is distinct enough.

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 auth_status or validate_configuration. The description states what it does but not the conditions that would make it the right 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?

Annotations are absent, so the description carries the full burden. It usefully discloses that an empty list is returned when FILE_WORKSPACE_DIR is not set, which adds behavioral context. However, it does not state whether the operation is read-only, what fields are returned for each file, or how the listing is ordered.

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

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

The description is a single sentence that front-loads the action and resource, then adds the key edge case. No filler or redundant 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 no output schema and no annotations, the description should compensate by explaining return format. It does not specify what elements the list contains (e.g., relative paths, file names, metadata), leaving an agent uncertain about the result structure. The edge case is helpful but not sufficient for full 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?

There are zero parameters, and the schema is empty with 100% coverage. Per the rubric, a zero-parameter tool gets a baseline of 4; the description has no parameter semantics to add.

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

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

The description states a specific verb ('List') and resource ('files available in the configured workspace directory'), which clearly identifies the tool's function. It distinguishes from task-file tools like get_task_files by referencing a workspace directory, though it does not explicitly name a sibling.

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 download_file, upload_file, or get_task_files. The only condition mentioned is the FILE_WORKSPACE_DIR unset case, which describes a behavioral outcome rather than a usage criterion.

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 alone must disclose behavior. It reveals only that a comment is added, but does not mention write permissions, whether hidden/internal comments behave differently, or side effects; these are material 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 entire description is one short, front-loaded sentence with no filler. Every word contributes to the purpose.

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

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

For a simple mutation with fully documented parameters, the tool is callable from this description alone. However, with no annotations or output schema, an agent is left without guidance on return behavior, authentication, or the hidden flag's effect, so this is a minimal but not comprehensive definition.

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 documents all five parameters, including hidden and author_email defaults. The description adds no parameter meaning itself, so 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 uses the specific verb 'Add' with the direct object 'comment' and target 'task', clearly distinguishing post_comment from siblings like get_comments and update_comment. Even without a title, the purpose is unmistakable.

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

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

The description does not explicitly state when to choose this over alternatives or mention prerequisites. Its verb makes the intended use obvious relative to get_comments and update_comment, so guidance is implied rather than stated.

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

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

With no annotations, the description must carry the behavioral disclosure burden. It correctly states the tool reads a single bounded chunk rather than the entire response, and it references the offload summary as the source of context. However, it does not describe behavior for invalid or out-of-range chunk_index values, chunk stability, or error cases. It also mentions 'total_chunks' as if it were an input, though it is not present in the schema, which could slightly mislead.

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 exactly two sentences, with the primary action front-loaded and no redundant wording. Every sentence contributes either the purpose or the input-sourcing guidance, making it efficient and easy to scan.

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 two-parameter tool, the core purpose and input provenance are clear. However, because there is no output schema, the description should explain the response shape and iteration logic more explicitly — for example, that chunk_index ranges over 0..total_chunks-1 — which is only implied. This is a meaningful gap for an agent that needs to read all chunks 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 coverage is 100%: both parameters already have descriptive text ('worksection://offload/... URI' and 'Zero-based chunk to read'). The description adds context by pointing to the offload summary, but the referenced 'total_chunks' is not a declared parameter, so the added value is limited. This matches the baseline for fully documented schemas.

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 identifies a specific verb ('Read') and a precise resource ('one bounded chunk of a response that was too large to return inline'). This clearly distinguishes it from sibling getter tools, which target domain objects rather than offloaded response chunks. It also names the input source ('offload summary'), leaving no ambiguity about what the tool does.

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 instruction to 'Use the resource_uri and total_chunks from the offload summary' provides a clear context for when this tool is appropriate, and implies it should be used when consuming a previously offloaded large response. It does not explicitly state exclusions or alternatives, but no sibling tool covers the same offload-read purpose, so the guidance is sufficient.

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 must carry the full burden of behavioral disclosure. It only says 'reopen' but does not mention any mutational side effects (e.g., changing status), whether it requires specific permissions, if it is reversible, or what happens to associated timers or subtasks. For a write operation, this is insufficient.

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

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

A single sentence, direct and to the point. It is concise and easy to parse, but lacks any additional helpful details that could strengthen the definition.

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

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

The tool is a mutative action (reopening a task) with no annotations, no output schema, and no details on side effects, prerequisites, or return value. For its simplicity, it is minimally acceptable but incomplete given the lack of contextual or behavioral information.

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

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

The input schema already has 100% coverage with descriptions for both parameters ('Project the task belongs to', 'Task id'), so the baseline is 3. The description adds nothing about the parameters, but since the schema fully describes them, this is acceptable.

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 'Reopen a previously completed task.' clearly indicates the action and the object, but does not differentiate from sibling tools like 'complete_task' or 'update_task' beyond naming the reverse operation. It lacks specific context about what 'complete' vs 'reopen' means in this system.

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

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

There is no explicit guidance on when to use this tool versus alternatives. The description implies a counterpoint to complete_task, but does not state when either should be used. An agent would have to infer its usage from the tool name context.

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

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

With no annotations provided, the description carries the full burden. It does disclose a meaningful behavioral trait: filtering is applied locally for reliability. However, it does not cover result ordering, how multiple filters combine, or any auth/scoping caveats, so the disclosure is partial.

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 no repetition or filler. The criteria are listed first, followed by the scope and the local-filtering caveat. Every clause earns its place.

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

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

For an 8-parameter search tool with no output schema and no annotations, the description is minimally viable but thin. It omits combination semantics, return shape, and performance implications of local filtering, yet it covers the core operation and scope well enough for basic invocation.

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

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

Schema description coverage is 100%, so the baseline is 3. The description paraphrases several parameters already documented in the schema and adds the account-vs-project scope nuance, but it does not add genuinely new semantic 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 uses a specific verb ('Search'), identifies the resource ('tasks'), enumerates the filter criteria ('text, status, assignee, priority and due date'), and clarifies scope ('across the account or inside one project'). This clearly distinguishes it from simple retrieval siblings like get_tasks or get_all_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?

There is no guidance on when to prefer this tool over siblings like get_tasks_by_status, get_tasks_by_priority, get_overdue_tasks, or get_all_tasks. The 'Filtering is applied locally' note hints at internal behavior but does not state selection criteria or exclusions.

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

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

No annotations are provided, so the description carries the burden of behavioral disclosure. It clearly states the destructive/replacement behavior ('Replace every tag'), which is the key behavioral trait. However, it does not disclose whether the operation is reversible, whether it requires specific permissions, or what happens if the task has no existing tags. The core mutation is disclosed, but additional behavioral context is missing.

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 sentence that is front-loaded with the key behavior ('Replace every tag') and the target resource ('a task'). Zero wasted words, and the replacement semantics are stated before any other detail. This is an efficient, well-structured 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 mutation tool with 3 fully documented parameters and no output schema, the description is mostly adequate. The key gap is the lack of explicit contrast with add_task_tags, which is a sibling tool. An agent could benefit from knowing that this tool overwrites the entire tag set while add_task_tags appends. The description implies this but doesn't state it directly.

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

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

Schema description coverage is 100%, so the schema already documents all three parameters. The description adds the semantic meaning that the 'tags' list is the complete replacement set, which is valuable. However, it doesn't add details about tag format constraints beyond what the schema already states (non-empty, no commas). Baseline 3 is appropriate since 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 'Replace every tag on a task with the given list' uses a specific verb ('Replace') and resource ('tags on a task'), and clearly distinguishes this from the sibling add_task_tags by stating the replacement semantics. An agent can immediately understand the tool's behavior and differentiate it from related tag 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 usage context: use this when you want to set the complete tag set, replacing existing tags. However, it does not explicitly state when to prefer this over add_task_tags or mention any exclusions or prerequisites. The sibling list includes add_task_tags, so the contrast is implied but not spelled out.

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 disclose behavior on its own. It only says the timer is started and provides no information about side effects, whether a timer must not already be running, ownership semantics, or what happens on success or failure.

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 filler. It is somewhat awkwardly phrased ('Start a running timer' could imply starting a timer that is already running), but it remains concise and front-loaded with the core intent.

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 timer-start operation, the description is minimally viable for basic invocation. However, with no annotations, no output schema, and no usage guidance, an agent would not know important behavioral details such as whether starting a timer replaces an existing one or whether user_email defaults to the current user in all contexts.

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 documents all three parameters with clear descriptions (task to time, project the task belongs to, person the timer belongs to), so schema coverage is complete. The tool description itself adds no additional parameter meaning, but the baseline of 3 is appropriate because the schema carries the burden.

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 identifies a specific action (start) and a specific resource (timer on a task), making the basic intent clear. It does not explicitly compare itself to stop_timer or get_running_timers, but the verb 'start' distinguishes it reasonably from sibling timer 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?

There is no guidance about when to use this tool versus stop_timer, get_running_timers, or get_time_report. The description relies entirely on the tool name and the reader's inference, and it does not mention prerequisites such as having an active project/task or an existing timer.

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. It does disclose the key side effect that elapsed time is stored, but it does not describe behavior when no timer is running, whether the optional comment is persisted, or how user_email affects the operation. This leaves behavior only partially transparent.

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, front-loaded with the verb and direct object, with no filler. It states both the action and the persistence side effect efficiently.

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 output schema and no annotations, the description is adequate but brief. It covers the core action but omits error/edge behavior, response information, and the role of optional parameters user_email and comment; schema descriptions mitigate the parameter gap.

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 each parameter already has a meaningful description in the schema. The tool description adds no additional parameter-level meaning, so it stays at the baseline for complete schema 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 identifies a specific action (stop the running timer), the resource (a task), and the consequence (elapsed time stored). This clearly differentiates it from sibling tools like start_timer and get_running_timers.

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 when-to-use or when-not-to-use guidance is provided, and no alternative tool is named. The usage is implied by the verb 'stop' and the presence of sibling tools like start_timer, but it is left to inference.

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 'Replace,' which implies mutation, but it does not mention whether the operation is destructive to the original text, whether any permissions are required, what the response looks like, or whether the change is reversible. This is a significant gap 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?

The description is a single, front-loaded sentence with no filler or redundant phrasing. Every word contributes to communicating the core action, 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?

The flat 4-parameter schema with 100% coverage makes the tool fairly simple to invoke, and the description clarifies the core operation. However, because there is no output schema and no annotations, the description does not explain what the tool returns or any side effects. It is minimally sufficient but not richly 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 parameters are already documented in the schema. The description confirms that 'text' is the replacement body and that the target is an 'existing comment,' but it does not add any meaning beyond what the schema properties already provide. 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 uses a specific verb and resource: 'Replace the text of an existing comment.' It clearly identifies the action and object, and the word 'existing' distinguishes it from sibling tools like post_comment, which create new comments. This is a precise, non-tautological statement.

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

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

The description implies when to use the tool—when you want to overwrite the text of an already-created comment—but it does not explicitly name alternatives or exclusion criteria. An agent can infer the use case, but there is no direct guidance such as 'use post_comment for new comments'.

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. 'Change' implies mutation, but the description does not clarify partial-update semantics, whether null values clear or preserve fields, permission requirements, or what response is returned. 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 focused sentence with no filler, and the core action and affected fields are front-loaded. Every word adds value.

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 annotations and output schema, this description is too thin. It does not address update behavior, validation constraints, or how the three required identifiers are used to target the entry, leaving an agent without enough context to call the tool reliably in non-obvious situations.

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 already documents all seven parameters with descriptions. The description adds only the synonym 'amount' for the money parameter and no meaningful extra semantics beyond what the schema provides, matching the baseline for high schema 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 uses a specific verb ('Change') with a clear resource ('an existing time entry') and lists the mutable fields (hours, comment, date, amount). It aligns with the sibling add_costs as creation and get_costs as reading, so the tool's purpose is unambiguous.

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

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

The description implies this is for updating an existing entry, but it does not explicitly state when to use it instead of add_costs or get_costs, nor does it mention any prerequisites or constraints. No exclusions or alternative routing are provided.

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

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

With no annotations, the description carries the full burden of behavioral disclosure. It only states the change operation without explaining whether updates are partial (only provided fields), how null values are handled, permission requirements, or side effects. This is insufficient for a mutation tool with 6 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, efficient sentence with no wasted words. The main action and target are front-loaded. It is concise but not under-specified to the point of obscuring the purpose.

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

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

For a mutation tool with 6 parameters, no output schema, and no annotations, the description is too thin. It fails to explain critical details like partial update behavior, required vs optional fields beyond the schema, or any operational constraints. This leaves significant gaps for 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%, so each parameter has a description. The description adds little beyond listing the fields, which are already in the schema. It does not clarify relationships (e.g., whether dates must be in a specific format) or update semantics. 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 clearly states the action ('Change') and the resource ('a project'), and enumerates the specific fields affected (title, description, manager, dates). This distinguishes it from sibling update tools like update_task or update_comment, which target other resources. It is slightly generic but adequate.

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. While the resource name implies projects, no explicit context, prerequisites, or exclusions are provided. The agent must infer usage from the schema and sibling names.

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 'Change' and lists fields, without explaining partial-update behavior, null semantics, permission requirements, or what happens when fields are omitted.

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 identifying the operation and the fields affected.

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

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

For a simple update tool with fully documented parameters, the description is mostly adequate. However, with no annotations and no output schema, the lack of behavioral context (e.g., how null values are handled, whether the update is partial) leaves some ambiguity.

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 parameters are already documented. The description lists the mutable fields but adds no meaning beyond what the schema provides, warranting the baseline score.

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 ('Change') and identifies the resource ('a subtask') while enumerating the mutable fields. This clearly distinguishes it from sibling tools like update_task and create_subtask by resource and operation type.

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

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

The description gives no guidance on when to use this tool versus alternatives, nor any exclusions or prerequisites. It simply states what the operation does, leaving the agent to infer usage from the tool name and parameters.

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 only states that fields can be changed, but does not clarify partial-update semantics, null-field behavior, permissions, side effects, or response format.

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 sentence with no wasted words. It is front-loaded with the action and resource, though it sacrifices some useful detail for brevity.

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 mutable tool with 8 parameters, no annotations, and no output schema, the description is too sparse. It omits update semantics, how nulls are interpreted, and any guidance on required identifiers, leaving the agent to infer behavior from the schema alone.

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 parameters. The description paraphrases several field names (title, description, assignee, dates, priority) but adds no extra meaning such as date formats, priority bounds, or null behavior.

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 ('Change'), identifies the resource ('a task'), and lists the affected fields (title, description, assignee, dates, priority). This clearly differentiates it from update_subtask, update_project, update_comment, and update_costs.

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 about when to choose this tool over alternatives. The description simply restates the action and does not mention exclusions, prerequisites, or sibling tools.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It does state that arbitrary filesystem paths are rejected, but this is already encoded in the schema for workspace_filename ('Absolute paths, '..' segments and symlinks are rejected'), so it adds little beyond structured data. It does not disclose permissions, overwrite behavior, return value, error conditions, or any side effects of attaching a file. For a mutation tool, this is a significant gap.

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

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

The description is two sentences with no filler. The primary action and resource are front-loaded, and the alternative input modes and rejection restriction are stated compactly. Every sentence earns its place; nothing is redundant.

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 too thin to be considered complete. It covers the core action and input constraints but omits critical context for an agent deciding to call it: what happens on success (e.g., returned attachment object), what happens on overwrite/duplicate, permissions required, and behavior when both content_base64 and workspace_filename are given. The schema covers parameter formats but not operational behavior, leaving the agent to guess at consequences.

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% (every parameter has a description), so the baseline is 3. The description adds meaning by grouping content_base64 and workspace_filename as alternative modes, clarifying the 'or' relationship implied by the schema. However, it does not explain precedence if both are provided, size limits, or encoding details beyond what the schema already states. It adds marginal structure but no new semantic depth.

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 opens with 'Attach a file to a task,' a specific verb and resource that clearly identifies the tool's purpose. It also distinguishes two input modes (base64 or workspace file) and explicitly rejects arbitrary filesystem paths, which sets it apart from sibling tools like download_file or get_task_files without needing to open schemas.

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 two acceptable ways to provide content (inline base64 or workspace-relative filename) and states a restriction ('Arbitrary filesystem paths are rejected'). However, it offers no explicit guidance on when to prefer this tool over alternatives, no exclusions, and no mention of prerequisites (e.g., task must exist). Usage is derivable from the purpose but not explicitly framed against sibling tools.

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 behavioral disclosure. It usefully states that the tool contacts no external service and never returns secret values, giving agents important safety context beyond a generic 'report' description.

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, well-structured sentence that front-loads the primary purpose and then adds relevant caveats. No filler or redundant information is present.

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

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

For a zero-argument diagnostic tool, this description provides enough context about the output scope and safety characteristics. It could be slightly richer in explaining how results are returned, but it is largely complete.

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

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

The tool takes zero parameters and the input schema is empty, so there are no parameter semantics to clarify. The description appropriately avoids mentioning parameters.

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

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

The description clearly states the tool reports the server's effective configuration and startup check results. It identifies a specific verb and resource, though it does not explicitly distinguish itself from sibling health_check.

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 like health_check. The description explains what the tool does but not the conditions or scenarios that should lead an agent to select it.

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

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

With no annotations, the description carries the behavioral burden and does well: it discloses the interactive browser flow, the loopback wait, encrypted token storage on disk, and the non-failing admin_key behavior. It omits return/report format and timeout behavior, but those are secondary given the detailed flow description.

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

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

The description is three focused sentences with no filler. It front-loads the core action and then adds behavioral specifics, earning every sentence's place.

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

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

For a login tool with one optional parameter and no output schema, the description covers the main flow, side effects, and an important edge case. It could mention what the reported result looks like, but the essential information needed to call it correctly is present.

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

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

Schema description coverage is 100%, with the timeout_seconds parameter already fully documented. The description's mention of waiting for the loopback redirect adds slight context but does not need to compensate for schema gaps.

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

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

The description states a specific action: starting the OAuth2 browser login, opening the authorization page, waiting for the loopback redirect, and storing tokens. This clearly distinguishes it from siblings like auth_status and worksection_logout by naming the exact resource and behavior.

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 gives clear context for when the tool applies and explicitly notes an exclusion: in admin_key mode it has nothing to do and reports rather than failing. It does not name alternative tools like auth_status or validate_configuration, but the invocation context is sufficiently clear.

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. It discloses the exact effect (delete tokens from disk), the side effect (only local credentials removed), and explicitly states what is not affected (Worksection data). This is transparent and accurate, though it doesn't mention if the operation is reversible or requires authentication state.

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 concise sentences with no fluff. The main action is front-loaded, and the clarifying statement about scope follows immediately. Every word earns its place.

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

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

For a simple, no-argument, no-output tool, the description fully covers what it does and its side effects. It is complete enough for an agent to call it correctly without additional information.

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

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

The tool has no parameters, and schema coverage is 100% (empty schema). The description adds nothing about parameters, but the baseline for zero parameters is 4 because there is nothing to document. It correctly implies no arguments are needed.

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

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

The description clearly states the action: delete stored OAuth tokens from disk. It specifies the resource (OAuth tokens) and the scope (local credentials), and distinguishes itself from siblings like worksection_login and auth_status by noting that nothing in Worksection itself is affected.

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 implies usage: to remove local credentials without affecting remote state. However, it does not explicitly mention when to use it versus alternatives (e.g., logging out entirely) or any prerequisites like being authenticated. The clear scope gives good context, but exclusions are not spelled out.

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