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

No annotations are provided, so the description carries full responsibility for disclosing behavior. It only states the action ('Add a comment') without mentioning side effects, error conditions, or requirements beyond English. It does not explain what happens if taskId/taskNumber are missing or how existing comments are affected. 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 concise, front-loading the core action and then adding usage timing and a constraint. The three sentences are efficient with no wasted words. Slightly longer than strictly necessary but 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 mutation tool with no output schema and no annotations, the description covers the core action and usage timing but omits important context such as return value, error handling, or prerequisites like needing an active session (though params suggest auto-from-session). It is adequate but not fully complete for an agent to predict all 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 all five parameters are already documented with descriptions. The description adds no extra parameter-specific meaning beyond what the schema provides. The baseline of 3 applies because the schema does the heavy lifting, and the description does not contradict or enrich 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?

States a specific verb and resource ('Add a comment to a task') which is clear and unambiguous. Does not explicitly differentiate from siblings like list_comments or update_task, but the action is distinct enough that an agent can infer its role. The usage context ('Call AFTER making changes...') reinforces its purpose.

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

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

Provides explicit temporal guidance ('Call AFTER making changes and BEFORE complete_ai_task') and a constraint ('content in English'). This tells the agent when to use it, though it does not mention alternatives or exclusions. Still, the guidance is clear and actionable.

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

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

No annotations are provided, so the description carries the full behavioral burden. It explains the default status and per-entry fields, but does not disclose the effect on tasks, whether completion is reversible, partial failure behavior, authentication needs, or return/error semantics. This is a significant gap for a mutating batch 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 two short front-loaded sentences with no filler. The first sentence captures the core operation, and the second adds useful per-entry variation details without redundancy or excess length.

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

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

With no annotations and no output schema, this description is too thin for a mutating batch operation. An agent does not know what 'complete' does to the tasks, what the response will be, or how failures in the batch are handled. The schema is thorough, but the description does not complete the operational picture.

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 repeats some parameter information (message, prUrl, commitHash, default status) but adds no meaning beyond what the schema already documents.

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: 'Complete multiple AI tasks in a single call.' It clearly distinguishes this batch variant from single-task siblings like complete_ai_task and from batch_start_tasks, 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 phrase 'multiple AI tasks in a single call' provides clear usage context: use this when completing several tasks at once. It does not explicitly name an alternative or state when not to use it, but the batch framing is sufficient for basic routing.

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 behavioral burden itself. 'Get' implies a read-only operation and 'multiple tasks in a single call' conveys the batching behavior, but the description does not address partial failures, response shape, or how missing task numbers are handled. This is minimal but acceptable for a simple batch read.

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

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

The description is three short, purposeful clauses with the main purpose front-loaded. There is no filler, and each sentence contributes either to selecting the tool or understanding how to invoke it 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 straightforward batch read tool, the description plus fully documented schema give an agent enough to select and invoke it correctly. The lack of an output schema means return formatting is not specified, but the phrase 'full details' provides a sufficient contract for a read operation, and no critical invocation details are missing.

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

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

Schema description coverage is 100%, so the schema already documents taskNumbers, teamId, and projectId clearly, including the max 50 items and auto-from-session behavior. The description's 'Accepts an array of task numbers' only echoes the schema and adds no meaningful parameter semantics beyond 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 verb and resource: 'Get full details of multiple tasks in a single call.' It also distinguishes itself from the sibling get_task by emphasizing the batch scope and efficiency, so an agent can immediately tell the two apart.

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 a clear usage context: use this tool when you need multiple task details, and it explicitly names the alternative with 'More efficient than calling get_task multiple times.' It does not spell out when not to use it, but the batching guidance is clear enough.

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

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

With no annotations, the description carries the full behavioral burden. It does disclose useful side effects: it sets tasks to IN_PROGRESS / PROCESSING and returns compact results. However, it does not explain partial-failure behavior, whether the batch is atomic, what happens if a task cannot be started, or what 'compact results' actually 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?

Three short sentences, each adding distinct value: the action, the state effect, and the efficiency comparison with the single-task sibling. There is no filler or repetition, and the most important purpose is front-loaded.

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

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

For a low-complexity tool with fully documented parameters, the description is nearly sufficient: an agent knows what to pass, what state change occurs, and that results are compact. The main gaps are the unspecified result shape and batch failure semantics, which matter because there is no output schema and no annotations, but they do not block a correct invocation.

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

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

