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

No annotations are present, so the description carries the full behavioral burden. It does disclose a meaningful trait beyond the schema: the server fetches the board to validate the token and capture its board ID. But it omits what happens on an invalid token, whether the config persists, or whether the operation is idempotent/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?

Two tight sentences with no waste, front-loading the action and following with the server-side behavior that matters most to the caller.

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-param add tool with 100% schema coverage and no output schema, the description covers purpose and the key verification behavior adequately. Only failure/error semantics and persistence details are missing, which keeps it from a 5.

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 (name, token) are already fully documented in the schema. The description's 'by name and API token' merely restates them and adds no syntax or format detail beyond the schema; 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 and resource ('Add a new board') plus the mechanism ('by name and API token'), clearly distinguishing it from read/remove siblings like get_board, list_boards, and remove_board. It stops short of naming an alternative sibling explicitly, so it lands at 4 rather than 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?

Usage is implied ('Add a new board to the config'), making it evident this is the tool for registering a board. However, there is no explicit when-to-use versus when-not guidance, no mention of prerequisites, and no reference to the sync_board_ids or list_boards siblings that might otherwise be relevant.

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

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

No annotations are provided, so the description carries the full behavioral burden. It implies a mutation but says nothing about required permissions, whether the comment text supports formatting, who the author defaults to, or whether the action 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?

One short, front-loaded sentence with no waste, which is structurally fine. But the brevity stems from under-specification rather than disciplined economy, so it is only minimally adequate.

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 five-parameter mutation tool with no output schema and no annotations, the description is far too thin. It should at least explain the required identifiers and the optional author/timestamp fields to make the tool callable 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 only 20% (just board_name is documented, and only inside the schema, not the description). The description explains none of the five parameters, notably leaving text, task_id, authorUserId, and createdTimestamp undefined in both places, so it fails to compensate for the coverage gap.

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 (add) and resource (comment) tied to a task, so the core action is unambiguous. However, it offers no differentiation from the sibling get_comments, leaving the agent to infer the read/write split from names alone.

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 get_comments, nor any mention of prerequisites like a valid board or task. The agent gets no context beyond the literal action.

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

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

No annotations are provided, so the description carries the full behavioral burden. It states the core action but omits whether this requires specific permissions, whether timestamps must be in the past, whether the board must be configured, and what constraints apply. For a mutation tool without annotations, this is a notable gap.

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

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

The description is a single efficient sentence that front-loads the core action. It is not padded, but it is also under-specified, which is a mild weakness rather than a conciseness problem.

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

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

For a 7-parameter mutation tool with no annotations, no output schema, and only 57% schema description coverage, the description is too thin. It should address required board configuration, usage constraints, and the meaning of undocumented parameters to be complete enough 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 description coverage is 57%, leaving several parameters (userId, task_id, labelNames, comment) without schema descriptions. The description only clarifies the timestamp format and the manual-entry nature, not the meaning of the undocumented parameters. Baseline 3 is appropriate given partial schema coverage.

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

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

The description states a specific verb and resource: 'Add a manual time entry to a task', reinforced by the ISO 8601 timestamp requirement. It clearly distinguishes the tool from read siblings like get_manual_time_entries_for_task and get_time_entries_for_task, though it doesn't explicitly name them.

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

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

No guidance is given on when to use this tool versus alternatives such as get_time_entries_for_task or get_manual_time_entries_for_task. It also omits any exclusions or preconditions (e.g., whether the task must belong to the given board, whether overlapping entries are allowed).

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

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

No annotations are provided, so the description carries the full behavioral burden. 'Add a label' implies a mutation, but the description does not state permissions needed, whether the label is created or merely attached, whether it is idempotent, or what happens on duplicate labels. It provides zero behavioral context for a write operation.

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

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

One short sentence, front-loaded with the action. It is efficient and wastes no words, though it is arguably too terse given the complexity of the 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?

For a 4-parameter mutation tool with no annotations, no output schema, and only 25% schema coverage, the description is incomplete. It omits parameter meanings, behavioral traits, and usage context, leaving the agent with significant gaps before 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 only 25% (only board_name is documented). The description does not explain the 'name' parameter (is it an existing label name or a new label to create?), 'pinned', or 'task_id'. With low coverage and no compensating detail, the description leaves key parameters ambiguous.

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 clear verb+resource: 'Add a label to a task.' It is specific and distinguishable from siblings like get_labels (retrieval) and create_task. It lacks scope details (e.g., which board, whether it creates a new label or applies an existing one) but the core action is unmistakable.

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

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

