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

No annotations are present, so the description carries the burden. It discloses that the operation is a POST per labelId, which is a useful execution detail. However, it does not describe whether labels are added to existing labels or replace them, nor failure or idempotency behavior.

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

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

The description is concise, with the core action front-loaded and a brief behavioral note in parentheses. The final fragment 'cardId + labelIds: [string]' is redundant with the schema but does not significantly bloat the text.

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 thin. It omits whether the operation is additive or replaces existing labels, which is critical for a tool named 'add_card_labels'. It also does not mention prerequisites for labelIds or what the response contains.

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

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

Schema description coverage is 0%, and the description merely lists 'cardId + labelIds: [string]', which repeats the schema types without explaining the semantics of each parameter. The names are self-explanatory, but the description adds no additional meaning beyond what the property names imply.

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

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

The description states a specific action ('Attach labels to a card') on a clear resource, which immediately distinguishes it from the sibling planka_remove_card_labels. It does not explicitly name alternatives, but the verb 'attach' 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 explicit when-to-use or exclusion criteria, but the action of attaching labels is inherently different from the sibling removal tool, so usage is implied. It also notes the operation performs one POST per labelId, which hints at the expected execution but not when to choose this over alternatives.

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

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

With no annotations provided, the description must carry the behavioral disclosure burden. It only reveals that the tool creates a board; it does not mention side effects, permissions, error behavior, or whether the call is reversible. This is a significant gap for a mutating operation.

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

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

The description is a single compact sentence that front-loads the core action and includes the essential parameter shape. There is no filler or redundant 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?

The tool has no annotations and no output schema, so the description should at least hint at the return value or outcome. It does not mention what the tool returns, how to obtain the created board's ID, or behavior on invalid input, leaving an agent to guess for downstream calls.

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 0% and the fields parameter is a bare object, so the description compensates by enumerating expected subfields: name, type: 'board', and position. It does not fully specify value constraints or defaults, but it provides meaningful guidance beyond the schema.

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

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

The description clearly states the specific action and resource: 'Create a board in a project.' This distinguishes it from sibling tools like create_project, create_card, and update_board without needing to inspect schemas.

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

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

The purpose implies this is the tool to use when adding a new board to an existing project, but it gives no explicit guidance on when not to use it or which alternatives to prefer. Prerequisites such as requiring a valid projectId are not stated.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It names the mutation and target list but does not disclose side effects, required permissions, failure modes, constraints on fields, or what the operation returns.

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

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

The description is a single concise sentence, front-loaded with the core action and target, followed directly by the required payload shape. No unnecessary words.

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

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

Given no annotations, no output schema, and a sparse input schema, the description is too thin for an agent to invoke the tool confidently in all cases. It does not explain field formats, required vs optional semantics beyond dueDate, or what a successful call returns.

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

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

The schema provides no property-level descriptions and the fields object is empty, so the description must compensate. It usefully defines the expected fields shape: type: 'story', name, position, and optional dueDate. It could add types/formats for position and dueDate, but it adds crucial meaning to an otherwise opaque schema.

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

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

The description states a specific verb and resource: 'Create a card in a list.' This is unambiguous and clearly distinct from sibling tools like planka_update_card, planka_delete_card, and planka_list_cards.

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 tool name and description: use it when a new card should be created. However, it does not explicitly state when to prefer alternatives or mention conditions such as 'use planka_update_card to modify an existing card.'

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It implies a write operation ('Create'), but it does not mention side effects, permissions, idempotency, or what the tool returns. This is a significant gap for a mutation tool.

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

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

The description is extremely concise: two short sentences with no wasted words. The action is front-loaded ('Create a project'), and the field details are presented immediately after. It earns its place by conveying both purpose and essential parameter structure.

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 create tool with no output schema and no annotations, the description leaves out critical context: what the response looks like, whether name is required, and whether there are any other constraints on the nested object. It provides the field names but not enough for an agent to call 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?