Schema description coverage is 100%, so the schema already documents all three parameters and their meanings. The description adds no parameter-level detail beyond 'multiple AI tasks', which maps to taskNumbers but not to teamId or projectId. The baseline of 3 is appropriate because the schema does the heavy lifting.

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

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

The description opens with a specific verb and resource: 'Start multiple AI tasks at once.' It then clarifies the effect by stating statuses are set to IN_PROGRESS / PROCESSING and distinguishes itself from start_task by explicitly framing itself as a batch alternative. An agent can clearly tell this from its siblings even before inspecting the schema.

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

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

The description gives clear context for when to use it—starting multiple tasks together—and names the alternative directly with 'More efficient than calling start_task multiple times.' It does not explicitly state when not to use it, but the batch-vs-single contrast provides adequate 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?

No annotations are provided, so the description carries the burden of disclosing side effects. It does not state that this is a write operation, whether files are overwritten, whether the commit is pushed directly, or what response/errors to expect. The sequencing hint is useful but not sufficient behavioral context.

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

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

Three short, front-loaded sentences with no filler. 'Max 50 files' duplicates schema metadata, but it is a critical constraint worth reinforcing. The message is compact and 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?

Adequate for a straightforward commit operation given a fully documented schema. However, without annotations or an output schema, the description leaves behavioral expectations unstated (e.g., what happens on success, whether the branch must already have a PR, and how partial failures are handled).

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 parameters. The description adds a small semantic constraint ('commit message in English') and repeats the max-files rule from the schema, but does not add meaning 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?

States a specific verb and resource: 'Commit files to a branch.' It immediately distinguishes itself from the sibling create_pull_request by explicitly saying it should be called after that tool, so an agent can tell this is the follow-up commit step.

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?

Gives explicit sequencing ('Call AFTER create_pull_request') and a hard limit ('Max 50 files'). It does not enumerate alternatives or when-not-to-use scenarios, but the key usage constraint is clearly communicated.

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

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

With no annotations, the description carries the disclosure burden. It discloses the key side effect (auto-move to Review), a default status, and a prerequisite call order. It doesn't describe FAILED-status behavior or reversibility, but the main behavioral traits are 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?

Multiple short sentences deliver the core action, side effect, ordering prerequisite, language requirement, and default status with no filler. The most important scoping information is front-loaded.

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

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

For a mutation-focused tool with no output schema, this description plus fully covered schema gives an agent the necessary recipe: call after add_comment, provide an English message, and let status default. Minor gaps remain around FAILED behavior and when to prefer batch_complete_tasks, but they don't block correct use.

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 documents all eight parameters, so the description only needs to add marginal value. It adds an English-language constraint for message and echoes the COMPLETED default, but otherwise relies on 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 says the tool reports AI work results and auto-moves the task to the Review column, giving a clear action and resource. It doesn't explicitly differentiate from move_task or batch_complete_tasks, but the intent 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?

It explicitly instructs 'Call AFTER add_comment', which gives sequencing relative to a sibling, and states that the message must be in English. It doesn't mention when not to use it or alternative batch tools, but the main usage context is 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 language requirement and the ordering constraint, which are useful behavioral hints. However, it does not mention side effects like branch creation permanence, potential failure modes, or permissions. The mutation nature is implied by 'create' but not elaborated.

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

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

The description is two concise sentences with no wasted words. The core action and key constraint are front-loaded, making it easy 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?

The description covers the essential usage context (ordering and language), and the schema fully documents parameters. It lacks a note about return values, but since there's no output schema, a brief mention could help. Still, it's adequate for an agent to invoke correctly, especially with auto-filled IDs.

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

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

The schema covers all six parameters with descriptive text, so the description adds no extra parameter semantics. The baseline of 3 applies because the schema already provides full documentation.

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

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

The description states a specific action ('Create a branch and pull request') with a clear resource, and it names the sibling commit_files to differentiate itself. The purpose is unambiguous.

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

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

It gives an explicit ordering constraint ('Call BEFORE commit_files') which directs when to use this tool relative to a key sibling. However, it doesn't list other alternatives or scenarios where this tool should not be used, so it's not fully comprehensive but clear enough for the main 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?

No annotations are present, so the description must carry the behavioral burden. It discloses that the operation creates a task and imposes an English-only restriction, but it does not mention permissions, side effects, session-based defaults, or result behavior. 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?