No guidance on when to use this tool vs alternatives like get_labels or update_task. It does not clarify whether this creates a new label definition or attaches an existing label to a task. With no exclusions or context, the agent must infer usage.

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

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

No annotations are provided, so the description carries the full burden. It only implies a mutation ('Add') and the prerequisite that the parent task must exist, but discloses nothing about required permissions, side effects, return values, or whether the subtask inherits fields from the parent.

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 one-sentence description is front-loaded and free of filler, so it is concise. However, it is arguably too terse for a tool with seven parameters and no annotations, bordering on under-specification rather than optimal brevity.

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

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

Given the tool's complexity (7 parameters, 3 required), lack of annotations, and no output schema, the description is far too sparse. It does not cover parameter meanings, behavioral traits, or usage context, leaving the agent with insufficient information to invoke the tool correctly.

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

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

Schema description coverage is only 14% (just board_name), yet the description adds no parameter detail. It does not explain name, task_id, userId, finished, or the dueDate parameters, leaving the schema to do nearly all the work with minimal descriptions.

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

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

The description states a specific verb 'Add' and resource 'subtask' with the prerequisite 'to an existing task'. It clearly distinguishes the tool from sibling create_task by scoping it to subtasks, though it does not explicitly name or contrast with alternatives.

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

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

The description implies usage: adding a subtask to an existing task. However, it offers no explicit guidance on when to prefer this over create_task or other alternatives, and no when-not conditions.

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

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

With no annotations provided, the description carries the full behavioral burden and discloses almost nothing about this mutation. It does not say whether the new task is returned, whether required fields must reference existing board/column IDs, what happens if column_id is invalid, or what side effects (position, ordering) occur.

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

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

One front-loaded sentence with zero waste, which is structurally sound. But at eight words for a 10-parameter mutation tool it is under-specified rather than concise, so the brevity costs more than it saves.

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?

A mutation tool with no annotations, no output schema, and half its parameters undocumented needs the description to fill those gaps, and it does not. An agent would have to infer required-field relationships (e.g. swimlane_id on swimlane boards) and the return behavior entirely on its own.

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

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

Schema coverage is only 50%, and the description adds no parameter meaning whatsoever. Five properties (color, position, description, pointsEstimate, totalSecondsEstimate) are undocumented in both place, and even the enum-constrained color and the date-grouping behavior of groupingDate get no narrative clarification.

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 ("Create a new task") with board scope, so the agent knows exactly what entity is being produced. However, it offers no differentiation from siblings such as create_subtask, which is a near-neighbor an agent could easily confuse with this 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?

No when-to-use guidance, no prerequisites, and no named alternatives. The description never mentions create_subtask for subtasks or import_csv for bulk creation, both of which are plausible routing alternatives the agent must disambiguate without help.

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. 'Permanently' usefully discloses irreversibility, but permissions, confirmation needs, and side effects on subtasks/comments/relations are absent.

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

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

One front-loaded sentence with no filler; 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 destructive mutation with no annotations, no output schema, and an undocumented required task_id, the definition omits too much. It states permanence but not permissions, confirmation, or cascading effects.

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 50% and the description adds no parameter meaning. board_name is documented in the schema as referencing list_boards, but task_id is undocumented in both the schema and the description.

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, 'delete', and resource, 'task', and flags permanence, so an agent can distinguish it from create_task and update_task. It does not explicitly name an alternative or scope, which keeps it from 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 when-to-use guidance, prerequisites, or alternatives are provided. The agent is left to infer that this is the destructive counterpart to update_task and move_task_to_board.

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 context. The verb 'Get' implies a read, but it says nothing about pagination, ordering, permissions, or result volume for what could be a large list. That is a significant gap for a list 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?

A single short sentence with no waste, but under-specified for a list tool. Conciseness here tips into thinness.

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

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

No annotations, no output schema, and no return/ordering/pagination detail. For a board-wide task retrieval tool this leaves the agent unable to predict result shape or size.

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

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

Schema coverage is 100%, and the board_name parameter is fully documented in the schema including a pointer to list_boards. The description adds no meaning beyond the schema, so the baseline of 3 applies.

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

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

States a specific verb+resource ('Get every task') and scopes it to 'a board'. It doesn't differentiate itself from the close sibling 'get_tasks_by_column', leaving ambiguity about whether filtering is possible.

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 and no alternatives named. With siblings like get_tasks_by_column and get_task present, the agent gets no help choosing between 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?

