planka-mcp

Server Quality Checklist

Profile completionA complete profile improves this server's visibility in search results.

Latest release: v0.3.0
Disambiguation4/5
Tools are mostly distinct by resource and action. The only potential confusion is between update_task_details and set_task_labels (both can modify labels) and add_comment vs add_result, but descriptions clarify their intended uses.
Naming Consistency3/5
Most tools follow verb_noun snake_case, but the set mixes list_ and find_ for searches, set_ vs assign_ for people operations, and includes whoami as an outlier. These deviations make the naming pattern less predictable.
Tool Count2/5
30 tools exceeds the 25+ threshold for 'too many'. While each tool has a purpose, several are narrowly scoped (e.g., find_informal_assignments, update_checklist) and could potentially be consolidated.
Completeness3/5
Core workflows for projects, lists, and tasks are well covered, but there is no delete_task tool and no way to create or delete boards, leaving notable lifecycle gaps.
Average 4.4/5 across 30 of 30 tools scored. Lowest: 3.6/5.
See the Tool Scores section below for per-tool breakdowns.
- No community issues in the last 6 months
- No commit activity data available
- Last stable release on August 17, 2026
- No critical vulnerability alerts
- No high-severity vulnerability alerts
- No code scanning findings
- CI status not available
Add a LICENSE file by following GitHub's guide. Once GitHub recognizes the license, the system will automatically detect it within a few hours.
If the license does not appear after some time, you can manually trigger a new scan using the MCP server admin interface.
MCP servers without a LICENSE cannot be installed.
This repository includes a README.md file.
No tool usage detected in the last 30 days. Usage tracking helps demonstrate server value.
Tip: use the "Try in Browser" feature on the server page to seed initial usage.
Add a glama.json file to provide metadata about your server.
If you are the author, simply .
If the server belongs to an organization, first add glama.json to the root of your repository:
```
{
  "$schema": "https://glama.ai/mcp/schemas/server.json",
  "maintainers": [
    "your-github-username"
  ]
}
```
Then . Browse examples.
Add related servers to improve discoverability.

How to sync the server with GitHub?

Servers are automatically synced at least once per day, but you can also sync manually at any time to instantly update the server profile.

To manually sync the server, click the "Sync Server" button in the MCP server admin interface.

How is the quality score calculated?

The overall quality score combines two components: Tool Definition Quality (70%) and Server Coherence (30%).

Tool Definition Quality measures how well each tool describes itself to AI agents. Every tool is scored 1–5 across six dimensions: Purpose Clarity (25%), Usage Guidelines (20%), Behavioral Transparency (20%), Parameter Semantics (15%), Conciseness & Structure (10%), and Contextual Completeness (10%). The server-level definition quality score is calculated as 60% mean TDQS + 40% minimum TDQS, so a single poorly described tool pulls the score down.

Server Coherence evaluates how well the tools work together as a set, scoring four dimensions equally: Disambiguation (can agents tell tools apart?), Naming Consistency, Tool Count Appropriateness, and Completeness (are there gaps in the tool surface?).

Tiers are derived from the overall score: A (≥3.5), B (≥3.0), C (≥2.0), D (≥1.0), F (<1.0). B and above is considered passing.

Tool Scores

