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

With no annotations, the description carries the full burden for behavioral disclosure. It discloses behaviors beyond the schema: labels are auto-created on the board if missing, position has a default (65535) with explicit ordering semantics, and checklistName has a default of 'Checklist'. These details add contextual depth beyond raw parameter names.

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 paragraph that front-loads the core operation and then packs several key behaviors inline. It is efficient with no wasted sentences; a slight deduction for density—one long sentence carries a lot of nested conditional detail that could be structured for easier scanning.

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 batch-create tool with 100% schema coverage, the schema already carries the heavy lifting for constructing a payload. The description covers the one critical behavioral context not inferable from the schema alone: label auto-creation and defaults. Return values are not explained, but the absence of an output schema makes that acceptable, so the definition is complete enough.

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

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

Schema description coverage is 100%, so the schema already documents all parameters and defaults. The description still adds value by clarifying the task-in-checklist structure (task ∈ checklist ∈ card), label auto-creation semantics, and the per-card override behavior. It does not repeat every schema detail, but the added value is modest rather than essential.

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 multiple cards at once') with a clear resource and scope. It enumerates what each card can include and is clearly distinct from siblings like mcp_kanban_card_manager which likely handles single-card operations.

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

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

The description implies when to use it—when creating multiple cards in one call—but does not explicitly state exclusions or alternatives, e.g., when a single-card tool would be preferred. No explicit routing to siblings despite the batch nature being clear from name and first sentence.

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 exist, so the description carries the full burden, yet it mostly repeats schema-level facts such as position ordering and checklist tasks. It discloses that cards can be deleted and moved, but not whether deletion is destructive, what fields are required per action, or what happens on partial failures.

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

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

The description is compact: two sentences that front-load the resource and operation set, then add useful ordering semantics. The position explanation is dense but relevant; no filler or repetition is present.

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

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

With 13 parameters, 9 possible actions, no output schema, and no annotations, this high-level overview is not complete enough. It never explains which parameters are needed for each action, how actions like move/duplicate differ, or what a successful call returns, leaving important invocation details undocumented.

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

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

Schema description coverage is 100%, so the baseline is 3. The description adds the action-oriented framing and task-list mention, but the parameter details (position, tasks, dueDate, etc.) are already fully documented in the schema, so it does not materially compensate beyond that baseline.

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

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

The description clearly identifies the resource: kanban cards inside board columns/lists, and names the main operations (creating, updating, moving, duplicating, deleting, reordering). It is distinct from sibling list/task/comment managers, though it relies on the resource term 'card' rather than naming 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 implies use for card-level operations such as create/move/duplicate/delete, and mentions the checklist association. It provides no explicit when-to-use guidance or explicit exclusions relative to sibling tools like task_manager or list_manager, so an agent must infer the boundary.

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. 'Manage' implies CRUD operations, but it doesn't specify permissions needed, side effects (e.g., if deletions are permanent), rate limits, or response formats. This leaves significant gaps for a tool with multiple actions including destructive ones like delete.

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 states the core function without fluff. However, it could be more front-loaded by specifying the exact operations (e.g., CRUD on card comments) to improve clarity immediately.

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

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

Given the complexity of a multi-action tool with no annotations and no output schema, the description is inadequate. It doesn't explain what 'manage' entails, the scope of operations, or expected outcomes, leaving the agent to infer behavior from the schema alone, which is insufficient for safe and effective 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 description coverage is 100%, so the schema already documents all parameters fully. The description adds no additional meaning beyond implying that parameters relate to comment operations, but it doesn't clarify dependencies (e.g., cardId required for create) or usage patterns. Baseline 3 is appropriate as the schema handles 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 states the tool manages card comments with various operations, which provides a basic purpose but lacks specificity. It mentions the resource (card comments) and general action (manage), but doesn't specify what 'manage' entails or distinguish it from sibling tools like mcp_kanban_card_manager or mcp_kanban_task_manager that might also handle comments indirectly.

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 doesn't mention prerequisites, context, or exclusions, and with siblings like mcp_kanban_card_manager that might handle card-related operations, there's no indication of how this tool fits into the workflow or when it should be preferred.

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

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