No annotations are provided, so the description carries the full behavioral burden. 'Get' implies a read-only operation, but the description says nothing about permissions, whether board_name must be pre-resolved, pagination, or failure behavior for unknown task IDs.

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 short sentence with no waste, but it is under-specified rather than genuinely concise — the brevity comes at the cost of content 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?

With no output schema, no annotations, two required parameters, and one undocumented parameter, the description leaves too much unspecified. It should at least describe the returned attachment shape or the board/task scoping model.

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 50%: board_name is documented (pointing to list_boards) but task_id is bare. The description adds no parameter meaning whatsoever, so it fails to compensate for the undocumented required task_id.

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

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

States a specific verb+resource: 'Get attachments on a task.' An agent knows exactly what it retrieves. However, it offers no differentiation from siblings in a large toolset (e.g., get_comments, get_relations), though none are near-duplicates, so 4 rather than 5.

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

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

There is no guidance on when to use this versus alternatives, no prerequisites, and no mention of when-not to use it. The agent must infer everything 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 behavioral burden. 'Get' strongly implies a safe read and the enumerated fields describe what is returned, but nothing states permission requirements or confirms read-only behavior beyond implication.

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

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

One sentence, front-loaded with verb and resource, followed by the payload contents. Nothing is wasted and nothing critical is buried.

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

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

For a simple read-only getter with one fully documented parameter, the description is nearly sufficient, and the enumerated return fields partly compensate for the absent output schema. It lacks only usage/routing guidance relative to list_boards and get_board_custom_fields.

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

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

Schema description coverage is 100% and the single board_name parameter is fully documented in the schema, including a pointer to list_boards. The description adds nothing about the parameter, which is the expected baseline when 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 gives a clear verb (Get) and resource (board) and enumerates the payload (columns, swimlanes, colors, settings), which distinguishes it from a mere list_boards-style call. It stops short of naming list_boards or get_board_custom_fields as alternatives, so the differentiation relies on 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 when-to-use, when-not-to-use, or alternative-selection guidance in the description. The only routing hint, '(see list_boards)', lives in the schema's parameter description, not in the tool description itself.

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

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

No annotations are provided, so the description carries the burden. It usefully signals that this returns field schema/metadata ('definitions') rather than values, which is real behavioral context, but it says nothing about permissions, whether it includes archived fields, or response shape.

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 economical sentence with the resource front-loaded and no filler. It is appropriately sized, though extremely terse for a tool with no annotations to fall back on.

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

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

For a simple one-parameter read lookup with no output schema, the description is minimally adequate. The absence of any note on return format is acceptable since no output schema exists, but with no annotations, more disclosure about what 'definitions' includes would help.

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

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

Schema coverage is 100% and the single board_name parameter is fully documented in the schema, including a pointer to list_boards. The description adds nothing beyond that, so the baseline of 3 applies.

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

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

States a specific verb (Get) and resource (custom field definitions) with clear board scope. The phrase 'available on the board' distinguishes it from the sibling get_task_custom_fields, which presumably returns values per task, but the differentiation is implicit rather than stated.

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, no prerequisites, and no mention of the sibling get_task_custom_fields or list_boards. The agent must infer that this should be called before interpreting custom field values on 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?

No annotations are provided, so the description carries full behavioral burden. It discloses that the time window is optional, but says nothing about permissions, pagination/limit behavior beyond what the schema states, ordering semantics, or the shape of returned events.

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, tightly scoped sentence with zero filler, front-loading the resource and the audit-log clarification. Nothing is wasted.

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

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

Adequate minimum for a read tool with a well-documented schema, but with no annotations and no output schema, the description could stand to mention permissions, result count defaults, or return shape. It leaves behavioral gaps that annotations would normally cover.

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 80%, so the schema already documents all five parameters including formats (ISO 8601/epoch ms), default/max limit, ordering enum, and board_name. The description adds nothing parameter-specific beyond the optional-window framing, so 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?

States a specific verb (Get) and resource (board-level events / audit log). The audit-log clarification and time-window scoping distinguish it clearly from get_board, get_time_entries_for_board, and other board 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 when-to-use, when-not-to-use, or named alternative. The 'audit log' parenthetical marginally suggests the appropriate context, but there is no routing guidance versus get_board or get_time_entries_for_board.

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, and it offers almost nothing: it does not say this is a read-only lookup, what a 'collaborator' is (users? roles?), whether results are paginated, or what permissions are needed. It essentially restates 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?

