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

With no annotations, the description carries the full burden, and it does disclose the key non-obvious behavior: the operation merges and preserves existing relations rather than replacing them. It doesn't cover error cases, duplicate handling, or return behavior, but the core mutation semantics are clear and honest.

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 tight sentences with the primary action front-loaded. The merge behavior is stated in a compact second sentence, and every clause adds meaningful information without fluff.

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

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

For a simple additive relation tool with fully documented parameters, the description is largely sufficient. The main gap is not addressing what happens on duplicate or invalid relations, or what the tool returns, but no output schema exists and the core calling context is 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 coverage is 100%, so all parameters are already described. The description adds a helpful example of the edge structure ({task, type}) and clarifies that taskId is the task being modified, but it does not materially extend the parameter explanations beyond the schema.

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

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

The description names a specific action ('Add a relation edge'), the target resource ('to a task'), and provides a concrete example shape. The merge sentence also distinguishes it from sibling relation tools like kanbn_set_relations and kanbn_remove_relation, even though they aren't named 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 merge statement ('existing relations are preserved and only the new edge is appended') implies the additive use case and signals this is not a replace-all operation. However, it never explicitly contrasts this with kanbn_set_relations or states when-not to use it, so the guidance remains implied rather than explicit.

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

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

With no annotations, the description carries the full burden of behavioral disclosure. It only says 'add,' implying mutation, but does not describe whether the task file is modified, whether it must already exist, what happens on conflict, or whether the operation is reversible.

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

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

The description is a single, direct sentence with no filler. It is efficient, though the phrase 'this board' is slightly imprecise without saying which project root or board context applies.

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

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

For a tool with no annotations and no output schema, the description is too thin: it omits side effects, prerequisites, and expected outcome. The schema covers parameters, but behavioral and usage context needed for safe invocation 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?

All three parameters are fully described in the schema (100% coverage), so the description does not need to restate them. It adds no extra parameter context, which is acceptable for this coverage level.

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

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

The description identifies a specific action (add) and resource (existing task file) with the target being the current board. It distinguishes itself from create_task by noting the file already exists, though it does not fully differentiate from move/import siblings.

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

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

No explicit guidance is given about when to choose this tool over alternatives such as create_task, add_untracked_task, or move_simple_task_to_board. 'Existing task file' implies a precondition, but no when-to-use or when-not-to-use context is stated.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It only says 'Add an untracked task file to a column in the index' without explaining what modifications occur to the index, whether the task file is physically moved or just referenced, what happens if the task is already tracked, or whether any reversible side effects exist. For a mutating operation, this is a significant transparency gap.

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

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

The description is a single, front-loaded sentence with no unnecessary words. It conveys the core action efficiently and does not waste the agent's attention with redundant details.

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

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

Given the lack of annotations, no output schema, and the existence of many similar sibling tools, the description is incomplete. It does not explain what 'untracked' means in this context, whether an initialized index or board is required, or what happens as a result of the operation. An agent cannot fully anticipate the tool's behavior or prerequisites from this definition alone.

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

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

Schema coverage is 100%, with each parameter having a clear description (path, taskId, columnName). The tool description adds minimal extra meaning beyond what the schema already provides, such as framing the task as 'untracked'. Since the schema handles parameter documentation effectively, the baseline of 3 is appropriate.

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

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

The description clearly states a specific action: adding an untracked task file to a column in the index. It uses a specific verb ('Add'), a clear object ('untracked task file'), and a destination ('column in the index'). This distinguishes the tool from siblings like kanbn_create_task, kanbn_move_task, and even kanbn_add_task_to_board by focusing specifically on untracked task files.

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 kanbn_add_task_to_board or kanbn_create_task. It doesn't mention prerequisites, conditions, or situations where another tool would be more appropriate. Usage context is left entirely to the agent to infer from the tool name and description.

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

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

There are no annotations, so the description carries the full burden of disclosing behavior. It only states 'Archive a task' without explaining whether the action is reversible, what state changes occur, or what side effects may affect the board. This is minimal behavioral disclosure without real transparency.

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

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

The description is a single short sentence with no unnecessary words, which is concise. However, it is under-specified rather than efficiently informative, so the structure does not earn high marks for quality.

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 no annotations and no output schema, the description leaves substantial gaps: it does not mention reversibility, side effects, or prerequisites. Parameter coverage is complete, but the missing behavioral context makes the tool hard to invoke safely and confidently.

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

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

Schema description coverage is 100%: both 'path' and 'taskId' have descriptions in the input schema. The description itself adds no parameter-level meaning, but the baseline of 3 applies because the schema already documents the parameters adequately.

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 'Archive' and names the resource 'a task on the Kanbn board,' so the core action is clear. However, it does not distinguish itself from siblings like kanbn_delete_task or kanbn_unarchive_task beyond the action itself.

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

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

No guidance is given on when to use this tool versus alternatives such as kanbn_delete_task, kanbn_move_task, or kanbn_unarchive_task. The description provides no prerequisites or exclusions, so usage must be inferred entirely from the tool 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. It only restates the tool name and implies a read-only check via the word 'check,' but it does not disclose return type, error behavior, path handling, 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, front-loaded sentence with no wasted words. It is concise and easy to parse, though it is minimal and adds little beyond the tool name.

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

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

For a simple existence check with full schema coverage, the description is adequate but not complete. There is no output schema or annotations, so return semantics and behavior are left to inference; the tool is callable but not fully self-explanatory.

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

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

Schema description coverage is 100%, so both 'path' and 'slug' are already documented. The description adds no additional meaning beyond what the input schema provides, which is the baseline expectation.

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

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

The description clearly states a specific verb and resource: 'Check whether a board exists.' This is distinct from create, delete, and list board tools, though it does not explicitly differentiate itself from similar validation or ensure-type siblings like kanbn_validate_board or kanbn_ensure_board.

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

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

There is no guidance on when to use this tool versus alternatives. It does not mention kanbn_validate_board, kanbn_ensure_board, kanbn_list_boards, or any other sibling, and it provides no conditions, exclusions, or prerequisites.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. The verb 'Get' implies a read-only operation, which is the only behavioral signal; the description does not disclose what statistics are included (e.g., whether archived tasks or column breakdowns are counted), what the return value looks like, or what happens on an invalid path. It adds little beyond the tool name.

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

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

The description is a single, front-loaded sentence with zero filler. Every word adds meaning, and the length is appropriate for a tool with one optional 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?

With no output schema and no annotations, the description is the only source of behavioral context, and one sentence leaves real gaps: what exactly the 'per-board task statistics' consist of and what shape the result takes. However, with a single optional path parameter and a clear reporting purpose, the tool is simple enough that the description is minimally adequate.

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

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

The single parameter `path` has full schema description coverage ('Path to the project root directory'), so the schema already documents it completely. The description adds no parameter-level detail, so the baseline 3 applies.

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

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

The description states a specific verb ('Get') and a concrete resource ('a summary with per-board task statistics'), making the tool's reporting nature clear. It is a complete sentence with a defined scope, but it does not differentiate from sibling reporting tools like kanbn_burndown or kanbn_list_boards, so an agent must infer why this one exists.

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

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

There is no guidance on when to use this tool versus alternatives. The description is a single declarative sentence with no when-to-use context, no prerequisites, and no exclusions, leaving the agent to infer the tool's role purely from its name and one-line description.

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 data is returned as an object; it does not disclose whether this is a safe read operation, how dates/sprints are normalized, what defaults apply, or whether the tool can fail or mutate anything.

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

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

The description is a single front-loaded sentence with no wasted words. It is efficient, though it is so terse that it sacrifices useful context.

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

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

With six optional parameters, no output schema, and many sibling tools, the description is incomplete. It does not explain what the returned burndown object contains, how the parameters interact, what defaults exist, or 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?

Schema description coverage is 100%, so the parameters are already documented in the schema. The description adds no additional meaning beyond the schema, but the baseline 3 is appropriate because the schema fully covers each parameter's purpose.

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

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

The description uses a specific verb ('Get') and a specific resource ('burndown chart data'), and states the return shape ('as an object'). This clearly distinguishes it from sibling tools such as kanbn_status or kanbn_search, none of which mention burndown data.

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

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

The description gives no guidance on when to use this tool versus alternatives, no context about sprints or board state, and no exclusions. An agent must infer usage solely from the tool name and the generic verb 'get'.

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 wording implies a non-destructive scan because it says 'collect' and 'in use across task files,' which is useful behavioral context. However, with no annotations, the description does not explicitly confirm that no files are modified, how task files are discovered, or how failures are handled, so the burden is only partially met.

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

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

The description is one concise sentence with no filler, and the core behavior is front-loaded. Every element earns its place.

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

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

The tool is simple and the path parameter is covered by the schema, but with no output schema or annotations the description should say more about what the returned value looks like and what happens when path is omitted. It is adequate for basic invocation but leaves some operational ambiguity.

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

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

