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

No annotations are supplied, so the description carries the full burden of behavioral disclosure. It only states the return value and does not mention whether the operation is read-only, what happens when the column is empty, how conflicts are resolved, or whether skipDone/skipReview alter the outcome. This leaves important behavioral traits undisclosed.

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, stating the exact purpose and the ordering rule in a front-loaded manner. 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?

With five parameters, no annotations, and zero schema descriptions, the description is too terse to be complete. It does not explain how to identify a column or what the filter parameters do. While an output schema may cover the return shape, the lack of input guidance leaves the agent guessing about required combinations of columnId and columnName, and the meaning of skipDone and skipReview.

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 0% and the description provides no parameter-level meaning. It does not explain how to specify the column (columnId vs columnName), the role of projectKey, or what skipDone and skipReview do. Since the description is the only source of parameter semantics and it says nothing, this dimension scores at the bottom.

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 returns the highest-priority ticket from a column, using the specific phrase 'highest-priority ticket (lowest priority value)' which disambiguates the ordering semantics. It is distinct enough from siblings like kanban_find_column_tickets or kanban_search_tickets, though it does not explicitly name them.

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

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

No guidance is provided on when to use this tool versus alternatives such as kanban_find_column_tickets or kanban_search_tickets. The description lacks any context about when this tool is the right choice, such as 'when you only need the single highest-priority item' or 'instead of listing all column tickets.'

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. 'Add' implies mutation, but the description does not state effects on existing columns, default behavior for optional fields like wipLimit or orderIndex, permissions, or whether the operation is idempotent.

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, which is concise, but it is also under-specified. It front-loads the core action but lacks supporting detail that would make it genuinely 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?

The tool has 4 parameters with 0% schema description coverage and no annotations. The description is too minimal to support correct invocation: it does not explain required parameters, optional parameters, prerequisites, or expected behavior, and it leaves the agent to guess at the semantics of the input 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 0% and the description adds no meaning to the parameters. It does not explain projectKey, name, wipLimit, or orderIndex beyond their names and schema constraints, so an agent cannot infer which values are valid or how they interact.

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 ('Add') and resource ('a new column') and clearly indicates the target ('to a project'). This distinguishes it from sibling tools like kanban_rename_column and kanban_delete_column, though it could be more explicit about the kanban board context.

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 kanban_rename_column or kanban_create_project. The description implies creation but provides no context for choosing it over other column-related 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. It does disclose that the tool mutates state by creating an epic, but it says nothing about required project existence, side effects on the board, 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 extremely concise and front-loads the action, with no wasted words. However, the brevity omits contextual information that would make the tool easier to invoke correctly.

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

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

For a creation tool with four parameters and no annotations, a single sentence is insufficient. It explains neither the required field semantics nor when the tool should be selected, even though an 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?

Schema description coverage is 0%, and the description mentions none of the four parameters (name, projectKey, color, description). It fails to compensate for the schema's complete lack of 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 a specific verb and resource: 'Create a new epic in a project.' This clearly differentiates the tool from sibling operations like kanban_update_epic, kanban_delete_epic, and kanban_create_ticket.

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 for when to use this tool versus alternatives such as creating a ticket or updating an existing epic. The description implies usage only through the verb 'create' but provides no prerequisites or exclusions.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It only states the core creation action and the custom-column option, without mentioning persistence, uniqueness constraints, key semantics, permission requirements, or any side effects of creating a project. This is thin for a mutation tool with no annotation safety signals.

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

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

The description is a single front-loaded sentence with no filler. The main action and the notable optional behavior are both conveyed 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?

The description is minimally viable for a straightforward creation tool, especially with the schema providing required parameters and the output schema covering return shape. However, with no annotations and no explanation of key semantics or uniqueness behavior, an agent cannot fully anticipate constraints or edge cases before calling 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?

Schema description coverage is 0%, so the description must compensate for undocumented parameters. It only clarifies the columns parameter ('optional custom column names') and leaves key, name, and description semantically unexplained beyond their labels. In particular, the likely identifier role of key is not addressed, which is a gap for a creation endpoint.

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') and resource ('project') and adds a meaningful differentiator: optional custom column names. This resource noun distinguishes it from sibling tools like kanban_create_ticket, kanban_create_epic, and kanban_create_column even without naming them explicitly.

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

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

The description implies when to use the tool (when a new project is needed) but provides no explicit guidance on prerequisites, exclusions, or alternatives such as kanban_create_epic or kanban_create_column. The required key and name are visible in the schema, but the description doesn't explain the relationship between them or when this tool 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?

No annotations provided, so the description carries full responsibility. It indicates a mutation ('create') but does not disclose required permissions, effects on existing data, projectKey validity, or what happens on failure. It adds no behavioral detail 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?

Single sentence, 8 words, no fluff; the verb and object are front-loaded. It is appropriately short, but the brevity comes at the cost of substance.

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?