A single short, front-loaded sentence with no waste. However, the brevity reflects under-specification rather than disciplined conciseness.

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

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

For a plain read tool with no annotations, no output schema, and one of two required parameters undocumented, the description is too thin. It leaves the agent guessing about return contents, collaborator meaning, and the task_id 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 coverage is 50%: board_name is documented in the schema (with a pointer to list_boards), but task_id is undocumented in both schema and description. The description adds no meaning about either parameter, leaving the task_id format (UUID? slug?) unknown.

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: retrieve collaborators of a task. An agent can distinguish it from get_users (all users) and get_task (the task itself), though the description does not explicitly differentiate. Clear but no sibling routing.

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 versus get_users or get_task, no prerequisites, no exclusions. The agent must infer 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?

No annotations are provided, so the description carries the full burden of behavioral disclosure. It only implies a read operation via 'Get' and says nothing about permissions, pagination, ordering, or output format, adding almost no behavioral context 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 no wasted words. It is appropriately concise, though its terseness contributes to gaps in other dimensions rather than being a structural flaw.

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

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

With no annotations, no output schema, 50% schema description coverage, and a task_id parameter undocumented in both schema and description, the definition is missing too much for an agent to call it confidently. It identifies the resource but omits pagination, output shape, and parameter semantics.

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

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

Schema description coverage is 50%: board_name is documented as a configured board name referencing list_boards, while task_id has no description. The tool description adds no parameter meaning, so it fails to compensate for the undocumented task_id parameter.

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

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

The description states a specific verb and resource: 'Get comments on a task.' An agent can tell this is a read operation for comments, though it does not explicitly distinguish itself from the sibling add_comment 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?

Usage is implied by the verb 'Get' and the resource 'comments,' but there is no explicit when-to-use guidance, no exclusions, and no mention of the add_comment sibling as an alternative. The agent must infer the appropriate context.

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

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

No annotations are provided, so the description carries the full burden. 'Get' implies a safe read, but it says nothing about permissions, which date fields exist (start date, due date, both?), or the shape of the result — all of which matter more here because there is no output 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 short sentence with no filler and the resource stated up front. It is efficient, though the brevity is partly under-specification rather than deliberate tightness.

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 annotations and no output schema, the description is too thin: it never defines what 'date/due-date information' contains or how the required board_name/task_id pair scopes the lookup, so an agent cannot predict the return value.

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

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

Schema coverage is only 50%: board_name is documented in the schema with a pointer to list_boards, while task_id is bare. The description adds no parameter meaning beyond 'for a task', so it fails to compensate for the coverage gap.

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 (get) and resource (date/due-date information for a task), which reads clearly as a read-only counterpart to the sibling set_date. It does not explicitly name or contrast with that sibling, so differentiation is left to the agent's inference from the tool 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?

There is no when-to-use guidance, no prerequisites, and no mention of the obvious alternative (set_date for writing dates). The agent must infer the read-vs-write split purely from naming.

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

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

No annotations are provided, so the description carries the full behavioral burden, yet it only implies read-only behavior via the verb 'get'. It says nothing about permissions, whether labels are ordered, pagination, or what happens if the task has no labels or the board_name is invalid.

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 and no redundancy; the tool's purpose appears immediately. It is arguably too terse for a tool with an undocumented required parameter, but as a sizing measure it is efficient.

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

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

For a simple two-parameter read tool with no output schema and no annotations, the description is minimally adequate: an agent knows it retrieves labels for a task. However, it lacks any note on how task_id is obtained, board context, or return shape, leaving gaps an agent must guess at.

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 50%: board_name is documented in the schema, but task_id is not. The description adds no meaning to either parameter, so the undocumented task_id (format, source, e.g. from get_tasks_by_column) remains ambiguous for the agent.

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), resource (labels), and scope (on a task), so an agent can immediately tell what it returns. It does not distinguish itself from siblings such as create_label or get_task_custom_fields, and there is no explicit sibling routing, which keeps it below 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 sentence describes what the tool returns but gives no guidance on when to use it versus alternatives (e.g., create_label for adding, or get_task_custom_fields for a different metadata type). There are no prerequisites or exclusions stated, 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?

With no annotations, the description carries the full behavioral burden. 'Get' implies a read, but nothing is said about return format, pagination, permissions, or how manual entries differ from non-manual ones – a significant gap for a no-annotation 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?