The schema already documents the 'path' parameter with 100% coverage, so the baseline applies. The description mentions 'task files' but does not add detail about the path's default, format, or relation to the project root beyond what the schema already provides.

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

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

The description states a specific verb ('Collect') and resource ('distinct assigned/author value in use across task files'), making the action clear. It does not explicitly differentiate itself from sibling tools like kanbn_get_contributors or kanbn_find_contributor, 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?

No sentence explains when to use this tool instead of kanbn_get_contributors, kanbn_find_contributor, or kanbn_contributor_usage. The intended use case must be inferred entirely from the tool name and one-line description.

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

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

With no annotations provided, the description must disclose side effects on its own. It only says 'Add a comment to a task,' which implies a write operation but does not state whether comments are appended, whether existing comments are affected, what permissions are needed, or whether the operation is reversible. This is a significant gap for a mutation tool.

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

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

The description is a single, clear sentence with no redundant words or filler. It is front-loaded with the action and resource, making it easy to scan, though it is extremely concise.

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

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

Given the absence of annotations and output schema, the description should provide more context about the tool's behavior, such as whether the task must already exist and what the tool returns. It is too sparse to be considered complete for a mutating tool, though the schema covers parameters.

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?

All four parameters have descriptions in the input schema (100% coverage), so the baseline is 3. The description adds no parameter-specific information beyond the schema, which is acceptable given the high schema coverage.

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

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

States a specific verb and resource: 'Add a comment to a task.' This clearly distinguishes it from other task-related tools like kanbn_edit_task or kanbn_move_task, and no sibling handles comments, so the purpose is unambiguous.

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

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

The description provides no explicit guidance on when to use this tool versus alternatives such as kanbn_edit_task. It implies usage when a comment needs to be added, but it does not mention prerequisites like the task existing or any exclusions.

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

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

No annotations are provided, so the description carries the full burden of disclosing behavior. It conveys that the tool produces a usage report and covers spelling variants and unknown values, but it does not state whether the operation is read-only, what data is examined, how the report is returned, or whether any project setup 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?

The description is one concise, front-loaded sentence without unnecessary words. It communicates the core action and distinctive coverage efficiently.

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

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

For a reporting tool with only one optional parameter, the description plus schema is minimally sufficient to attempt a call. However, with no output schema or annotations, the agent is left without details about the report's structure or return format, and it is unclear whether path is needed for workspace resolution.

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

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

Schema description coverage is 100% for the single 'path' parameter, so the schema already documents its meaning. The description adds no extra context about how path should be supplied or what happens when it is omitted, so it meets the baseline without adding value.

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

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

The description states a clear action ('Report') on a specific resource ('how the workspace's contributors are used') and adds useful scope ('including spelling variants and unknown values'). It does not explicitly differentiate itself from sibling contributor tools such as kanbn_get_contributors or kanbn_find_contributor, so it stops short of full distinctiveness.

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 contributor usage report with attention to spelling variants and unknown values is needed. However, it provides no explicit when-not guidance or alternatives, and the large sibling set includes several contributor-related tools, so the agent must infer the correct selection.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. The verb 'Find' weakly implies a read-only operation, but the description does not explicitly state that it makes no modifications, does not explain how 'known contributor' is determined, and does not mention any configuration or data dependencies. For an unannotated tool this is a meaningful gap.

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

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

A single sentence with zero filler, front-loaded with the action ('Find tasks') followed by the precise condition. Every word earns its place; nothing is redundant or missing from a conciseness standpoint.

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 query tool, the description adequately conveys the core purpose, and the schema covers the input. However, with no output schema and no annotations, the description fails to disclose the return shape (tasks? warnings? counts?) or what defines a 'known contributor', leaving an agent to guess at the result format.

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

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

Schema description coverage is 100% — the single 'path' parameter is already documented as 'Path to the project root directory'. The description adds nothing about the parameter, but the schema fully handles it, so the baseline of 3 is appropriate.

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

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

The description states a specific verb and resource — 'Find tasks' — and gives the precise filter condition: assigned user or comment author is not a known contributor. This is clear and specific enough to convey what the tool does, though it does not explicitly name or distinguish itself from siblings like kanbn_get_contributors, kanbn_find_contributor, or kanbn_contributor_usage.

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 such as kanbn_contributor_usage, kanbn_get_contributors, or kanbn_find_contributor, nor any exclusions or prerequisites (e.g., whether a contributor list must first be configured). Usage is only implied: it appears to be a diagnostic/audit operation.

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

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

No annotations are provided, so the description carries the full behavioral disclosure burden. It only says 'create,' which implies mutation, but it does not disclose side effects, whether the tool is idempotent, what happens if the slug already exists, where files are written, or what the return value is. This is a significant gap for a creation operation.

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

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

The description is a single, front-loaded sentence with no filler words or redundant detail. It is concise, though it may be too terse to fully support correct invocation given the tool's complexity and number of siblings.

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, a nested options object, no output schema, no annotations, and many similar board-related sibling tools, a one-sentence description is not enough. The description omits behavioral details, prerequisites, failure modes, and guidance on how this relates to the board lifecycle, making it incomplete for reliable autonomous use.

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

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

Schema description coverage is 100%, with each parameter having a basic description in the input schema. The tool description adds no additional parameter semantics beyond labeling the board as 'secondary.' The schema itself already provides the necessary parameter-level meaning, so a baseline score of 3 is appropriate.

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

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

The description states a specific verb and resource: 'Create a new secondary board.' The word 'secondary' gives some differentiation from primary-board initialization tools, though it does not explicitly name or contrast sibling tools. It is clear enough for an agent to know what operation is intended.

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 closely related siblings such as kanbn_init_board, kanbn_initialize_board, or kanbn_ensure_board. The word 'secondary' implies it is for non-primary boards, but no explicit when-to-use or when-not-to-use conditions are provided.

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

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

With no annotations provided, the description carries the full behavioral burden. It discloses that this creates a task (a mutating operation), but gives no detail on side effects, return values, board path requirements, or validation behavior. It does not contradict any annotations since none exist, but a creation tool with zero annotation coverage should disclose more than this.

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 zero filler, front-loading the primary purpose before the requirement note. Efficient and scannable. It loses a point only because the brevity approaches under-specification given the tool's 9 parameters.

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

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

For a tool with 9 parameters, nested objects (comments, subTasks, relations), no output schema, and a complex sibling set, this description is thin. It omits return value expectations, behavior on missing board, and the destructive relations-replacement caveat (which only lives in the schema, not the description). The rich schema carries most of the load, but the description leaves an agent without key execution context.

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

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

Schema description coverage is 78%, just below the high threshold, so the description should compensate somewhat. It adds nothing about parameters beyond restating that 'name' is required — information already present in the schema's 'required' array. No new meaning is added for path, column, relations, or nested objects.

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+resource ('Create a new task on the Kanbn board') that clearly distinguishes creation from the edit/delete/archive siblings. It correctly identifies the required field. However, it doesn't differentiate itself from adjacent creation-ish tools like kanbn_add_untracked_task or kanbn_add_task_to_board, which could confuse an agent deciding between creation pathways.

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

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

The description states the required field and that all others are optional, giving some usage context. But it offers no explicit when-to-use vs. alternatives — no guidance to prefer kanbn_edit_task for modifications or kanbn_add_untracked_task for untracked tasks. Usage is implied by the name rather than stated.

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

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

With no annotations, the description carries the behavioral transparency burden. The verb 'Find' reasonably signals a non-mutating read operation)Skip; the criterion is stated. But it doesn't disclose return format, whether results are limited only to cross-board tasks by default when allTasks is false, or any behavior around uninitialized/empty boards.

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

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

A single, focused sentence with no filler. The action is front-loaded and the filtering criterion is immediately clear. This is appropriately concise for a simple lookup tool.

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

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

For a low-complexity tool with fully documented optional parameters nominated, the description covers the core behavior sufficiently. The main gap is that there is no output schema and no mention of what the returned task data looks like, but the phrase 'Find tasks' gives a reasonable expectation of a list of tasks.

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

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

Schema description coverage is 100%, so both parameters are already documented. The description adds no param-specific meaning beyond the schema's own text, making the baseline score of 3 appropriate.

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

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

The description clearly identifies the action ('Find') and the resource/target ('tasks') along with a precise criterion ('appear on more than one board'). This gives an agent a concrete understanding of what the tool does. However, it doesn't distinguish it from similar sibling tools like kanbn_tasks_on_other_boards or kanbn_find_task_boards, so some differentiation is left to the tool name.

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

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