There are no annotations, so the description must carry the behavioral disclosure burden. It only states that labels can be managed and added/removed in single or multiple quantities; it does not disclose side effects of delete/update, return values, per-action parameter requirements, or error 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 concise and front-loaded, listing the operation set before adding the card-specific detail. The first sentence is partially redundant with the action enum, but overall the text is short and readable.

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 nine parameters, no annotations, and no output schema, the description is too thin. It does not explain which parameters are required for each action, how labelId versus labelIds differ, or what result to expect from each 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 has 100% description coverage for all nine parameters, including enums for action and color, so the description does not need to re-explain parameter meanings. The description adds no substantive parameter detail beyond the schema, matching the baseline for high coverage.

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

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

The description clearly identifies the resource (kanban labels) and enumerates the supported operations: create, update, delete, get_all, add_to_card, and remove_from_card. This is specific enough to distinguish it from the card, list, and comment manager sibling tools, though 'manage' is a generic verb.

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 about when to use this tool versus alternatives like mcp_kanban_list_labels or mcp_kanban_card_manager. The second sentence hints at card-label operations, but there are no stated selection criteria, exclusions, or complementary 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 disclosure burden. It does disclose the aggregation behavior: labels across all cards with counts and state breakdowns. However, it does not explicitly state read-only semantics, whether empty labels are included, or any performance implications of searching all boards.

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 focused sentence front-loads the action and result, and the parenthetical example of state values adds useful concreteness. There is no filler, repetition, or unnecessary detail.

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

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

For a simple optional-parameter list tool with no output schema, the description covers the main behavior and the nature of the returned data. It lacks explicit alternative routing and exact return shape, but the low complexity and complete schema mean no critical information is missing.

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

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

The single parameter boardId is already fully described in the schema with 100% coverage, including the behavior when omitted. The description adds no new parameter-level meaning, so the baseline 3 applies.

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

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

The description uses a specific verb ('List') and resource ('labels across all cards in the board(s)') and adds distinctive output details (card counts and state breakdowns). It is clear, but it does not explicitly contrast with the similarly named sibling scheduler_list_labels, so it stops short of full sibling differentiation.

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

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

The description gives no guidance on when to use this tool over alternatives such as mcp_kanban_label_manager or scheduler_list_labels, and it states no exclusions or conditions. The only contextual hint about scoping lives in the input schema, not in the description itself.

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 itself must disclose behavioral scope, and it does clarify that it operates on top-level board columns containing cards. It does not, however, describe the effects of destructive actions such as delete, permissions needed, or whether cards are affected when a column is removed.

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 tight sentences with no wasted words. The clarifying 'IMPORTANT' note is placed right after the main purpose recognized and clearly flags the most likely misuse.

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

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

The description is adequate for tool selection and scope understanding, but it is incomplete for a manager with five actions. It does not outline what each action requires, mention that create/update/delete have different parameter obligations, or describe expected return behavior in the absence of an output schema.

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

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

Schema description coverage is 100%, so the schema already documents each parameter. The description adds useful domain context about what a 'list/column' is, but it does not add action-specific parameter requirements, such as which parameters are needed for create versus update.

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 names a specific resource ('kanban board lists/columns') and provides concrete examples ('Backlog', 'To Do', 'In Progress', 'Done'). It also draws a clear boundary against card task-lists and sub-tasks, which prevents confusion with sibling card/task 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 gives an explicit when-not signal: it is NOT for card task-lists or sub-tasks inside cards. However, it stops short of naming the correct sibling alternative (e.g., mcp_kanban_task_manager), leaving some inference to the agent.

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. 'Manage board memberships' implies CRUD operations but doesn't specify permissions needed, rate limits, whether operations are destructive, or what happens when memberships are created/updated/deleted. The description is too generic to provide meaningful 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 extremely concise with just 6 words, which is efficient. However, it's arguably too brief given the complexity of the tool (6 parameters supporting 5 different actions). While front-loaded, it lacks necessary detail that would help an agent understand the tool's scope.

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

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

For a tool with 6 parameters supporting 5 different actions (including destructive operations like 'delete'), no annotations, and no output schema, the description is inadequate. It doesn't explain what the tool returns, what the different actions do, or provide any behavioral context needed for safe and effective 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 description coverage is 100%, so the schema already documents all 6 parameters thoroughly. The description adds no additional parameter information beyond what's in the schema. The baseline score of 3 is appropriate when the schema does all the parameter documentation work.

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 'Manage board memberships with various operations' which provides a general purpose (managing memberships) but is vague about what 'manage' entails. It doesn't specify the exact operations available or distinguish this tool from sibling tools like mcp_kanban_project_board_manager which might also handle board-level 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?