Two short sentences with the core operation front-loaded and no filler. The 'IMPORTANT' warning is effectively placed and each 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?

The rich schema covers all parameter semantics and the description states the essential action and constraints. However, with no annotations and no output schema, the description leaves out behavioral and session context (e.g., auto-populated teamId/projectId and expected return value), making it adequate but not fully complete.

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

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

Schema description coverage is 100%, with all nine parameters already documented including types, enums, and auto-from-session notes. The description only restates the English requirement and required fields that the schema already conveys, adding no new semantic detail.

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 action ('Create a new task') and clearly identifies the resource and required inputs. The verb 'create' is distinct from sibling mutations like update_task and move_task, so the agent can tell them apart without opening the schema.

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

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

Provides clear context by naming the required fields (title and columnId) and highlighting the English-language constraint. It does not explicitly exclude alternative tools, but the creation intent is self-evident 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?

No annotations are present, so the description carries full responsibility for behavioral disclosure. It only says 'Read a file' without explaining return format, handling of the optional ref, authentication prerequisites, or side effects. While the read operation is inherently non-destructive, this is not stated and the description offers minimal context beyond the action itself.

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

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

The description is a single, focused sentence with no wasted words. The key action and resource are front-loaded, making it easy for an agent to parse quickly. It is appropriately sized for the tool's simplicity.

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

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

For a straightforward read tool, the description is reasonably complete. The schema covers parameter semantics, and the absence of an output schema is acceptable for a tool that returns file content. However, it doesn't mention that teamId/projectId are auto-populated from session (though schema notes this), and it doesn't specify how ref defaults to the default branch. These are minor gaps but not critical given the schema's coverage.

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 100% coverage with descriptive text for all four parameters (path, ref, teamId, projectId). The description adds no parameter-specific detail, so the baseline of 3 applies. The description's mention of 'file' and 'repository' loosely maps to path but doesn't enrich 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 clear verb ('Read') and resource ('a file from the connected GitHub repository'). It distinguishes this from sibling tools like get_repo_tree (which reads tree structure) and commit_files (which writes). The scope 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 usage but gives no explicit guidance on when to use this tool versus alternatives. It doesn't mention that it's for raw content retrieval, nor does it contrast with get_repo_tree or commit_files. The name and description make the primary use case obvious, but no alternatives or exclusions are provided.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It only mentions the return value (connection or null), but does not state whether the operation is read-only, requires authentication, or has any side effects. The verb 'get' implies non-destructive, but that is not explicit. More context about expected behavior 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?

The description is a single, well-structured sentence that states the purpose and the key return condition without any filler. It is front-loaded and easy to parse.

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

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

There is no output schema, so the description must convey what the agent can expect. It mentions returning a connection or null, but does not describe what the connection object contains (e.g., repo URL, owner). For a simple existence check this may suffice, but an agent wanting to use the connection details would need more info. The description is adequate but not fully complete.

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

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

Schema description coverage is 100%, with both parameters ('teamId' and 'projectId') having clear descriptions about auto-filling from session. The tool description adds no extra parameter details beyond what the schema provides, so it stays at the baseline of 3.

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

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

The description clearly states the action ('Get'), the resource ('GitHub repository connection'), and the scope ('for a project'). It also notes the null return when no repo is connected, which distinguishes it from sibling tools like get_project (project details) and get_repo_tree (repo contents). This is a specific, unambiguous definition.

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 does it mention prerequisites like requiring an active session or a connected repo. No exclusions or alternative tools are named, so the agent has to infer appropriate usage from the name and context.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It implies a read operation ('Get') but does not explicitly state it is non-destructive, nor does it mention any authentication requirements, error behavior, or side effects. The description is too minimal to inform an agent about the operation's safety profile.

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

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

The description is a single sentence with no wasted words. It efficiently communicates the core purpose and the unique GitHub connection aspect, making it easy to parse.

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

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

Given the low complexity and full schema coverage of parameters, the description is mostly adequate. However, with no output schema, it does not describe the return value beyond 'details', leaving the agent to guess what fields are included. For a get operation, this is a minor but notable 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?