The input schema provides only an opaque 'fields' object with no internal properties, so schema description coverage is 0%. The description compensates by specifying the nested structure: type ('private'|'shared') and name. This gives essential meaning that the schema lacks, though it does not state whether fields are required or if other fields are allowed.

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

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

The description clearly states the action 'Create a project' with a specific verb and resource, and it is distinct from sibling tools like update_project or delete_project. It also names the key fields, which reinforces what the tool does.

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

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

There is no guidance on when to use this tool over alternatives such as planka_update_project or planka_read_projects. It only says 'Create a project' with no mention of prerequisites, exclusions, or conditions that would route an agent to a sibling tool.

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

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

With no annotations, the description carries the full burden of behavioral disclosure. It only says 'Delete', which implies destructiveness, but it does not state that the action is permanent, whether it requires special permissions, or whether it affects related data (e.g., cards in the board). This is a significant gap for a mutation tool.

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

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

The description is a single concise sentence with no fluff. The action is front-loaded, and the structure is clear. While it could include more behavioral detail, it does not waste words, and the simplicity matches the tool's minimal parameter set.

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 simple nature, the description is incomplete. It omits critical context such as irreversibility, side effects (e.g., whether cards are also deleted), and any permission requirements. The absence of annotations and output schema makes this lack of information more impactful, leaving an agent uncertain about the consequences of calling this tool.

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

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

Schema description coverage is 0%, so the description must compensate. The phrase 'by id' clarifies that the 'id' parameter is the board's identifier, but it adds little beyond the parameter name itself. It does not explain the id's format, how to obtain it, or any constraints, leaving the agent to assume it is the board 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?

The description states a clear verb ('Delete') and a specific resource ('board') with the identifier method ('by id'). It unambiguously distinguishes from sibling delete tools by naming the board as the target resource, so an agent can immediately tell this tool apart from planka_delete_card or planka_delete_project.

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

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

No guidance is provided on when to use this tool versus alternatives. It does not mention that this operation is destructive, irreversible, or that it might cascade to associated cards. There are no explicit conditions, prerequisites, or exclusions, leaving the agent to infer the appropriate use solely from the resource name.

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

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

No annotations are provided, so the description carries the full burden, yet it only says 'Delete'. It does not disclose that deletion is likely irreversible, whether related data (labels, tasks) is cascaded or cleaned up, or any permission requirements. For a destructive operation with zero annotation coverage, this is a significant gap.

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

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

A single front-loaded sentence with zero filler; every word earns its place. The structure cannot be improved without adding content, which belongs to other dimensions.

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

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

For a destructive tool with no annotations and no output schema, the description is the only source of behavioral context, and it omits irreversibility, cascade effects, and failure behavior. Although the tool is simple (one parameter), an agent gets barely enough information to invoke it safely.

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

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

Schema description coverage is 0%, and the description adds only 'by id', which clarifies that the single string parameter identifies the card to delete. This is a modest contribution beyond the bare schema, though the parameter name 'id' combined with the tool name makes its role nearly self-evident.

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

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

The description states a specific verb ('delete') and resource ('card') with the targeting mechanism ('by id'), making the purpose unambiguous next to read/list/update/create siblings. It does not explicitly name or contrast sibling tools, so it stops short of full differentiation, but the delete+card combination is clear.

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

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

No guidance is given on when to choose this tool over alternatives such as planka_update_card or planka_remove_card_labels, nor any prerequisites like the card existing or consequences of deleting it. The usage context is purely implied by the verb; nothing is stated explicitly.

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

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

No annotations are present, so the description carries full responsibility for behavioral disclosure. It states the destructive action, but does not mention irreversibility, cascade deletion of boards/cards, idempotency, or not-found/error behavior. For a delete operation, this is a significant gap.

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

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

The description is a single, front-loaded sentence with no filler or redundant detail. Every word contributes to the core 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 simple one-parameter delete tool, the core operation and required input are stated. However, with no annotations and no output schema, important context such as consequences, success/failure behavior, and prerequisites is missing, leaving the definition minimally viable rather than complete.

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

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