Output schema exists, so return value structure is covered. However, the description leaves 8 parameters unexplained, with 0% schema coverage and no annotations. It does not clarify the role of column, epic, or estimate fields, nor what constitutes a valid request.

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 0%, and the description provides no explanation of parameters. It only mentions 'project column' generically, not mapping to columnId or columnName, and does not clarify required fields like projectKey and title.

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

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

States the verb 'Create' and resource 'ticket' in a project column, clearly distinguishing it from sibling tools like update/delete/move. However, it doesn't explicitly name any alternative or exclude other create tools (e.g., create_project, create_column), so it lacks 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 vs alternatives. Does not mention that it is the appropriate tool for adding a new ticket, nor any conditions or prerequisites. With 30+ siblings, 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 full burden of behavioral disclosure. It explicitly warns that deleting a column also removes contained tickets, which is a critical destructive side effect beyond what the name alone implies. It does not mention permanence or permission requirements, but the most important behavioral trait is stated.

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

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

The description is a single front-loaded sentence. Every word earns its place, and the most important side-effect information is compactly included in parentheses without bloating the description.

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

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

For a one-parameter destructive operation with an output schema, the description is nearly complete: it names the target, the required ID, and the cascading effect on tickets. A small gap is the lack of explicit irreversibility or permission context, but the essential invocation details are present.

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

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

The input schema has 0% description coverage)Skip the parameter is self-explanatory: columnId is an integer ID identifying the target column. The description's phrase 'by id' reinforces the parameter's role but adds little beyond the schema's property name and type.

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 column by id. The parenthetical about removing contained tickets additionally distinguishes this from simple column renaming or ticket deletion, so an agent can tell exactly what operation is being offered.

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

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

The description gives no guidance about when to use this tool versus alternatives such as moving tickets first or deleting individual tickets. Deleting a column is obviously implied by the name, but no explicit context, prerequisites, or exclusions are provided.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It only says 'delete' and does not mention irreversibility, cascading effects, permissions, error semantics, or what happens to related data.

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 very short, contains no filler, and front-loads the key verb and resource. It is concise, though it is arguably too sparse to be a fully adequate tool definition, so it does not earn 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 destructive mutation tool with no annotations, this definition is thin: it does not cover side effects, reversibility, preconditions, or how to get a valid epicId. The presence of an output schema covers return values, but the operational context needed before calling a delete endpoint is still 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 0%, so the description must compensate, but it only uses the generic phrase 'by id' and never names the epicId parameter, explains how to obtain it, or clarifies its meaning beyond the schema property name. This leaves the agent to infer the parameter's semantics from the schema alone.

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-resource pair ('Delete an epic') and specifies that deletion is by ID, so the core purpose is unambiguous. The resource type 'epic' distinguishes it from sibling tools like delete_ticket and delete_column, though it does not 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?

There is no guidance about when to use this tool versus alternatives, no prerequisites, and no mention of whether deleting an epic has cascading effects on tickets or columns. The agent must infer usage entirely from the verb and resource name.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. 'Delete' implies a destructive mutation, but the description does not state whether deletion is permanent, cascades to linked items, or requires special permissions. This is a significant gap for a destructive 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 short sentence that is front-loaded with the action and resource. It is concise and easy to parse, though it omits behavioral details that would make it more 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?

For a destructive tool with no annotations and no output schema details, the description is too thin. It does not explain return values, error conditions, or side effects. An agent would not know what to expect after calling it or whether it is safe to 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?

Schema description coverage is 0%, but the schema itself documents the single parameter 'ticketId' with type and exclusiveMinimum. The description adds no meaning beyond the schema, but with only one well-defined parameter, the schema carries the meaning adequately. 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 verb ('Delete') and resource ('a ticket by id'), which clearly identifies the operation. It distinguishes from siblings like kanban_delete_epic and kanban_delete_column by naming the resource type, 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 on when to use this tool versus alternatives like kanban_update_ticket or kanban_find_ticket. The description implies deletion by id but provides no context about prerequisites, such as whether the ticket must exist or whether deletion is permanent.

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

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

No annotations are provided, so the description carries the behavioral burden. It conveys that this is a non-mutating filter operation and identifies two filtering modes, but it does not disclose edge-case behavior such as what happens when both priorities and min/max bounds are supplied or whether the bounds are inclusive.

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

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

Two short sentences with no filler; the action and primary filtering input are front-loaded. Every sentence contributes 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 seven parameters, no annotations, and 0% schema coverage, the description is too thin. It omits how to specify the column, the role of the required projectKey, limit behavior, and how the two priority-filtering modes interact, so an agent would have to infer these 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 0%, so the description must compensate for missing parameter documentation. It clarifies only priorities/priorityMin/priorityMax as a 'priority band,' leaving projectKey, columnId, columnName, and limit semantically unexplained and not stating whether columnId or columnName is the expected selector.

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

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

The description opens with a specific verb ('Filter') and resource ('tickets within a column'), then narrows the operation to 'by priority band.' This clearly distinguishes it from siblings such as kanban_find_ticket and kanban_search_tickets, so an agent can tell 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 second sentence gives a usable directive ('Supply priorities or priorityMin/priorityMax bounds'), which tells the agent what inputs to provide. However, it does not explicitly say when to prefer this tool over kanban_find_ticket or kanban_search_tickets, nor does it state exclusions; the usage context is implied rather than explicit.

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

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