A single compact sentence with no waste and the scope ('on a specific task') placed up front. Efficient, though it errs toward under-specification rather than true crispness.

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 one of two parameters undocumented, the description does too little. It never clarifies the manual-vs-regular time-entry distinction or the return shape, leaving meaningful gaps.

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

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

Schema coverage is only 50%: board_name is documented in the schema, but task_id has no description anywhere. The phrase 'on a specific task' vaguely gestures at task_id but adds no format or meaning beyond the parameter name, so the description fails to compensate for the coverage gap.

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 ('Get') and resource ('manual time entries') scoped to 'a specific task', so the operation is clear. However it does not distinguish itself from the close sibling get_time_entries_for_task, leaving the 'manual' qualifier as the only differentiator an agent must infer.

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, no prerequisites, and no mention of alternatives such as get_time_entries_for_task, get_time_entries_for_board, or add_manual_time_entry. The agent gets no routing help among the closely related time-entry siblings.

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

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

No annotations are provided, so the description carries the full burden. It implies a read operation ('Get') but says nothing about permissions, pagination, or behavior when no relations exist. It does not disclose how the three relation types are structured in the response.

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, short sentence with the resource and the relation-type enumeration front-loaded. No filler or restatement of the 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?

A no-annotation, no-output-schema read tool with 50% schema coverage and no behavioral or usage context. It is under-specified for an agent to confidently choose it over sibling task-inspection tools.

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

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

Schema coverage is 50%. task_id is undocumented in both schema and description; board_name is documented in the schema. The description adds no parameter meaning (e.g., whether task_id must be a full ID format or how board_name interacts with task lookup).

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 clear verb+resource: 'Get task relations' and enumerates the relation types (relatesTo/dependsOn/requiredBy). It is distinguishable from siblings like get_subtasks or get_collaborators, though it doesn't explicitly contrast with them.

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

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

No guidance on when to call this versus alternatives. It doesn't say whether relations are a superset of subtasks/dependencies, or when an agent would need this instead of get_task or get_subtasks.

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

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

With no annotations, the description carries the full behavioral burden. 'Get' implies a read, but it says nothing about whether results are paginated, ordered, nested recursively (do subtasks have their own subtasks?), or what permissions/board access are required. For a zero-annotation tool this is a substantial 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 short sentence with no filler and the resource scoping front-loaded. It is efficiently sized, though so terse that the brevity reflects under-specification rather than tight editing.

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 read tool with no output schema, the description is minimally viable: the agent knows it returns subtasks. However, it omits the meaning of task_id and any hint about the return shape (flat list vs. nested tree), which matters for a hierarchy-related call.

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

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

Schema description coverage is 50%: board_name is documented in the schema (including a pointer to list_boards), but task_id has no description anywhere. The description adds no parameter meaning at all, so it fails to compensate for the undocumented required task_id.

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

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

States a specific verb ('Get') and resource ('subtasks') scoped to a single task, so an agent immediately knows it retrieves child tasks of one parent. It does not differentiate itself from nearby siblings such as get_task or create_subtask, but the purpose itself is unambiguous.

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

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

The description gives no when-to-use context, no prerequisites, and no mention of alternatives (e.g. get_task, create_subtask, or how to get top-level tasks). The agent must infer that this is the read path for a task's children purely from the 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?

With no annotations and no output schema, the description carries the full behavioral burden, yet it only says 'detailed information' without stating what fields are returned, whether permissions are required, or how an invalid/missing ID behaves. The safety and response profile is left entirely opaque.

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 efficient, though its brevity is partly the cause of the missing detail rather than a deliberate compression of rich 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 lookup tool with zero annotations, no output schema, and two undocumented parameters, the description leaves an agent guessing about return contents, error handling, and the meaning of includePosition. Not adequate to call the tool correctly without opening the schema.

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

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

Schema coverage is only 33%: board_name is documented (with a useful pointer to list_boards) but task_id and includePosition have no description anywhere. The description mentions the ID lookup but never explains the format of task_id or what includePosition toggles, so it fails to compensate for the coverage gap.

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 ('Get detailed information about a specific task') and the access key ('by its ID'), which distinguishes it from sibling collection getters like get_all_tasks and get_tasks_by_column. It does not explicitly name any sibling, so differentiation is only implicit.

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?

