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 implies a mutation (adding a relationship) but does not mention permissions, reversibility, side effects, or error conditions. For a state-changing operation, 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 sentence with no wasted words. It perfectly fronts the action and resources, making it immediate 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?

For a simple two-parameter operation with full schema coverage and no output schema, the description is minimal but not fully complete. It lacks any context about constraints (e.g., whether a card can be its own child, cycle prevention) or the expected success/failure semantics, though these may be less critical given the tool's simplicity.

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

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

Schema description coverage is 100%, and both parameters have clear descriptions ('Parent card ID' and 'ID of the card to add as a child'). The description adds no further semantic meaning beyond the schema, so the baseline of 3 applies.

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

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

The description clearly states the action ('Add a child card to a parent card') with a specific verb and resources. It distinguishes itself from siblings like 'remove_card_child' and 'list_card_children' by the verb, though it doesn't explicitly reference 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?

There is no guidance on when to use this tool versus alternatives, no exclusion conditions, and no mention of prerequisites or context. The description only states the basic operation, leaving the agent to infer when it is appropriate.

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

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

With no annotations provided, the description is the sole source of behavioral information. It merely states the action without disclosing side effects (e.g., whether it replaces an existing link, whether it requires permissions, what the response looks like, or if it can fail). This is minimal and 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 concise sentence that delivers the core purpose without any fluff. It is appropriately sized for a straightforward operation and is front-loaded with the key 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 add operation with complete schema documentation and no output schema, the description is minimally complete. However, it omits any context about the return value, error conditions, or constraints (e.g., whether the URL must be unique per card), which could be useful for an agent, though not critical given the low complexity.

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

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

Schema description coverage is 100% for all three parameters (url, card_id, description), so the schema already documents them clearly. The description adds no additional meaning beyond what the schema provides, 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 ('attach') and the resource ('external link (URL) to a card'), which precisely distinguishes it from sibling tools like update_card_external_link and remove_card_external_link. There is no ambiguity about what this 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 description provides no guidance on when to use this tool versus the related list, update, or remove external link tools. It does not mention any prerequisites, constraints, or typical scenarios, relying entirely on the agent to infer usage from the operation name and 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?

No annotations are provided, so the description carries the full burden of behavioral disclosure. It only states the action without mentioning side effects, permissions, idempotency, or failure conditions. For example, it doesn't indicate what happens if the user is already a member. This is a mutation tool with no behavioral context, which 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 with zero filler. 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?

The tool is a mutation with no annotations and no output schema. The description is minimal and doesn't explain return values, prerequisites, error handling, or use cases. For a tool that alters state, this is incomplete. Similar to the 'update_drive' example, more context is needed.

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

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

Schema description coverage is 100%, with both parameters already described as 'Card ID' and 'User ID to add as a card member'. The description adds no additional meaning beyond the schema. Baseline is 3 because the schema handles the documentation, and the description doesn't compensate further.

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: 'Add a user as a member of a card.' It specifies the verb 'Add', the resource 'a user', and the target 'a card'. It is unambiguous and distinct from siblings like remove_card_member and update_card_member_role, as it's the only add operation for 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 provides no explicit guidance on when to use this tool vs alternatives. However, given the sibling set (remove_card_member, update_card_member_role), the usage is implied: this is the tool for adding a member. There's no context on prerequisites or exclusions, but the implied usage is sufficient for a straightforward operation.

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 a key side effect: the tag is created if it doesn't exist. This goes beyond the schema, which only mentions the tag name. However, it does not elaborate on idempotency or permissions, but for a simple mutation it is reasonably 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, front-loaded sentence with zero wasted words. It conveys the core action and the side effect efficiently, earning a perfect score for 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?

For a simple tool with only two parameters and no output schema, the description is sufficient for an agent to call it correctly. It doesn't mention error cases or return values, but those are not essential given the simplicity. The description covers the essential behaviors without missing critical 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 schema covers 100% of parameters with descriptive text ('Tag name (created if it doesn't exist yet)' and 'Card ID'). The description adds little beyond the schema, mostly restating the tag creation aspect. Therefore, 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 states a specific action ('Attach a tag') and resource ('to a card'), and clarifies the creation behavior. This clearly distinguishes it from sibling tools like remove_card_tag and list_card_tags. The purpose is unambiguous.

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

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