With no annotations, the description carries the full burden. 'Look up' implies a read operation, and it usefully discloses that completed tickets include completionSummary. However, it does not explicitly state that the operation is non-mutating or describe any error behavior if the ticket is not found.

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

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

Two concise sentences with no filler. The main purpose is front-loaded, and the additional return-value detail is brief and relevant.

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

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

For a simple single-parameter lookup with an output schema, the description is nearly complete. It covers what context is included and highlights completionSummary, leaving only edge cases like missing tickets or exact response layout to 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 0%, but the single parameter ticketId is self-explanatory and the title reinforces that it is an ID. The description does not add extra meaning beyond the schema, yet the parameter's semantics are obvious from its name and type.

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 ('look up'), a clear resource ('single ticket'), and the contextual scope ('with project, column, and epic context'). It also notes the return value, distinguishing it from broader queries like kanban_search_tickets or kanban_find_column_tickets.

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 when a single ticket's full details are needed by ID, but it does not explicitly state when to prefer this over sibling tools or when not to use it. The context is clear enough for a simple lookup, but exclusions/alternatives are 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 present, so the description carries the full burden. It implies a read operation through 'Fetch' but does not explicitly state that it has no side effects, whether it requires special permissions, or what happens when the batch does not exist.

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 starts with the action word 'Fetch' and quickly identifies the object. There is no filler or redundant phrasing.

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 an output schema present, return values are likely covered. However, the description lacks any context about when a batch is relevant or how batchId is typically obtained, which is not fully compensated elsewhere.

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 0%, so the description must compensate. It only implies batchId is the batch identifier, but does not explain its format or what constitutes a 'batch'. No additional parameters are described.

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 names the verb 'Fetch' and the resource 'Kanban batch', and adds 'with its planned ticket items' to specify content. It is distinct from siblings like get_board or get_ticket_runs, though it does not explicitly name them.

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

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

The description provides no guidance on when to use this tool versus alternatives. It does not state prerequisites (e.g., needing a batchId) or suggest when not to use it.

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

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

With no annotations provided, the description carries the full burden for behavioral disclosure. The verb 'Fetch' and the tool name clearly indicate a read operation, and the description adds a useful behavioral detail about the completionSummary field. However, it does not mention side effects (likely none), permissions, pagination, or error behavior, leaving some 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 two sentences with no filler. The core purpose is front-loaded in the first sentence, and the second sentence adds a valuable return-field detail without increasing verbosity. Every sentence earns its place.

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

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

For a simple one-parameter board fetch with an output schema, the description adequately covers the tool's purpose and a notable return field. It could explicitly mention that the board includes all columns and tickets in order, but the output schema likely covers return structure. Overall, nothing critical 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 input schema has 100% description coverage for the single required parameter projectKey ('Project key identifier'). The tool description adds no additional parameter semantics beyond the schema, 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 states a specific verb ('Fetch'), a specific resource ('full board for a project'), and the content ('columns and tickets'). It also highlights the 'completionSummary' field, which helps distinguish it from sibling tools that focus on individual tickets, columns, or lists of projects.

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

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

The description implies when to use the tool by stating it fetches the full board for a project, but it does not explicitly contrast with siblings like kanban_find_ticket or kanban_search_tickets, nor does it mention when not to use it. No exclusions or alternative tool guidance is provided.

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

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

No annotations are provided, so the description carries the behavioral burden. The verb 'Fetch' indicates a non-mutating read operation, and the presence of an output schema covers return shape. However, the description does not disclose whether metrics are precomputed, how missing data is handled, or any project-scope caveats.

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

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

The description is a single sentence with no filler, front-loading the action and the metric types. It earns its place and remains highly 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?

The tool is simple with one required parameter and an output schema, so the description is minimally viable for invocation. But it omits usage guidance and any parameter detail, leaving gaps for an agent that must decide between this and sibling tools.

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

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

Schema description coverage is 0%, and the description only says metrics are 'for a project,' adding no format, example, or allowed values for projectKey. The agent must infer semantics from the parameter name alone.

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 verb ('Fetch'), a clear resource (metrics for a project), and enumerates the metric types (burn-up, burndown, and velocity). No sibling tool covers metrics, so it is easy to distinguish from the other kanban tools.

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

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

No guidance is given about when to use this tool versus alternatives; no sibling tool is mentioned and no conditions or exclusions are stated. The only context is the implied need for project metrics.

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 data is 'append-only' and 'history', which implies immutability and read-only nature, but it does not mention that this is a read operation (no side effects) or any rate limits. The term 'append-only' is useful but could be reinforced by explicitly saying it does not modify state.

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

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

The description is a single, efficient sentence that front-loads the core purpose. It is concise and avoids fluff, but it could be slightly expanded with usage guidance without losing conciseness.

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

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