'by its ID' implies the precondition that a task ID is already known, which is the only usage signal. There is no statement of when to prefer this over get_all_tasks, get_tasks_by_column, or get_subtasks, and no 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 behavioral burden. 'Get' implies a read, but nothing states whether it requires permissions, whether unset fields are omitted or returned empty, or how many values to expect. For a tool with zero annotation coverage 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 clean sentence with the resource front-loaded and no wasted words. It is appropriately sized, though the brevity reflects under-specification rather than tight editing.

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 half the parameters undocumented, the description should explain the return shape (e.g. field name/value pairs) and the task_id requirement. It leaves an agent guessing at both input and output.

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

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

Schema coverage is only 50%: board_name is documented in the schema (referencing list_boards), but task_id has no description anywhere. The tool description adds no parameter meaning at all, so it fails to compensate for the coverage gap.

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 (Get) and resource (custom field values set on a task), and the phrase 'set on a task' implicitly distinguishes it from the board-level sibling get_board_custom_fields. It does not explicitly name that sibling, so an agent must infer the task-vs-board 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 when-to-use guidance, no prerequisites, and no mention of alternatives such as get_board_custom_fields for definitions or get_task for general task data. The agent gets no help choosing among the many sibling read tools.

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

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

No annotations are provided, so the description carries the full behavioral burden. 'Get' weakly implies a read, but there is no mention of return shape, pagination, ordering, or behavior when swimlane_id is omitted (all lanes vs none). For a bare read tool this is thin.

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, front-loaded sentences with no filler. However, the terseness comes at the cost of the missing context a 3-parameter tool needs, so it is efficient rather than fully earned.

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

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

No annotations, no output schema, and low schema coverage mean the description must compensate, and it does not. An agent cannot tell from this text how the tool relates to the many other task-retrieval siblings or what a call will return.

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 only 33% (only board_name is documented in the schema). The description adds nothing about column_id format, how board_name interacts with column_id, or what omitting swimlane_id does. It essentially restates the schema's required/optional split.

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 ('Get tasks') plus the filtering dimension ('filtered by column ID'), so the agent knows what the tool returns. It does not differentiate itself from siblings such as get_all_tasks or get_task, which also retrieve tasks, so the boundary 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?

No guidance on when to use this over get_all_tasks, get_task, or get_subtasks. The only usage note is that swimlane_id is optional, which is already implied by the schema's required list.

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

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

No annotations are provided, so the description carries the full burden. It discloses read access and entry types but omits permissions, pagination behavior, the limit default, authentication needs, and response shape.

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 waste. It states the resource, subtypes, and scope efficiently.

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

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

With 5 parameters, no annotations, and no output schema, the one-sentence description is incomplete. It does not cover when to use the tool, the nuance that from or to is required, the limit default, or the structure of returned time entries.

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 80%, so the baseline is 3 even without parameter detail in the description. The description repeats the board and time-window scoping already in the schema and adds no meaning for userId or limit 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?

States a specific verb 'Get' and resource 'time entries' scoped to the board and a time window. It also enumerates entry subtypes (manual, Pomodoro, Stopwatch), which clearly distinguishes it from the task-level sibling get_time_entries_for_task by 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 when-to-use, when-not, or alternative tool guidance is provided. The sibling get_time_entries_for_task exists but is not mentioned, and the description offers only implied usage 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 behavioral burden. It does disclose what is returned (the three entry types: manual, Pomodoro, Stopwatch), which is genuine added context, but says nothing about permissions, ordering, pagination, or behavior when no window is supplied. Partial coverage for a read tool with zero annotation support.

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

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

A single front-loaded sentence with no wasted words; the scope (which entry types) and filter (task + window) are stated immediately.

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

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

No output schema and no annotations, so the description must carry both safety and return-shape context. It covers the purpose and the entry types returned but omits permissions, pagination, and empty-window behavior, leaving gaps an agent would need to resolve.

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 75%, so the schema already documents to/from/board_name. The description reinforces the 'time window' semantics of from/to but adds no format or boundary detail beyond the schema, and board_name is not mentioned at all. Baseline 3 is appropriate when 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?

States a specific verb (Get) and resource (time entries) with clear scope qualifiers: all entry types (manual, Pomodoro, Stopwatch), scoped to a specific task and a time window. This implicitly distinguishes it from get_manual_time_entries_for_task (manual only) and get_time_entries_for_board (board-level), so an agent can route correctly.

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 when-to-use statement and no alternative tool named. The scope words ('a specific task', 'time window') imply usage context, but the agent must infer the choice versus get_manual_time_entries_for_task and get_time_entries_for_board. Implied usage only.

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. 'Get' implies a safe read, but the description says nothing about the return shape, whether users from the whole workspace or only direct collaborators are included, or any permission requirements.

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

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