The only parameter, id, is a string and the schema provides no description, so schema coverage is effectively 0%. The description's 'by id' reinforces that the parameter identifies the project, but it adds no information about where to obtain the id or its format. Minimal value is added beyond the self-explanatory schema property.

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

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

The description clearly states the action ('Delete'), the resource ('project'), and the selection method ('by id'), making it distinguishable from read/create/update siblings. It names the resource explicitly, though it does not explicitly contrast with planka_delete_card or planka_delete_board.

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

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

No guidance is provided about when to use this tool versus alternatives, such as first retrieving the project via planka_read_projects or distinguishing project deletion from board/card deletion. The description only restates the operation without contextual 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, the description carries the transparency burden. It does disclose a useful behavioral trait: boards are collected from each project included. However, it remains silent on whether archived boards are included, pagination, or response shape, which are modest gaps for a list operation.

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

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

The description is one sentence with no filler. It front-loads the verb and object, then adds the workspace-aggregation scope in a parenthetical that 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 zero-parameter list tool, the description states the operation and scope clearly. The absence of output-schema details is a minor omission, but an agent has enough to invoke the tool correctly.

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

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

The input schema is empty, so there are no parameters to describe. Baseline 4 is appropriate because no parameter information is needed, and the description confirms the tool takes no filtering arguments.

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

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

The description uses a specific verb and resource: 'List all boards in the workspace.' The parenthetical 'collected from each project included' clarifies that this is a workspace-wide aggregation, which distinguishes it from single-board tools like planka_read_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?

The description implies when to use it: any time the full set of workspace boards is needed. However, it never explicitly contrasts with planka_read_board or states when not to use this tool, so the usage guidance is inferred rather than stated.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It states the operation is a read-only listing ('List all cards') and clarifies the aggregation behavior ('collected from each board included'). However, it does not disclose potential performance implications of listing all cards across all boards, whether the result is paginated, or whether it includes cards from archived boards. The core behavior is transparent, but edge-case behavior is not.

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

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

The description is a single, concise sentence that front-loads the action and scope, with a parenthetical clarification that adds useful detail without bloat. Every word earns its place; there is no redundancy or unnecessary information.

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

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

For a zero-parameter, read-only listing tool, the description is mostly complete: it states what it does and the scope. However, it does not mention whether the result includes cards from all boards regardless of board visibility/archival status, nor does it describe the output format (though no output schema exists, so the description could have added value by noting the return shape). Given the simplicity of the tool, the missing details are minor but still leave some ambiguity for an agent deciding whether this tool meets a user's request.

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

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

The tool has zero parameters, and the schema coverage is 100% (the schema is empty, so there is nothing to document). The description adds meaning by explaining the scope of the operation ('all cards in the workspace') and the aggregation method ('collected from each board included'). Since there are no parameters, the description's clarification of scope is the only semantic content needed, and it provides it.

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

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

The description clearly states the action ('List all cards') and the scope ('in the workspace'), and adds a clarifying parenthetical that cards are collected from each board. This distinguishes it from sibling tools like planka_read_cards (which likely reads a specific card) and planka_list_boards (which lists boards, not cards). It could be slightly more explicit about the difference from planka_read_cards, but the verb+resource+scope is clear.

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

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

The description implies a broad, workspace-wide listing use case, which is distinct from reading a single card or listing boards. However, it does not explicitly state when to use this tool versus planka_read_cards or planka_list_boards, nor does it mention any exclusions or prerequisites. The context is clear enough for an agent to infer the primary use case, but there is no explicit routing guidance.

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

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

With no annotations, the description carries full burden for behavioral disclosure. It only says 'Get', implying read-only, but does not mention error handling, authentication requirements, or what happens if the board does not exist. This is a significant gap for a read operation.

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

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

The description is a single sentence, which is concise and front-loaded. However, it is under-specified; it earns its place but does not provide enough substance to be considered well-structured.

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

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

The tool is simple (one parameter, no output schema, no annotations), but the description does not mention return format, possible errors, or any operational context. An agent would need to infer expected behavior from the name alone.

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

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