The wording implies the usage scenario: use this when you need to identify tasks shared across multiple boards. However, it provides no explicit guidance about when NOT to use it or which sibling tool to prefer, such as kanbn_find_orphaned_tasks or kanbn_tasks_on_other_boards.

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 explaining behavior. It discloses the resolution algorithm and precedence, which is valuable behavioral detail. It does not describe the return format or what happens if no user can be resolved, but the core resolution behavior is transparent.

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

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

The description is a single, well-structured sentence that front-loads the action and parenthetically provides the key resolution detail. No redundant words or repetition of schema content.

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

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

For a simple one-parameter tool this is mostly sufficient, but the phrase 'when contributors are declared' is ambiguous and the return value is not described. There is no output schema to fill that gap, so the description could be slightly more explicit.

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

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

The schema already fully documents the only parameter, 'path', as the project root directory. The description adds no additional parameter meaning, so the baseline of 3 applies given 100% schema coverage.

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

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

The description clearly identifies the tool's purpose: resolving the current user with a specific precedence order (KANBN_USER, then git email/name). It is concise and distinct from sibling tools like kanbn_get_contributors, though it does not explicitly contrast itself 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?

The description provides no guidance on when to use this tool versus alternatives such as kanbn_get_contributors or kanbn_find_contributor. The condition 'when contributors are declared' hints at context but does not clarify when this tool is preferred over sibling tools.

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

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

No annotations are provided, so the description must carry the behavioral transparency burden. It clearly indicates destructive scope by saying 'entire ... directory,' but it does not mention irreversibility, side effects on associated files/tasks, or error behavior when the path 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, front-loaded sentence with no wasted words. It directly communicates the action and the target resource.

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

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

For a simple one-parameter tool, the description plus schema are adequate for basic invocation. However, because this is a destructive operation with no output schema and no annotations, the description omits useful context about expected return behavior, irreversibility, and failure conditions.

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

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

The input schema already documents the only parameter, path, with 100% coverage and a clear description. The tool description adds no new parameter semantics beyond restating that the path refers to a board directory, 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 uses a specific verb and resource: 'Delete an entire Kanbn board directory.' It clearly distinguishes from sibling tools like kanbn_delete_board_file and kanbn_delete_task by emphasizing the whole directory, not a file or task.

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

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

The phrase 'entire Kanbn board directory' implies the tool is for whole-board deletion, but there is no explicit guidance about when to prefer it over alternatives such as kanbn_delete_board_file or kanbn_delete_task, and no exclusions are stated.

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

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

With no annotations, the description itself conveys that this is destructive and reveals the return value ('orphaned task IDs'). However, it does not disclose whether the deletion is permanent, what happens to the orphaned tasks, or any required permissions, so there are still 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?

A single, front-loaded sentence with no filler. The delete target and the return value are stated compactly.

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 delete tool with no annotations and no output schema, the description provides the essential outcome but omits usage context, effect on tasks, and any caveats about the operation. It is adequate but not complete.

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

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

Schema description coverage is 100%, so the schema already explains 'slug' and 'path.' The description's terms 'secondary' and 'orphaned task IDs' add context but no parameter-level details beyond the schema.

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

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

The description names a specific action ('Delete') and a specific resource ('secondary board file'), and adds the distinguishing outcome 'returning orphaned task IDs.' It is clear what the tool does, though it does not explicitly state how it differs from the sibling kanbn_delete_board.

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

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

No when-to-use guidance or alternatives are provided. The phrase 'secondary board file' implies a scope but the description never says when to choose this over kanbn_delete_board or kanbn_find_orphaned_tasks.

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

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

With no annotations, the description must carry the full behavioral burden. 'Remove' implies a destructive mutation, but it does not disclose whether deletion is permanent, affects associated data, or requires a specific board state. No preconditions, side effects, or reversibility information is 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?

The description is a single sentence that front-loads the action and object with no filler. It is concise and to the point, though it sacrifices useful details that are scored elsewhere.

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 sits in a large sibling set with several overlapping actions (delete_task, archive_task, remove_all), and the description does not explain what a 'simple task' is or how this removal differs from those alternatives. With no output schema and no annotations, the agent lacks critical context for correct selection and invocation.

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

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

Schema description coverage is 100%, so the schema already documents 'path' and 'input' with clear meanings. The description adds no further semantic detail beyond the phrase 'simple task', which is not explained in relation to the 'input' parameter. 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 ('Remove') and resource ('simple task') with a location ('from the board'), clearly identifying the action. However, it does not differentiate from sibling tools like kanbn_delete_task or kanbn_archive_task, and 'remove' is a synonym for the name's 'delete', providing no new distinction.

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

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

There is no guidance on when to use this tool over alternatives. The description does not mention kanbn_delete_task, kanbn_archive_task, or any criteria that select for 'simple' tasks, leaving the agent to infer the usage context 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 provided, the description carries the full burden of behavioral disclosure, and it only says 'Delete', implying a permanent destructive action without confirming it. It does not state whether deletion is irreversible, whether the task file is removed from disk, whether the force parameter bypasses a confirmation prompt, or how deletion differs from archiving.

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 single sentence is efficient and front-loaded with the action and resource, with zero wasted words. However, it is so terse that it sacrifices valuable context about permanence and alternatives that could have been added in one or two extra clauses.

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 and no output schema, the description is incomplete. An agent cannot tell whether deletion is recoverable, when force is required, or how this differs from archive/restore flows — information critical to avoiding irreversible data loss in a Kanban board tool.

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

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

Schema description coverage is 100%, so the schema already fully documents path, force, and taskId including meaningful descriptions such as 'Force deletion without confirmation'. The description adds no additional parameter context, so the baseline 3 is appropriate.

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

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

The description states a specific verb and resource ('Delete a task from the Kanbn board'), making the core action unambiguous. However, it does not distinguish from the sibling tool kanbn_delete_simple_task, which performs a similar deletion on simple tasks, nor from kanbn_archive_task, which could be a safer alternative for the same resource.

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 choose this tool over alternatives such as kanbn_archive_task (non-destructive removal), kanbn_delete_simple_task, or kanbn_remove_all. There is no mention of prerequisites like the board needing to be initialized or the task file needing to exist.

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 only says 'Edit an existing task' without disclosing behaviors like partial updates, error handling if the task doesn't exist, or whether fields are overwritten. The relations parameter warning does disclose that the whole relations collection is replaced, which is a positive signal, but the overall tool description lacks behavioral depth.

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

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

The description is a single, concise sentence that front-loads the purpose. No filler or redundancy. It earns its place.

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

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

For a tool with 15 parameters and no output schema, the one-line description is insufficient. It doesn't explain the update model (partial vs full), required preconditions (e.g., valid board path), or what happens on success/failure. The relations warning is helpful but only covers one parameter. The description lacks the context an agent needs to call it correctly.

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

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

Schema description coverage is high (87%), so the baseline is 3. The tool description adds no additional parameter meaning beyond what the schema provides. The relations parameter's description includes a warning about replacement, but that is part of the schema, not the tool description. Thus the description contributes nothing extra.

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

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

The description clearly states the tool's purpose: to edit an existing task on the Kanbn board. It distinguishes from creation (kanbn_create_task), deletion (kanbn_delete_task), and other specific operations like rename or move, making it the general editing tool. The verb 'edit' and resource 'task' are specific.

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

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

The main description offers no explicit guidance on when to use this tool versus the many specific task-modification tools such as kanbn_rename_task, kanbn_move_task, or kanbn_comment. However, the 'relations' parameter includes a warning that suggests using kanbn_add_relation/kanbn_remove_relation for merging relations, providing a small usage hint. Overall, the description lacks a clear when-to-use statement.

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 adds a useful implementation detail about board detection methods (initialised, initialized, isInitialized, isInitialised) and implies idempotency ('if absent'). However, it does not state what happens if the board already exists (no-op vs error), whether it modifies existing boards, or what the return value is. These gaps are notable for a tool without 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 sentence with no filler. The main action is front-loaded, and the parenthetical detail about detection methods is relevant and compact. Every part contributes to understanding the tool.

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

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

Given no output schema and no annotations, the description should clarify what the tool returns or how it behaves on an existing board. It gives enough to invoke it, but the lack of a specified return value and explicit 'already exists' behavior leaves an agent guessing about the outcome. For a setup-style tool, this is a moderate gap.

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

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

Schema description coverage is 100%, so the three parameters (name, path, columns) are already documented. The description adds no additional meaning about parameters—it focuses on the tool's behavior rather than clarifying how name, path, or columns affect initialization. Baseline 3 is appropriate.

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

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

The description clearly states a specific verb and resource: 'Ensure a Kanbn board exists, initializing one if absent.' It conveys the idempotent ensure behavior, distinguishing it from plain creation or existence checks, though it does not explicitly name 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 description gives clear context: use this when you need a board to exist, with initialization if missing. This implies a setup/ensure workflow, but it does not explicitly contrast with alternatives like kanbn_create_board, kanbn_init_board, or kanbn_board_exists, nor does it mention any exclusions or prerequisites.

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

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