The input schema covers both parameters with descriptions indicating they are auto-from-session if omitted, achieving 100% coverage. The description adds no additional parameter context, so it stays at the baseline 3 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 clearly states a specific verb 'Get' and a specific resource 'details of a specific project', and adds a distinguishing feature 'including its GitHub connection'. It differentiates from list_projects (which likely lists projects) by focusing on a single project, but it does not explicitly name the alternative.

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

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

The description provides no explicit guidance on when to use this tool versus alternatives like list_projects or get_task. It does not mention that parameters are optional and auto-filled from session context, nor does it state any conditions for use. The usage context is only implied by the resource type.

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

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

No annotations are provided, so the description carries the full burden of disclosing behavior. It implies a read-only browsing operation but does not state whether the tree is recursive, what metadata is included, how the connected repository is determined, 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, front-loaded sentence with no filler. It communicates the core purpose efficiently and does not waste the agent's attention.

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

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

With no output schema and no annotations, the description leaves important context unstated, such as default ref behavior, tree depth, and the relationship to the connected repository. For a tool with four optional parameters and many siblings, this is not fully complete.

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

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

Schema description coverage is 100%, so all four parameters already have meaningful descriptions. The tool description adds no per-parameter detail beyond that, so the baseline score of 3 is appropriate.

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

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

The description states a specific verb and resource: 'Browse the file tree of the connected GitHub repository.' It clearly distinguishes itself from the sibling get_file_content by focusing on the tree rather than file contents, though it does not explicitly name or contrast any 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?

No guidance is given about when to use this tool versus get_file_content, get_github_context, or other siblings. The description only says what the tool does, leaving the agent to infer when it is 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?

No annotations are provided, so the description must carry the behavioral burden. It signals a non-mutating read via 'Get' and clarifies the identifier requirement, but it does not mention permissions, idempotency, behavior when both taskId and taskNumber are provided, or error handling for missing identifiers. The behavioral 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?

The description is a single focused sentence, front-loaded with the purpose, followed by a compact list of returned fields and the identifier constraint. There is no filler, redundancy, or excessive 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 read-only single-task retrieval with zero required parameters, the description covers core invocation (taskId or taskNumber) and enumerates expected return values, while the schema documents all parameter semantics including session-based defaults for teamId/projectId. It does not address edge cases like neither or both identifiers provided, but overall the 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%, so the description adds little beyond what the schema already provides. It restates the OR relationship between taskId and taskNumber, which is already documented in the schema's taskId description. The field list in the description does not clarify parameter formatting or constraints 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 ('Get') and resource ('task') and enumerates the exact fields returned: description, metadata, screenshot, page URL, CSS selector, browser info, console/network errors, comments, AI status. This clearly distinguishes it from sibling list/search/batch tools that return lighter or multi-task views. The name itself 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 usage when full details of a single task are needed, but it does not explicitly state when to prefer list_tasks, search_tasks, or batch_get_tasks. It provides an invocation constraint (taskId OR taskNumber) but no exclusions or alternative routing. Usage guidance is 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?

No annotations are present, so the description carries the full behavioral burden. It discloses auto-discovery from the API token, the side effect of auto-selecting team/project for subsequent calls, and the returned payload (AI task queue). It does not cover idempotency or failure modes (e.g., no token, zero teams/projects), but the state-changing behavior is well documented.

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 front-loaded with purpose and ordering ('Initialize the MCP session. Call this FIRST'), and each sentence contributes distinct information. At five sentences it is slightly longer than minimal, but the length is justified because with 0 parameters and no annotations, the description must carry the setup semantics.

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 0-parameter tool with no output schema and no annotations, the description covers the essential call sequence (first), the return value (AI task queue), and the follow-up route (set_context). Only edge-case behavior such as authentication failure or an empty team/project list is missing, which is a minor gap for a session-init tool.

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

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

The tool has 0 parameters, so the baseline is 4. The description adds meaningful context about implicit inputs — the API token and the resulting team/project auto-selection — which is the semantic information an agent needs in place of explicit 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 uses a specific verb-plus-resource ('Initialize the MCP session'), states the tool's key output ('returns the AI task queue'), and differentiates itself from siblings by positioning it as the mandatory first call, distinct from set_context, list_teams, and list_ai_queue. An agent can immediately understand what this tool does and why it exists.

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

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