Schema description coverage is 0%, so the description must compensate. It says 'by id', which indicates the id parameter is the identifier, but adds no format, example, or meaning beyond the schema's bare type. For a single-parameter tool, this is minimal but not entirely absent.

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

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

The description clearly states the action ('Get') and the resource ('a board by id'), which is unambiguous. However, it does not explicitly distinguish itself from sibling tools like planka_list_boards, though the name and phrasing imply a single-board fetch rather than a list.

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

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

No guidance is provided on when to use this tool versus alternatives. There is no mention of scenarios where list_boards might be more appropriate, nor any exclusions or prerequisites.

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

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

No annotations are provided, so the description carries the full burden of revealing behavioral traits. The 'GET' method in the description hints that this is a read-only operation, but it does not explicitly state the lack of side effects, required permissions, or rate limits. This falls short of full transparency.

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

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

The description is a single short sentence that immediately conveys the action and resource. It contains no filler or repetitive information, earning a high score for efficiency.

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

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

For a simple read tool with one parameter and no output schema, the description is superficially adequate but lacks details about the return payload, error handling, or prerequisites. Without annotations or output schema, the agent has to infer expected results, which is a gap.

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

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

The description adds minimal meaning to the 'id' parameter by indicating it is the card's identifier. However, with 0% schema description coverage, it does not elaborate on format, source, or validation. The phrase 'by id' is the only semantic contribution.

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

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

The description uses a specific verb ('Get') and resource ('card by id'), clearly identifying a single-card retrieval operation. It differentiates from sibling 'planka_read_cards' (plural) by explicitly scoping to one card via id. The inclusion of the REST endpoint adds context but the core purpose is unambiguous.

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

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

The description provides no guidance on when to use this tool versus alternatives. It does not mention conditions, exclusions, or the existence of 'planka_read_cards' for listing multiple cards. The requirement of an 'id' parameter is implied but not stated as usage guidance.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It only says it is an alias, without describing read-only nature, output format, or any side effects. This is severely lacking for a tool that mutates nothing but still needs behavioral context.

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

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

The description is one short sentence, which is concise. However, it is too sparse to be helpful; it merely references another tool without providing any operational detail. It is not verbose, but it lacks substance.

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

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

For an alias tool with no output schema and no annotations, the description is extremely incomplete. It does not explain what the alias does, what it returns, or any limitations. An agent would need to look up planka_list_cards to understand behavior, which is not provided in this definition.

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

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

The tool has zero parameters, so there is no parameter burden. The schema coverage is 100% (empty). The description adds nothing about parameters, but none are needed. Baseline for 0 params is 4, and the description does not detract.

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

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

The description states it is an alias of planka_list_cards, which implies it reads cards, but it does not directly describe what that does. An agent must infer the purpose from the sibling name or look up the referenced tool, making it somewhat clear but not self-contained.

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

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

No guidance on when to use this tool versus alternatives. As an alias, it presumably shares usage with planka_list_cards, but that is not stated. There is no mention of when to prefer this over the original or other 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 must carry the burden. It only states 'Get a project' without disclosing side effects, return format, error behavior, or permission requirements. The read-only nature is implied but not stated, and nothing beyond the obvious is added.

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

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

The description is a single, concise sentence with no fluff. It front-loads the action and resource. However, it is under-specified, which reduces its effectiveness despite its brevity.

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

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

For a tool with no annotations and no output schema, the description is extremely minimal. It fails to explain what the response contains, possible errors, or any contextual details that would help an agent use it correctly. Given the simplicity of the tool, more information is expected.

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

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

The schema has zero description coverage for the 'id' parameter. The description mentions 'by id' but adds minimal meaning beyond the schema property name; it doesn't clarify the format, source, or what constitutes a valid 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?

The description states a clear verb ('Get') and resource ('project') with an identifier ('by id'), which distinguishes it from the plural sibling 'planka_read_projects'. However, it is terse and doesn't explicitly contrast with other read tools, so it's clear but not highly differentiated.

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

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