With no annotations, the description carries the full burden of behavioral disclosure. 'Get' implies a read-only operation, but it does not confirm side effects, error conditions, or output structure. The agent is left unaware of what constitutes 'potential issues' or what the response format looks like.

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 brief, but it is under-specified rather than appropriately concise. It lacks essential operational details and does not front-load any distinguishing or warning information, falling short of what an agent needs.

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

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

For a tool with one parameter and no output schema, the description is incomplete. It fails to explain what 'action rules' refers to, what kinds of issues are reported, or how results are returned. Without annotations or output schema, the agent lacks critical context to interpret the tool's behavior.

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

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

The single parameter 'path' is described in the schema as 'Path to the project root directory' with 100% coverage, so the schema already handles its semantics. The tool description adds no additional meaning beyond what the schema provides, meeting the baseline for high coverage.

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

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

The description clearly states the verb 'Get' and the resource 'potential issues with the board's action rules', which conveys the tool's primary purpose. It distinguishes it from sibling tools like kanbn_get_action_rules by focusing on issues rather than the rules themselves, though it could be more explicit about the distinction.

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

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

No guidance is provided on when to use this tool versus alternatives. There is no mention of context, prerequisites, or exclusions, leaving the agent to infer usage solely from the tool name and one-line description.

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

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

With no annotations, the description carries the behavioral burden and does disclose the core lookup behavior: matching against name, display name, or aliases. However, it omits details such as exact versus partial matching, behavior when no contributor or multiple contributors match, and the output shape, leaving the behavior only minimally transparent.

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

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

The description is a single front-loaded sentence with no filler, which is appropriately compact for a simple lookup tool. It is not a 5 because the same brevity contributes to the missing behavioral and usage detail addressed in other dimensions.

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

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

For a two-parameter tool with no output schema and no annotations, the description covers the input semantics but does not clarify what is returned or how ambiguous/no-match cases are handled. It is minimally viable for a simple lookup but not fully complete.

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

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

Schema coverage is 100%, so the baseline is 3, but the description adds real semantic value for the 'value' parameter by explaining that it is matched against name, display name, or aliases. The 'path' parameter is left to the schema, which already describes it adequately.

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 ('Find the contributor a value refers to') and adds matching criteria (name, display name, aliases), which makes the lookup purpose clear. It does not explicitly contrast with sibling tools like kanbn_get_contributors or kanbn_current_user, so some selection differentiation is left to inference.

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

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

There is no explicit guidance on when to use this tool versus alternatives, no exclusions, and no prerequisites. The only contextual hint is the phrase 'a value refers to', which implies a lookup scenario but does not tell the agent how to choose this over sibling contributor tools.

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

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

With no annotations, the description carries the behavioral disclosure burden. 'Find' implies a read-only operation and the return shape is disclosed, but the description does not explicitly confirm there are no side effects, how missing files are detected, or what happens when no files are missing. This is adequate but not rich.

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

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

The description is a single, front-loaded sentence with no filler. It communicates the action, the target resource, and the return format efficiently, with every word earning its place.

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

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

For a one-parameter diagnostic tool with no output schema, the description covers the core operation and return shape. However, given a large sibling set with similar task-inspection tools, it would benefit from clarifying what 'indexed tasks' means or how this differs from orphaned-task and simple-task finders.

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

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

The input schema already documents the single 'path' parameter as 'Path to the project root directory', so schema coverage is 100%. The description adds no additional parameter-level context, making the baseline score of 3 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 ('Find'), a precise resource ('indexed tasks whose file is missing'), and the output shape ('{task, column} entries'). It clearly distinguishes this tool from generic task-finding siblings by focusing on missing files.

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 used when you need to locate tasks that have lost their associated files, but it does not explicitly state when to prefer this over related tools like find_orphaned_tasks, find_tracked_tasks, or task_file_exists. No alternatives or exclusions are given.

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

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

With no annotations provided, the description carries the behavioral burden. The verb 'Find' implies a read-only operation, and the parenthetical adds useful context, but the description does not explicitly confirm that no state is modified, what happens on invalid input, or what happens if no matching tasks are 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?

A single sentence that front-loads the action and resource, then adds the key consequence in a parenthetical. It is concise, focused, and contains no filler or redundant schema information.

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

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

The core query semantics are clear and the parameters are fully documented, but there is no output schema and the description does not state the return format, such as task IDs or references. For a simple lookup tool this is adequate but not fully complete.

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

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

Schema description coverage is 100%, with 'path' already described as the project root directory and 'slug' as the board slug. The tool description adds no additional parameter-level meaning, 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 precise verb and resource: find tasks that are only referenced by a single board, and adds the consequence that they would be orphaned if that board were deleted. This makes the tool's purpose unambiguous and distinguishes it from related board-relationship 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 parenthetical '(would orphan on its deletion)' implies the tool should be used when assessing the impact of deleting a board. However, it does not explicitly state when to prefer this over alternatives such as kanbn_cross_board_tasks or kanbn_tasks_on_other_boards, nor does it mention any exclusions.

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

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

No annotations are provided, so the description carries the behavioral burden. It does disclose meaningful scoping behavior: only non-file column lines are considered, and omitting input means board-wide search. However, it does not explicitly state that the operation is read-only, nor does it describe the return shape, which leaves some ambiguity.

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

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

A single sentence that front-loads the action and target, defines the domain in parentheses, and states the alternative invocation mode. There is no filler or redundant restatement; every clause contributes to agent comprehension.

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

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

For a low-complexity discovery tool with two optional, fully documented parameters, the description is largely complete and directly actionable. The main gap is the absence of return-format information, which is more relevant because there is no output schema, but the core invocation semantics are clear.

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

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

Schema description coverage is 100%, so the schema already documents 'path' as the project root and 'input' as the title or omission trigger. The description reinforces those behaviors but adds no additional matching syntax, path expectations, or edge-case guidance beyond the schema.

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

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

The description states a specific verb ('Find'), a specific resource ('simple tasks'), clarifies the resource type ('non-file column lines'), and defines the two operational modes: by title or all on the board. This makes it clearly distinguishable from sibling tools like kanbn_get_simple_task or kanbn_get_task.

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

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

The description gives clear usage context: provide a title to match, or omit it to list all simple tasks on the board. It does not explicitly name alternatives or exclusions, but the two-mode behavior is enough for an agent to know when this tool applies.

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. 'Find' implies a read-only operation, but the description does not mention return format, scope (e.g., across all boards), or any edge cases. This is a minimal, non-contradictory but under-informative description.

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

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

A single sentence conveys the exact purpose with no filler or redundancy. It is appropriately front-loaded and every word earns its place.

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

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

For a simple lookup tool with fully described parameters, the description is minimally adequate. However, without an output schema or annotations, it omits any detail about what the returned data looks like or how the results are structured, leaving a moderate gap.

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

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

Schema description coverage is 100%, so both path and taskId are already documented. The description does not add parameter-level detail beyond what the schema provides, which is acceptable per the baseline for high coverage.

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

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

The description uses a specific verb ('Find') and resource ('boards and columns') with a clear object (a task), making the tool's function unambiguous. It does not explicitly compare itself to sibling tools, but its scope is distinct enough from related tools like kanbn_find_task_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?

No guidance is given about when to use this tool versus alternatives such as kanbn_find_task_column or kanbn_cross_board_tasks. The description merely states what it does without any context 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 behavioral disclosure burden. It usefully discloses that the tool throws if the task doesn't exist or isn't indexed, which is important failure context. However, it does not describe the return format or explicitly confirm non-mutating behavior.

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

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

The description is a single compact sentence with no wasted words. The core action is front-loaded and the failure condition follows efficiently.

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

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

For a simple two-parameter lookup tool, the description covers the main behavior and key error conditions. The lack of an output schema means a return-value shape would be helpful, but 'find the column a task is in' sufficiently indicates the result. Minor gap: it doesn't specify what form the column identifier takes.

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

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

Schema description coverage is 100%, with both 'path' and 'taskId' already described in the input schema. The description adds no parameter-level detail, but the schema already handles that responsibility, so the baseline score 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?

Description states a specific verb ('Find') and resource ('the column a task is in'), and adds error behavior by mentioning throws. It doesn't explicitly contrast with closely related siblings like kanbn_find_task_boards, so differentiation relies partly on the tool name.

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

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

The intended use is implied by the purpose statement, but there is no explicit when-to-use guidance or alternative recommendations. An agent must infer when to prefer this over similar lookup tools such as kanbn_find_task_boards or kanbn_get_task.

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

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

With no annotations provided, the description must fully disclose behavioral traits. It only says it lists task IDs and optionally filters by column; it does not mention read-only behavior, whether it searches all boards, path handling, or what happens when no column is given. The minimal information leaves the agent guessing about important 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?