The description explicitly says 'Call this FIRST before any other tool,' which is unambiguous when-to-use guidance. It also names the exact alternative and condition: 'If you have multiple teams or projects, call set_context afterward.' This is textbook explicit when/when-not/alternatives 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 present, so the description carries the burden. It indicates the output is 'compact summaries' and that starting work is a separate step (start_task), but it doesn't explicitly state read-only behavior, pagination, or included fields. 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?

Three short clauses, each earning its place: what it lists, what filters exist, and what to do next. The main action is front-loaded and there is no filler.

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

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

For a simple list tool with no required parameters and no output schema, the description covers the core need and the follow-up action. The vague 'compact summaries' is the only gap; it doesn't specify exact return fields, but the workflow 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 baseline is 3. The description only reiterates 'priority and tag filters' without adding new semantics for teamId/projectId or value formats.

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"), a precise resource ("tasks queued for AI processing"), and the return style ("compact summaries"). It clearly distinguishes this from sibling list_tasks and search_tasks, which operate on the general task set.

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: this is the tool to see queued AI work, with optional priority/tag filters, and explicitly points to start_task as the follow-up action. It doesn't name alternatives or exclusions, but the AI-queue scope is evident.

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 behavior burden itself. 'List all' conveys a read-only, non-destructive operation, but it does not disclose details such as return format, ordering, or what happens when no project context exists. The basic behavior is clear, though richer context is absent.

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

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

The description is a single, front-loaded sentence with no filler. 'List all kanban columns in a project' manages to convey scope and action 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 simple read-only list operation with fully documented optional parameters, the description and schema together provide enough context to call the tool. There is no output schema, but the absence of return-value details is a minor gap for a straightforward enumeration tool.

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

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

Schema description coverage is 100%: both teamId and projectId are documented with 'auto from session if omitted.' The description adds no further parameter detail, and since the schema already fully covers the parameters, 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 identifies a specific verb ('List') and resource ('kanban columns in a project'), making the tool's main function obvious. It does not explicitly contrast with sibling tools like list_tasks or get_project, but the resource is distinct enough to avoid ambiguity.

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

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

The description provides no guidance on when to use this tool versus alternatives, and no exclusions or prerequisites are mentioned. 'In a project' hints at the need for project context, but the description does not explain which project or how 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?

No annotations are provided, so the description carries the burden of behavioral disclosure. 'List all comments' communicates a read-only operation and scoping, but it does not mention pagination, ordering, size limits, or whether a session is required. The behavior 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?

A single sentence with no filler or repetition. The core behavior is front-loaded and 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 simple list operation with fully documented parameters, the description is nearly adequate. However, without annotations or an output schema, it leaves unstated details such as whether a task identifier is effectively required and whether results are paginated. An agent could likely invoke it, but only with help from the schema.

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

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

Schema description coverage is 100%, so the schema already documents all four parameters. The description adds no parameter-level meaning beyond saying the comments belong to 'a task'; it does not clarify the taskId/taskNumber alternative or session defaults, but the schema covers 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?

States the specific action ('List'), resource ('comments'), and scope ('all comments on a task'). It is clearly distinct from sibling tools like add_comment, and there is no ambiguity about 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?

The description implies when to use the tool: to view all comments for a task. However, it does not state when not to use it, mention alternatives, or provide any exclusions. Usage context is present but only by 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 of behavioral disclosure. It clearly indicates a read-only listing operation scoped to a team, but does not mention output format, ordering, pagination, or team context behavior. This is adequate for a simple list tool but leaves some ambiguity.

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. 'List all projects in a team' is front-loaded and immediately understandable.

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 one optional parameter and no output schema, the description covers the core operation. However, it lacks guidance on output shape or how it relates to sibling tools, so it is adequate but not fully complete.

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

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

Schema description coverage is 100%, and the teamId parameter is already described as 'Team ID (auto from session if omitted).' The tool description adds no additional parameter semantics beyond the schema, 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 is a clear verb+resource combination: 'List all projects in a team.' It clearly distinguishes from sibling tools like 'list_teams' (which lists teams) and 'get_project' (which retrieves a single project), though it does not explicitly name 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?

The description gives no explicit guidance on when to use this tool versus alternatives, nor any exclusions or prerequisites. 'List all projects in a team' implies its use case but does not help an agent choose between this and related list/get 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, the description carries the burden. It discloses that the result is a compact summary rather than full task details, which is a useful behavioral trait, but it omits details like pagination, ordering, or whether all tasks are truly returned without limits.

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 redundant wording. The main behavior is front-loaded, and the alternative is pointed to succinctly.

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

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