No guidance is given on when to use this tool versus alternatives like 'planka_read_projects' or other read tools. The singular 'by id' implies a specific use case, but there is no explicit context or exclusion criteria.

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

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

With no annotations present, the description carries the full burden of behavioral disclosure. It conveys the core read-only behavior through the verb 'list,' but it does not state whether the result is paginated, what scope 'all' covers, or what the response shape looks like.

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

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

The description is one short, front-loaded sentence with no filler or tautology. For a zero-parameter tool this is appropriately concise, though it does not add any richer structure or context.

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

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

Given the tool's low complexity, the description is minimally viable for an agent to make the call. However, it does not explain the meaning of 'all projects' or the expected return format, and since there is no output schema or annotations, those gaps are not filled elsewhere.

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

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

The tool has zero parameters and the schema has 100% coverage, so there is no parameter semantics for the description to clarify. The baseline of 4 applies because no parameter documentation is needed.

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

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

The description states a specific verb ('list') and resource ('projects') with the qualifier 'all,' so an agent can tell this is a read-only enumeration tool. It is implicitly distinguished from the singular sibling planka_read_project, though it does not explicitly reference any sibling or scope qualifier.

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

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

No guidance is given about when to use this tool versus alternatives. Sibling tools like planka_read_project, planka_list_boards, and planka_read_cards exist, but the description contains no conditions, exclusions, or relationships to help an agent choose among them.

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

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

With no annotations, the description carries the full burden and does disclose the critical behavior: there is no GET endpointcase and the tool returns a graceful {ok:false,error}. This is honest and prevents an agent from assuming a successful read will occur, though it doesn't fully detail the error payload or edge cases.

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

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

The description is very short and front-loads the intended action, followed by an essential caveat. It contains no filler, though the juxtaposition of 'Read' with 'returns error' creates minor ambiguity that could be clearer.

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

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

The description is not complete for agent use: it does not explain that the tool always fails, does not mention the output shape beyond the error flag, and lacks any pointer to an alternative tool that can actually read card/task data. More context is needed to prevent misuse.

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

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

The schema has zero description coverage, and the description only says 'by id' without explaining the id semantics, format, or whether the parameter is validated. The parameter is still a required string, but the description does not compensate for the missing schema details.

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

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

The description states a specific operation ('Read a task by id') and clearly identifies the resource and verb. The caveat about the missing GET endpoint clarifies the tool's actual behavior as a graceful-failure stub, though it doesn't differentiate from sibling read tools like planka_read_card.

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

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