A single, front-loaded sentence with no filler. It immediately states the action and the only optional modifier, earning every word. No structural improvements are needed.

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

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

The tool has no output schema and many conceptually similar siblings, so the description needs to clarify what counts as a 'tracked task', the scope of listing, and the shape/format of returned IDs. It does none of that, making the definition incomplete for reliable 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 coverage is 100%, so the baseline is 3. The description adds meaning for columnName by explaining it is a filter, but path is not elaborated beyond the schema's 'Path to the project root directory'. The description does not introduce any behavior not already implied by the schema.

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

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

The description states a clear verb ('List') and resource ('tracked task IDs') with an optional filter ('by column'). It distinguishes the tool from siblings like kanbn_find_untracked_tasks and kanbn_find_simple_tasks by the 'tracked' qualifier, though it does not explicitly name those alternatives.

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

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

No guidance is given about when to use this tool versus the many similar find/list tools among the siblings. There is no mention of alternatives, exclusions, or conditions that would help an agent decide between this and kanbn_search, kanbn_find_task_column, or kanbn_find_orphaned_tasks.

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

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

With no annotations provided, the description carries the burden of conveying safety and behavior. 'List' implies a read-only operation, and 'not in the index' specifies the selection criteria. However, it does not clarify what 'the index' refers to, what the output shape is, or how the optional path parameter affects results.

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

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

The description is a single, front-loaded sentence with no filler. Every word contributes to defining the operation and its selection criterion, making it easy to parse quickly.

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

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

For a simple list operation with one optional parameter, the description is mostly adequate, but it leaves the meaning of 'index' implicit and does not state what the returned task file list looks like. The lack of annotations and output schema means a bit more context would help, though this is not a complex tool.

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

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

The single parameter 'path' has a schema description ('Path to the project root directory'), so schema coverage is 100%. The tool description adds no extra semantic detail about how the path is used or whether it is required, so the baseline score of 3 is appropriate.

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

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