The tool is simple with one required parameter and an output schema that likely describes the run history structure. The description captures the essential purpose. It lacks explicit read-only disclosure, but with an output schema present, the return value is likely self-explanatory. Given the simplicity, this is nearly 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 0% for a single parameter 'ticketId'. The description does not explain the parameter beyond the schema's type and exclusiveMinimum. It is obvious that ticketId identifies the ticket, but the description could add value by specifying expected format (e.g., integer ID from kanban_find_ticket) or clarifying that it refers to the ticket whose runs are being fetched.

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 fetches run history for a ticket, including events and artifacts. It distinguishes this from sibling tools like kanban_get_ticket or kanban_get_board by specifying 'run history' and 'append-only'. However, it could be more specific about what a 'run' is (e.g., CI/CD pipeline run) and how it differs from related tools.

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

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

The description implies when to use it (when you need run history for a ticket) but does not explicitly state when not to use it or mention alternatives. With many sibling tools, this could be improved by naming a sibling like 'kanban_get_ticket' for basic ticket details. The phrase 'append-only' gives some context, but no exclusions are provided.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. 'Associate' implies a mutation, but the description does not say whether the link is created, updated, or overwritten, nor does it disclose idempotency, failure behavior, or side effects.

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, which is economical but under-specified for a tool with six parameters and no property descriptions. It lacks structure and additional useful detail, so this reads as under-specification rather than effective 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?

With six parameters, no annotations, and no schema property descriptions, the description is not complete enough for reliable invocation. It does not explain how docsProjectId, kanbanProjectId, or projectKey relate to the operation, nor when linkType is needed. The presence of an output schema helps with return values but not with invocation semantics.

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 0%, and the description only clarifies two concepts: the documentation path and the ticket. The optional parameters linkType, projectKey, docsProjectId, and kanbanProjectId are left entirely unexplained, which is a significant gap for a 6-parameter tool.

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 ('Associate') and identifies the two key resources ('documentation path' and 'ticket'). It is clear in what the tool accomplishes, but it does not differentiate itself from related siblings like kanban_list_doc_links or kanban_list_ticket_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?

No guidance is given about when to use this tool versus alternatives. It does not mention reading existing links with list tools, nor does it state any preconditions or exclusions. Usage is only implied by the action described.

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. 'Retrieve' implies a read-only operation, but the description does not mention pagination, ordering, error cases, or whether the links are URLs or internal IDs; it also does not explicitly confirm non-mutation.

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 short sentence with no filler and the key information is front-loaded. It is appropriately sized for a single-parameter read 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 output schema covers return values, and the single required parameter is simple, so the basic call can be made from this definition. However, the absence of usage guidance and the near-twin sibling kanban_list_ticket_links leave an agent uncertain about when this tool is the right choice.

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?

With 0% schema description coverage, the description must explain ticketId, but it only says 'associated with a ticket,' which is largely inferable from the parameter name. It does not specify how ticketId is used, expected format, or any relationship to the returned links beyond the obvious.

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 ('Retrieve') and names the resource ('documentation links') and its scope ('associated with a ticket'). It is clear on its own, but it does not explicitly distinguish itself from the similarly named sibling kanban_list_ticket_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?

No guidance is given about when to choose this tool over alternatives; it does not mention kanban_list_ticket_links, kanban_link_doc, or any exclusion criteria. The agent is left to infer usage from the tool 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 behavioral burden. The verb 'List' signals a read-only operation and 'all epics' indicates scope, but the description does not disclose pagination, result limits, ordering, visibility, or error behavior. The basic side-effect profile is clear, but important details are unspecified.

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 with no filler; every word adds meaning. It is appropriately sized for a simple list operation with a single parameter.

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

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

For a one-parameter read tool with an output schema, the description covers the core purpose, but it leaves gaps around usage alternatives and projectKey semantics. It is minimally viable but not rich enough for an agent to handle edge cases or disambiguate from search-oriented siblings without additional inference.

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 0% description coverage and only a bare `projectKey: string`. The phrase 'for a project' merely paraphrases the parameter name and does not explain what a valid projectKey looks like, where to obtain it, or how it maps to epics. With low schema coverage, the description needed to compensate but did not.

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 ('all epics') with a clear scope ('for a project'), making it easy to distinguish from sibling tools like create/update/delete_epic or list_projects. An agent can 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 intended use is implied: call this tool when you need all epics for a project. However, it does not explicitly state when not to use it or mention alternatives such as kanban_search_tickets or kanban_find_ticket, so usage guidance remains 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?

With no annotations, the description carries the full burden of behavioral disclosure. 'List' clearly indicates a read-only operation and the zero-parameter schema implies no mutation, but the meaning of 'available', ordering, scope, or pagination is not disclosed.

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

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

The description is three words long with no filler and presents the core purpose directly. It is highly concise and appropriately 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 listing call with an output schema, very little is needed for invocation. The main gap is that 'available' is undefined, and there is no guidance on how this tool relates to sibling list/search tools.

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

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