Behavior4/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
The description discloses the behavioral consequence that cards placed in a 'closed' list will be closed by Planka, advising to use that type only for genuine done stages. This adds meaningful context beyond the annotations (readOnlyHint=false, destructiveHint=false) and the schema's parameter description.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is just two sentences: the first states the tool's purpose, and the second provides a critical behavioral warning. It is concise, front-loaded, and every sentence earns its place.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness4/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the simple create-list operation, the presence of an output schema, and full parameter schema coverage, the description covers the essential behavioral nuance (closed list behavior) without needing to explain return values or basic parameter mechanics. It is sufficiently complete for an agent to select and invoke the tool correctly.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100%, so parameters are already well-documented. The description's note about the 'closed' list type adds a behavioral caveat but does not significantly expand semantics beyond what the schema already states (e.g., 'closed (cards land here as finished)'). It also does not illuminate the 'after' or 'color' parameters beyond their schema descriptions.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose4/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the action ('Add a workflow stage to a project') with a specific resource (project) and implicit object (list). It distinguishes from sibling tools like create_board and update_list by focusing on workflow stages, though it does not explicitly name alternatives.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines2/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
No guidance is provided on when to use this tool versus alternatives such as create_board or update_list. The only usage-related note concerns the 'closed' list_type parameter, which is more about parameter selection than tool selection. There are no explicit prerequisites or exclusions.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior4/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Beyond annotations (readOnlyHint=false, destructiveHint=false), the description adds meaningful context: removing a member does not delete their work or affect their account. This clarifies the tool's side effects and safety profile, though it could further detail behavior on role changes.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is two sentences, front-loaded with the primary action, and every sentence provides essential information. No unnecessary words or repetition.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness4/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
The description covers the main actions, a prerequisite, and a key behavioral guarantee. With a complete input schema and output schema present, the description is sufficiently complete for a membership management tool, though it could mention that multiple people can be processed simultaneously.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The schema descriptions already fully cover all three parameters (role, people, project_id) at 100%. The tool description does not add parameter-specific details beyond the overall action, which is adequate given the schema's thoroughness.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly specifies the tool's function: adding people to a project, changing their roles, or removing them. This distinguishes it from related tools like assign_people/unassign_people, which operate at the task level.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines3/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description notes that membership rights are required, providing a prerequisite for use. However, it does not explicitly differentiate when to use this tool versus alternatives like assign_people or unassign_people, leaving the usage context implicit.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior3/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already indicate readOnlyHint=false and destructiveHint=false, so the description only adds the permission requirement. It does not disclose any other behavioral traits like side effects, rate limits, or whether changes are reversible. The description adds moderate value beyond annotations.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is two sentences: the first enumerates the actions, the second states the permission requirement. It is concise, front-loaded, and contains no unnecessary words. Every sentence earns its place.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness4/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
The description covers purpose and permission adequately. An output schema exists, so return values are not needed. It does not mention the required board_id parameter explicitly, but the schema handles that. For a straightforward update tool, this is largely complete.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100%, so the schema already documents all parameters. The description summarizes the actions (rename, describe, hide, favourite) which map to the parameters, but it does not add meaning beyond what the schema provides. Baseline 3 is appropriate.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the verb actions (rename, describe, hide, favourite) and the resource (board). It lists specific operations, distinguishing it from other board-related tools like create_board or delete_list. The mention of 'container' in parentheses adds clarity.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines4/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides a clear precondition: 'Requires managing that board - instance admin, or one of its managers.' This tells the agent who can use the tool. While it does not explicitly compare to sibling tools, the context is sufficient since no other tool directly updates board attributes.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior4/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
The description adds behavioral context beyond annotations: it explicitly states that items are never deleted and must be reopened, and that only held or unclaimed tasks are mutable. Annotations already indicate non-destructive write (readOnlyHint=false, destructiveHint=false), but the description enriches this with concrete policies. No contradiction.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is two sentences, front-loaded with the primary use case and benefit, followed by constraints. Every sentence adds value—no redundancy or fluff. It is efficiently structured for quick agent comprehension.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness4/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Despite the tool having 6 parameters and an output schema, the description covers the core workflow (add, complete, reopen) and key constraints. It does not mention the ability to assign owners or set dependencies, but those are well-documented in the schema. The presence of an output schema reduces the need to describe return values. Overall, the description is largely adequate for an agent to decide when and how to use the tool.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
All 6 parameters have clear schema descriptions (100% coverage), so the baseline is 3. The description does not add parameter-specific meaning beyond the schema; it focuses on overall purpose. While it implicitly references add/complete/reopen, it does not elaborate on assign_items or depends_on_tasks, which are covered in the schema.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool is for breaking tasks into checklist steps and tracking progress. It uses the verb 'break' and 'tick off', explicitly describing the resource (checklist steps on a task). The description distinguishes this tool from siblings like update_task_details by focusing on sub-item management.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines3/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides a usage constraint ('Only tasks you hold, or unclaimed ones, can be changed') but does not explicitly state when to use this tool versus alternatives. Since no sibling tool directly competes for checklist management, the guidance is implied but not explicit. Missing when-not or alternative naming.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior4/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already show this is not read-only (readOnlyHint: false) and not destructive (destructiveHint: false). The description adds clear behavioral context by stating that changing type to inactive keeps cards intact and is reversible, which is valuable beyond the annotations. It also implicitly states renaming and reordering are safe operations.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
Two sentences, zero waste. Every word serves a purpose. The description is front-loaded with the primary actions and concludes with a clarifying example. There are no redundant or filler phrases.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness4/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a tool with 6 parameters, 2 required, and 100% schema coverage plus an output schema, the description is complete enough. It covers the main actions (rename, type change) and highlights a key behavioral nuance (inactivating is reversible). It could optionally mention that reordering is also supported, but 'change its type' implies multiple modifications are possible, so this is sufficient.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema coverage is 100%, so the baseline is 3. The description adds minimal meaning beyond the schema: it clarifies the special meaning of 'inactive' for list_type and mentions that reordering preserves cards, but the other parameters (name, after, color) are adequately explained in the schema descriptions. No new semantics are added for those.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool renames a list or changes its type with specific verb+resource ('Rename a list or change its type'). It distinguishes from siblings like 'create_list' and 'delete_list' and adds a concrete example of what changing type to 'inactive' means.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines3/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description gives explicit context for one use case ('Retiring a stage is a type change to inactive'), but does not provide guidance on when to use this tool versus alternatives like 'delete_list' (destructive) or 'update_project' (more broad). No when-not-to-use advice is given.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior3/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already declare readOnlyHint=false and destructiveHint=false, indicating a mutable but non-destructive update operation, which aligns with the description. The description adds value by stating the requirement for 'structure rights,' which goes beyond annotations. However, it does not discuss error states, partial update behavior, or what happens if the project_id doesn't exist. The behavioral disclosure is adequate but not exhaustive.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is extremely concise at two sentences with no wasted words. The first sentence front-loads the primary purpose and lists the key behavioral settings. The second sentence adds a critical prerequisite. Every sentence provides distinct value.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness4/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool has 7 parameters, 100% schema coverage, annotations for safety, and an output schema that would explain return values, the description covers the essential conceptual overview and a key prerequisite. The one gap is it doesn't explain the 'openWorldHint: true' annotation's implication (that the tool may have side effects outside the agent's knowledge), but this is an annotation already available to the agent. The description is sufficiently complete for an experienced agent.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100%, so each parameter has a description in the schema itself. The tool description provides a useful high-level summary of the parameter categories ('default view, kind of task it creates, whether checklists open expanded'), which helps an agent understand the conceptual groupings. However, the description doesn't add specific syntax details, constraints, or non-obvious behaviors for individual parameters beyond what the schema already provides. A score of 3 is appropriate per the baseline guidance for high schema coverage.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states both major capabilities: renaming a project and changing its behavior settings (default view, task kind, checklist expansion). It uses specific verbs like 'Rename' and 'change how it behaves' which precisely describe the tool's action against the 'project' resource. The description effectively distinguishes this from sibling tools like get_project, create_project, and list_projects.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines4/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description explicitly states a requirement: 'Requires structure rights.' This provides direct guidance on when the tool can be used. While it doesn't explicitly list when NOT to use it or name alternatives among siblings, the scope is well-defined, making it clear this is for updating existing project settings, not creating or deleting projects.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior3/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already declare readOnlyHint=true and destructiveHint=false, and the description doesn't contradict them. The description adds scope context ('one project, or the whole directory') and the role-listing behavior, but these mostly mirror the parameter schema and don't reveal additional behavioral traits such as pagination, auth, or result shape.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
Two sentences, front-loaded with the main action, and no filler or redundant details. Every sentence adds value: the first states what it does, the second states when to use it.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness5/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a simple read-only list tool with one optional parameter, an output schema, and thorough annotations, the description is complete. It covers the tool's function, scope, and intended use case without needing additional detail.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100%, so the schema already documents project_id and its default. The description paraphrases the same scope info without adding extra meaning about the parameter's format or behavior beyond what the schema provides.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description opens with a specific verb and resource: 'List people and their roles' and clarifies scope with 'members of one project, or the whole directory.' This clearly distinguishes it from sibling tools like assign_people or set_project_members, which modify assignments rather than list them.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines4/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
It provides an explicit use case: 'Use it to resolve a partial name before assigning work.' This gives clear context for when to call the tool, though it does not mention when not to use it or name alternative tools.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior4/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already indicate a non-destructive write (readOnlyHint=false, destructiveHint=false). The description adds valuable behavioral context: the requirement to hold the claim and the workflow timing for auditability. It could mention error behavior if the claim isn't held, but this is adequate.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
Two sentences with no filler. The first sentence front-loads the core purpose, the second adds crucial timing and prerequisite information. Every word earns its place.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness4/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
With a simple scope, annotations, and full schema coverage, the description covers purpose, timing, and prerequisites. The presence of an output schema mitigates the need to describe return values. It could have briefly mentioned idempotency, but the schema already handles that.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100%, so parameters are already well-documented. The description's mention of 'what you did, what you produced, where it lives' reinforces the note parameter but doesn't add new semantic details beyond schema. No additional meaning for task_id or idempotency_key is provided.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool's action: 'Attach your output to a task' with specifics about content ('what you did, what you produced, where it lives'). This distinguishes it from sibling add_comment by focusing on work output rather than general commentary.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines4/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
Provides explicit timing ('Post this before moving the task to done') and a prerequisite ('Requires that you hold the claim'). Does not explicitly name alternatives, but the strong contextual guidance makes appropriate usage clear.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior4/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already indicate a non-read-only, non-destructive operation. The description adds key behavioral details: tasks start unclaimed and labels must already exist, so this tool never invents board structure. These go beyond the basic annotation flags.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
Three sentences, front-loaded with the action, then essential behavioral notes. No redundant information or fluff.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness4/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
With 8 parameters, full schema coverage, and an output schema, the description sufficiently covers core behavior, unclaimed state, and label constraints. It doesn't explain return values, but the output schema handles that.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100%, so the baseline is 3. The description adds only minimal param-specific context (e.g., default todo stage, label existence), which is largely redundant with schema descriptions.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly identifies the action (create a new task), the target resource (a board's todo stage), and provides use cases (follow-up work or asked to file). This distinguishes it from sibling tools like update_task_details, claim_task, and move_task.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines4/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
It gives specific context for when to use this tool (follow-up work or filing a task) and notes that the task lands unclaimed, implying you may need to claim it before working. It doesn't explicitly name alternative tools, but the guidance is sufficient.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior3/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already cover read-only false and non-destructive, and the description adds context about use cases but does not disclose additional behavioral traits like side effects, permissions, or reversibility. It provides some value beyond annotations but not substantial behavioral detail.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is two sentences, front-loaded with the primary action, and includes a useful example ('Blocked' or 'Icebox') without redundancy. Every sentence earns its place.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness4/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool has an output schema and annotations, the description is sufficiently complete for a mutation tool with three parameters. It could mention edge cases like requiring at least one destination parameter, but the schema and sibling context make the description adequate.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The input schema has 100% coverage for all three parameters, each with descriptions. The tool description does not add any new information about parameter semantics, so it matches the baseline for complete schema coverage.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool moves a task to another list or project, with specific verbs and resource. It also distinguishes itself from update_status by indicating it is for non-standard stages, making its purpose unambiguous.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines5/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
Explicitly states when to use this tool ('for stages that are not part of the todo/in_progress/review/done flow') and contrasts with update_status, providing a clear exclusion and directing to the alternative. This is excellent usage guidance.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior3/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already indicate this is a write operation (readOnlyHint=false) and non-destructive (destructiveHint=false). The description adds the audience nuance ('for the humans watching the board') but does not disclose additional behaviors like notification, permissions, or whether comments append or replace. Thus, it meets the basic bar but adds limited behavioral detail.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is two sentences, front-loaded with the verb and resource, and every phrase serves a purpose. It efficiently communicates the tool's purpose and the key alternative without wasteful text.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness5/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the simple parameter set (2 required parms, fully documented), the presence of an output schema, and clear annotations, the description is complete. It explains the purpose, audience, and relevant alternative tool, leaving no critical gaps for an agent to invoke it correctly.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100%, so the schema already fully documents both task_id and text. The description does not add any extra parameter meaning beyond what the schema provides, so the baseline of 3 is appropriate.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool's function: 'Leave a comment on a task.' It specifies the content types ('a question, a blocker, or progress context') and distinguishes from the sibling tool add_result by directing users to use that for actual deliverables.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines5/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description explicitly says 'Use add_result for the actual deliverable,' providing a clear when-not-to-use and naming the alternative. It also gives context for when to use: to leave qualitative updates for humans watching the board.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior4/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
The description adds behavioral context beyond annotations by enumerating exactly what data is returned (list-status mappings, label usage, member roles, own role). It does not contradict the readOnlyHint/openWorldHint annotations. Could mention open-world caveats, but annotations already cover safety.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is two succinct sentences that front-load the purpose and enumerate return contents. Every sentence earns its place with no wasted words.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness5/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a read-only retrieval tool with one well-documented parameter, strong annotations, and an output schema, the description fully covers purpose, return content, and usage timing. It is contextually complete.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The schema already fully describes the sole parameter project_id with a reference to list_projects. The description adds no additional parameter details, so the baseline of 3 is appropriate.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool retrieves the full structure of a single project, listing specific components (lists, status mappings, labels usage, members, roles). This distinguishes it from siblings like list_projects (which lists projects) and get_task (task-level details).
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines4/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The instruction 'Read this before changing structure or assigning people' provides explicit timing guidance, indicating the tool should be used before mutation or assignment operations. It implies but does not explicitly name alternatives, though the context is clear.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior4/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already mark this as read-only and non-destructive. The description adds value by revealing the scope of the returned detail (labels, subtasks, assignees, comments, dependencies), giving the agent a precise expectation of the data. It does not mention auth or rate limits, but none are suggested by the annotations; no contradiction.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is concise (two sentences), front-loaded with the core function, and every word adds value. It efficiently combines resource scope and usage timing without redundancy.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness5/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
With one well-documented parameter, an output schema, and read-only annotations, the description covers the essential context. It tells what the tool does, what content is returned, and when to use it, making it complete for this simple reference tool.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100% for the single task_id parameter, including its source ('from list_actionable_tasks'). The description does not add any additional parameter semantics, so the baseline score of 3 applies.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool provides 'Full detail for one task' and enumerates specific fields (description, labels, subtasks, assignees, comments, waiting on). This distinguishes it from siblings like list_actionable_tasks and claim_task by focusing on retrieving comprehensive detail for a single task.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines4/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description explicitly instructs to use it 'after you claim a task, to understand what has to be done.' This gives a clear temporal usage context, though it does not name alternative tools or exclusion scenarios, so it falls short of a 5.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior4/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already declare this as a safe, read-only, open-ended operation. The description adds useful context beyond annotations by noting it returns the user's role on each project and is scoped to projects the user 'can work in.' This helps the agent understand the response content and access scope without contradicting the annotations.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is two sentences with no wasted words. The first sentence states the core function and result ('projects (tabs) ... role you hold'), and the second sentence gives a practical starting point. Information is front-loaded and easy to parse.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness5/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the simple one-parameter schema, the presence of an output schema, and annotations covering safety, the description provides all necessary context: what the tool does, the scope ('you can work in'), and when to use it ('Start here'). No significant gaps remain.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The input schema fully documents the only parameter, board_id, with a clear description: 'Only projects inside this board. Omit for all.' Since schema coverage is 100%, the description does not need to explain parameters further, and it does not add additional meaning beyond what the schema provides.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool's function: 'List the projects (tabs) you can work in, with the role you hold on each.' This identifies a specific resource (projects/tabs) and distinguishes it from single-project operations like get_project and board-level operations like list_boards.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines4/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides explicit usage guidance: 'Start here when you are asked to do something on a named project.' This tells the agent when to invoke this tool, though it does not explicitly mention when not to use it or name alternative tools for other scenarios.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior4/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already indicate the tool is a write operation and not destructive. The description adds valuable context about the side-effect that project membership remains unchanged, which is not obvious from the name or annotations.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
Two concise sentences, front-loaded with the action and followed by a clarifying nuance. Every sentence earns its place without redundancy.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness5/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a simple two-parameter mutation with output schema and annotations, the description adequately captures the essential behavior and the key distinction from sibling tools. No critical information is missing.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Input schema covers 100% of parameters with descriptions for both task_id and people. The tool description does not add further parameter-level detail, so the baseline of 3 is appropriate.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description uses a specific verb ('Take people off') and identifies the resource (task) and the precise action (removes the assignment). It distinguishes this tool from assign_people and set_project_members by clarifying that project membership is untouched.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines4/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description implies when to use this tool by highlighting that it only removes the assignment and does not affect project membership. This gives context for choosing it over alternatives, but it does not explicitly name alternatives or list exclusions.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior4/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations (readOnlyHint: false, destructiveHint: false) indicate this is a non-read, non-destructive operation. The description adds behavior beyond annotations by stating 'A label still applied to cards is never deleted', which prevents the agent from assuming deletion is unconditional. This addresses a key behavioral nuance that annotations alone do not cover.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
Two sentences, each earning its place: the first states the core purpose, the second clarifies a critical behavioral constraint. No wasted words, information is well prioritized.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness4/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given 5 parameters (100% schema coverage), rich annotations, and an output schema, the description fully addresses the use case. It explains the purpose, how parameters relate to categories, and a key side-effect (deletion refusal). The output schema presumably covers return values, so no need to mention them. Slight deduction for not mentioning that rename affects only name (not color/position) or that colors map to specific labels.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters4/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema coverage is 100%, so baseline is 3. The description adds value by linking parameters to the label categories ('priority, size and state') and by explicitly noting deletion safety ('Refused if the label is on any card'), which the schema only implies for delete_unused. It also explains color semantics ('Unset ones cycle through the palette') beyond the schema's 'Colour for labels being created or recoloured'.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the verb ('Create, rename or remove') and the resource ('labels a project uses'), distinguishing it from siblings like set_task_labels (which assigns labels to tasks). The scope is specific to label management at the project level.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines4/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description implies when to use it (managing labels for priority, size, state) but does not explicitly state when not to use it or mention alternatives (e.g., set_task_labels for assigning labels to tasks). The context of 'project uses' is clear enough to infer usage boundaries.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior5/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
The description goes well beyond the annotations: it warns that create_api_key returns the key only once, replaces any existing key, and should be treated as a secret. It also states the server will never elevate its own role or grant admin. These are critical behavioral disclosures that the annotations (readOnlyHint false, destructiveHint false) do not capture.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is well-organized: a one-sentence purpose statement, a context condition, and then focused security notes. It is detailed but every sentence serves a purpose, with no filler or repetition.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness3/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
The description covers most actions but omits create_person, which appears in the action enum. For a tool with five distinct actions, one significant action being unmentioned is a notable gap. The output schema exists, so return-value documentation is not required, but the missing action limits completeness.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters4/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema coverage is 100%, so the baseline is 3. The description enriches parameter understanding by explaining the consequences of actions (e.g., create_api_key breaks existing keys) and the admin restriction, which adds meaning beyond the schema field descriptions. This justifies a 4.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description opens with 'Instance-level administration' and lists specific actions: change roles, add board managers, mint/revoke API keys. This clearly identifies the tool's resource (people) and scope (instance-level), distinguishing it from project-level siblings like set_project_members.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines4/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description explicitly notes the tool is disabled unless PLANKA_ALLOW_USER_ADMIN is set, providing a clear precondition. It implies use for instance-level tasks rather than project-level alternatives, but does not explicitly name any alternative tool or give when-not-to-use guidance, so it stops short of a 5.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior5/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
The description enriches the annotation-declared idempotency by explaining the atomic uniqueness row, the `already_taken` failure response, and the idempotent success on repeat claims. This goes well beyond the structured annotations and helps the agent predict runtime behavior.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is compact and information-dense, covering purpose, atomicity, race condition, idempotency, and self-only constraint in three sentences with no redundancy.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness5/5
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 an output schema, the description fully covers the critical aspects: when to claim, the atomic/unique semantics, the failure mode, idempotency, and the self-only limitation. No significant gaps remain.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The schema fully documents the required `task_id` parameter (100% coverage). The description adds no additional parameter-level detail, but the schema's description 'taken from list_actionable_tasks' already provides sufficient guidance. Baseline 3 is appropriate.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description explicitly states the tool's purpose: 'Claim a task for yourself before working on it.' It clearly identifies the verb (claim), the resource (task), and the scope (for yourself), distinguishing it from sibling tools like assign_people and release_task.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines4/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides clear context for when to use the tool ('before working on it') and implicitly warns against using it for other users ('never for another user'). It also advises what to do if a race is lost ('should simply pick another task'), but does not explicitly name alternative tools.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior5/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already declare readOnlyHint=true and destructiveHint=false, and the description reinforces and extends this with 'Read-only - it changes nothing on its own.' It also discloses the detection logic, the fact that the output includes the exact assign_people call, and the caveat that a mention is not always a hand-off. This goes well beyond the annotations.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single well-structured paragraph that front-loads the core purpose, then explains the problem context, output value, and safety caveat. Every sentence earns its place; there is no filler, and the length is justified by the richness of the scenario.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness5/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool's complexity and the presence of an output schema, the description is highly complete. It explains why informal assignments are a problem, what the tool reports, the exact follow-up action (assign_people call), and a human-confirmation safety note. Nothing essential is missing.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The input schema has 100% coverage with detailed parameter descriptions (e.g., 'Check every project inside one board', 'Include finished tasks'). The description adds no extra parameter-level meaning beyond the schema, so the baseline 3 applies.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description opens with a specific verb+object: 'Find work handed out in comments but never actually assigned.' It clearly distinguishes this from siblings like assign_people or find_tasks by focusing on the informal hand-off detection problem, with no ambiguity about 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.
Usage Guidelines4/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides strong context: it explains the problem scenario (teams writing 'Assigned to' in comments), states the tool reports such comments, and gives a clear 'confirm with a human before acting' warning. It does not explicitly name a sibling alternative to use instead, but the purpose is so distinct that the when-to-use intent is clear.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior5/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already declare read-only and non-destructive behavior, and the description adds valuable context: the filtering is server-side, only 'todo' stage cards in active lists are returned, and each result includes fields needed for decision-making (title, priority, due date, effort, labels, subtask counts, description excerpt). This goes well beyond the structured annotations.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is succinct yet comprehensive: opens with purpose, then gives ordering, filtering logic, result contents, and next step. No wasted words, and the structure flows logically.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness5/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
With an output schema present, the description need not repeat return details. It covers the essential context: what tasks are returned, in what order, what data is available, and how to proceed. This is complete for a read-only discovery tool.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100%, with clear descriptions for limit, search, and board_id. The tool description itself does not elaborate on these parameters, but the schema already handles them. Baseline 3 applies.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description uses a specific verb+resource ('List tasks') and clearly defines the scope ('genuinely ready to be worked on'). It distinguishes itself from siblings by emphasizing it's the first call, leading to claim_task, and explicitly describes the server-side filtering criteria that make it unique.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines4/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides clear context on when to use it ('Call this first, before any other tool') and what to do after (call claim_task). It doesn't explicitly mention when not to use it or alternatives, but the guidance is strong enough to be unambiguous.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior4/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already declare readOnlyHint=true, openWorldHint=true, and destructiveHint=false, so safety is covered. The description adds that it lists only boards 'you can reach' (access scoping) and defines the board-project relationship, which gives useful context beyond structured data.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
Two concise sentences front-load the action and add meaningful context without extraneous detail. Every sentence earns its place.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness5/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a zero-parameter, read-only tool with an output schema, the description is complete: it explains what boards are, what the list contains, and when to use it. The presence of an output schema removes the need to document return values.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters4/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
No parameters exist in the schema, so the description carries no burden for parameter semantics. Baseline of 4 applies because the tool requires no arguments.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
Clearly states it lists boards, defines boards as containers that hold projects, and distinguishes from list_projects by scope (boards vs projects). The use cases ('find where a project lives, or before creating a new project') reinforce its purpose.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines4/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
Explicitly states when to use it: to find where a project lives or before creating a new project. It doesn't provide exclusions or alternative tools, but the context is clear enough; siblings like list_projects are implicitly distinct.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior5/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Beyond the annotations (destructiveHint=false, idempotentHint=true), the description adds valuable specifics: it ensures no data deletion, states that the task and history stay on the board, and clarifies that other assignments are untouched. This gives the agent a concrete model of the tool's effects.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is three sentences long, with the first sentence immediately conveying the primary purpose. Every sentence adds distinct information: the action, the scope limitation, and the non-destructive guarantee. No redundant or filler content.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness5/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a simple tool with a well-covered schema and an output schema present, the description is sufficiently complete. It explains the core behavior, safety guarantees, and lasting effects on the task and board. The optional move_back_to_todo behavior is documented in the schema, so its omission from the description does not create a gap.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100%, with all three parameters (task_id, reason, move_back_to_todo) having clear descriptions in the schema. The tool description does not add additional meaning or clarify parameter relationships beyond what the schema already provides, so a baseline score of 3 is appropriate.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the action ('Give up your claim on a task') and the resource (task). It also distinguishes from sibling tools by explicitly noting that only your own claim is removed and other assignments remain untouched, differentiating it from tools like unassign_people.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines4/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides clear context for when to use the tool (when you cannot finish a task) and implicitly excludes using it for other people's assignments via 'Only your own claim is ever removed.' However, it does not explicitly name alternative tools or provide a 'when not to use' directive beyond the scope limitation.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior4/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
The description adds valuable context beyond the annotations: it explicitly states that labels are untouched and only the link to the task changes. This clarifies side effects and scope. Annotations already indicate mutating (readOnlyHint=false) and non-destructive (destructiveHint=false), and the description reinforces these without contradiction.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
Two concise sentences front-load the core action, followed by a clarifying note on scope. No wordiness, and every sentence contributes to understanding.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness5/5
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 covers purpose, effect, and boundary (labels untouched), and with full schema coverage and annotations, nothing further is needed. Output schema exists so return format need not be explained.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters4/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100%, giving parameter names and simple descriptions. The tool description adds meaning by clarifying that 'add' and 'remove' opertate on label names and that priority/size are represented as labels, helping the agent understand how to use the parameters in the context of the tool's purpose.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the action: 'Apply or take labels off a task'. It also distinguishes from sibling tools like manage_labels by explaining that labels themselves are untouched, making the tool's specific purpose unambiguous.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines4/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
It provides clear context: this changes a task's priority or size via labels, and labels themselves are not modified. This implicitly tells the agent not to use it for label management, though it doesn't explicitly name alternatives or exclusions.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior4/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
The description adds meaningful behavioral context beyond annotations: it discloses an authorization requirement (holding the claim), an environmental requirement (target list exists), and rejection of illegal transitions. Annotations already indicate mutation and idempotence, and no contradiction exists.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is three sentences: core action, legal transitions, and constraints. Every sentence is purposeful, front-loaded, and free of redundancy or filler.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness5/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a two-parameter status transition tool, the description covers the action, allowed moves, preconditions, and rejection behavior. The presence of an output schema and annotations covers return values and mutability, leaving no major gaps.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters4/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema covers both parameters with high coverage, but the description adds an important legal-move graph (todo -> in_progress -> review -> done plus in_progress -> todo) that the schema's status description does not provide. This helps the agent choose valid status transitions, going beyond the simple allowed-value list.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description states 'Move a task you have claimed to a new status,' giving a specific verb and resource. It further defines legal moves (todo -> in_progress -> review -> done, plus in_progress -> todo), which clearly distinguishes this status-workflow tool from generic siblings like move_task or update_task_details.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines4/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
It explicitly states prerequisites ('You must hold the claim on the task, and the board must have a list for the target status') and says illegal jumps are rejected, which tells the agent when the tool applies. It does not explicitly name alternatives such as move_task for non-status repositioning, so it falls just short of full alternative guidance.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior4/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations indicate readOnlyHint is false, destructiveHint is false, and openWorldHint is true. The description clarifies it is a copying tool (not destructive, but creates new resources) and explicitly states no cards are copied, which is important behavioral detail beyond annotations.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness4/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is three sentences, front-loaded with the main purpose, followed by an explicit usage guideline and an illustrative example. Each sentence adds value, though the example could be slightly more concise.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness5/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the high schema coverage, output schema exists (covering return values), and good annotations, the description is complete. It covers what the tool copies, what it doesn't, when to use it, and an example distinguishing it from alternatives. No gaps remain for an agent to select or invoke correctly.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters4/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema coverage is 100%, so baseline is 3. The description adds context by explaining the significance of copying column types versus just naming, which adds meaning beyond schema descriptions. It also implies that source_project_id is the template, aligning with the parameter descriptions.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool clones a project's layout (columns with types and order) and optionally labels/members, and explicitly says no cards are copied. This distinguishes it from create_project by emphasizing it copies structure, not creating from scratch.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines5/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description explicitly says 'Prefer this over create_project when an existing project is the template' and explains why copying a column is different from naming one 'Done', providing concrete guidance on when to use this tool over the alternative.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior5/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Beyond the annotations, the description reveals the key behavioral rule: a list with cards is never deleted. It also explains the workaround, which is essential because the tool name alone might imply it deletes any list. The annotations (readOnlyHint=false, destructiveHint=false) are consistent with this non-destructive but write-capable behavior, and the description adds critical context.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
Two sentences, with the main purpose front-loaded. The second sentence adds necessary context without fluff. Every word earns its place.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness4/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a simple two-parameter delete tool, the description covers the purpose, the key precondition (empty list), and the alternative action. An output schema exists, so return values are handled. Minor gap: it doesn't specify what actually happens when attempting to delete a non-empty list (error vs. no-op), but this is not critical for decision-making.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The input schema provides complete descriptions for both parameters (project_id and list_name_or_id), so the baseline is 3. The description does not add parameter-specific details beyond what the schema already documents.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description begins with 'Delete an empty list', which is a specific verb+resource with a clear constraint. It also distinguishes itself from siblings by mentioning update_list as the alternative for retiring a stage with cards, and clarifies that non-empty lists are never deleted.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines5/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
Explicitly states when to use (empty list) and when not to use (list holding cards), and provides a concrete alternative: move cards out first or use update_list(list_type='inactive'). This is clear, actionable guidance.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior5/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
The description discloses several non-obvious behaviors: the side effect of adding non-members to the project, name resolution rules ('resolved against the project's members and the user directory'), the error policy for ambiguous names ('reported rather than guessed'), and permission requirements for granting membership. This far exceeds the annotation hints (readOnlyHint: false, openWorldHint: true, destructiveHint: false) and provides valuable transparency.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is three sentences long, with the main action front-loaded. Every sentence provides essential information: the core function, the resolution/ambiguity behavior, and the permission constraint. There is no fluff or repetition of schema content.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness5/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool's complexity (side effects, permission edge cases, name resolution), the description covers all critical aspects: what it does, when adding to project happens, how names are handled, and authorization limits. An output schema exists, so the return format is already documented. No significant missing context.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters4/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema coverage is 100%, so the baseline is 3. The description adds meaning beyond the schema by explaining how the 'people' parameter is resolved ('Each name is resolved against the project's members and the user directory') and that ambiguous names are not guessed. This clarifies the interpretation of string inputs beyond the schema's simple list of name/email/id examples.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the primary action 'Assign people to a task' and the resource, with an added condition 'adding them to the project first if they are not members yet'. It also distinguishes itself from siblings like unassign_people and set_project_members by explaining its unique behavior of auto-adding members.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines4/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description gives clear context on when to use the tool (assigning people to a task) and includes permission guidance ('a worker can assign existing members but cannot pull new people onto the project'). However, it does not explicitly name alternative tools or state exclusions, leaving the comparison to siblings implicit.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior5/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
While annotations already indicate a mutating operation (readOnlyHint=false), the description adds crucial behavioral context about authorization requirements and task ownership. It also clarifies the non-destructive nature implicitly. No contradictions with annotations.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is compact and front-loaded with the action and examples. Each sentence provides distinct value: purpose, usage context, and constraints. No redundant information.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness5/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool's simplicity, 100% schema coverage, and presence of an output schema, the description fully covers purpose, usage, and constraints. It provides all necessary context for an agent to select and invoke this tool correctly.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters3/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema coverage is 100%, so the schema already documents all three parameters adequately. The description adds minimal extra meaning (e.g., 'you produced' implies ownership of the URL), but this doesn't significantly enhance parameter understanding beyond the schema.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description uses a specific verb ('Attach a link to a task') and gives concrete examples (pull request, document, dashboard). It clearly distinguishes this tool from siblings by mentioning its use alongside add_result for external outputs.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines5/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
Explicitly states when to use the tool ('when the output lives somewhere else') and names the alternative (add_result). Also provides a permission constraint ('Only tasks you hold, or unclaimed ones, can be changed'), offering clear context for usage.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior4/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already indicate readOnlyHint=false and destructiveHint=false, so the agent knows this is not destructive but is a write operation. The description adds critical context: the tool requires admin rights, and it creates default workflow lists, making the project immediately usable. However, it does not mention any potential side effects (e.g., board visibility changes, notification triggers), but given the annotation coverage, this is acceptable.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
Two sentences in the description, zero filler. The first sentence states purpose and benefit; the second sentence provides precise usage guidance with sibling reference. Every word earns its place.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness5/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
The tool has 7 parameters (all documented), a helpful output schema (not shown but present), has annotations covering safety, and the description adds the missing usage context (admin rights, sibling differentiation). For a creation tool of moderate complexity, this is fully complete.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters4/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100%, so the baseline is 3. The description adds value by explaining the default behavior for the 'lists' parameter ('Defaults to To Do / In Progress / Review / Done') and by hinting at the conventional typing logic ('a 'done'-style name becomes a closed list'), which is not in the schema. For 'project_type', it clarifies that only 'project' projects are scanned for tasks, a useful behavioral note.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the verb ('Create'), resource ('new project (tab) inside a board'), and key benefit ('pre-populated with workflow lists so it is immediately usable'). It distinguishes itself from sibling 'copy_project_structure' by contrasting the intended use case.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines5/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description explicitly states the prerequisite ('Requires admin rights on that board') and gives a clear when-not-to-use scenario: if the goal is to reproduce an existing project's layout, use 'copy_project_structure' instead, with reasoning about list type fidelity.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior4/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
The annotations already declare destructiveHint=false, so the agent knows this is non-destructive. The description adds behavioral context beyond annotations by specifying the ownership constraint ('Only tasks you hold, or tasks nobody has claimed, can be edited'), which is critical for safe invocation. However, it could also mention what happens on failure (e.g., if the task is claimed by another worker), earning a 4 rather than 5.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is two sentences with zero wasted words. The first sentence is front-loaded with the verb and objects, and the second sentence adds critical usage constraints. Every sentence earns its place.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness5/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool's moderate complexity (7 parameters, 1 required), full schema description coverage, presence of an output schema, and clear annotations, the description is complete. It covers purpose, usage constraints, and ownership rules without needing to explain return values (handled by output schema). No gaps remain for an agent to safely invoke this tool.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters4/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100%, so each parameter already has a description in the schema. The tool description adds value by grouping the parameters ('title, description, deadline or labels') and framing their purpose ('Refine a task's...'), but does not add new semantics beyond what the schema provides. A 4 is appropriate for good grouping without extra detail.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description uses a specific verb 'Refine' and clearly identifies the resources acted upon ('task's title, description, deadline or labels'). It also gives a concrete example use case ('after investigating and learning what the work actually involves'), which strongly distinguishes it from siblings like 'create_task', 'get_task', or 'move_task'.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines5/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description explicitly states when to use this tool ('after investigating and learning what the work actually involves') and provides clear exclusion criteria: 'Only tasks you hold, or tasks nobody has claimed, can be edited; another worker's task is never touched.' This directly guides the agent on when not to use it and implicitly distinguishes it from related tools like 'claim_task', 'release_task', or 'update_status'.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior4/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already declare readOnlyHint=true and destructiveHint=false, so the safety profile is covered. The description adds context about the server's role and permission awareness, and notes that it can be used to preempt failures due to insufficient rights. No contradictions with annotations.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is two short sentences, front-loaded with the core purpose, and every clause adds value. It is concise without omitting necessary guidance.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness5/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a zero-parameter introspection tool with an output schema and thorough annotations, the description is fully complete. It explains what the tool does and when to invoke it, leaving no gap in understanding.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters4/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The tool has zero parameters and schema description coverage is 100%, so there are no parameter details needing explanation. The baseline of 4 applies because no parameter information is required.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states that the tool reports the server's active identity and allowed actions, distinguishing it from all sibling tools which operate on boards, tasks, and projects. The phrasing 'Who this server is acting as, and what it is allowed to do' is specific and unambiguous.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines5/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description explicitly says to call this tool when a request might exceed rights, giving a concrete trigger condition. This provides a clear 'when to use' directive, and no alternatives are needed since this is a unique introspection tool.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior5/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
The annotations indicate this is a mutating tool requiring specific authorization (admin/projectOwner role). The description openly clarifies that Planka will reject requests from other roles, adding an important behavioral caveat to avoid unexpected failures. No contradiction with annotations.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
Extremely concise at two sentences with zero waste. The first sentence identifies the tool, and the second provides critical usage guidance.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness5/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the full annotations (including an output schema for success details) and the presence of many sibling tools, this description is complete. It covers purpose, prerequisites (auth), behavioral constraints, and workflow sequencing (board before projects).
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters4/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema coverage is 100%, so parameters are well-documented. The description adds value by not repeating param details, but it's a very short description that trusts the schema. The shared parameter's schema description already covers the business impact, but the tool description doesn't expand on it further – a minor missed opportunity.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description starts with strong specificity, stating the tool creates a 'board' that holds projects (tabs) – a precise verb+resource+scope. It clearly distinguishes itself from siblings like `create_project` by noting the board is created first, then filled with projects.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines5/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
Explicitly states when to use this tool ('Create the board first') and what to do after ('then fill it with create_project or copy_project_structure'). Also provides a critical exclusion: requires an admin or projectOwner account, guiding agents away from this tool if they lack those credentials.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Behavior5/5
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations note readOnlyHint and openWorldHint, but the description adds substantial behavior: search matches tasks, checklist items, and mentions for a person; results include matched_by; results are read-only context; other people's tasks are off-limits for edit. No contradiction with annotations.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Conciseness5/5
Is the description appropriately sized, front-loaded, and free of redundancy?
Four sentences are front-loaded with the core purpose, then differentiation, then detail. No wasted words; each sentence adds value and the structure is logical.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Completeness5/5
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
With full schema coverage, annotations, and an output schema present, the description covers the high-level scope, sibling differentiation, and key behavioral nuances. Nothing essential is missing for a search tool of this complexity.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Parameters4/5
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema covers all 10 parameters with descriptions, so baseline is 3. The description adds meaningful semantics for the assignee parameter, explaining the three ways a person can be matched and that results indicate how via matched_by. This goes beyond schema.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Purpose5/5
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool searches tasks across all visible projects, including others' tasks. It explicitly distinguishes itself from list_actionable_tasks, naming the sibling tool and its different scope.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Usage Guidelines5/5
Does the description explain when to use this tool, when not to, or what alternatives exist?
Provides explicit when-to-use guidance: use for whole-workspace questions versus list_actionable_tasks for your own queue. Also explains read-only nature and that edits go through other tools, with a clear exclusion for editing others' tasks.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

GitHub Badge

Glama performs regular codebase and documentation scans to:

Confirm that the MCP server is working as expected.
Confirm that there are no obvious security issues.
Evaluate tool definition quality.

Our badge communicates server capabilities, safety, and installation instructions.

Card Badge

Copy to your README.md:

[![planka-mcp MCP server](https://glama.ai/mcp/servers/KT-SPARKS/planka-mcp/badges/card.svg)](https://glama.ai/mcp/servers/KT-SPARKS/planka-mcp)

Score Badge

Copy to your README.md:

[![planka-mcp MCP server](https://glama.ai/mcp/servers/KT-SPARKS/planka-mcp/badges/score.svg)](https://glama.ai/mcp/servers/KT-SPARKS/planka-mcp)

Latest Blog Posts

Who's Calling? MCP Hosts Are an Identity Blind Spot (And the Spec Knows It)
By Om-Shree-0709 on July 25, 2026.
mcp
Agent Identity
OAuth 2.1
Your AI Chatbot Just Exposed Your CEO's Salary to an Intern
By Om-Shree-0709 on July 2, 2026.
Agent Identity
MCP Security
OAuth Delegation
Why MCP Servers Need Execution Sandboxing (And Why Your Current Stack Isn't Enough)
By Om-Shree-0709 on June 30, 2026.
Agentic Ai
Prompt Injection
WebAssembly

MCP directory API

We provide all the information about MCP servers via our MCP API.

curl -X GET 'https://glama.ai/api/mcp/v1/servers/KT-SPARKS/planka-mcp'

If you have feedback or need assistance with the MCP directory API, please join our Discord server