The description is minimally sufficient for a simple list operation, but with no output schema it does not specify the exact shape of a 'compact summary', pagination behavior, or session prerequisites. The optional session-derived parameters are covered by the schema, but the overall context is not fully fleshed out.

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 input schema. The description adds no further parameter semantics, but the schema fully compensates.

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 action ('List all tasks') and a clear resource ('in a project'), with the distinguishing scope of 'compact summaries' that separates it from get_task (full details) and search_tasks (search). The purpose is immediately 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?

Names the alternative tool get_task for when full details are needed, giving a clear usage contrast. It does not explicitly discuss when to prefer search_tasks or mention prerequisites like session initialization, but the core differentiation is present.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It only states the core list operation and does not explain session/teamId resolution, pagination, access requirements, or what member information is returned. The word 'List' at least implies a read-only 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. It communicates the entire operation efficiently and every word contributes to 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?

This is a simple tool with one optional parameter, and the schema covers the parameter well. However, the description lacks explicit guidance about session prerequisites, how the team is determined when teamId is omitted, and the expected output shape. It is adequate but has clear gaps in context.

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

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

The schema fully describes the single teamId parameter, including the fallback behavior 'auto from session if omitted.' The description adds no additional parameter-level meaning, 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 and resource: 'List all members of a team.' This clearly identifies the operation and distinguishes it from sibling tools like list_teams, which lists teams rather than members. It is a meaningful expansion of the tool name, not a tautology.

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

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

The description provides no guidance on when to use this tool versus alternatives such as list_teams or get_project. It also does not mention prerequisites like having an active session or team context. Usage must be inferred solely from the tool's obvious purpose.

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

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

With no annotations, the description carries the behavioral burden. 'List all teams the authenticated user belongs to' discloses the access scope, but it does not explicitly state read-only behavior, pagination, ordering, or what happens when the user has no teams.

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. It states the action, the resource, and the scope 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 simple parameterless list operation, the description is nearly complete. The only minor gap is the absence of any mention of the response shape, though returning a list of teams is strongly implied.

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

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

The tool has zero parameters, so there is no parameter information for the description to add. This is the baseline for parameterless tools, and the description's scope qualifier is sufficient.

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 clear resource ('teams'), with an explicit scoping qualifier ('the authenticated user belongs to'). It is unambiguous and easily distinguishable from sibling tools such as list_team_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 states what the tool does but gives no guidance on when to choose it over alternatives like list_team_members or list_projects. There are no context cues, prerequisites, or exclusions provided.

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

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

No annotations are provided, so the description carries the full burden. It implies mutation (moving a task) but does not disclose potential side effects, permission requirements, or reversibility. The statement about automatic handling by siblings adds context, but the description lacks deeper behavioral detail such as what happens to the task's position or any constraints.

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 sentences with zero filler. The purpose is front-loaded, and the usage restriction is stated immediately, making it highly scannable and efficient.

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

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

Given the moderate complexity (6 params, 1 required) and lack of output schema, the description covers purpose and usage but omits any indication of return behavior or prerequisites. However, schema descriptions handle parameter semantics, and the action is straightforward. The description is nearly complete for a simple move operation, though it could benefit from a note on typical invocation context.

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

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

Schema description coverage is 100%, so each parameter is documented in the schema. The description itself adds no additional parameter meaning beyond the overall action, providing no extra context for parameter selection or relationships. Baseline 3 is appropriate given full 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 specific action ('Move a task to a different kanban column') with a clear resource and target, and explicitly differentiates from sibling tools by naming start_task and complete_ai_task as automatic alternatives. This makes the tool's purpose 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?

Provides explicit when-to-use guidance ('Only use when explicitly asked') and names the exact sibling tools that handle the operation automatically, giving clear exclusion criteria. This is exemplary usage direction.

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 disclosing behavior. 'Returns compact summaries' and 'Use get_task for full details' are genuinely useful behavioral disclosures, but the description does not explain result fields, pagination, or default limits beyond what the schema already states.

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

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

The description is extremely concise and well-structured: the action is front-loaded, the output nature is stated next, and the follow-up tool is given last. Every clause earns its place with no filler.

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

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