A single tight sentence with no waste, and the resource scope is front-loaded. It is arguably too terse for the complexity of the concept, but structurally efficient.

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

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

For a single-parameter read tool with no output schema or annotations, the description is minimally adequate: it conveys what is fetched and by which board. It omits return-format and scope details that would matter given the presence of the overlapping get_collaborators sibling.

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?

Only one parameter (board_name) and schema coverage is 100%, with the schema already explaining it refers to a configured board and points to list_boards. The description adds no additional parameter meaning, so the baseline of 3 applies.

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

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

States a specific verb (Get) and resource (users with access to the board), so the reader knows exactly what is returned. However, it does not differentiate itself from sibling get_collaborators, which appears to cover a similar 'who has access' concept, leaving ambiguity about which to pick.

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 get_collaborators or get_board. The only hint of usage is the schema's reference to list_boards, which comes from the parameter description, not the tool 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 exist, so the description carries the full behavioral burden, yet it says nothing about mutation semantics: partial-failure behavior on bad rows, atomicity, row limits, whether existing tasks are touched, or required permissions. It only specifies the CSV input format.

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, front-loaded with the action and followed by the input format spec. No filler; every clause carries 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?

A mutation tool with no annotations and no output schema should cover return/behavior expectations, but the description stops at input format. It is sufficient to invoke correctly but incomplete on what an agent should expect from a bulk import.

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 schema parameters are already documented at 100% coverage, and the description adds genuine meaning beyond that by defining the CSV body's internal columns (required name; optional description, color, swimlaneId, position), which the schema does not enumerate.

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+resource+mechanism: "Bulk-create tasks on a board from CSV content." The "bulk"/"CSV" framing implicitly separates it from the sibling create_task, but no sibling is named outright, so it lands at a clear-but-not-explicitly-differentiated 4.

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

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

Usage is implied by "Bulk-create ... from CSV" (use this instead of repeated create_task calls when you have CSV), but the description never states when to choose this tool or any exclusions/preconditions beyond what's forced by the schema.

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

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

With no annotations, the description carries the full behavioral burden. It does disclose a meaningful trait beyond the obvious — that API tokens are never exposed — and specifies that names (not full board objects) are returned, but it is silent on ordering, whether archived boards are included, and any pagination or rate-limit behavior.

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

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

Two short sentences, zero filler, and the primary purpose is front-loaded ahead of the secondary security note. Every clause 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 trivial zero-parameter read tool with no output schema, the description covers what is returned (board names) and a notable security property. The one open question is whether any identifier is returned alongside the names, which matters for chaining into get_board, but that gap is minor at this complexity.

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

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

The tool takes zero parameters, so there is nothing for the description to clarify and the baseline is 4. The description correctly implies no filtering inputs are needed to enumerate all boards.

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 ('List all configured KanbanFlow board names') with an explicit scope ('all configured') that separates it from the singular get_board and the mutating add_board/remove_board siblings. It does not name a sibling explicitly, so it falls just short of a 5.

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

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

There is no when-to-use guidance, no exclusion, and no named alternative; the description says nothing about calling get_board for a single board's details or sync_board_ids for the ID-mapping job. The scope word 'all configured' only faintly implies usage.

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

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

No annotations are provided, so the description carries the full burden. It discloses that the tool changes a task's board/column/swimlane location, implying a mutation, but does not state whether permissions are required, whether the move is reversible, what happens to existing task data on the source board, or how the task ID is resolved across 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?

The description is a single, front-loaded sentence with no waste. It efficiently captures the core action and scope, though the parenthetical adds slight ambiguity without adding much 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?

For a mutation tool with no annotations and no output schema, the description is too thin. It should disclose at least basic safety, permission, or side-effect information to help an agent invoke it correctly, especially given six parameters and cross-board semantics.

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

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

Schema description coverage is 67%, so the schema documents most parameters (board_name, target_board_name, column_id, groupingDate). The description adds little beyond what the schema already provides, and swimlane_id has no description in either the schema or the description, leaving a minor gap.

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 (move) and resource (task) with the scope (from one configured board to another), which is clear and distinguishable from siblings like update_task. It could be slightly stronger by contrasting with update_task, but 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?