No guidance is provided about when to use this tool versus alternatives. The description doesn't mention sibling tools or provide context about when board membership management is appropriate versus other board-related operations available in the sibling tools.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It mentions the tool can create, update, and delete, implying mutability, but provides no detail on side effects, required permissions, reversibility, or response behavior. The structural note about boards containing column lists is contextual but not behavioral.

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

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

The description is compact—two sentences that state the purpose and a relevant structural fact. It is front-loaded with the main function, and every sentence earns its place. The note about board structure is concise and useful.

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

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

This is a complex tool with 10 distinct actions and 11 parameters, yet the description gives only a generic overview. It does not explain action-specific parameter usage, return values (no output schema), or how the actions interrelate. For a tool of this complexity, the description is insufficiently detailed.

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

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

Schema description coverage is 100%, so all parameters are already described in the schema. The tool description adds nothing beyond what the schema provides; it does not explain relationships between parameters and actions or provide usage hints. Per the baseline rule for high 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 names the resource (projects and boards) and lists the operation types (retrieve, create, update, delete, get summary), giving a clear overall purpose. It differentiates from sibling tools by resource type, but does not name specific actions or siblings, leaving some ambiguity about the exact scope (e.g., which action does what).

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, nor about choosing among its own actions. The description lists operation categories but does not explain scenarios (e.g., when to use get_projects vs get_project, or when pagination parameters apply). An agent is left to infer usage from the schema alone.

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

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

With no annotations provided, the description must carry the behavioral burden. It does add a small nuance ('across the Kanban board' and 'cardId/taskId substring') but largely repeats the parameter schema. It does not explicitly state that this is a read-only operation or mention any side effects, pagination, or default limits, which would be useful context for a query 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, information-dense sentence that front-loads the main purpose and enumerates criteria. It is efficient and not overly verbose, though it is long due to the number of criteria listed. It earns a high score for compactness without sacrificing clarity.

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

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

Given the tool's complexity (10 parameters, no output schema, no annotations), the description covers the functional scope well. It explains the searchable fields and filter options but omits details like default result limits, sorting, or whether it returns only card IDs or full objects. These are minor gaps for a query tool and do not impede basic usage.

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

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

Schema description coverage is 100%, so the schema already documents all parameters. The description lists the same criteria without adding new meaning or clarifying any ambiguous defaults (e.g., labelMatchMode default). It offers no value beyond the schema, so the baseline 3 is appropriate.

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

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

The description states a specific action (search and filter), a clear resource (cards and their checklist tasks/sub-tasks), and enumerates the criteria. This immediately distinguishes it from sibling tools like mcp_kanban_card_manager (which likely handles CRUD) and mcp_kanban_list_labels (which focuses on label listing).

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 clearly implies its use as a query/filter tool across the board, but it does not explicitly name alternatives or state when not to use it. It is obvious from the verb and resource that this is for searching, not modifying, so an agent can infer its role among siblings, but explicit guidance would be stronger.

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. 'Manage' implies mutation operations (starting/stopping/resetting), but the description does not specify permissions required, side effects (e.g., whether stopping records time data), or error conditions. It lacks details on what 'get' returns or how time data is stored, leaving significant gaps for a tool with multiple action types.

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

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

The description is a single, efficient sentence with zero waste. It is front-loaded with the core purpose and avoids unnecessary elaboration. Every word earns its place by directly stating the tool's function, making it highly concise and well-structured for quick understanding.

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

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

Given the tool's complexity (multiple actions like start, stop, get, reset) and lack of annotations and output schema, the description is incomplete. It does not explain return values, error handling, or behavioral nuances (e.g., what happens if you start a stopwatch that's already running). For a mutation-heavy tool with no structured output, more context is needed to guide effective use.

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

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

The input schema has 100% description coverage, with clear documentation for both parameters ('action' with enum values and 'id' as card ID). The description adds no additional meaning beyond the schema, such as explaining the relationship between actions or what 'id' refers to in the context of stopwatches. Since schema coverage is high, the baseline score of 3 is appropriate, as the description does not compensate but also does not detract.

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

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