The description gives clear context for when to use this tool (attaching a tag to a card) but does not explicitly mention alternatives such as remove_card_tag or list_card_tags. There are no exclusions, and the name and action make the usage scenario self-evident, so a 4 is appropriate.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It only says 'Add' without detailing side effects, permission requirements, idempotency, or what happens on failure (e.g., if the card or checklist doesn't exist). The mutation is implied but not elaborated. There is no contradiction, but the behavioral context is 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, clear sentence: 'Add an item to a card checklist.' It has zero redundancy, front-loads the core action, and is immediately scannable. Every word contributes. This is an example of efficient communication.

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 7 parameters (3 required, 4 optional) and no output schema, the one-line description is insufficient for an agent to understand how to use the tool correctly. It doesn't mention what happens on success (e.g., returns the new item) or failure, nor does it explain how optional parameters like 'sort_order' or 'responsible_id' affect behavior. The absence of annotations further compounds the gap. The schema provides parameter names but not integration 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 covers all 7 parameters with descriptions (100% coverage), so the baseline is 3. The tool description adds no extra parameter meaning or guidance beyond what the schema already provides. For instance, it doesn't explain the relationship between 'checked', 'due_date', and 'responsible_id' or any constraints. The schema already handles basic semantics, so this is an acceptable 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 states the action ('Add') and the resource ('an item to a card checklist'). It is specific enough to distinguish from removal or modification tools, though it doesn't explicitly contrast with sibling tools like update_checklist_item or remove_checklist_item. The phrase 'card checklist' makes the target 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 provided on when to use this tool versus alternatives such as update_checklist_item for modifying an existing item, or create_checklist for creating a new checklist. The description does not mention any prerequisites (e.g., the checklist must already exist) or conditions favoring this tool over siblings. An agent would have to infer usage from the name alone.

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

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

No annotations are provided, so the description carries full responsibility for disclosing behavioral traits. It only states the action ('Add a comment') without mentioning side effects, permissions required, return behavior, or error conditions. 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 a single, clear sentence with no filler or redundancy. It is appropriately front-loaded 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?

The tool has low complexity (two parameters, no output schema). The description covers the core action adequately. However, it does not mention any prerequisites (e.g., the card must exist) or what response the agent can expect. For a simple add operation this is borderline acceptable but not 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 input schema provides 100% coverage with descriptive text for both parameters ('Comment text (Markdown)' and 'Card ID to comment on'). The tool description adds no further meaning beyond what the schema already specifies, so 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 states the verb 'Add' and the resource 'comment to a Kaiten card', clearly distinguishing it from sibling comment operations (list_comments, update_comment, delete_comment). It is specific 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?

The description gives no explicit guidance on when to use this tool versus alternatives like update_comment or delete_comment. The action itself is self-evident, but the description does not mention exclusions or conditions. It relies on the agent to infer that this tool is for creating 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?

No annotations are provided, so the description must disclose behavioral effects. It mentions the action and the two ways to block, but doesn't explain side effects (e.g., whether the card becomes read-only), required permissions, or what happens on success. 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 efficient sentence that front-loads the core action and the two blocking modes. There is zero waste, and it reads clearly.

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

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

For a mutation tool with no annotations, no output schema, and only a terse description, the definition is incomplete. It doesn't clarify whether reason and blocker_card_id are mutually exclusive, whether blocking has lasting effects, or what the API returns. An agent calling this tool would lack crucial 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 coverage is 100%, so all parameters already have detailed descriptions. The description's mention of 'reason' and 'blocking card' maps to those fields but adds no new semantics beyond rephrasing. Per the baseline, a 3 is appropriate when the schema carries the full 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 clearly states the verb 'block' and the resource 'card', and specifies two ways to block (with a reason or by a blocking card). It is specific enough to distinguish from the unblock_card and list_card_blockers siblings, though it doesn't explicitly name them. The clarity is good, if not perfect.

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 related tools like update_card_blocker or unblock_card. The description simply states what it does without context for selection among alternatives, leaving the agent to infer usage.

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 merely restates the action ('create a board') without disclosing side effects, return values, permission requirements, failure behavior, or what happens on success. This is minimal and adds no behavioral knowledge beyond the verb 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 sentence, front-loaded with the core action, and contains zero waste. It is appropriately sized for a simple creation tool 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 creation tool with no output schema and no annotations, the description is thin. It doesn't state what the function returns (likely the created board), any constraints (e.g., space must exist), or what happens if validation fails. This leaves an agent without enough context to fully predict behavior beyond the basic action.

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 three parameters (title, space_id, description), achieving 100% coverage. The tool description adds no parameter-specific elaboration, so it doesn't enhance the schema. Baseline of 3 applies as per the 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 specific verb ('create'), the resource ('board'), and the context ('in a space'). It clearly distinguishes this from sibling tools like update_board, delete_board, and get_board by specifying the create action and resource. No ambiguity remains about the tool's 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?

The description provides no guidance on when to use this tool versus alternatives, no prerequisites (e.g., the space must exist), and no exclusions. An agent must infer that it's the right tool for creating a board, but no explicit routing or conditions 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 burden of behavioral disclosure. It states the action ('Create'), implying a mutation, but does not disclose potential side effects, required permissions, reversibility, or what happens on success (e.g., whether the created card is returned). It also does not mention any preconditions beyond the schema's required fields. The description adds minimal behavioral detail beyond the obvious.

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. It contains no filler or redundant details, and the optional lane is mentioned succinctly. It is appropriately brief for the tool's simplicity, though slightly more detail on behavior could be added without harming 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 that the tool has 6 parameters and no output schema, the description should provide more context about the operation's result or any constraints. It does mention the core location context (board, column, optional lane) but omits details such as whether the created card is returned, how errors are handled, or any prerequisites like existing board/column eligibility. The schema covers parameter definitions, but the absence of an output schema means the description should clarify the return value, which it does not. Overall, it is adequate but not complete for a create operation.

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

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

Schema description coverage is 100%, so the input schema fully documents all six parameters. The tool description adds a small semantic nuance by highlighting that lane_id is optional ('and optional lane') and reiterating the need for board and column. However, it does not explain owner_id or description beyond what the schema already states, so it does not significantly compensate for or enhance parameter understanding beyond the schema.

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

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

The description clearly states the verb ('Create'), the resource ('a new card'), and the location constraints ('on a board in a specific column (and optional lane)'). It is specific and distinguishes this tool from siblings like update_card, move_card, and delete_card, which perform different actions. The purpose is unambiguous and immediately actionable.

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 specifies the context of use (creating a card on a board in a column/lane) but does not explicitly mention alternatives or when not to use this tool. While it is obvious that this is the creation tool among card-related siblings, there is no explicit guidance on choosing it over other actions. The context is clear, but exclusions are not stated.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It only says 'add', implying mutation, but offers no information about side effects, error conditions, required permissions, or what happens on success. 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 a single, front-loaded sentence with zero wasted words. It efficiently conveys the core operation without redundancy, 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 tool is simple, with no output schema and full parameter coverage in the schema. However, the lack of behavioral context, such as whether the checklist is created with no items or what the response is, leaves the definition incomplete for fully understanding the operation's impact. It is minimally adequate but could be improved.

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

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

The schema provides 100% coverage for all three parameters, so the baseline is 3. The description adds no extra meaning beyond what the schema already states, such as how 'sort_order' is used or any constraints on 'card_id' or 'name'.

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

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

The description states the specific verb 'add' and resource 'checklist to a card', making the purpose clear. It distinguishes from sibling tools like 'remove_checklist' and 'update_checklist' by naming the action explicitly, though it lacks any detail beyond the basic 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?

No guidance is provided on when to use this tool versus alternatives. It does not mention exclusions, prerequisites, or relationships to other checklist-related tools. An agent has to infer usage solely from the name and basic action.

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 of behavioral disclosure. It only states the creation act without mentioning side effects, permission requirements, reversibility, or response behavior. For a mutation tool, 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?

A single, front-loaded sentence with no filler. Every word serves to state the purpose. It is concise without being under-specified for the core action.

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 schema covers all parameters and the operation is simple, the description provides the essential action. However, it lacks any context about the board-column relationship, column type meanings, or potential constraints, which could help an agent anticipate edge cases. Overall, it is adequate but minimal.

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 5 parameters documented in the schema. The tool description adds no extra meaning beyond 'create a column', so it does not improve on what the schema already 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 action (create), the resource (column), and the context (on a board). This matches the verb+resource pattern and naturally distinguishes it from sibling tools like update_column, delete_column, or create_board.

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. With many sibling tools (create_board, create_card, update_column, etc.), the description gives no hints about prerequisites, exclusion criteria, or selection conditions.

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 behavioral traits. It implies a write operation (`Create`) but does not mention permissions, side effects, reversibility, or what happens if a lane with the same title already exists. For a mutation tool, this is a significant omission.

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 states the core action and context directly, and the essential information is front-loaded. 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 create operation with a schema that fully describes parameters, the description is minimally adequate. However, it does not mention what the tool returns (e.g., the created lane object), and it lacks usage guidance, which is partly captured under other dimensions. Given the lack of annotations and output schema, the description could be more informative but is not severely deficient.

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 (`title`, `board_id`, `wip_limit`, `sort_order`). The description adds no additional meaning about parameters, so the baseline score of 3 is appropriate.

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

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

The description clearly states the action (`Create`) and the resource (`a new lane (swimlane)`) and specifies the scope (`on a board`), making it easy to identify the tool's purpose. It does not explicitly differentiate from sibling tools like `create_column` or `update_lane`, but the resource name is unambiguous enough that an agent would not confuse it.

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_lanes`, `update_lane`, or `delete_lane`. It does not state any prerequisites, such as needing an existing board, nor does it explain when creation is appropriate. The intended usage is left entirely 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?

No annotations are provided, so the description carries the full burden of behavioral disclosure. It only states the mutation action without mentioning permissions, side effects, reversibility, or response format. For a create operation, such omissions are significant gaps.

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 clear sentence with no unnecessary words, earning high marks for conciseness. It front-loads the essential verb and object. However, it is so minimal that it sacrifices potential structure or elaboration, but this is not a significant penalty for a simple tool.

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

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

For a simple create operation with two well-documented parameters and no output schema, the description is minimally adequate. However, it fails to mention what the response contains, any required preconditions, or what constitutes a successful creation. These missing details reduce completeness for an agent that needs to call it correctly in isolation.

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 both parameters (title and external_id) with descriptions, providing 100% coverage. The description itself adds no extra meaning beyond the schema, so the baseline of 3 applies. No additional semantics are needed since the schema is complete.

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 'space', which unambiguously identifies the operation. It distinguishes itself from sibling tools like list_spaces, get_space, and update_space by the verb, making the purpose clear. It doesn't add extra context about what a space is, but for a simple CRUD tool it's 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. It doesn't state conditions for creation, prerequisites, or contrast with update_space or delete_space. The agent is left to infer usage context, which is insufficient for a tool with many 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 must carry the full behavioral burden. It does disclose the crucial fact that deletion is irreversible, which is a key behavioral trait. However, it does not elaborate on other consequences such as cascading deletion of associated data (cards, columns), permission requirements, or whether the operation can be undone in any way. The mention of irreversibility is a clear positive, but the lack of broader disclosure keeps this at a 3.

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: two short sentences with the core action ('Delete a board') front-loaded, followed by a critical warning. Every word earns its place, and there is no redundancy. The structure is efficient and immediately 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?

For a simple delete operation with two well-documented parameters and no output schema, the description is generally adequate. However, it omits any mention of side effects (e.g., whether deleting a board also deletes its cards, columns, etc.) or error conditions. While not strictly required, such context would help an agent anticipate consequences. The presence of the irreversibility warning is a plus, but the overall completeness falls short of a 4.

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 already having descriptive names and types. The tool description adds no additional meaning about board_id or space_id beyond what the schema already states. Per the calibration rule, with high schema coverage, a baseline of 3 is appropriate; the description does not enhance parameter understanding.

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

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

The description states the action and resource clearly: 'Delete a board.' It is specific and unambiguous, and the name delete_board distinguishes it from other delete operations like delete_space or delete_card without requiring further context. The verb-resource pairing is exact and leaves no room for misinterpretation.

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 a usage hint by noting 'Irreversible — confirm with the user,' which implies a precondition for use (obtain confirmation). However, it does not explicitly mention when to use this tool versus alternatives (e.g., archiving instead of deleting) or any exclusions. The guidance is minimal but not entirely absent, meriting a mid-level score.

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 highlights irreversibility and advises user confirmation, which are critical for a destructive action. However, it does not mention side effects (e.g., related data like comments or attachments), required permissions, or what happens on success/failure. This is a minimal but valuable 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 exceptionally concise: two short sentences that front-load the action ('Delete a card by ID') and immediately convey the critical warning. Every word earns its place, with no fluff or repetition. This is an ideal length for a simple, single-parameter destructive tool.

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

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

Given the simplicity (one parameter, no output schema, no nested objects), the description is adequate but not fully complete. It covers the action and irreversibility but does not mention expected return value or error behavior. Since there is no output schema, the description should arguably explain what the client receives, but for a delete operation this may be implied (e.g., success/failure). It 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 input schema has 100% coverage, with the parameter card_id fully described as 'Card ID to delete (irreversible)'. The description adds no additional parameter meaning beyond what the schema already provides. Per the baseline rule for high schema coverage, a score of 3 is appropriate.

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

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

The description clearly states the verb (delete), the resource (card), and the identification method (by ID). This is specific and distinct from sibling delete tools (delete_comment, delete_board, etc.) which operate on different resources. 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 description gives a safety guideline ('confirm with the user first') but does not explicitly discuss when to use this tool versus alternatives. Since the resource is clearly a card and siblings are for other resources, the intended usage is implied but not directly contrasted. The warning adds useful operational guidance, but it lacks explicit alternative 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 carries full burden. It explicitly discloses the critical behavioral trait — irreversibility — which is the key danger for a delete operation. It could add detail on cascading effects (e.g., whether cards inside the column are also deleted), but the main risk 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?

Two short clauses with zero waste. The purpose is front-loaded ('Delete a column'), followed by the essential warning. 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 2-parameter delete with full schema coverage and no output schema expectations, the description is reasonably complete. It covers purpose and the destructive nature. The only gap is lack of detail on downstream effects on contained data, which would matter to an agent deciding whether to call 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 coverage is 100% and both parameters already have clear schema descriptions, so the baseline is 3. The description adds no parameter semantics beyond the schema — it merely echoes 'column' which maps to column_id.

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?

'Delete a column' is a specific verb+resource. The intent is unambiguous, and the resource is clear enough to distinguish from delete_space/delete_board/delete_lane by name, though the description does not explicitly call out sibling differentiation.

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

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

No guidance on when to use this tool versus alternatives, no prerequisites (e.g., whether the board must be mutable), and no conditions. The only usage hint is 'confirm with the user,' which is a safety admonition rather than selection 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. It discloses a critical behavioral trait: 'Irreversible.' This warns the agent about permanence, which is essential. However, it does not mention any side effects, required permissions, or error conditions. Since it is a simple delete, the irreversibility note is a significant disclosure, but not exhaustive.

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, with two short sentences that convey the action and a crucial warning. It front-loads the verb and resource, ensuring immediate comprehension without fluff. 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 delete operation with two parameters fully documented in the schema and no output schema, the description covers the essential information: what it does and its irreversibility. It could potentially mention that the comment is removed from the card, but the name already implies this. Given its simplicity, it is adequately complete.

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

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

The schema provides complete coverage for both parameters (card_id and comment_id), each with descriptions. The tool description adds no new meaning beyond the schema, merely referring to 'by ID' without specifying which one. Since schema coverage is 100%, the baseline is 3, and the description 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 states a specific verb and resource: 'Delete a card comment by ID.' This clearly distinguishes it from siblings like add_comment, list_comments, and update_comment, leaving no ambiguity about the tool's function.

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

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

The description does not explicitly mention when to use this tool versus alternatives, but the verb 'delete' inherently signals its purpose. It does not mention exclusions or prerequisites (e.g., that the card must exist), though this is implied by the schema. Given the sibling tools, more explicit routing could help, but it is adequate.

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 behavioral burden. It does disclose the critical trait of irreversibility and instructs user confirmation. However, it omits other potential side effects, such as whether cards within the lane are also deleted or whether the operation fails if the lane is non-empty. The description covers the main risk but is not exhaustive.

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 sentences: 'Delete a lane. Irreversible — confirm with the user.' It front-loads the action, then the caution. Every word earns its place with zero wasted text, 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?

Given the tool's simplicity (2 parameters, no output schema, no nested objects), the description covers the primary purpose and the key warning. However, it does not specify the return format or behavior with regard to child content (e.g., cards in the lane), which an agent might need to know to handle side effects. It is adequate but has 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 baseline is 3 even with no param info in the description. The schema already describes lane_id as 'Lane ID to delete (irreversible)' and board_id as 'Board ID,' which duplicates the description's irreversibility warning. The description adds no additional meaning beyond the schema, so a 3 is appropriate.

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

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

The description uses a specific verb and resource: 'Delete a lane.' It clearly distinguishes from siblings like list_lanes, update_lane, and create_lane by naming the delete action. Even without naming alternatives, the purpose is unambiguous and matches the tool name.

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 (e.g., when to use update_lane instead, or when deletion is appropriate versus archiving). The only usage-related note is 'confirm with the user,' which is a process instruction, not a tool-selection criterion. No exclusions or conditions 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, the description bears full responsibility for behavioral disclosure. It explicitly states that the operation is irreversible, which is the most critical behavioral trait for a delete operation. It also instructs to confirm with the user, indicating the expected interaction pattern. It does not mention potential side effects like cascading deletes, but for a simple single-resource delete, this is sufficient.

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 exceptionally concise and front-loaded: it begins with the action and resource, then immediately conveys the critical warning. Every sentence earns its place, with zero fluff or redundancy. The structure is ideal for quick agent parsing.

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

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

For a tool with a single parameter, no output schema, and no annotations, the description is complete enough. It covers the purpose, the irreversible nature, and the confirmation requirement. It does not specify return values, but the absence of an output schema makes that less critical. The description is sufficient for an agent to 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?

The schema description coverage is 100%, meaning the parameter `space_id` is already fully documented in the schema (including its irreversibility). The tool description adds no additional meaning beyond what the schema provides; it merely restates that it deletes by ID. This matches the baseline expected 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 the action ('Delete') and the resource ('a space by ID'). It is unambiguous and easily distinguished from sibling delete tools (e.g., delete_board, delete_lane) due to the explicit 'space' target. The phrasing is direct and leaves no room for misinterpretation.

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 a clear usage guideline by warning that the action is irreversible and advising confirmation with the user. While it does not explicitly mention alternatives or when not to use it, the destructive nature is highlighted, making the appropriate context evident. This is more than implied guidance; it gives a concrete precaution for 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 provided, the description carries full burden for behavioral disclosure. The verb 'Get' hints at a read-only operation, but it does not explicitly state that it has no side effects, nor does it mention permissions, error conditions, or what happens if the board ID is invalid. This lack of explicit transparency is a gap.

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

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

A single sentence that is direct and free of fluff. It conveys the essential information (action, resource, scope of return) without unnecessary detail, making it highly efficient for an agent to parse.

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

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

The description mentions that the result includes columns and lanes, which gives some sense of the return content despite there being no output schema. However, it does not clarify whether these are all columns/lanes, any nesting, pagination, or error behavior. With no annotations or output schema, the description should provide more context but remains minimally 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%, so the schema already documents the parameter as 'Board ID'. The description says 'by ID', which is essentially redundant with the schema. It adds no new semantic meaning (e.g., type of ID, format requirements, or relationship to other parameters), 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 ('Get a single board by ID') and the resource (board), and adds that it returns columns and lanes, which distinguishes it from other tools like list_boards or get_space. The verb and resource are specific 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?

The description implies usage for fetching a specific board, but does not explicitly state when to use it versus alternatives (e.g., list_boards for enumerating boards, or get_space for spaces). No exclusions or conditional guidance are provided, leaving the agent to infer the 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, the description must carry the burden of behavioral disclosure. It states 'Get' which implies a read-only operation, and mentions 'full JSON' which clarifies the return payload. However, it does not disclose error behavior, permissions, or potential side effects, leaving notable gaps for a tool with zero annotation support.

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

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

The description is a single, tightly-worded sentence with no filler. It front-loads the action and scope immediately, making it highly efficient and easy to parse. 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 fetch tool, the description is adequate but not complete. It indicates the return is 'full JSON' but does not specify the structure of that JSON, error handling (e.g., what happens if the ID doesn't exist), or any caveats. Given no output schema, the agent has to infer the response structure from vague wording.

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% (card_id is described as 'Card ID to retrieve'). The description adds no new meaning beyond the schema—the phrase 'by ID' merely echoes the parameter description. Baseline 3 applies because the schema already fully documents the parameter, and the description offers no supplementary 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?

The description clearly states a specific verb ('Get') and resource ('a single card by ID'), and further specifies the return format ('full JSON'). It distinguishes itself from list_cards by emphasizing single-ID retrieval, making its purpose unambiguous even among many 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?

The description provides no guidance on when to use this tool versus alternatives like list_cards. It only implies usage (when you have a card ID and need one card), but does not state prerequisites, exclusions, or recommend alternatives. This is insufficient for an agent to choose it confidently.

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. The description only states the operation's purpose and does not disclose whether it is read-only (though implied by 'get'), whether it returns full history or a limited set, ordering, pagination, or any side effects. For a tool with no annotations, this lack of behavioral context 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. It includes a clarifying parenthetical that adds specificity without redundancy. Every word earns its place, and there is no extraneous information.

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

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

Given the absence of an output schema, the description should explain what the tool returns or the nature of the history data. It only says 'movement history' without specifying the format (e.g., list of changes, timestamps, actors), pagination, or whether it covers all changes or a limited window. For a tool with one parameter and no output schema, this is incomplete and leaves an agent guessing about 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 input schema fully describes the only parameter (card_id as an integer with description 'Card ID'), achieving 100% schema description coverage. The tool description does not add any additional meaning to the parameter, such as format expectations or constraints. Since the schema already documents it adequately, 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 states a specific verb ('Get') and a precise resource ('movement history (board/column/lane changes) of a card'). It clearly distinguishes this tool from sibling tools like move_card, as it is the only one that retrieves historical location changes. The parenthetical clarifies the exact type of changes covered, 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 description provides no explicit when-to-use or when-not-to-use guidance, nor does it mention any alternative tools. However, the purpose is inherently clear for a read-only history lookup, and the name implies usage for auditing or tracking card movement. This is an implied usage scenario rather than explicit guidance, so it falls short of a 4.

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. It conveys a read-only operation and that the result includes items, but does not detail error behavior, permissions, or response structure. Adequate for a simple getter.

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

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

One concise sentence that states the purpose and the return content. No fluff, 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 retrieval operation with full schema coverage, the description communicates what is retrieved (the checklist with its items) and requires no further context. No output schema is present, but the phrase 'with its items' covers the essential return expectation.

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 describes both parameters with basic descriptions ('Card ID' and 'Checklist ID'), which is 100% coverage. The description does not add extra semantic detail beyond that, so 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?

Clearly states the action 'Get' and resource 'card checklist', and specifies it includes items. This distinguishes it from create/update/delete checklist tools. No 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?

Does not explicitly mention when to use this tool vs alternatives. However, as a getter, usage is implied when a checklist's items are needed. No explicit exclusions or alternatives are named.

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 what the tool does but does not explicitly confirm it is read-only or side-effect-free. Since it's a simple getter, the read-only nature is implied, but the description could have been more explicit about lack of side effects or rate-limiting behavior.

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

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

The description is a single, efficient sentence that front-loads the core purpose ('Get the user the API token belongs to') and defines the term 'me'. Every word earns its place with zero redundancy.

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

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

Given the tool's simplicity (zero parameters, no output schema), the description is nearly complete. It clearly states what it returns (the user identity). It could optionally specify the output format (e.g., user object fields), but this is minor for a basic getter. Overall, an agent can confidently invoke 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?

The tool has zero parameters, so the input schema is empty. Per the rules, a baseline of 4 applies when there are no parameters to document. The description adds no parameter-specific information because none is needed.

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

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

The description clearly states the verb ('Get') and the resource ('the user the API token belongs to'), and explicitly defines 'me' as the current user. It distinguishes this tool from all siblings, which operate on spaces, boards, cards, and other resources, none of which address authentication identity.

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

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

The description implies the use case: identify the authenticated user when needed. It doesn't explicitly state when not to use it or mention alternatives, but the sibling list makes it evident that this tool is unique for current-user retrieval. The context is clear enough, though explicit exclusions would have scored higher.

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 does state 'read-only', which is a critical behavioral trait indicating this is a non-mutating operation. However, it does not describe the return format, potential error conditions (e.g., not found), or any other side effects. For a simple getter this is acceptable 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?

The description is a single, front-loaded sentence that states the purpose and the read-only nature in a direct manner. There is no filler or redundant wording, making it appropriately concise 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?

For a simple read-only tool with one parameter, the description is largely complete. It clearly states the operation and read-only nature. The absence of an output schema means the agent may not know the exact return structure, but for a getter of a custom property, the returned object is reasonably intuitive. It does not mention error handling or alternatives, but these are not essential for a basic get operation.

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

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

The schema already provides full coverage for the parameter 'property_id' with the description 'Custom property ID'. The tool description adds only 'by ID', which is redundant with the schema. Since schema coverage is 100%, the baseline is 3; the description adds no meaningful extra semantics beyond what the schema already provides.

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

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

The description states a specific verb ('Get'), a clear resource ('a single custom property'), and an identifier ('by ID'), and notes that the operation is read-only. This clearly distinguishes it from sibling tools like 'list_custom_properties' (which retrieves all) and 'list_custom_property_select_values' (which retrieves value options), making the 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 usage is implied: use this when you need a specific custom property and know its ID. However, the description does not explicitly compare it to alternatives or state when not to use it (e.g., to fetch all properties use list_custom_properties). It provides no explicit exclusion or routing guidance, relying on the purpose to imply context.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It states 'Get' which implies a read-only operation, but does not explicitly state that it is read-only, nor does it describe what happens if the space does not exist, return format, or permission requirements. Given the lack of annotations, more transparency is expected.

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 the key verb and object front-loaded. There is zero redundant text, 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 tool with one parameter and no output schema, the description is minimal. However, without annotations, it should clarify its read-only nature and any error behavior. The description is adequate for basic invocation but lacks behavioral context that would be expected in the absence of annotations.

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 100% of parameters, and the only parameter (space_id) is already described as 'Space ID'. The description's phrase 'by ID' adds no additional meaning beyond the schema. With high schema coverage, a baseline of 3 is appropriate.

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

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

The description states a specific verb (Get), a resource (space), and the identifying parameter (by ID). This clearly distinguishes it from list_spaces (which retrieves multiple), and from create/update/delete operations. No ambiguity 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 implies usage: when you know the space ID and need a single space. However, it does not explicitly contrast with list_spaces or mention when to prefer this over listing. For a simple getter, the context is somewhat self-evident from the purpose, but explicit routing to alternatives is absent.

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

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

No annotations are provided, so the description carries the full burden. It states the result type (summary with cards and totals) but does not disclose whether the operation is read-only (though 'get' implies), error behavior, permissions, or any side effects. There is no further detail on what happens with missing sprint IDs or how deleted cards are handled beyond the 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, efficient sentence that front-loads the core purpose. It is free of filler and directly communicates 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?

There is no output schema, so the description should clarify what the summary contains. 'Cards, totals' is vague; it does not specify which card fields, what totals are included, or the response structure. It also lacks information on error behavior or edge cases (e.g., nonexistent sprint ID), making the tool under-specified 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%, with both parameters documented ('Sprint ID' and 'Exclude deleted cards from the summary'). The description adds nothing beyond the schema, merely restating that it queries by sprint ID. The baseline of 3 is appropriate because the schema already handles parameter meaning.

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

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

The description clearly states the verb (get), resource (sprint summary), and contents (cards, totals), and specifies it is keyed by sprint ID. This distinguishes it from sibling tools like list_sprints, which list sprints rather than summarize a specific sprint.

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 or when not to use it. While the purpose implies it is for retrieving a summary of a specific sprint, there is no mention of context, exclusions, or alternatives.

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 hints at a caveat by saying 'attempt to list all boards,' implying that omitting space_id may not always succeed. However, it does not disclose why or what happens on failure, missing deeper behavioral details.

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

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

A single, front-loaded sentence that conveys both usage modes with no wasted words. It is concise and structured well for quick parsing.

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

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

For a simple list tool with one optional parameter and no output schema, the description covers the essential behavior and parameter semantics. The 'attempt' caveat hints at limitations but does not fully explain them, leaving a minor 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 coverage is 100% and the schema already explains the space_id behavior ('recommended. Omit to attempt listing all boards'). The description restates this, adding little beyond what the schema provides. 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 clearly states the tool lists boards, with an optional space filter, distinguishing it from siblings like get_board (single board) and create_board. However, it does not explicitly name alternatives, so it misses the top score.

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

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

It explains when to pass space_id and when to omit it, providing clear context for the two usage modes. It does not explicitly compare to sibling tools or list exclusions, but the context is sufficient for an agent to select it appropriately.

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. The verb 'List' implies a read-only, non-destructive operation, which is a key behavioral trait. However, the description does not mention permissions, side effects, or any additional behaviors beyond the action. For a simple list operation, this is minimally 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 sentence with zero filler and the action is front-loaded. It is appropriately sized for a simple tool. While it could include a bit more context, it remains concise and to the point.

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 simplicity of the tool (one parameter, no output schema, no annotations), the description is minimally sufficient. However, it omits any explanation of what a blocker is in this system and what the return value might look like. For a list operation, an agent might need to know the expected response fields or the semantics of blockers. The description does not address these, leaving some incompleteness.

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 card_id is fully described in the schema (100% coverage) with a basic 'Card ID' explanation. The tool description adds no extra meaning beyond what the schema already provides. Since schema coverage is high, the baseline of 3 applies—the description does not enhance parameter understanding.

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 resource ('blockers on a card'), making the purpose clear. It is distinct from sibling tools—no other tool lists blockers, so an agent can identify it as the correct operation. The only minor gap is not defining what constitutes a 'blocker,' but the core 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 usage (use when you want to see blockers for a given card) but offers no explicit guidance on when to choose this tool over alternatives or any exclusions. Since there is no competing list-blockers tool, the context is clear, but the description itself provides no routing hints or prerequisites.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It only says 'list', which implies a read-only operation returning a collection, but it does not disclose anything about pagination, ordering, the structure of returned items, or any side effects. For a 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?

A single sentence, five words, with no fluff. The entire description is the purpose statement and is front-loaded. Every token 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 is simple (1 parameter, no output schema), and the description is adequate for calling it correctly. However, it doesn't specify what the response looks like (e.g., list of card objects vs IDs), which could matter to an agent. Given the lack of annotations and output schema, a bit more detail would improve completeness, but it's minimally viable.

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 card_id as an integer with description 'Parent card ID' and 100% coverage. The description adds no additional meaning beyond the schema's parameter description, 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 states a specific verb and resource: 'List child cards of a parent card.' It clearly identifies the operation and differentiates it from siblings like list_cards (which lists all cards) and add_card_child/remove_card_child (which modify hierarchy). An agent can immediately tell what this tool does 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?

The context is clear: use this when you have a parent card and want its children. However, there is no explicit guidance on when NOT to use it or when to prefer a sibling like list_cards. The description implies the use case but doesn't spell out exclusions or alternatives.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It only states the action without mentioning output format (e.g., array of link objects), permissions required, pagination behavior, or error conditions. The simple phrasing 'List external links' implies read-only nature but adds no further context.

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

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

The description is a single concise sentence with no wasted words. It is appropriately front-loaded with the action and resource, 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?

For a simple list tool with one parameter and no output schema, the description is minimally adequate. It tells the agent what the tool does but does not describe the return structure (e.g., array of external link objects) or any edge cases (e.g., card with no links). Given the simplicity, a 3 reflects a functional but sparse description.

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

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

Schema description coverage is 100% for the single parameter card_id, which the schema already describes as 'Card ID'. The description adds no additional 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 'List external links attached to a card' clearly states the verb 'list', the resource 'external links', and the scope 'attached to a card'. It distinguishes itself from sibling tools like list_card_tags or list_card_children by naming the specific object type (external links).

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

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

The description provides no guidance on when to use this tool versus alternatives. It does not mention any conditions, prerequisites, or scenarios where this tool is preferred. For example, it does not clarify whether it returns all external links without pagination or how it differs from get_card.

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 states 'List members assigned to a card,' which implies a read operation but does not mention permissions, response format, or any side effects. For a tool with no annotation safety hints, this lacks necessary transparency about what happens when invoked.

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 redundant information. It is front-loaded with the action and resource, making it easy to scan and process. There is zero waste.

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 parameter and no output schema. The description states what it does, but it does not explain the return structure (e.g., array of member objects) or any edge cases (e.g., empty result, invalid card). For a minimal read tool, this is acceptable but leaves some ambiguity about the output.

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

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

Schema coverage is 100% for the single parameter card_id, and the schema already describes it as 'Card ID'. The description adds no additional meaning beyond the schema. Since the schema fully documents the parameter, 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 a specific verb ('List') and resource ('members assigned to a card'), making its purpose unambiguous. It distinguishes itself from sibling tools like list_card_blockers or list_tags by naming the exact entity it returns, so an agent can select it without confusion.

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 is sufficient for a simple read-only listing tool. It does not explicitly state when to use it over alternatives, but the resource is unique among siblings (members vs. other associations), so the intended usage is clear. No prerequisites or exclusions are mentioned, which is acceptable for such a straightforward operation.

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

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

With no annotations, the description bears full burden. It mentions 'compact projection' but does not define which fields are returned or how pagination works. No statement about read-only behavior, rate limits, or side effects; only the verb implies a read operation.

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

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

The description is concise, front-loaded with the verb and resource, and efficiently mentions filters and output. Both sentences earn their place with no 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?

The tool has 22 optional parameters and no output schema, yet the description provides minimal context: no explanation of filter combination, ordering default, pagination behavior, or the composition of 'compact projection'. This is insufficient for a tool with such complexity, leaving agents to guess at behavior.

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. The tool description adds only 'full-text query' and 'compact projection', but the former is redundant with the query param and the latter is about output, not parameters. It does not add meaning beyond the schema, so the baseline of 3 applies.

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

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

The description states a specific verb ('List') and resource ('cards'), and mentions the primary filters (board, column, full-text query). It clearly distinguishes from get_card which fetches a single card, and other list_ tools target different resources. The purpose is immediately clear.

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 indicates optional filters but does not explicitly state when to prefer this tool over alternatives like get_card or other list_ tools. It lacks guidance on combinational semantics (AND/OR) or when not to use it. Since it's the only tool for listing cards, the purpose is implicit but not fully 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 provided, the description carries the full burden of behavioral disclosure. It only states it lists tags, implying read-only, but gives no detail on response format, pagination, potential errors, or whether it returns an empty list for cards with no tags. The agent has no explicit assurance this is non-destructive.

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 or repetition. It is appropriately front-loaded and delivers the essential information in the fewest possible words, which is ideal for quick agent parsing.

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

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

For a simple list operation with a single parameter, the description is arguably sufficient to understand the core function. However, it lacks any mention of output structure, sorting, or error conditions. Given no output schema and no annotations, a slightly richer description (e.g., 'Returns all tags for the specified card, with no pagination') 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% and the only parameter, card_id, has a description that is self-explanatory ('Card ID'). The tool description adds nothing beyond the schema, so the baseline score of 3 applies because the schema fully documents the parameter without needing additional guidance.

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 (tags attached to a card), making it unambiguous. It distinguishes itself from siblings like list_tags (all tags) and add_card_tag/remove_card_tag (mutation) by specifying the scope of tags attached to a specific card.

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 such as list_tags or get_card. It does not mention any prerequisites (e.g., that the card must exist) or when it would be more appropriate than listing all tags. The agent must infer usage from the name alone.

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

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

With no annotations, the description carries the burden of behavior disclosure. The verb 'List' clearly implies a read-only operation, and the listing of output fields (id, name, color, letter) sets accurate expectations. There are no hidden side effects or constraints, and the description is straightforward enough that an agent would not be surprised by the tool's behavior.

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

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

The description is a single sentence that leads with the verb and resource, immediately stating the scope and the fields returned. There is zero redundancy; every word contributes to understanding the tool's function.

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 action, the description fully covers what the tool returns (id, name, color, letter). Pagination is handled by the schema parameters, and no output schema exists to require further explanation. The context is complete for an agent to use 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 description coverage is 100% – both 'limit' and 'offset' are described in the schema with ranges and purpose. The tool description adds no parameter details beyond what the schema already 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 states a specific verb ('List'), a clear resource ('card types'), and scope ('in the workspace'), and enumerates the output fields (id, name, color, letter). It is unambiguous and distinguishes itself from sibling list tools by naming a unique entity.

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: an agent would call this when it needs card types. However, it does not explicitly state when to use this tool over alternatives or mention any exclusions. Since the purpose is self-evident, the usage is implied rather than explicitly guided, but it does not actively mislead.

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 'List all columns', which implies a read operation but does not mention return structure, pagination, sorting, error handling, or access requirements. For a simple operation this is minimal but non-contradictory.

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

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

The description is a single, front-loaded sentence with no wasted words. It conveys the essential information—what the tool does and its 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 read-only tool with one parameter and no output schema, the description is adequate: it states the operation, the resource, and the input. It does not mention return format, but that is not necessary given the simplicity. It could be improved by mentioning that it returns a list of column details, but the current state is sufficient.

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% — the schema describes board_id as 'Board ID' and its type. The description adds no extra parameter semantics, but the baseline is 3 because the schema already covers the parameter fully.

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

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

The description clearly states the verb 'List' and the resource 'columns (stages)' scoped by 'of a Kaiten board'. It is unambiguous about what the tool does. However, it does not explicitly differentiate from sibling tools like list_boards or list_lanes, so the distinction is left to the name.

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. The description does not mention any conditions, prerequisites, or alternative tools. An agent must infer that this is the right tool for listing columns, which is not explicitly stated.

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

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

No annotations are provided, so the description carries full responsibility for behavioral disclosure. It only says 'List comments on a card,' without hinting at any side effects, return format, ordering, pagination, or permissions. While it implies a read-only operation, that is not explicit, and there is no additional behavioral context.

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

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

The description is a single sentence with zero waste, and it places the core verb and resource upfront. For a very simple list operation, this length is acceptable and appropriately sized, though it could be slightly more informative without losing 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?

Given the tool's simplicity (one parameter, no output schema, no nested objects), the description is minimally adequate but lacks specifics like the return shape, whether all comments are returned, or how to handle pagination. Since there is no output schema or annotations, the description could have clarified the expected result, making it slightly incomplete for a fully informed agent 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 input schema provides a 100% description coverage for the single parameter card_id (described simply as 'Card ID'), so the schema already explains the parameter. The description adds no extra meaning beyond the schema, 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 states a clear verb and resource: 'List comments on a card.' It is specific enough to distinguish from sibling list tools like list_cards or list_tags, since it targets comments scoped to a card. The purpose is unambiguous and immediately actionable.

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, no mention of prerequisites, exclusions, or conditions. Although the sibling tools are many, the description doesn't reference any alternative or explain when to prefer it over similar list operations. This leaves the agent to infer usage purely 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?

No annotations are provided, so the description carries the full burden. It discloses the 'read-only' nature, which is a behavioral trait. However, it does not mention pagination behavior (despite having limit/offset parameters), default result size, or the shape of the returned data. For a list tool, some expectation of output structure would be helpful. The description adds a little beyond the schema but lacks depth.

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, compact sentence that conveys the essential action and read-only nature without excess words. It is front-loaded and every word earns its place. Minimalism is a strength here, not a weakness.

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

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

Given the tool has four optional parameters, no output schema, and no annotations, the description is adequate but somewhat thin. It clarifies the action and read-only status but does not hint at what the response looks like (e.g., a list of property metadata), nor does it explain the purpose of 'include_values' beyond the schema. An agent might still call it correctly, but additional context about typical usage (e.g., 'use include_values to fetch stored values along with metadata') would improve completeness.

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

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

The input schema has 100% description coverage, so each parameter has a meaningful description ('Max results', 'Text search over property names', 'Pagination offset', 'Include property values'). The tool description adds nothing about parameters beyond what the schema already provides. Since the schema covers all parameters, the baseline of 3 is appropriate; the description does not need to compensate for any gaps.

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

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

The description clearly states the verb 'List' and the resource 'company custom properties', and additionally notes it is read-only. However, it does not explicitly differentiate from closely related siblings such as get_custom_property (which retrieves a single property) or list_custom_property_select_values (which lists values for a specific property). The purpose is unambiguous but not explicitly distinguished from 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 provides no guidance on when to use this tool versus related tools like get_custom_property or list_custom_property_select_values. There is no mention of alternatives, prerequisites, or suitable scenarios. The read-only note hints at safety but doesn't direct the agent to choose this over a single-property lookup when only one is 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 provided, the description carries the full burden of behavioral disclosure. It does state 'read-only,' which is a useful safety hint, but it does not mention error behavior (e.g., what happens for invalid property_id), return format, or pagination. For a simple list operation 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 a single, concise sentence that front-loads the key information (verb, resource, and read-only nature). There is no wasted wording, and it is easy to parse at a glance.

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, one-parameter list tool with no output schema, the description is adequately complete. It clearly states the operation and the parameter's purpose. The only minor gap is lack of explicit mention of the return format (a list of values), but that is strongly implied by the verb 'List' and the tool name. The read-only note adds useful 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 the parameter property_id is already described as 'Custom property ID (select/catalog type)'. The description adds no additional meaning about the parameter, leaving it to the schema, which is sufficient. 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 the specific verb 'List' with a clear resource: 'select/catalog values of a custom property'. This distinguishes it from sibling tools like list_custom_properties (which lists properties) and get_custom_property (which retrieves a single property), leaving no ambiguity about what this 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 explicit guidance is given about when to use this tool versus alternatives. The purpose is obvious from the name and description (retrieve the enum values of a specific custom property), but there is no stated context or exclusions, such as 'use only for select-type properties' or 'use list_custom_properties to find property IDs first.'

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?

Since there are no annotations, the description carries the full burden. It explicitly states that the tool lists all lanes, implying a read operation, but it does not disclose any additional behavioral aspects such as return format, pagination, or side effects. For a simple list tool, this is acceptable but not enriched, so a 3 is appropriate.

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 purpose. Every word contributes to the tool's definition, and there is no unnecessary verbosity. It is optimally structured for quick comprehension.

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 one required parameter and no output schema, the description is nearly complete. It specifies the board context and clarifies that lanes are swimlanes/rows. Minor omissions like explicitly stating read-only behavior or describing the output are not critical given the simplicity of the operation.

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

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

The schema provides 100% coverage for the single parameter (board_id) with a clear description. The tool description does not add any additional meaning beyond what the schema already states. The baseline of 3 applies because the schema handles the parameter 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 clearly states the action ('List all lanes') and the resource ('lanes (swimlanes/rows) of a Kaiten board'), which is specific and unambiguous. It does not explicitly differentiate from sibling tools like list_columns, but the term 'lanes' is distinct enough that an agent can infer the tool's 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?

The description provides no guidance on when to use this tool versus alternatives such as list_columns or list_boards. It does not state when this tool is appropriate, nor does it mention any exclusions or prerequisites. An agent must rely on the tool name and context to infer usage.

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 basic function without mentioning any side effects, permissions, pagination behavior, or return format. Since it's a read-only listing operation, it may be safe, but the description offers no extra behavioral 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, compact sentence with no redundancy. It fronts the action ('List') and specifies the scope ('all spaces in the Kaiten workspace'), making it highly efficient and immediately actionable.

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, zero-annotation tool with no output schema, the description is mostly complete. An agent knows what to call and why, and the absence of parameters simplifies usage. However, it does not explicitly indicate the return type (e.g., an array of space objects), which, while implied, could be clearer given no output schema exists.

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 is empty (100% coverage). There is nothing to explain, and the description aligns perfectly with the schema. The baseline of 4 for zero-parameter tools applies, as the description adds no unnecessary 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?

The description clearly states the tool lists all spaces in the Kaiten workspace. It uses a specific verb (list) and resource (spaces), and distinguishes it from sibling tools like get_space (which fetches a single space) and create/update/delete operations. No ambiguity 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 implies usage when the agent needs a full list of spaces, but it does not explicitly mention when not to use it or name alternatives. For a simple listing operation, this implied guidance is minimally acceptable, but it lacks explicit 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?

With no annotations provided, the description carries the full burden of behavioral disclosure. It only says 'list sprints' and mentions filtering, but does not disclose pagination behavior, default limits, return format, or any side effects. It implies a read operation but does not state it explicitly, nor does it mention permissions or scope. This is minimal disclosure for a tool with no annotation support.

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

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

The description is a single sentence with no fluff, meeting basic conciseness. However, it lacks useful structure such as front-loading key constraints or providing alternative guidance. It could be slightly more informative (e.g., mentioning pagination or default behavior) while remaining concise, so it rates a 3 rather than a 4 or 5.

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 on behavior and response expectations. It only covers the basic action and filter, but omits pagination details, default limit, sorting, or what fields are returned. This leaves an agent uncertain about the full output and call semantics, making it incomplete for a simple but not fully self-explanatory tool.

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

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

The input schema already provides descriptions for all three parameters (limit, active, offset) with 100% coverage. The description adds 'optionally filtered by active status', which essentially restates the active parameter's schema description. It does not add meaning beyond the schema, so the baseline of 3 applies.

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

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

The description clearly states a specific verb ('List') and resource ('sprints'), and mentions optional filtering by active status. It does not explicitly differentiate from sibling list_* tools, but the resource name is distinct enough (sprints vs. spaces, boards, columns, etc.). A score of 4 reflects clarity without explicit sibling differentiation.

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

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

No guidance is provided on when to use this tool versus alternatives. There is no mention of exclusions (e.g., when to prefer get_sprint_summary) or conditions. The description only states what it does, not when to use it, leaving the agent to infer context from the resource name alone.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. The verb 'List' implies a read-only operation, but the description does not explicitly state that no side effects occur, nor does it mention any permissions or limitations. For a simple list 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 directly states the action and scope. There is no verbosity or irrelevant information, and the key 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 zero-parameter tool with no output schema, the description fully conveys what the tool does and its scope. An agent can correctly invoke it without needing additional context about parameters, return format, or side effects beyond what is stated.

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

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

The tool has zero parameters, so the description need not elaborate on parameter meanings. The baseline for no parameters is 4, and the description does not introduce any confusion or require additional explanation.

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'), a clear resource ('all tags'), and scoping ('in the Kaiten workspace'). This clearly distinguishes it from sibling tools like list_card_tags, which are card-scoped, by emphasizing the workspace-wide scope.

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_card_tags. It does not mention when to prefer this over listing tags for a specific card, nor does it note any prerequisites or exclusions.

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

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

No annotations are provided, so the description carries the burden of behavioral disclosure. The verb 'list' implies a read-only operation, and since it has no parameters, it is safe to assume no side effects. However, the description does not explicitly state that it is non-destructive or describe any potential response characteristics, though for a simple list this is minimally sufficient.

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 with no unnecessary words. The key information (list all users, workspace scope) is front-loaded and immediately actionable. There is zero wasted verbosity.

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

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

For a zero-parameter list tool with no output schema, the description is complete enough for an agent to understand the purpose and invoke it correctly. It does not mention the exact shape of the response (e.g., user fields), but that is not essential for a basic listing operation. The description sufficiently covers what the tool does.

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

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

The tool has zero parameters, so the schema is trivially complete. The description adds no parameter-level detail, but none is required. Baseline for 0-parameter tools is 4, and the description does not need to compensate for any missing schema information.

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 (users), and the scope (all users in the Kaiten workspace). It fully distinguishes itself from siblings like get_current_user by specifying 'all users', so an agent knows exactly what to expect.

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 purpose implies usage for retrieving all users, but there is no explicit guidance on when to use this tool versus alternatives such as get_current_user for a single user. No context or exclusions are provided, so the agent must infer the intended scope.

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 'move', implying a mutation, but does not mention prerequisites, reversibility, or constraints (e.g., whether at least one of lane_id/column_id is required). It also does not address side effects like position history or validation behavior.

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

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

The description is a single, concise sentence with no redundant words, and the core action is front-loaded. It is appropriately sized for a simple tool, though it could arguably be even more specific without losing 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 mutation tool with no annotations and no output schema, the description is insufficient. It does not clarify whether at least one target is required, what happens if only one is provided, or the effect on the card's location history. An agent could easily misinvoke by supplying no lane or column, making the description incomplete for 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?

Schema coverage is 100%, so each parameter already has a description. The tool description adds the 'and/or' qualifier, clarifying that either lane or column (or both) can be targeted, which is useful. However, it does not provide additional meaning beyond what the schema already conveys, so it stays at 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 states a specific verb and resource: 'Move a card to a different column and/or lane.' This distinguishes it from most sibling tools like get_card or delete_card. However, it does not explicitly differentiate from update_card, which could also alter a card's position, so it falls short of a 5.

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

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

There is no guidance on when to use this tool versus alternatives such as update_card, which might also change a card's column or lane. The description only states what the tool does, leaving the agent to infer selection criteria without any explicit when-to-use or when-not-to-use information.

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 states 'detach' but does not clarify side effects: whether the child card is deleted or merely unlinked, any permissions required, or reversibility. For a mutation tool, this is a significant gap, as agents need to understand the consequence of the 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, succinct sentence that front-loads the core action. There is no redundant information, and it is appropriately sized for a simple operation. 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?

Given that this is a simple mutation with two well-documented parameters and no output schema, the description captures the essential operation. However, it does not explicitly state that the child card remains intact (only the relationship is removed), which is important for agents to understand side effects. Without annotations, more behavioral context would be expected, but the low complexity mitigates the 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 provides 100% coverage with descriptions 'Parent card ID' and 'Child card ID to detach', which are already clear. The tool description adds no additional meaning beyond the schema, so a baseline score of 3 is appropriate given the 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 'Detach a child card from a parent card' clearly specifies the action (detach) and the resource relationship (child card from parent card). It distinguishes this from sibling tools like add_card_child and list_card_children, so an agent can identify the correct operation without ambiguity.

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

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

The description implies the use case—removing an existing child-parent relationship—but does not explicitly state when to use this versus alternatives, nor does it mention any constraints (e.g., requires existing relationship). There is no comparison to siblings, so the agent must infer usage from the wording.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It only states the action without mentioning side effects, such as whether the removal is permanent, if it cascades to dependent data, or if specific permissions are required. This is a significant gap for a removal tool, as an agent cannot anticipate the consequences.

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

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

The description is a single, concise sentence that immediately conveys the action. There is no unnecessary verbosity, and the core operation is front-loaded. It is well-structured and easily parseable 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 removal tool with no output schema and no annotations, the description lacks essential behavioral context. It does not mention the outcome of the operation, error cases, or any requirements. While the parameter schema is complete, an agent cannot fully anticipate the tool's behavior or preconditions from the description 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?

The schema provides 100% coverage with descriptions for both parameters (card_id and link_id). The description adds no additional meaning beyond what the schema already conveys, so it does not compensate for or enhance parameter documentation. The baseline of 3 is appropriate given the 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 the specific verb 'Remove' and the resource 'external link from a card', which clearly distinguishes it from sibling tools like add_card_external_link and update_card_external_link. It is concise and unambiguous, though it does not elaborate on the nature of an external link.

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

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

No guidance is provided on when to use this tool versus alternatives. The description does not mention any prerequisites, such as listing existing links first, nor does it clarify that this is the sole removal method. The agent must infer usage from the name and sibling context, which is insufficient for a destructive operation.

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 bears full responsibility for behavioral disclosure. It states the removal action but does not mention permissions, reversibility, effects on related entities, or response behavior. For a mutation 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 with no filler. It is appropriately brief for a simple operation and includes the essential action and target, meeting the standard for efficient communication.

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

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

Given the simple nature of the operation and full schema coverage, the description is minimally adequate. However, with no annotations and no output schema, it does not mention expected response, failure modes, or prerequisites. A bit more context (e.g., confirmation 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 description coverage is 100%, so both parameters are already explained in the schema ('Card ID' and 'Member user ID to remove'). The description adds no additional parameter meaning beyond the schema, warranting the baseline score of 3.

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

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

The description clearly states the action and resource: 'Remove a member from a card.' It distinguishes from sibling tools like add_card_member and update_card_member_role through the verb 'remove,' though it does not explicitly name alternatives. 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?

No explicit guidance is given on when to use this tool versus alternatives. It implies usage when removal is desired, but lacks context such as preconditions, error handling, or when not to use it. Unlike the get_calls example, no alternative tool is 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?

With no annotations, the description carries the full burden, but it only states the basic action. It does not disclose whether the removal is idempotent, how it behaves if the tag is not associated with the card, or any permission requirements. The destructive nature is implicit 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 a single, concise sentence that is direct and front-loaded with the action. It avoids verbosity, though it could be slightly enriched without losing conciseness.

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

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

Given the simplicity of the operation and full parameter coverage, the description is minimally adequate. However, the lack of annotation and absence of guidance on failure modes or idempotency leaves a small gap for an agent to fully predict behavior.

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 descriptions for both parameters (tag_id and card_id). The description adds no additional meaning beyond what the schema already states, 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 states a clear verb ('Remove'), a specific resource ('tag from a card'), and the key identifier ('by tag ID'). It distinguishes from sibling tools like add_card_tag and list_card_tags by indicating a removal operation, though it doesn't explicitly contrast with 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 given on when to use this tool versus alternatives. It doesn't mention checking existing tags via list_card_tags before removal, or the relationship to add_card_tag. The context is implied by the operation name but not explicitly stated.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure, and it does disclose the key trait: the operation is irreversible. This is genuinely valuable for a destructive tool. However, it doesn't mention what happens to the checklist's contained items on deletion or whether the operation is idempotent. 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 five-word description leads with the action and packs the critical caveat (irreversibility) into the second sentence. There is zero waste. It is slightly terse — no supporting detail — but for a simple delete tool this is appropriately compact and 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 two-integer-parameter delete operation with full schema coverage and no output schema (typical for delete tools returning success status), the description covers the essentials: what it does, the scope, and the irreversible consequence. Nothing critical an agent needs to call 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?

Schema description coverage is 100%, with both card_id and checklist_id documented in the schema. The description adds no parameter-level detail beyond what the schema already provides. At 100% coverage, the baseline of 3 applies — 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 states a specific verb ('Delete'), resource ('checklist'), and the scope ('from a card'), making the action unambiguous. It also adds 'Irreversible,' which is meaningful context. The purpose is clearly distinguishable from sibling tools like create_checklist, get_checklist, and update_checklist.

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 when-to-use is implied by the name and the clear action — an agent can infer this removes a checklist from a card. However, the description provides no explicit context on when to use this versus alternatives (e.g., remove_checklist_item for a single item) or any exclusions or prerequisites. It meets the minimum but offers no explicit 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 provided, the description carries the full burden of behavioral disclosure. It does not explicitly mention that the deletion is permanent or destructive, nor does it mention permissions, side effects, or error behavior. It simply restates the action without adding meaningful context 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?

The description is one sentence and to the point, with no unnecessary words. It is appropriately concise for a simple deletion operation, though it could be slightly more informative without harming 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?

For a simple delete operation, the description gives the essential action but omits details like success behavior, error handling, or any prerequisites. Given the lack of an output schema and annotations, it is minimally sufficient but not comprehensive.

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 three parameters with descriptions (100% coverage), so the tool description need not repeat them. It adds no additional semantics beyond the schema, matching 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 tool deletes a checklist item, using a specific verb and resource. It distinguishes from sibling tools like add_checklist_item or update_checklist_item, which have different actions.

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 when to use remove_checklist for the entire checklist or update_checklist_item for modifying an item. No context, prerequisites, or exclusions 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?

No annotations are provided, so the description must disclose behavioral traits. It only states 'delete' without elaborating on side effects, irreversibility, permissions, or what happens to the card. For a destructive action, this is minimal and does not inform the agent of potential consequences.

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 redundant wording. It front-loads the action and resource effectively. It is appropriately sized for the simplicity of the operation, though it 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?

While the tool is simple, the description lacks important context such as usage guidance, behavioral side effects, and any relationship to blocking operations. With two required parameters and no output schema, the description does not fully equip an agent to call the tool correctly in various scenarios. It only covers the bare 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?

Schema description coverage is 100% for both parameters (card_id and blocker_id), and the schema provides descriptive labels. The description adds no extra meaning beyond what the schema already states, so the baseline of 3 is appropriate; no additional context is provided.

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 ('Release (delete)') and the resource ('a card blocker'), which is specific and unambiguous. It distinguishes itself from siblings like block_card and update_card_blocker by indicating this is the removal operation. The parenthetical 'delete' reinforces the destructive nature.

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

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

The description offers no guidance on when to use this tool versus alternatives such as block_card or update_card_blocker. It does not mention any conditions, prerequisites, or exclusions. An agent would have to infer when to call this based solely on the name and 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 provided, the description carries the full burden of behavioral disclosure. It only says 'update', implying mutation, but doesn't disclose whether it requires special permissions, whether changes are reversible, what happens if the board doesn't exist, or what the response looks like. 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, front-loaded sentence with zero waste. It clearly identifies the action and the target without any extraneous words.

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

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

For a simple update tool with 4 parameters (2 required) and no output schema, the description covers the core action but lacks details on success/error behavior, prerequisites (e.g., board existence), or any side effects. While the schema covers required fields, the absence of annotations and output schema means the description could offer more context, but it's minimally adequate for a straightforward update.

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

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

Schema description coverage is 100% for all 4 parameters, so the schema already documents each parameter. The description adds only that 'title' and 'description' are the updatable fields, which is a marginal clarification. It doesn't add syntax, format, or additional 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 states a specific verb ('Update'), a resource ('a board'), and the specific attributes ('title or description'). It clearly distinguishes this from sibling tools like update_space, update_column, and update_lane by explicitly naming the resource type.

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

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

The description implies usage for updating boards, but provides no explicit guidance on when to use vs alternatives, or any prerequisites/conditions. It is obvious from the resource name that it's for boards, but there's no mention of when not to use it (e.g., when to use create_board instead) or any side conditions.

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 'Update card fields' without describing side effects, required permissions, idempotency, error handling, or whether omitted fields are left unchanged. This is a mutation tool, so the lack of behavioral context beyond the verb 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 sentence, front-loaded with the action and fields. There is no unnecessary jargon or repetition. Every word earns its place, making it highly concise and efficiently structured.

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

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

Despite having only 7 parameters with a required card_id, the description omits crucial context: it doesn't state that only provided fields are updated (partial update), what happens if the card doesn't exist, or whether size_text and owner_id are optional. With no output schema and no annotations, the description should clarify update behavior but remains too vague for an agent to call it safely without additional assumptions.

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 each parameter thoroughly. The description's list of fields adds no meaning beyond what the schema provides. It doesn't clarify partial update semantics or how fields interact. Baseline 3 is appropriate because the schema does the heavy lifting and the description doesn't compensate for any gaps.

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

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

The description clearly states the tool updates card fields and lists the modifiable attributes (title, description, owner, due date, ASAP flag, size). This is a specific verb+resource combination that distinguishes it from create_card and delete_card, though it doesn't explicitly differentiate from other update tools like update_board. However, the resource is obvious from the name and description.

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 vs alternatives. It doesn't mention scenarios like partial updates, when to use create_card instead, or any exclusions. An agent must infer that this is the right tool for updating card fields, but there's no explicit context or comparison with 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?

No annotations are provided, so the description carries the full burden of behavioral disclosure. It states that the tool updates a blocker's reason or blocking card, but does not disclose whether the update is incremental or a full replacement, what happens if both fields are provided, whether the blocker must exist, or any permission requirements. For a mutation tool, this is thin and leaves key behaviors ambiguous.

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

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

The description is a single, efficient sentence that front-loads the action and scope. There is no redundancy or extra fluff — every word earns its place. It communicates the core behavior clearly in minimal 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?

For a tool with 4 parameters, no output schema, and no annotations, the description is adequate but not complete. It states what it does, but lacks details about return values, error conditions, or side effects. Given the relative simplicity of the update operation, this is acceptable, but a more thorough description would include expectations about the outcome.

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 explains each parameter. The description adds minimal value by framing the two optional fields (reason and blocker_card_id) as the 'reason or blocking card' being updated, tying them to the tool's purpose. This is slightly helpful but does not go beyond what the schema already conveys. 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 states a clear action ('Update') on a specific resource ('card blocker') and specifies the two attributes that can be modified (reason or blocking card). This distinguishes it from sibling tools like block_card and unblock_card, which have different purposes. The purpose is unambiguous and sufficiently specific.

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 indication of when to use this tool versus alternatives, nor any conditions or prerequisites. It does not mention, for example, that this should be used only when a blocker already exists, or that block_card is for creating blockers. There is no guidance on context, making it harder for an agent to decide when to invoke 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 full burden for behavioral disclosure. It acknowledges mutation via 'update' but does not mention side effects, error conditions (e.g., link not found), permissions required, idempotency, or response behavior. For a write operation 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, clear sentence that efficiently conveys the operation and its target. No wasted words; it is appropriately front-loaded with the action and resource.

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 (4 flat parameters, no output schema, no annotations), so the description need not be extensive. However, it fails to mention that card_id and link_id are required identifiers, nor does it provide any usage caveats like 'only URL or description can be changed, not the link itself'. While the schema covers required fields, the description leaves out operational context that would help an agent call it correctly without opening 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%, with each parameter having a meaningful description ('New URL', 'New description', etc.). The tool description adds marginal value by explicitly naming which fields can be updated, but this mostly restates the schema. Since the schema already documents parameters well, 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 a specific action ('Update') and a specific resource ('external link'), and specifies the mutable fields (URL or description). It distinguishes from siblings like add_card_external_link and remove_card_external_link by focusing on modification, so an agent can immediately tell this is the update 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?

The description implies usage for modifying an existing external link (since it is an 'update' action), but it does not explicitly state when to choose this tool over alternatives or mention prerequisites such as requiring valid card_id and link_id. No exclusions or alternative routing is provided; the guidance is only implicit.

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

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

No annotations are provided, so the description bears full responsibility for behavioral disclosure. It only states the action ('Change a card member's role') without revealing potential side effects, permission requirements, failure conditions (e.g., if the member is not found), or whether the change is reversible. 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 a single, concise sentence that immediately states the core action and clarifies the parameter significance. There is no redundant information or filler, making it efficient 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?

For a simple tool with three required parameters and no output schema, the description is minimal but covers the basic action. However, it omits important context such as whether the member must already exist, what other type values are valid, or any error behavior. Given the lack of annotations, the description could be more complete, but it is adequate for the tool's simplicity.

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

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

The schema already documents all three parameters with descriptions (card_id, user_id, type), so schema coverage is 100%. The description adds no new information beyond what the schema provides—the 'type 2 = responsible' note is already present in the schema's description for 'type'. Thus, the description does not enhance parameter understanding beyond the 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 states a specific verb ('Change') and resource ('card member's role'), and clarifies the meaning of the 'type' parameter (2 = responsible). This differentiates it from sibling tools like add_card_member, remove_card_member, and list_card_members, so an agent can easily identify when this tool is appropriate.

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. It doesn't state prerequisites such as the member already existing on the card, nor does it mention that this is only for modifying roles and not for adding/removing members. The usage context must be inferred entirely from the tool name and sibling names, which is insufficient.

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

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

No annotations are provided, so the description carries the full burden. It discloses that the tool renames or reorders a checklist, implying mutation, but it fails to mention any side effects, permission requirements, or reversibility. It also does not clarify what happens if neither optional parameter is provided, nor the exact nature of the reorder operation (e.g., absolute vs. relative positioning).

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

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

The description is a single, efficient sentence that front-loads the core purpose. It contains no fluff and immediately conveys the action. However, it is under-specified in terms of details, but that is a completeness issue rather than a conciseness problem.

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 too thin. It does not explain that card_id and checklist_id are required identifiers, nor how the optional name and sort_order interact. It also omits what the response will look like and whether the operation is idempotent. This leaves the agent guessing about essential usage details.

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 has a short description (e.g., 'New name', 'Position'). The tool description adds marginal value by tying 'name' and 'sort_order' to 'rename' and 'reorder', but this essentially reiterates the schema. The baseline of 3 is appropriate since the schema already documents the parameters fully.

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: 'Rename or reorder a card checklist.' It clearly identifies the operation (update) and the target (checklist), and it distinguishes from siblings like update_checklist_item by specifying 'card checklist' rather than items. It does not explicitly mention the two optional fields, but the intent is clear.

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

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

The description implies usage through the name and the phrase 'rename or reorder', but it provides no explicit guidance on when to use this tool versus alternatives like update_checklist_item or remove_checklist. There is no mention of exclusions or prerequisites, but the sibling names are self-explanatory enough to infer the appropriate scenario.

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

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

With no annotations provided, the description is the sole source of behavioral disclosure. It states the action but does not mention side effects, idempotency, permission requirements, or behavior when only partial fields are supplied. It implies a write operation but adds no other behavioral context.

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

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

The description is a single, focused sentence that front-loads the core purpose and then lists the main updatable aspects. There is no redundancy or fluff, and it is appropriately concise for a simple mutation tool.

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

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

The tool has 8 parameters (only 3 required) and no output schema, yet the description does not explain that only specified fields can be updated or that other fields remain unchanged. It also lacks information about return values or error conditions. An agent would have to infer partial-update semantics from the schema alone, which is not sufficient.

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 has a short schema description. The tool description loosely maps 'toggle done' to checked, 'edit text' to text, and 'set due/responsible' to due_date and responsible_id, but adds little beyond the schema. Since the schema already documents parameters, 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 ('Update a checklist item') and enumerates the supported modifications (toggle done, edit text, set due/responsible). This distinguishes it from sibling tools like add_checklist_item and remove_checklist_item, which are specific to other operations.

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

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

The description provides no guidance on when to use this tool versus alternatives. It does not mention prerequisites, whether it is for updating an existing item only, or any conditions that would make another tool more appropriate. Given no annotations, the description should carry this burden but does not.

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 bears full responsibility for disclosing behavior. It only states 'Update', which implies mutation, but doesn't describe side effects, reversibility, permission requirements, or what happens if conflicting values are provided. For a mutating tool with zero annotation coverage, this is a significant omission.

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, compact sentence that lists the modifiable attributes efficiently. It's front-loaded with the verb and resource, and wastes no words. The structure is clean, though it could arguably be slightly more informative without losing 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?

Given 6 parameters and full schema descriptions, the description is minimally adequate. However, it omits context like the fact that board_id and column_id are required, whether updates are partial or full replacements, or the absence of an output schema. For an update tool with no annotations, it provides the core purpose but not enough to fully guide invocation in edge cases.

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 6 parameters with descriptions (100% coverage), so the description doesn't need to explain each. It does add a synonym ('position' for the sort_order parameter) which aids interpretation. However, it doesn't clarify any interdependencies or constraints beyond what the schema states, so it meets the baseline for 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 uses a clear verb ('Update') and specifies the resource ('a column') along with the exact attributes it can modify (title, type, position, WIP limit). This distinguishes it from sibling tools like list_columns, create_column, and delete_column, though it doesn't explicitly name those alternatives. It's direct 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 on when to use this tool versus alternatives. It doesn't mention prerequisites (e.g., needing an existing column), what happens if fields are omitted, or how it relates to other column operations. The agent must infer that 'update' means modifying an existing column, but there's no explicit context or exclusions.

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