Usage is implied by the description's scoping, but there is no explicit when-to-use or when-to-use-alternatives guidance. An agent could infer this is for cross-board moves, but there is no stated condition or warning about when to prefer update_task for in-board column changes.

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

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

No annotations are provided, so the description carries the full burden. For a destructive mutation it says nothing about irreversibility, required permissions, whether dependent tasks/columns are affected, or confirmation/failure 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 zero waste. It is tight, though so terse that it borders on under-specification rather than optimizing information density.

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 destructive tool with no annotations and no output schema, so the description must explain consequences and failure modes. It does not, leaving the agent unable to judge risk or expected result.

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?

Only one parameter exists and schema description coverage is 100%; the schema already documents board_name and even points to list_boards. The description's 'by name' adds marginal reinforcement but no new syntax or format 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?

States a specific verb+resource ('Remove a configured board') and identifies the selector ('by name'). It is clearly distinguishable from siblings like add_board, get_board, and list_boards by virtue of the verb, though it never names those siblings 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?

There is no when-to-use guidance, no preconditions, and no mention of alternatives such as get_board (to verify) or add_board (to reverse). The agent is left to infer context 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 behavioral burden, and it delivers almost nothing: no statement of permissions, side effects (does setting a date move the task between columns?), reversibility, or idempotency. For a mutation tool with zero annotation coverage this is a significant gap.

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

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

Front-loaded with the operation, then the parameter notes in two short sentences; nothing is padded. The format reminders duplicate the schema descriptions, costing it a point.

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

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

With 7 parameters, 4 required, no annotations, and no output schema, the description should cover prerequisites and return behavior, but it addresses only 3 of 7 parameters and omits status, dateType, task_id, and board_name entirely. It is not sufficient to invoke the tool 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 only 43% (status, dateType, task_id, target_column_id are undocumented in the schema), so the description should compensate, but it only names three parameters. Worse, it labels target_column_id as optional while the schema marks it required, which is actively misleading and could cause malformed calls.

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 concrete verb and resource ('Set or update the due date on a task'), so the agent knows exactly what operation is performed. However, it offers no differentiation from siblings such as get_dates or update_task, which also touch task dates/fields.

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 call this instead of update_task or get_dates, nor any preconditions (e.g., must the task/board exist, must the target column accept dates). The single inference an agent can draw is the required/optional parameter split.

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

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

With no annotations, the description carries the full burden. It usefully discloses that this is a conditional write ('update the stored board ID if it changed'), implying local config mutation, but says nothing about required permissions/auth, failure behavior, or whether remote KanbanFlow state is touched.

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 well-formed sentence with the action first and the conditional parameter behavior parenthetically embedded. No filler and nothing redundant.

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 and no annotations, the description covers the core action but omits what happens on failure, whether anything is returned (e.g., updated IDs), and any permission requirements that an agent would need 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% and the single parameter is already documented as 'omit to sync all configured boards'. The description repeats the same omit-means-all semantics, so it adds little beyond the schema; 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 (re-fetch/update) and a precise resource (stored KanbanFlow board ID), which cleanly separates it from siblings like list_boards, add_board, or remove_board. It is clear what the tool does, though it does not explicitly name which siblings it is not for.

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

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

Usage is implied rather than stated: the reader infers the tool is run when stored board IDs may have drifted. There is no explicit when-to-use, no exclusions, and no mention of the alternative tools (add_board, list_boards) that an agent should prefer for other board operations.

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

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

With no annotations, the description carries the full burden of behavioral disclosure. It implies mutation but says nothing about permissions, whether omitted fields are preserved, whether changes are reversible, or side effects on related data. Only the field list hints at scope.

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 with the verb and field list front-loaded. No filler, though the parenthetical is more a recap than load-bearing 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 an 11-parameter mutation tool with no annotations, no output schema, and sparse parameter descriptions, the description is too thin. It omits required parameters (board_name, task_id) usage, permission expectations, and the effect of null/partial updates.

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 low at 27%, so the description should compensate. Its parenthetical list recaps several self-evident properties (name, description, color, position) but leaves responsibleUserId, task_id, and the estimate formats unexplained, and adds no syntax detail beyond what names already convey.

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+resource (update a task) and enumerates the updatable fields, which distinguishes it from create_task and delete_task in the sibling list. It is clear what the tool does, though it does not explicitly contrast itself with the closest sibling, move_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?

There is no guidance on when to use this tool versus alternatives such as move_task_to_board (which also moves tasks between columns/boards) or set_date. No prerequisites or conditions are stated.

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