The tool has zero parameters and the input schema is empty, so there are no parameter semantics for the description to add. The baseline of 4 for a no-parameter tool 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 ('projects'), making the action clear. It does not explicitly distinguish itself from sibling listing tools like kanban_list_epics or kanban_list_doc_links, so it does not earn 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?

'Available projects' implies this is the tool for retrieving a project list, giving some usage context. However, it does not state when to avoid it or mention alternatives such as kanban_search_tickets or kanban_list_epics, leaving routing mostly to inference.

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

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

With no annotations, the description must carry the behavioral burden. 'Return' implies a read-only operation, but it does not explicitly state that no state is modified, nor does it disclose error behavior or authorization needs. The description is adequate for a simple list operation but leaves some behavior implicit.

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

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

The description is a single, front-loaded sentence with no filler or repetition. Every word adds value, and it is 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 zero-parameter read-only list operation with an output schema present, the description is nearly complete. It states exactly what is returned. It could be slightly stronger by mentioning that this is the canonical source of allowed values for estimate-related workflows, but nothing critical 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 tool has zero parameters, so there is no parameter semantics to add. Per the rubric, a zero-parameter tool gets a baseline of 4. The description correctly focuses on what the tool returns rather than input details.

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 ('Return') and names a precise resource ('allowed Scrum poker estimate values'). This clearly distinguishes it from sibling tools like kanban_set_estimate and kanban_get_metrics, which have different purposes.

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 the tool should be used when an agent needs the set of allowed Scrum estimates, but there is no explicit when-to-use guidance or mention of alternatives. It does not state, for example, that it should be used to validate estimates before calling kanban_set_estimate.

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, but it only states 'Find all tickets referencing a documentation path.' It does not reveal whether the operation is read-only, how path matching works (exact vs. partial), whether indirect references are included, or what the returned ticket list contains. The word 'Find' weakly implies a read operation, but meaningful behavioral context is absent.

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

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

The description is a single, focused sentence with no filler or repetition. It is appropriately sized for a simple lookup tool, though it could have used one more sentence to clarify parameter roles.

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

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

For a two-parameter query tool with an output schema, the description captures the core relationship (tickets → doc path) but omits parameter semantics and usage differentiation. It is minimally complete but leaves an agent without enough guidance to confidently distinguish this from similar list/search tools or to understand projectKey's role.

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 0%, so the description must compensate by explaining the parameters. It only hints at docPath through 'documentation path' and says nothing about projectKey. The agent is left to infer that projectKey scopes the project, which is not stated anywhere. This does not adequately compensate for the total lack of schema descriptions.

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

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

The description uses a specific verb ('Find') and resource ('all tickets referencing a documentation path'), making the query intent unambiguous. It clearly differentiates from the sibling tool kanban_list_doc_links, which performs the reverse direction (docs linked to a ticket). This is a strong, specific purpose statement.

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

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

The description implies the use case: given a documentation path, retrieve tickets that reference it. However, it never explicitly states when to prefer this tool over alternatives like kanban_search_tickets or kanban_find_ticket, nor does it provide exclusions. Context is clear but usage boundaries are left to inference.

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

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

With no annotations, the description carries the burden of behavioral disclosure. It adds useful behavioral context by requiring a completionSummary when moving to Done and noting that deployment proof is optional. However, it does not disclose side effects like whether the move is reversible, whether it triggers anything downstream, or authorization requirements.

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

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

The description is two sentences, front-loading the core action and then giving the key condition. It is tight and readable, though 'Deployment proof is optional' slightly repeats what the schema already states.

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?

Although an output schema exists, an agent still lacks essential operational context: the schema requires only ticketId but the tool needs a target column, and it is unclear whether columnId or columnName should be provided, or how they interact. The Done-related guidance is helpful but does not make the tool fully callable in non-Done 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?

Schema coverage is only 43%, so the description must compensate. It adds meaningful detail for completionSummary, enumerating the three required elements, and clarifies deploymentProof is optional. Yet it leaves columnId, columnName, and priority unexplained, so parameter meaning remains incomplete.

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: 'Move a ticket to another column.' This clearly distinguishes the tool from siblings like kanban_update_ticket and kanban_reorder_column_tickets, and the Done-column condition adds precision.

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: whenever moving a ticket between columns. It gives a clear conditional rule for Done, but it does not explicitly say when to prefer this tool over kanban_update_ticket or kanban_reorder_column_tickets, nor does it mention exclusions such as completing vs staging.

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 indicates that the tool mutates a column, but it does not disclose side effects, auth requirements, reversibility, or behavior when only some metadata fields are provided.

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, front-loaded sentence with no filler. Every phrase — 'Rename', 'update metadata', 'column', 'by id' — adds necessary disambiguation.

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

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

For a mutating tool with four parameters, no annotations, and 0% parameter schema coverage, the description leaves too much to inference. The presence of an output schema covers return values, but parameter semantics and behavioral caveats remain incomplete.

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

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

Schema description coverage is 0%, so the description must compensate. It hints at 'id' and 'metadata' but does not map to the actual parameters name, wipLimit, orderIndex, or explain that all are optional beyond columnId. This is insufficient for an agent to confidently supply correct values.

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

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