The schema covers all optional parameters and the description covers the core output behavior plus a path to full details. However, with no output schema and a closely related sibling (list_tasks), the description leaves some ambiguity about when this tool is the right choice and what a compact summary contains.

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 10 parameters are already documented. The description adds no parameter-specific meaning beyond the generic phrase 'with filters,' so the baseline 3 is appropriate.

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

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

The description states a specific action ('Search tasks') and a key scope ('with filters'), and it clarifies that results are 'compact summaries,' which differentiates it from get_task. It does not explicitly distinguish search_tasks from the sibling list_tasks, so it falls just short of a 5.

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

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

The description implies the search->get_task flow: use this tool for filtered, compact results, then get_task for full details. However, it does not explicitly address when to use search_tasks versus list_tasks or other listing/sibling tools, so the guidance is only implicit and incomplete.

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 a key behavioral trait: the tool sets session-wide state that persists across subsequent tool calls. This is beyond what annotations (none) or schema provide. It also clarifies that IDs are optional and that the tool changes context rather than performing a one-off action. It doesn't mention whether setting one ID resets the other, but the 'and/or' phrasing covers partial updates.

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?

Three sentences, all informative. The core action is front-loaded, followed by usage timing and the key behavioral consequence. No wasted words.

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

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

For a simple 2-param tool with no output schema, the description covers the essential context: when to use it, what it does, and the session-wide effect. It could mention whether both IDs are required together or if setting one clears the other, but the 'and/or' phrasing and optional parameters make this reasonably 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 both parameters. The description adds context that these IDs become the active defaults, but doesn't add syntax or format details beyond what the schema provides. Baseline 3 is appropriate.

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

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

The description clearly states the tool's purpose: 'Set or change the active team and/or project for this session.' It uses a specific verb ('set/change') and resource ('active team/project'), and distinguishes itself from siblings by focusing on session-level context rather than listing or fetching data.

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

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

The description explicitly says when to use it: 'Use this after init_session when you have multiple teams/projects.' It also explains the benefit and behavior: 'Once set, all subsequent tool calls will use these IDs automatically — no need to pass teamId/projectId every time.' This gives clear context and implies when not to use it (when you don't need to change 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, so the description must disclose behavior. It discloses the status changes and return context, but doesn't mention edge cases like idempotency, prerequisites, or permission requirements. Transparent about the core effect but not comprehensive.

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 sentences, no fluff, main action and key detail (OR condition) front-loaded. Efficient 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?

No output schema, so description must explain return, which it does ('full context'). It also gives usage context ('FIRST'). Lacks error handling and prerequisites, but schema covers optional parameters. Adequate for a mutation tool.

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

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

Schema coverage is 100%, so baseline is 3. The description reinforces the OR condition between taskId and taskNumber, which is already in the schema, so it adds little new information. teamId/projectId are left to 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?

States a specific action ('Start working on an AI task') with clear effects (moves to In Progress, sets AI status to PROCESSING) and return (full context). The 'FIRST' directive differentiates it from sibling tools like move_task and batch_start_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?

Explicitly instructs 'Call this FIRST for every AI task', which is strong usage guidance. However, it doesn't mention when not to use it or alternative tools like batch_start_tasks for multiple tasks.

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 must carry the behavioral burden. It does add useful constraints: avoid column-moving behavior and keep title/description in English. However, it does not disclose mutation effects, validation behavior, idempotency, error behavior, or what happens when multiple/differing identifiers are supplied.

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

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

The description is compact and front-loaded with the core action. Each sentence earns its place: the main purpose, the exclusion, the identifier rule, and the language constraint. There is no 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?

For a tool with 10 optional parameters, no required fields, no annotations, and no output schema, the description provides enough to call it in basic cases but leaves important gaps. It does not clarify whether updates are partial or full replacement, what happens if both taskId and taskNumber are provided, or what the response/error behavior looks like.

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 covers all parameters (100% coverage), so the baseline is 3. The description adds value beyond the schema by requiring title/description to be in English and clarifying the acceptable identifier pair 'taskId OR taskNumber', which is important for correct invocation.

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

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

The description states a specific verb and resource: 'Update task properties.' It also distinguishes itself by explicitly saying not to use it for moving columns, making it easy for an agent to separate from start_task/complete_ai_task or move_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 gives an explicit when-not-to-use instruction ('Do NOT use this to move columns') and names the intended alternatives ('use start_task/complete_ai_task instead'). It also notes that taskId OR taskNumber can be used, which is practical selection guidance.

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