The description uses a specific verb ('List') and a specific resource ('task files that aren't in the index'), so an agent can tell this is a discovery/read operation. It is reasonably distinct from sibling tools like kanbn_find_tracked_tasks, though it does not explicitly name the alternative. The term 'index' is slightly ambiguous, preventing 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?

No guidance is provided about when to use this tool versus related tools such as kanbn_find_tracked_tasks, kanbn_find_missing_task_files, or kanbn_find_orphaned_tasks. The description only states what it does, not when it is the right choice.

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

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

No annotations are provided, so the description must carry behavioral disclosure. It implies a read operation but does not state side effects, what 'resolved' means, prerequisites, or failure behavior. This is a meaningful gap for a tool with zero annotation coverage.

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

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

A single, front-loaded sentence with no filler or redundancy. It is appropriately brief for a simple getter, though it could have used the spare sentence to add usage context.

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

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

For a one-parameter getter with no output schema, naming the returned object ('resolved action rules') is minimally viable. However, the description does not explain what 'resolved' involves or how the result differs from related config/validation tools, leaving some ambiguity.

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

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

The schema fully documents the single 'path' parameter with a clear meaning, so the description does not need to add much. It adds no additional parameter context, but none is required beyond schema coverage.

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

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

The description uses a specific verb 'Get' and a concrete resource 'resolved action rules for the board,' so an agent can tell it returns resolved rules. It does not explicitly differentiate from related tools like kanbn_get_config or kanbn_find_action_warnings, but the name and phrasing are clear.

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

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

The description provides no guidance on when to choose this tool over siblings such as kanbn_get_config, kanbn_find_action_warnings, or kanbn_validate_board. Usage context is only implied by the tool name, not stated.

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

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

With no annotations provided, the description carries the full behavioral burden, and it does disclose meaningful behavior: it returns null when no separate config file exists. This is genuinely useful for an agent deciding whether the config is present. It doesn't mention side effects, but for a get operation the main ambiguity (the null case) is covered.

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

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

A single efficient sentence that front-loads the core function and packs in the behavioral null clause without waste. It earns every word, though it could have added a phrase about the optional path parameter without much cost.

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

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

For a low-complexity tool with one optional parameter and no output schema, the description covers the essential ambiguity (null return) well. The sibling kanbn_save_config hints at a read/write pair but the description still stands on its own. Nothing critical an agent needs to call it correctly appears to be missing.

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

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

Schema description coverage is 100%, so the 'path' parameter is already fully documented in the schema. The description adds no additional parameter meaning, which keeps it at the baseline of 3 since the schema does the heavy lifting.

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

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

The description uses a specific verb (Get) with a clear resource (Kanbn config) and adds the distinguishing null-return behavior. This effectively differentiates it from siblings like kanbn_save_config and kanbn_get_action_rules, so an agent can identify its purpose 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 description conveys what to expect (the config or null when no file exists) but offers no explicit when-to-use guidance versus the sibling kanbn_save_config or other config-related tools. It is the sibling kanbn_save_config that the agent might confuse it with; a short note about it being the read counterpart would help. The null-return clause gives some contextual signal about when a config file is absent.

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

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

With no annotations provided, the description carries the burden of behavioral disclosure. 'Get' implies a read operation, and 'normalised to the object form' reveals output transformation, but it does not mention default behavior when the optional path is omitted, error conditions, or what 'object form' contains.

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

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

The description is a single, tight sentence that front-loads the core action and adds the normalization detail without redundancy. Every word contributes meaning.

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

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

For a simple read tool with one optional parameter, the description is minimally sufficient, but it lacks an explanation of what 'object form' means and does not describe the returned contributor data. With no output schema and no annotations, slightly more context would make it complete.

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

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

Schema description coverage is 100%, so the single 'path' parameter is already documented as 'Path to the project root directory.' The description adds no semantic detail beyond that, so the baseline score applies.

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

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

The description clearly identifies the verb ('Get') and resource ('the workspace's contributors'), and adds that results are 'normalised to the object form.' It does not explicitly contrast with sibling tools like kanbn_find_contributor or kanbn_collect_contributor_values, so it stops just short of full differentiation.

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

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

No guidance is given about when to use this tool versus alternatives. The sibling list contains several contributor-related tools, but the description provides no conditions, exclusions, or pointers to them.

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. 'Get' implies a read operation, but the description does not say whether the tool is purely read-only, whether the board must already exist, or what happens if no date format is configured.

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

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

The description is a single concise sentence with no filler or repetition. Every word contributes to the meaning, and the core action is front-loaded.

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

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

For a simple one-parameter tool with no output schema, the description is mostly adequate. However, it does not clarify how the board is located when path is absent, whether the returned string is a formatting pattern or a resolved value, or any error behavior. These are minor gaps for a getter but still leave some ambiguity.

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

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

The schema already describes the only parameter, 'path', with 100% coverage. The tool description adds no extra meaning about how the path is used, whether it is optional in practice, or how it relates to locating the board beyond what the schema provides.

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

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

The description clearly states a specific verb ('Get') and a specific resource ('the board's date format string'), making the tool's purpose unambiguous. It is easy to distinguish from sibling tools because no other sibling targets the date format, but it does not add any additional context or scope qualifiers.

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 such as kanbn_get_config or kanbn_get_workspace_options. The description implies use when the date format string is needed, but it does not state conditions, 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 does disclose a key behavior: the tool throws if the task cannot be resolved, and it guarantees exactly one result. However, it does not disclose what 'resolve' means (exact match? case-insensitive? partial?), whether the task must be on a specific board, or what the return value looks like. The 'or throw' disclosure is valuable but incomplete for a tool with zero annotation coverage.

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 packed sentence that front-loads the core behavior ('Resolve exactly one simple task by title') and immediately states the failure mode ('or throw'). Every word earns its place, and there is no redundant filler or repetition of schema information.

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

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

For a simple lookup tool with only two parameters and no output schema, the description is mostly adequate. However, the lack of annotations means the description should disclose more about the return value and matching semantics. The 'or throw' behavior is disclosed, but an agent cannot tell whether the result is a task object, a path, or a status message, nor whether the title match is exact or fuzzy. Given the tool's simplicity, this is a moderate gap rather than a severe one.

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

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

Schema description coverage is 100%, so the schema already documents both parameters ('Path to the project root directory' and 'Title to match'). The description adds the semantic constraint that the title must resolve to exactly one task, which is useful context beyond the schema. However, it doesn't add details like whether the title match is case-sensitive or whether the path is optional. Baseline 3 is appropriate since the schema does the heavy lifting and the description adds only marginal semantic value.

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

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

The description states a specific verb ('Resolve'), a resource ('exactly one simple task'), and a matching criterion ('by title'), which clearly distinguishes it from sibling tools like kanbn_get_task (which likely fetches by ID) and kanbn_find_simple_tasks (which likely returns multiple matches). The phrase 'or throw' adds a precise behavioral guarantee. It loses one point because it doesn't explicitly name the sibling alternative or elaborate on what 'simple task' means relative to other task types.

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

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

The description implies when to use this tool: when you need exactly one task by title and want an error if it doesn't resolve. However, it does not explicitly state when to prefer kanbn_find_simple_tasks (for multiple/partial matches) or kanbn_get_task (for ID-based lookup), nor does it mention any prerequisites like the board needing to be initialized. The usage context is clear enough for an agent to infer, but the guidance is not 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?

There are no annotations, so the description carries the full burden of behavioral disclosure. It only says 'Retrieve details' and does not mention what the returned details look like, behavior when a task is missing, whether the path parameter is needed, or any other operational nuance.

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 and immediately states the verb and object. It is appropriately concise, though slightly more contextual detail could have been added without reducing clarity.

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

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

The schema covers parameters fully, but the description omits output expectations and fails to distinguish this tool from several similar sibling tools. With no output schema or annotations, the description is too thin to fully orient an agent in this large tool family.

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

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

Schema description coverage is 100%, so both parameters are already documented clearly in the schema. The description adds no additional parameter-level meaning, so the baseline score of 3 is appropriate.

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

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

The description clearly states the action ('Retrieve details') and the resource ('a specific task from the Kanbn board'), so the basic purpose is unambiguous. However, it does not explicitly distinguish this tool from related siblings like kanbn_get_simple_task or kanbn_load_archived_task.

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

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

No guidance is given about when to use this tool instead of the many similar retrieval tools. With siblings such as kanbn_get_simple_task, kanbn_load_archived_task, and kanbn_find_simple_task present, the agent is left without selection criteria.

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

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

With no annotations provided, the description must carry behavioral disclosure. It simply says 'Get' without stating that it is a read-only operation or what happens if the board does not exist. It does not mention permissions, side effects, or error conditions, so agents have no behavioral expectations beyond the action word.

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, highly concise and front-loaded with the core action. There is no redundant phrasing or extraneous information, making it efficient for an agent to parse.

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

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

For a simple getter with one optional parameter, the description identifies what is retrieved (a string) but does not specify prerequisites (e.g., an initialized board) or error behavior. It also does not explain the significance of the template or when to use it, leaving some gaps for an agent.

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

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

The parameter 'path' is fully described in the schema (100% coverage) as 'Path to the project root directory'. The description adds no additional meaning about how the path is used or its defaults, so it does not compensate beyond the schema.

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

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

States exactly what it retrieves – the board's task template string. The verb 'Get' and resource are specific, and none of the sibling tools share this exact purpose, so an agent can distinguish it without opening other schemas.

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

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

No guidance on when to use this tool versus alternatives. The description does not mention when it should be invoked or any exclusions. While the name suggests it's for retrieving a template, there is no explicit context.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure, but it only states that the tool gets options. It does not clarify whether this is read-only, whether a workspace must already be initialized, what happens if the path is invalid, or what form the returned options take.

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

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

The description is a single, front-loaded sentence with no filler or redundant wording. It is appropriately brief for a simple getter, though the brevity does sacrifice some explanatory value.

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

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

This is a simple one-parameter tool, but the description is still incomplete for effective use. It does not explain what 'Kanbn options' means, what the return value contains, or how this tool relates to kanbn_get_config and similar siblings, making it hard for an agent to know when to select it.

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

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

Schema description coverage is 100% for the single 'path' parameter, which already explains that it points to the project root directory. The 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 uses a specific verb ('Get') and a specific resource ('workspace-scoped Kanbn options'), making the core action clear. However, it does not differentiate this tool from siblings like kanbn_get_config or kanbn_get_date_format, so the exact meaning of 'options' remains somewhat ambiguous.

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 the many related getter tools in the sibling list. The description provides no context, no exclusions, and no mention of alternatives, leaving the agent to infer usage from the name alone.

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

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

No annotations are provided, so the description must carry the full behavioral burden. It only says 'Initialize a new Kanbn board', implying mutation, but does not disclose side effects such as whether an existing board is overwritten, whether a directory must already exist, whether files are created, or what happens on failure. For a tool that creates a board, this is minimal behavioral transparency.

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

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

The description is a single, well-formed sentence that front-loads the action and object. There is no filler or redundant wording. It is appropriately sized for the tool's simplicity and adds no unnecessary detail.

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

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

For a mutation tool with no annotations and no output schema, the description is notably incomplete. It does not explain what 'initialize' entails (e.g., file creation, config setup), how it interacts with an existing board, whether the path is required to exist, or what the return value indicates. An agent would need to infer behavior from the schema and siblings, making this less than complete for safe invocation.

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

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

Schema description coverage is 100%, so the input schema already adequately describes all three parameters (name, path, columns). The description adds no additional parameter-level meaning, such as defaults, constraints, or relationships between parameters. Baseline 3 is appropriate since the schema does the heavy lifting and the description does not contradict or enhance it.

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

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

The description clearly states the verb 'Initialize' and the resource 'new Kanbn board' with a location ('target directory'). It is specific about the action, but it does not differentiate from close siblings like kanbn_initialize_board or kanbn_create_board, which likely serve similar purposes. The phrase 'new Kanbn board' helps slightly but does not explicitly distinguish from alternatives.

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

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

There is no guidance on when to use this tool versus alternatives such as kanbn_initialize_board, kanbn_ensure_board, or kanbn_create_board. The description does not mention prerequisites, exclusion conditions, or context that would help an agent choose this tool over others. It only states what the tool does, not when to invoke it.

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

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

No annotations are provided and the description reveals no behavior beyond the alias relationship. It does not mention whether initialization is destructive, idempotent, or creates or overwrites files, nor what side effects occur. The description therefore fails to disclose any behavioral traits.

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 short and front-loaded, but brevity here is under-specification rather than conciseness: a single alias pointer replaces all substantive content. It earns its place only as a cross-reference, not as a tool 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?

With no output schema, no annotations, and a one-line alias note, the description is incomplete for a tool that takes three parameters and may initialize files or board structure. It lacks the canonical definition of kanbn_init_board, behavior details, and expected result. An agent would have to guess at the operation's 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 coverage is 100%, with name, path, and columns each described in the input schema. The description itself adds nothing about parameter semantics, but because the structured schema carries that burden, the baseline of 3 applies.

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

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

The description only says 'Alias for kanbn_init_board,' which names a sibling tool but never states what initializing a board does, what resources it affects, or what effect it has. 'Initialize' and 'init_board' are essentially synonymous with the tool name, so the description borders on tautology. It does not stand alone as a 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?

There is no guidance on when to invoke this tool, when not to, or how it differs from kanbn_ensure_board or kanbn_create_board. The only instruction is that it is an alias for kanbn_init_board, which simply defers the decision without explaining the initiating conditions. An agent cannot decide between this and the many board-related 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 must carry the full burden of behavioral disclosure. It only states that the tool lists IDs, but does not disclose the format of the list (e.g., newline-separated, array), whether it includes tasks from all boards, or any side effects. This is a significant gap for a read operation.

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

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

The description is a single sentence with no redundant words. It is appropriately concise for a simple read 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 zero annotations and no output schema, the description is insufficiently complete. It does not explain the return format, potential errors, or ordering of results. For a list operation, an agent needs to know what it will receive to use the tool correctly.

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

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

Schema description coverage is 100%, so the single parameter 'path' is already described. The description does not add any context about how 'path' is used beyond what the schema provides, but with full schema coverage, a baseline of 3 is appropriate.

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

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

The description clearly states the tool lists IDs of archived tasks, which is a specific and distinct operation. It is easily differentiated from siblings like kanbn_archive_task and kanbn_unarchive_task, 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 implies it should be used when the agent needs to know which tasks are archived, but no explicit when-to-use or alternative guidance is provided. The sibling tool kanbn_load_archived_task suggests a related use case, but the description does not mention it.

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

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

No annotations are provided, so the description carries the burden of behavioral disclosure. The verb 'List' reasonably implies a read-only operation with no side effects, but the description does not explicitly state that, nor does it describe workspace resolution behavior, error cases, or return structure. The safety profile is inferable but not explicit.

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

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

The description is one concise sentence with no filler or redundant wording. It front-loads the action and resource immediately, and every word contributes to the tool's purpose.

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

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

For a simple list operation with one optional parameter, the description plus schema is arguably sufficient to invoke the tool. However, there is no output schema and no mention of what the returned board list contains or how the optional path affects the workspace. The description is minimally viable but not richly contextual.

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

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

Schema description coverage is 100%, so the single parameter 'path' is already documented as 'Path to the project root directory.' The description adds no additional parameter meaning, which is acceptable given the schema's clarity; the baseline of 3 applies because the schema handles the parameter semantics.

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

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

The description states a specific verb ('List') and resource ('all boards in the workspace'), making the tool's purpose immediately clear. It also distinguishes this from sibling board-related tools like kanbn_board_exists and kanbn_boards_summary by emphasizing enumeration of all boards rather than checking or summarizing.

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 such as kanbn_boards_summary, kanbn_board_exists, or kanbn_create_board. With over sixty sibling tools, the absence of any usage context or exclusions leaves the agent to infer selection from the name alone.

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

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

No annotations are provided, so the description carries the full burden. 'Load' suggests a read operation, but it does not clarify whether loading changes archive status, what data is returned, or whether any side effects occur. This ambiguity matters because sibling tools like kanbn_unarchive_task and kanbn_restore_task 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 short sentence with no filler and the action is front-loaded. It is concise and readable, though it borders on under-specification for such a simple tool.

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

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

The tool is low-complexity with two parameters and full schema coverage, so the basic invocation can be constructed. However, there is no output schema and the description does not describe return shape, side effects, or how this differs from unarchiving/restoring, leaving some important context 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 already documents both parameters completely with 100% coverage. The description adds no additional parameter semantics, so the schema carries the load and a baseline score of 3 is appropriate.

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

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

The description states a clear verb and resource: 'Load a task from the archive.' It distinguishes itself from siblings by specifying archived tasks, separating it from kanbn_get_task, but it does not explicitly contrast with kanbn_unarchive_task or kanbn_restore_task.

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

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

The phrase 'from the archive' implies the tool is for retrieving archived tasks, giving some usage context. However, it does not mention when not to use it or point to alternatives like kanbn_list_archived_tasks or kanbn_restore_task, so the guidance is only implicit.

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

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

No annotations are provided, so the description carries the full disclosure burden. It only says 'Move a simple task to another column' and gives no information about side effects, reversibility, permissions, or whether the operation mutates files or board state. As a mutating operation, this is a significant lack of behavioral transparency.

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

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

The description is a single, concise sentence with no filler and the action is front-loaded. It earns its place but is arguably too sparse to serve as complete guidance for a mutating tool with multiple sibling alternatives.

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 4-parameter mutation tool with no annotations and no output schema, the description is too thin. It does not define 'simple task', explain when to choose this over 'kanbn_move_task', or describe what the caller should expect after a successful move. The schema covers parameters, but the behavioral and selection context is 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 100%, so all four parameters are already documented in the input schema. The description adds little beyond restating the purpose; it does not explain the relationship between 'input', 'column', 'position', and 'path' beyond what the schema provides. Baseline 3 is appropriate because the schema handles the load.

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

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

The description states a specific action ('Move') and resource ('a simple task') with a clear destination ('another column'), which makes the core purpose understandable. It distinguishes from 'kanbn_move_simple_task_to_board' by specifying a column rather than a board, but it does not explicitly differentiate from the sibling 'kanbn_move_task' or clarify what counts as a 'simple task'.

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

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

The phrase 'simple task' weakly implies this tool is for simple tasks rather than regular tasks, giving some usage context. However, there is no explicit statement of when to use this tool versus 'kanbn_move_task', 'kanbn_move_simple_task_to_board', or other sibling tools. No prerequisites, exclusions, or alternative routing are provided.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure, but it only states the action itself. It does not reveal whether the task is removed from its source board, whether the target board must already exist, what happens on title conflicts, or how column/position defaults behave.

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

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

The description is a single front-loaded sentence with zero filler words, effectively conveying the core operation at a glance. It is slightly under-specified given the tool's complexity, but structurally it is clean and economical.

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

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

For a tool with no annotations, no output schema, and 5 parameters, a seven-word description is insufficient. It omits the disposition of the source task, board existence requirements, column/position semantics, and the simple-task concept that distinguishes it from kanbn_move_task and kanbn_move_simple_task.

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

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

Schema description coverage is 100%, so every parameter is already documented structurally, which sets the baseline at 3. The description adds no additional meaning beyond the schema, such as how 'input' matches a task title or what a board slug refers to.

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 ('Move'), a specific resource ('a simple task'), and a destination ('onto another board'), which aligns with the tool name and conveys the core operation. The phrase 'another board' partially differentiates it from kanbn_move_simple_task, though it does not clarify how it differs from kanbn_move_task or kanbn_add_task_to_board.

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

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

No guidance is given on when to use this tool versus the many relevant siblings (kanbn_move_task, kanbn_move_simple_task, kanbn_promote_simple_task, kanbn_add_task_to_board). There are no usage conditions, exclusions, or prerequisites stated, leaving the agent to infer the choice 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 states the basic mutation—moving an existing task to a different column—but does not mention validation behavior, error cases, whether the target column must already exist, or what happens if the task is already in the target column.

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

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

The description is a single efficient sentence that front-loads the action and object with no filler or redundant wording. Every word contributes to the core 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 tool is relatively simple, the schema is complete, and no output schema is expected, so the missing return-value detail is not a major gap. However, the description omits usage boundaries among the many sibling move-related tools and does not disclose failure behavior, leaving the definition minimally adequate rather than fully complete.

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

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

The schema describes all parameters with 100% coverage, so the description adds little beyond the structured information. The phrases 'existing task' and 'different column' slightly reinforce the parameter semantics, but the description does not explain formats, constraints, or relationships between parameters beyond what the schema already provides.

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

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

The description uses a clear verb and resource ('Move ... existing task') and names the destination ('a different column'), so an agent can understand the core purpose. However, it does not differentiate this tool from sibling move tools such as kanbn_move_simple_task or kanbn_move_simple_task_to_board, so it is not fully distinct.

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

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

No guidance is given about when to use this tool versus alternatives. There are no explicit conditions, exclusions, or references to sibling move tools, leaving the agent to infer the appropriate context 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 supplied, the description carries the full burden, but it only states the conversion without explaining side effects: whether the simple task is removed, whether a file is created or overwritten, or whether the action is reversible. This is insufficient for a mutating promotion 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, direct sentence with no filler. It states the core purpose immediately and 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?

There is no output schema and no annotations, while the description leaves important context unresolved: what counts as a simple task versus a real task file, where the task is created, and what happens to the original simple task after promotion. An agent would need additional domain knowledge to call this correctly with confidence.

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

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

Schema coverage is 100%, and each parameter already has a meaningful description (project root path, title to match, optional column). The tool description adds no parameter-level detail, but the baseline of 3 applies because the schema does the heavy lifting.

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

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

The description names a specific verb ('Convert') and a clear resource ('a simple task' into 'a real task file'), which separates this from sibling simple-task operations like get, move, or delete. It is clear enough to identify the promotion action, though 'real task file' is somewhat domain-specific.

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

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

The description implies the tool is for when a simple task should become a full task file, but it does not explicitly state when to prefer this over create_task or edit_task, nor does it give exclusions. There is enough implicit context for a basic call, but no explicit routing 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 carries the behavioral disclosure burden. It clearly states that the tool removes the entire board and all its data, and explicitly requires confirm: true as a safety gate. It does not mention irreversibility or permission needs, but the destructive scope is unambiguously 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 a single, compact sentence that front-loads the action and object, then states the critical confirmation requirement. No filler or redundancies are present; every word earns its place.

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

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

The description is adequate for a simple destructive tool: it names the target, the scope, and the confirm gate. However, it omits explicit irreversibility, does not explain how path determines which board is affected, and offers no contrast with the similarly named kanbn_delete_board sibling, which would help an agent choose correctly.

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

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

Schema description coverage is 100%, so the baseline is 3. The description's 'Requires confirm: true' only restates the confirm parameter's schema description and adds no extra nuance about path resolution, defaults, or interactions between parameters.

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

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

The description uses a specific verb and resource: 'Delete the whole board and all its data.' This clearly conveys the destructive scope and differentiates it from task-level operations, though it does not explicitly distinguish it from sibling tools like kanbn_delete_board or kanbn_delete_board_file.

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 kanbn_delete_board or kanbn_delete_board_file. The confirm requirement is a precondition, not usage direction, so an agent is left to infer the correct context for this destructive operation.

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

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

No annotations are provided, so the description carries the burden. It discloses that omitting 'type' removes all relations, which is important behavioral context. However, it does not state whether the operation is reversible, whether it affects other tasks' relations (bidirectional edges), or any side effects on associated files. Given the tool is a mutation, this is a modest but not complete disclosure.

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

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

Two concise sentences, both front-loaded with the core purpose and the key behavioral nuance (type filter). No filler words. Could arguably add a note about the dual source/target parameters, but it earns a 4 for its efficiency and clarity.

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

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

The tool has four parameters, no output schema, and no annotations, so the description must carry more weight. It explains the type filter but fails to clarify the roles of 'task' and 'taskId' (which one is the source and which is the target), which is critical for correct invocation. It also does not mention whether relations are bidirectional or what happens if the task does not exist. Given the complexity of relation management, this is inadequate for a agent to safely call it without additional schema or annotation context.

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

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

The schema covers all parameters with descriptions (100% coverage), so the description does not need to repeat them. The description adds value by clarifying the 'type' parameter's behavior (filtering removal) and implying that the 'task' and 'taskId' parameters distinguish source vs target. However, it does not explain the relationship between 'task' and 'taskId' (which is which), leaving a gap that the schema also does not resolve.

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 specific action ('remove relation edge(s)') and the resource ('task'), and distinguishes it from its sibling 'kanbn_add_relation' and 'kanbn_set_relations' by focusing on removal. It also clarifies the optional type filter behavior, making the tool's scope unambiguous.

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

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

The description indicates when to use the tool (to remove relations) but does not explicitly contrast with alternatives like 'kanbn_set_relations' (which replaces all relations) or mention prerequisites (e.g., whether the task must exist). It provides no explicit when-not-to-use guidance, relying on the tool name to imply 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?

Since no annotations are provided, the description carries the full burden. It lacks details on side effects, such as whether renaming the slug affects file paths, task references, or requires permissions. It also doesn't indicate if the operation is idempotent or if it can fail if the new slug is already taken. The 'secondary board' hint adds minimal context beyond the name.

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

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

The description is a single concise sentence that effectively communicates the core purpose. It is front-loaded with the verb 'Rename' and includes the key qualifier 'secondary board', with no filler or redundant information.

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

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

Given the tool has 4 parameters (2 required) and no output schema, the description is too sparse. It does not explain the meaning of 'secondary board' (vs primary), the constraints on slug format, or the outcome of the operation (e.g., returns new slug). An agent may struggle to know when to use this versus kanbn_create_board or kanbn_delete_board.

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

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

Schema description coverage is 100%, so the schema already defines each parameter. The description adds that 'newName' refers to a display name and 'newSlug' to the board slug, which matches the schema. However, it doesn't clarify optionality or relationships (e.g., whether newName can be omitted if only renaming the slug), which would be useful given 4 params.

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 'Rename' and the resource 'secondary board', with the parenthetical clarifying the two aspects (slug and/or display name). This distinguishes it from board creation and deletion siblings, though it doesn't explicitly mention that it's not for the primary board beyond 'secondary'.

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

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

No explicit guidance on when to use this tool versus alternatives. It doesn't mention prerequisites like ensuring the board exists or that the slug must be valid. The description implies a use case (renaming a secondary board) but provides no contextual cues 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, the description carries the full behavioral disclosure burden. It only says 'rename an existing task,' giving no indication of error behavior, permissions, side effects, or how optional column/position parameters affect the result. Saying 'existing' is a minimal prerequisite signal but not enough.

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 fluff. It is front-loaded and easy to parse, though it might have used the remaining space to mention the optional move-after-rename behavior without becoming wordy.

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

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

This is a mutation tool with five parameters and no annotations or output schema. The description omits important context such as what happens when the task does not exist, how 'column' and 'position' interact with the rename, and what success or failure looks like. The schema covers the parameters, but operational context is missing.

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

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

Schema description coverage is 100%, so the schema already documents all five parameters and their purpose. The description adds no parameter-level meaning beyond the schema, so the baseline score of 3 is appropriate.

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

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

The description clearly states the verb ('rename') and resource ('an existing task on the Kanbn board'), making the core purpose obvious. It does not explicitly differentiate from the similar kanbn_edit_task tool, which could presumably also change task names.

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

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

No guidance is provided about when to use this tool versus alternatives like kanbn_edit_task, kanbn_move_task, or kanbn_create_task. The phrase 'existing task' implies the task must already exist, but there are no explicit conditions, exclusions, or alternative tool mentions.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It only says 'list', which implies a read operation, but it does not state that the path parameter is optional, what a typical response looks like, or that no data is modified. This is a minimal behavioral disclosure.

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

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

The description is a single, front-loaded sentence with no wasted words. It immediately states the action and resource, which is highly concise for a tool of this simplicity.

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

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

Given the low complexity (one optional parameter, no output schema, no annotations), the description adequately conveys the main purpose. However, it does not mention the optional nature of the path parameter, potential output format, or any side effects beyond 'list', leaving minor gaps for an agent that wants to invoke it correctly without prior knowledge.

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

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

Schema description coverage is 100% for the 'path' parameter, which already documents its meaning as 'Path to the project root directory'. The description adds no extra semantic information about how the path affects the result, so it meets the baseline of 3 without exceeding it.

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

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

The description states a specific verb and resource ('List the board slugs reserved by Kanbn'), making the core purpose clear. However, it does not explicitly distinguish itself from siblings like kanbn_list_boards or kanbn_validate_board_slug, though the word 'reserved' narrows the scope to a specific set of slugs.

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

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

The description gives no guidance on when to use this tool versus alternatives. For example, it does not suggest using it to check if a slug is reserved before creating a board, nor does it contrast with kanbn_validate_board_slug. The context must be inferred entirely.

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. iIt says the tool is an alias for unarchive but does not describe the acttual side effects (e.g., moving a task from archived to active, mutating board files) or any requirements beyond the schema.

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

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

A single sentence with no filler, and the key alias relationship is front-loaded and easy to parse. It could be slightly more expansive, but as an alias definition it is appropriately terse.

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 alias with fully documented parameters and no output schema, the description is minimally viable. However, it omits the core behavior and any effects, so an agent would need to consult the sibling tool's definition to fully understand what calling this tool will do.

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

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

Schema description coverage is 100% and already documents path and taskId clearly. The description adds no extra parameter nuance, so it stays at the baseline 3 rather than being penalized or rewarded.

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

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

The description identifies the tool as an alias for kanbn_unarchive_task, so the agent can infer the operation is 'unarchive'. However, it never states the actual behavior (restoring an archived task) in its own terms, relying on the sibling's name to carry meaning.

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

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

Alias for kanbn_unarchive_task" directly tells the agent this tool should be used exactly when kanbn_unarchive_task would be used, naming the relevant sibling. It does not add extra context about when unarchiving is appropriate, but the alias relationship is an explicit usage signal.

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

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

No annotations are provided, so the description must carry the burden of explaining behavior. It states the tool saves config, implying a file write, but does not disclose whether it overwrites an existing file, what path resolution occurs, or whether it creates directories. This is a meaningful gap for a mutating tool.

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

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

The description is a single, front-loaded sentence with no filler. Every word contributes to the core purpose, and the structure clearly communicates the action and target.

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

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

For a simple two-parameter save operation with complete schema coverage, the description is minimally adequate. However, without annotations or an output schema, the agent still lacks important context about file overwrite behavior, default path handling, and what a successful save returns.

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

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

Schema description coverage is 100%, so the parameters are already documented: 'path' is the project root and 'config' is the object to persist. The description adds no extra parameter meaning beyond what the schema provides, so the baseline of 3 is appropriate.

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

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

The description clearly states the action (save) and the resource (Kanbn config), and it is distinct from siblings like kanbn_get_config which reads config. However, it does not explicitly differentiate itself from related config or board tools, 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 no guidance on when to use this tool versus alternatives such as kanbn_get_config, nor does it mention any prerequisites, side effects, or context that would help an agent decide to call it. Usage is only implied by the verb 'save'.

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 does not explicitly state that the tool is read-only, what kind of results it returns (full tasks vs. IDs), how the 'quiet' flag alters output, or any side effects. The verb 'Search' hints at a read operation, but this is not stated, leaving the agent to guess at critical behavioral details.

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

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

A single sentence with no wasted words: it states the action, resource, mechanism, and a key scope qualifier. The parenthetical adds valuable differentiation without bloating the description. Every word earns its place, and the most important information is front-loaded.

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

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

The tool is complex: it has a nested filters object, an optional quiet flag, and no output schema. The description does not explain what the output looks like, how filters are combined, whether results are sorted, or how the quiet flag changes the response. For a search tool of this complexity, the description leaves too much to be inferred and is therefore 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 100%, so the parameters are already fully documented in the schema, including the complex 'filters' object with its many keys. The description adds no extra meaning beyond the generic term 'filters', which matches the baseline for high schema coverage. It neither compensates nor harms parameter understanding.

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

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

The description clearly states a specific action ('Search tasks on the board') and resource ('tasks'), and the parenthetical 'works across all columns' provides a meaningful scope qualifier that distinguishes it from column- or board-specific tools. However, it does not explicitly name or contrast with sibling lookup tools like kanbn_find_simple_tasks or kanbn_get_task, so it falls just short of full sibling differentiation.

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

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

The phrase 'works across all columns' gives implicit context that this tool is appropriate when the search must span the entire board rather than a single column or status, but the description provides no explicit when-to-use or when-not-to-use guidance and names no alternatives. It is adequate as an implied usage hint, not a clear routing instruction.

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