No guidance is provided on when to use this tool versus alternatives. The description implies the endpoint is unsupported but does not suggest using planka_read_card or another tool, leaving the agent without clear selection criteria.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It states only the action without revealing side effects (e.g., whether it's destructive to the card, idempotency, permission requirements, or error behavior). For a mutation tool, this is a significant gap. No contradiction with annotations since none exist.

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

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

The description is a single, front-loaded sentence with zero waste. It clearly states the action and lists the required parameters. However, it is so brief that it borders on under-specification, lacking essential behavioral and contextual details. The structure is efficient, but the content is sparse.

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 mutation with two required parameters, the description covers the basic operation and parameter identification. However, with no annotations or output schema, it omits behavioral details like whether labels are removed individually or all at once, any prerequisites, and expected outcomes. It is adequate but not comprehensive.

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

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

Schema description coverage is 0%, so the description must compensate. It mentions 'cardId + labelIds: [string]' but this merely restates the parameter names and types already visible in the schema. It does not explain what a labelId refers to, how to obtain valid IDs, or any constraints. The description adds minimal value beyond the schema.

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

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

The description clearly states the action: 'Remove labels from a card.' It specifies the verb (remove), the resource (labels from a card), and distinguishes it from sibling tools like planka_add_card_labels and planka_delete_card. The purpose is unambiguous and easily matched to the agent's intent.

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

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

The description implies when to use it (when labels need to be removed) but provides no explicit guidance on alternatives or exclusions. It doesn't mention when to prefer this over planka_add_card_labels or other card mutations. Usage context is inferred rather than stated, so it meets the 'implied usage' bar but not higher.

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

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

With no annotations provided, the description must carry full behavioral disclosure. It only says 'Update a board' and mentions 'id + fields,' but fails to state side effects, authorization needs, reversibility, or the effect on unspecified fields. This is nearly bare for a mutation tool.

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

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

The description is very short, but this is under-specification rather than effective conciseness. It front-loads the core action but omits essential details, so the brevity is not a strength.

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

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

This is a mutation tool with no annotations, no output schema, and an opaque 'fields' object. The description fails to explain the expected structure of 'fields,' potential errors, or any behavioral nuances. It is inadequate for an agent to call this 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 description coverage is 0%, so the description must compensate. It only repeats the parameter names ('id + fields') without explaining the format of 'fields' or what properties it accepts. This adds minimal value beyond the schema itself.

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

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

The description states a clear verb+resource ('Update a board'), which distinguishes it from other update tools like update_project or update_card. It doesn't elaborate on the specific update capabilities, 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?

No guidance on when to use this tool versus alternatives. It doesn't mention prerequisites, when updates are appropriate, or why one would choose this over other board operations. The description implies general update usage but provides no context or exclusions.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. 'Update' implies mutation, but the description does not state whether the update is partial or full replacement, whether unspecified fields are affected, or whether any permissions or side effects are involved. The opaque 'fields' object adds no behavioral clarity.

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

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

The description is extremely brief and front-loads the verb and resource, which is structurally efficient. However, it is under-specified to the point of being cryptic—the fragment 'id + fields' reads like a shorthand note rather than a complete, self-contained definition. It earns conciseness points but loses structure points for being too terse.

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

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

This is a mutation tool with no annotations, no output schema, and a nested 'fields' object that is completely undocumented. The description does not explain what fields can be updated, what the response looks like, or any usage constraints. An agent without prior Planka knowledge could not invoke this 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 0%, so the description must compensate for the lack of parameter documentation. 'id + fields' merely restates the parameter names from the schema without explaining what 'fields' can contain, what field names are supported, or the expected value format. This adds minimal semantic value beyond the raw schema.

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

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

The description states a specific verb ('Update') and resource ('a card'), making the core operation clear. It distinguishes from siblings like planka_create_card and planka_delete_card via the 'update' action, though it does not explicitly differentiate from the other update tools beyond naming the 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?

There is no guidance on when to use this tool versus alternatives such as planka_create_card, planka_add_card_labels, or planka_remove_card_labels. The description only says 'Update a card,' implying usage context but providing no exclusions, prerequisites, or conditions for choosing it over siblings.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. 'Update a project' indicates mutation, but it does not clarify whether the update is partial or full, whether the project must already exist, what side effects occur, whether the operation is idempotent, or what the response shape is. This is a significant gap for a mutation tool.

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

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

The description is short and front-loaded, with no filler words. However, it is under-specified to the point of being terse: the 'id + fields' fragment saves words but sacrifices necessary clarity, so the conciseness comes at the cost of usefulness.

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, and an opaque nested fields object, the description should provide substantially more context. It lacks any reference to allowed field names, response behavior, error conditions, or relationships with sibling project tools. As it stands, the tool definition is insufficient for an agent to use 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 0%, so the description must compensate for the lack of parameter documentation. 'id + fields' merely echoes the schema's property names and provides little semantic value: it does not explain what the fields object should contain, how fields are formatted, or how partial updates behave. An agent cannot confidently construct a valid fields argument from this text.

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

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

The description clearly states the action ('Update') and the resource ('a project'), so an agent can tell it apart from read_project, create_project, and delete_project. It does not, however, specify what aspects of a project can be updated beyond the vague 'fields', so it stops short of a fully rich purpose statement.

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

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

There is no guidance about when to use this tool versus alternatives such as create_project, read_project, or delete_project. The only context is 'id + fields', which is a requirement signal, not a usage guideline; it does not mention prerequisites, conditions, or exclusions.

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