The description clearly states the tool's purpose as 'Manage card stopwatches for time tracking', which includes a specific verb ('Manage') and resource ('card stopwatches') with a clear functional context ('for time tracking'). It distinguishes this tool from siblings like 'mcp_kanban_card_manager' or 'mcp_kanban_task_manager' by focusing on stopwatch functionality, but could be more precise about what 'manage' entails (e.g., starting, stopping, etc.).

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 prerequisites, such as needing an existing card, or differentiate from potential overlapping tools (e.g., if time tracking is also handled elsewhere). With no explicit usage context or exclusions, the agent must infer usage from the tool name and parameters alone.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It only describes the data model (hierarchy, isCompleted, checklists) and says nothing about side effects of actions, destructiveness, reversibility, permissions, or output behavior. For a multi-action tool with create/delete/sync operations, this is a clear gap.

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

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

The description is two sentences with no filler. The first sentence states the core purpose immediately, and the second provides essential hierarchy context. Every part earns its place, and it is front-loaded enough for quick scanning.

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 gives the essential hierarchy needed to understand where tasks live, but given the tool's complexity (11 actions, 10 parameters, no output schema, no annotations), it does not cover action semantics or expected results. The schema partially compensates by describing each action, so the description is adequate 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?

Schema description coverage is 100%, so every parameter already has a description. The tool description adds contextual meaning about hierarchy and the role of isCompleted, but it does not introduce parameter-specific semantics beyond what the schema already provides. The baseline of 3 is appropriate.

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

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

The description clearly scopes the tool to managing step-by-step tasks inside a card's checklist, and the hierarchy line reinforces the resource path. It does not explicitly name sibling tools or differentiate from them, but the domain is specific enough that an agent can tell it is for task/checklist items, not cards or lists.

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 guidance or comparison with sibling tools like card_manager or list_manager. The hierarchy implies the task layer, but there is no stated condition for when to pick this tool over alternatives, nor any exclusions or prerequisites.

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

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

With no annotations provided, the description carries the full behavioral burden. 'List all existing labels' clearly signals a read-only aggregation operation, and the state breakdowns specify the output composition. It could mention lack of side effects or board scope resolution more explicitly but is not misleading.

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

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

A single focused sentence that front-loads the action and resource, then gives the output detail. No filler or repeated schema 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 one-optional-parameter read operation with no output schema, the description is largely sufficient: it names the scope ('across all cards in the board(s)'), the returned concept ('labels'), and the accompanying counts/state breakdowns. It does not specify response fields or edge cases, but nothing critical is missing for selecting the 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 single boardId parameter is already fully described in the input schema, so schema description coverage is 100%. The description adds no format or behavior details beyond that, so it meets the baseline without adding extra semantic value.

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

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

States a specific verb ('List'), a specific resource ('existing labels'), and the result shape ('card counts and state breakdowns'). It is clear what the tool returns, though it does not explicitly distinguish from the similarly named sibling mcp_kanban_list_labels.

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 a board-wide label-discovery use case and the optional boardId parameter is meaningful, but it gives no explicit guidance about when to prefer this tool over siblings such as mcp_kanban_list_labels or scheduler_query_tasks. No exclusions or alternative conditions are 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 communicates a search/read behavior and defines the scope (cards plus checklist tasks/sub-tasks), but it does not explicitly confirm the operation is read-only, explain default board scoping when boardId is omitted, or mention return/limit 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 one front-loaded sentence that starts with the verb and resource, then gives a compact list of criteria. It contains no filler, but the long flat enumeration could be broken into a clearer structure for easier scanning, so it is not quite a 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?

For a 10-parameter query tool with no output schema and no annotations, the description covers the core search dimensions well but omits important contextual details such as the default all-boards scope, the limit parameter, and what a successful result looks like. It is adequate but not fully complete.

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

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

Schema description coverage is 100%, so the baseline is 3. The description adds a useful synthesized grouping of criteria (e.g., 'cardId/taskId substring', 'labels (with matchMode any/all)'), but it does not meaningfully add information beyond what the schema already documents for each parameter.

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

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

The description clearly identifies a specific action and resource: 'Search and filter cards ... across the Kanban board' and enumerates the searchable criteria. It does not, however, distinguish itself from the similarly named sibling tool mcp_kanban_query_tasks, so it loses the top point.

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

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

Usage is implied: an agent should use this tool when it needs to find cards or checklist tasks matching search/filter criteria. There are no explicit exclusions, alternative recommendations, or guidance about when a different sibling tool would be more appropriate, so it only meets the 'implied' bar.

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