States a specific action — 'Rename or update metadata' — on a specific resource, 'a column', addressed 'by id'. This clearly distinguishes it from sibling tools like kanban_create_column and kanban_delete_column.

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

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

The description implies the tool is for modifying an existing column identified by id, but it does not explicitly state when to use it over alternatives or when not to use it. Usage must be inferred from the wording and sibling names rather than being directly guided.

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

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

With no annotations, the description carries the behavioral disclosure burden. It usefully explains the priority semantics ('First ticket in the list receives priority 0'), but it does not disclose what happens to tickets omitted from ticketIds, whether the change is persistent, or whether full reordering is required.

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

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

Two short sentences with no filler. The core operation is stated first, and the key ordering detail is added second, making the description easy to scan and act on.

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, has an output schema, and the description covers the basic invocation. The main missing piece is whether ticketIds must include every ticket in the column or only those whose priority is changing, which materially affects how an agent should construct the call.

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

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

Schema description coverage is 0%, so the description must compensate. It clarifies that the ticketIds array order determines the new vertical order and that the first entry gets priority 0. However, columnId is left to be inferred purely from its name, and no detail is given about whether the list must contain all tickets in the column.

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 ('Set the vertical order') and resource ('tickets in a column'), making the core purpose clear. It distinguishes itself from related actions like moving tickets between columns, though it does not explicitly name or contrast any sibling tool.

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

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

The usage context is implied: use this tool when you need to reorder tickets within a column. However, there is no explicit guidance about when to prefer this over related tools like kanban_move_ticket or kanban_column_top_ticket, and no exclusions or prerequisites are provided.

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

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

There are no annotations, and the description does not disclose behavior beyond the operation name. It never confirms whether this is read-only, how pagination behaves, whether filters are combined with AND/OR semantics, or how results are ordered—leaving the agent to infer safety and behavior from the verb "search" alone.

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 written sentence with no filler and the main action front-loaded. It loses a point only because "optional filters" is vague where a short enumeration would have made the sentence simultaneously concise and informative.

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 nine parameters, one required field, and close sibling tools, this one-sentence description is insufficient for an agent to call the tool correctly. It establishes the broad intent but leaves parameter usage, pagination behavior, and filter semantics unstated.

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

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

Schema description coverage is 0%, yet the description adds almost nothing about the nine parameters. "Optional filters" is generic and does not explain projectKey, limit, offset, query, columnId, columnName, priorities, priorityMin, or priorityMax, so the description fails to compensate for the schema's silence.

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 pins down the action and resource: search tickets within a project, with optional filters and pagination. It is clear on its face, but it does not differentiate itself from siblings like kanban_find_ticket or kanban_find_column_tickets, which likely perform similar or overlapping lookup tasks.

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

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

The description provides no guidance about when to use this tool instead of kanban_find_ticket or kanban_find_column_tickets. It states the basic use case but offers no exclusions, no mention of exact-match vs. broad-search tradeoffs, and no pointer to 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 alone must disclose behavioral traits. It says 'assign' which implies a mutation, but it doesn't state whether the estimate is overwritten, whether it's reversible, or any permission requirements. It also doesn't describe the output despite having an output schema, which could be inferred but is not stated. The description is too terse to provide adequate transparency.

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

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

The description is one concise sentence with no wasted words. It front-loads the action and object. However, it's under-specified, which is not a structural issue but a content issue. The conciseness is good, but it sacrifices necessary detail for brevity.

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

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

Given the tool's moderate complexity (2 parameters, output schema present), the description is incomplete. It doesn't clarify the relationship to Scrum poker values, the effect of setting an estimate (e.g., state changes), or any special behaviors. The output schema exists but the description doesn't reference it, and with no annotations, the agent lacks critical context for correct invocation.

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

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

Schema description coverage is 0%, meaning the schema properties only have types, no descriptions. The tool description mentions 'estimate' and 'ticket' implicitly, but it doesn't clarify the semantics of the estimate parameter, such as the allowed range or relationship to Scrum values (e.g., numbers from a specific set). With 2 parameters and no description coverage, the description fails to compensate, leaving the agent guessing at the meaning of 'estimate'.

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 'assign' and the resource 'estimate to a ticket', which distinguishes it from other ticket operations like update or move. However, it doesn't explicitly specify the resource type or the fact that it uses Scrum poker values, which could be inferred from the tool name and the existence of a sibling tool kanban_list_scrum_values. Overall, it is clear enough for an agent to understand the basic 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 provides no guidance on when to use this tool versus alternatives, such as kanban_update_ticket or kanban_list_scrum_values. There is no mention of prerequisites, typical use cases, or exclusions. An agent would have to infer usage from the context, which is insufficient for a tool that modifies ticket state.

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

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

The description discloses key behavioral traits: atomicity, the existence of a single shared lease, the 'acquired is false' failure mode when another holder is active, and the precondition to build the preview first. It also implies the return of a token on success. Since no annotations are provided, the description carries the burden, and it covers the essential behavior but doesn't detail what 'acquired false' returns in full or any side effects like TTL expiry.

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 zero waste, front-loading the core action ('Atomically acquire') and the critical precondition. It is appropriately concise for a targeted lease-acquire operation.

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 (atomic lease acquisition) and the presence of an output schema (which may document the acquired flag and token), the description is adequate but not complete. It explains the failure mode and precondition but doesn't cover the full parameter semantics or the exact return contract beyond 'acquired is false and no token is returned.' Since the output schema exists, it doesn't need to detail return values, but parameter meaning remains underspecified.

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?

With schema description coverage at 0%, the description must compensate for parameter meanings, but it does not explain what candidateRef, baselineRef, ownerId, or ttlSeconds mean. The description only mentions 'ticket candidate' and 'other holder', which maps to ticketId and ownerId but leaves the rest to inference. This is a gap given 7 parameters and no schema descriptions.

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 atomically acquires a shared staging lease for a ticket candidate, with a specific precondition (build the immutable preview first) and outcome (acquired false if another holder is active). It distinguishes itself from sibling lease tools like kanban_staging_lease_status (status query), kanban_staging_lease_assert (assertion), kanban_staging_lease_heartbeat (renewal), and kanban_staging_lease_release (release).

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 indicates the critical prerequisite (build the immutable preview before calling) and explains what happens when another holder is active. However, it doesn't explicitly say when to use this vs. alternatives or when not to use it; the sibling context implies it's the acquire operation but there is no direct comparison. Still, the precondition and outcome provide clear usage context.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. The description mentions 'Validate' and 'immediately before' which implies a check operation, but it does not disclose what happens if validation fails, whether it has side effects (e.g., does it invalidate the lease?), or any rate limits or authorization requirements. This is a significant gap for a tool with no annotations.

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 states the trigger condition for use. It is concise and front-loaded with the action verb. No filler words, and it ends with a clear list of scenarios. It earns points for efficiency, though it could have used the space to add behavioral 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?

Given the tool has an output schema (likely indicating validation result) but no annotations, the description is incomplete for safe usage. It does not explain what the output contains, what happens on failure, or any prerequisites beyond 'immediately before' usage. An agent needs to know if this tool mutates state or only reads, which is missing.

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

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

The schema coverage is 67%, with leaseToken and fencingToken having descriptions, but projectKey lacks any description. The description does not add semantics beyond what the schema provides, so it does not compensate for the missing projectKey description. Baseline 3 is appropriate since schema partially covers, but the description does not enhance 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 ('Validate') and resource ('holder token and fencing generation'), but the overall purpose is somewhat vague. It mentions validating tokens 'before a staging alias change, migration, shared-fixture mutation, acceptance, or rollback,' but does not clearly distinguish this from sibling tools like kanban_staging_lease_status or kanban_staging_lease_heartbeat, which might also involve validation.

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 says to use it 'immediately before' certain operations, which provides some context, but it does not explicitly state when not to use it or mention any alternative tools. It lacks a clear comparison with sibling tools such as status or heartbeat, leaving the agent to infer when this specific assert tool is required.

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

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

No annotations are provided, so the description carries the behavioral burden. It discloses the key eligibility rule (expired/superseded holders cannot renew) and the extension action, but it does not describe failure behavior, idempotency, or what happens to the old lease/token. Useful but incomplete for a mutating lease 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?

Two short sentences with no filler; the action and its precondition are front-loaded, and the eligibility restriction is stated compactly. It is appropriately sized for a focused lease-renewal 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?

With an output schema present and sibling lease tools providing surrounding context, the description covers the core action and an important precondition. However, it leaves ambiguity about what 'superseded' means, how ttlSeconds modifies the lease, and what the caller should do when renewal is denied (e.g., call acquire again). These gaps make it slightly incomplete for an agent acting autonomously.

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 exactly 50%: leaseToken and fencingToken are well described in the schema, and ttlSeconds has min/max constraints. The description itself adds no parameter-level detail, so it neither compensates for projectKey's missing description nor clarifies how ttlSeconds is applied. Adequate but not additive.

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 ('Extend'), names the resource ('an active staging lease'), and gives the operational context ('while targeted hosted UAT is still running'). This clearly distinguishes it from sibling lease operations like acquire, release, status, and assert.

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 states the condition under which the tool is appropriate ('while targeted hosted UAT is still running') and provides a hard exclusion ('An expired or superseded holder cannot renew'). It does not explicitly name alternative tools (e.g., re-acquiring a lease), so it stops short of full routing guidance.

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

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

With no annotations provided, the description carries the full behavioral burden and discloses a key concurrency behavior: 'A stale fencing generation cannot release a successor lease.' This warns the agent that an outdated fencingToken will not release a newer lease. It does not detail all failure modes or side effects, but the most important non-obvious safety behavior is present.

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

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

Two sentences, both earning their place: the first states the action and when it applies, the second warns about the fencing guard. The most essential information is front-loaded with no redundant filler.

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

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

For a narrow lifecycle tool with an output schema, the description covers the action, the timing, and the critical concurrency constraint, which is enough for an agent to select and invoke it correctly. It omits explicit failure-behavior details, but those are partially implied by the fencing warning and may be covered by the 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?

The schema documents leaseToken and fencingToken, and the description adds meaningful semantic context by explaining that a stale fencing generation cannot release a successor lease, clarifying how fencingToken is validated. projectKey remains undescribed in both schema and description, but its meaning is clear from the name and context.

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

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

The description opens with a specific verb and resource, 'Release the staging lease', and adds the two exact conditions for doing so: 'after the candidate is accepted or the previous immutable deployment is restored.' This clearly distinguishes the tool from sibling lease operations like acquire, status, heartbeat, and assert by operation and lifecycle stage.

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

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

The description gives a clear decision rule for when to use the tool, specifying both triggering conditions. It does not explicitly name alternatives or state when not to use it, but the lease-related sibling tools make the choice sufficiently obvious.

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

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

With no annotations, the description must carry the behavioral burden. It adds a key privacy trait: 'without revealing its secret holder token', which is beyond the title. The verb 'Inspect' also implies a read-only, non-mutating action, though it does not explicitly detail side effects or preconditions like whether a lease must exist.

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

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

The entire description is one short, front-loaded sentence that names the action and the critical privacy constraint with no filler. Every word contributes to the intended meaning.

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

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

The output schema handles return values, but there are notable gaps: no guidance on when this should be preferred over lease siblings (acquire/assert/heartbeat/release), no mention of preconditions, and only an implicit read-only guarantee. It is minimally viable but not fully self-contained for distinguishing among the lease-related tools.

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

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

Schema description coverage is 0%, and the description does not mention the projectKey parameter at all. The schema only gives type/minLength, so the agent receives no semantic guidance about how projectKey scopes the lease or why it is required.

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 'Inspect' with the resource 'shared staging lease', which clearly names the operation. It also differentiates from siblings that might return or manage tokens by stating it does so 'without revealing its secret holder token'. The title reinforces 'Get Staging Lease Status'.

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

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

The description implies when to use it (inspecting lease status without exposing the token), but it does not explicitly state alternatives or exclusions, such as pointing to acquire, assert, heartbeat, or release for other lease operations. Usage context is only inferred from the siblings list and the caveat.

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 implies mutation via 'Update' but does not mention whether it performs a partial update (leaving unspecified fields unchanged), whether it requires specific permissions, whether it is reversible, or what happens if the epic does not exist. These gaps are significant 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 with no redundant words. It is front-loaded with the core action and immediately lists the relevant fields. It earns its place without wasting tokens.

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 explanation, the description is too thin. It does not mention preconditions (e.g., epic must exist), error behavior, partial vs. full update semantics, or what the response contains. An agent calling this tool would lack critical information to use it correctly and safely.

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

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

The description lists the updatable fields (name, description, color), which adds meaning beyond the bare schema property names. However, it does not explicitly mention epicId, which is required but obvious from context. Since schema description coverage is 0%, the description partially compensates by identifying what each field does, but it doesn't cover all parameters equally.

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) and the resource (epic) with specific fields (name, description, color). It distinguishes from siblings like create/delete, though it doesn't explicitly name alternatives. The verb+resource+fields is specific enough to be unambiguous.

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

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

No guidance is given on when to use this tool versus alternatives like kanban_create_epic or kanban_delete_epic. There are no prerequisites, no conditions for use, and no mention of what makes this the right choice. The description only states what it does, not when to use it.

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

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

With no annotations, the description carries the disclosure burden; it does convey that this is a mutating update, that completing a ticket triggers a structured summary requirement, and that deployment proof is optional. It does not disclose whether updates are reversible, how conflicting fields (e.g., columnId vs columnName) are resolved, or what side effects occur.

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

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

Three short sentences, front-loaded with the action and followed by the two most important constraints; every sentence earns its place. There is no fluff or repetition.

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

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

The description covers the central completion contract and optional proof, and an output schema exists so return values need not be described. For a 12-parameter mutation tool, it leaves gaps: no valid Done status value, no guidance on choosing among columnId/columnName/status, and no mention of completionEvidence or ticketId identification.

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

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

The description maps the broad 'field' list to several parameters (title, description, column/estimate/epic, completionSummary, deploymentProof) and adds the completionSummary content requirements beyond the schema. It omits explicit semantics for ticketId, status values, columnId vs columnName, epicId vs epicName, and completionEvidence, so it only partially compensates for the low 25% schema description 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 opens with a clear verb-and-resource statement ('Update ticket fields') and enumerates the main editable fields, so an agent immediately knows what the tool does. It does not explicitly distinguish itself from sibling tools like kanban_move_ticket or kanban_set_estimate, which also operate on columns and estimates, so it stops short of a 5.

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

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

The description gives a concrete conditional rule ('When moving a ticket to Done, provide completionSummary...') and notes that deploymentProof is optional, which is useful task-level guidance. However, it never states when to prefer this tool over kanban_move_ticket, kanban_set_estimate, or other siblings, and it does not list exclusions or prerequisites.

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