tpm-mcp

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It states the tool retrieves information, implying a read-only operation, but doesn't specify behavioral traits like authentication needs, rate limits, or potential side effects (e.g., if it logs usage). It adds value by detailing the types of information returned, but lacks depth on operational constraints.

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

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

The description is a single, efficient sentence that front-loads the core action ('Get information') and specifies the resource and details without waste. Every word earns its place by clarifying scope and content, making it easy to parse quickly.

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

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

Given the tool's low complexity (0 parameters, no output schema, no annotations), the description is reasonably complete for a simple info-fetching tool. It specifies what information is retrieved, but lacks details on output format, error handling, or server-specific nuances. Without annotations or output schema, more context on return values would be beneficial for full completeness.

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

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

The input schema has 0 parameters with 100% description coverage, so the schema fully documents the lack of inputs. The description adds no parameter-specific information, which is appropriate here. Baseline is 4 for zero parameters, as no compensation is needed for schema gaps.

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

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

The description clearly states the tool's purpose with a specific verb ('Get') and resource ('information about the tracker MCP server'), including what information is retrieved (database location, stats, and usage). It distinguishes itself from sibling tools that focus on notes, orgs, projects, tasks, and tickets rather than server metadata. However, it doesn't explicitly differentiate from potential similar tools like 'status' or 'health' that might exist elsewhere.

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

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

The description implies usage context by specifying what information is retrieved, suggesting it's for server diagnostics or monitoring. However, it provides no explicit guidance on when to use this tool versus alternatives (e.g., for checking server status vs. querying data), nor does it mention prerequisites or exclusions. The context is clear but lacks detailed when/when-not instructions.

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

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

With no annotations provided, the description carries full burden but lacks behavioral details. It doesn't disclose whether this is a safe operation, if it requires specific permissions, how notes are stored, or if there are rate limits. The description adds minimal context beyond the basic action, leaving gaps for a mutation tool.

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

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

The description is concise and front-loaded with the core action, using a single sentence. However, the parenthetical 'PROJECT MANAGEMENT (TPM)' adds minor noise without clear value, slightly reducing efficiency.

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

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

Given no annotations and no output schema, this is a mutation tool with incomplete context. The description lacks details on behavioral traits, error handling, or return values, making it inadequate for safe and effective use by an AI agent.

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

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

Schema description coverage is 100%, so the schema fully documents parameters. The description doesn't add any parameter-specific information beyond what's in the schema, such as examples or constraints. Baseline 3 is appropriate as the schema handles the heavy lifting.

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

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

The description clearly states the action ('Add a note/comment') and target ('to a ticket or task'), with the purpose ('for context or decisions'). It distinguishes from siblings like note_get or note_list by specifying creation rather than retrieval. However, it doesn't explicitly mention all entity types from the schema (org, project).

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

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

The description implies usage through the phrase 'for context or decisions' and the TPM context, suggesting when to add notes. However, it doesn't provide explicit guidance on when to use this tool versus alternatives like updating tasks/tickets directly, or when not to use it (e.g., for major changes). No sibling tool comparisons are made.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It states it's a 'Get' operation, implying read-only behavior, but doesn't specify permissions required, error handling, rate limits, or what 'full content' includes (e.g., text, metadata). This leaves significant gaps for a tool with no annotation coverage.

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

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

The description is front-loaded and concise, using only one sentence with no wasted words. It efficiently conveys the tool's purpose and context without unnecessary details, making it easy to parse quickly.

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

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

Given the tool's low complexity (single parameter, no output schema, no annotations), the description is adequate but incomplete. It covers the basic purpose but lacks behavioral details (e.g., permissions, error cases) and doesn't explain return values, which is a gap since there's no output schema. This makes it minimally viable but with clear room for improvement.

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

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

The description adds minimal value beyond the input schema, which has 100% coverage and clearly documents the 'note_id' parameter. The description mentions 'by ID', reinforcing the schema, but doesn't provide additional context like ID format or examples. With high schema coverage, the baseline is 3.

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

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

The description clearly states the tool's purpose with a specific verb ('Get') and resource ('full content of a specific note'), and it includes the domain context ('PROJECT MANAGEMENT (TPM)'). However, it doesn't explicitly differentiate from sibling tools like 'note_list' or 'task_get', which would require a 5.

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

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

The description implies usage by specifying 'by ID' and the domain context, suggesting it's for retrieving individual notes in project management. However, it lacks explicit guidance on when to use this tool versus alternatives like 'note_list' or 'task_get', and doesn't mention prerequisites or exclusions.

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

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

With no annotations provided, the description carries full burden. It discloses the return format (id, created_at, preview with character limit) and implies read-only behavior through 'List', but doesn't mention pagination, error conditions, permissions needed, or rate limits. It provides basic behavioral context but lacks comprehensive disclosure.

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

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

The description is extremely concise (two sentences) with zero wasted words. It's front-loaded with the core purpose, followed by specific usage guidance. Every sentence earns its place by providing essential information.

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

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

For a list operation with no annotations and no output schema, the description provides good context: it explains what the tool does, what it returns, and when to use alternatives. However, it doesn't mention pagination behavior (though limit parameter is documented in schema) or potential error scenarios, leaving some gaps in completeness.

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

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

Schema description coverage is 100%, so the schema already fully documents all 3 parameters. The description doesn't add any parameter-specific information beyond what's in the schema. This meets the baseline expectation when schema coverage is complete.

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

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

The description clearly states the verb ('List'), resource ('notes for an entity'), and scope ('Returns id, created_at, preview (first 100 chars)'). It explicitly distinguishes from sibling 'note_get' by specifying this returns previews only, not full content.

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

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

The description provides explicit guidance on when to use this tool vs alternatives: 'Use note_get for full content.' This clearly indicates this tool is for listing note previews while note_get is for retrieving complete note details.

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

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

No annotations are provided, so the description carries full burden. It mentions 'rarely needed', which adds some behavioral context about frequency, but does not disclose critical traits like permissions required, whether it's a mutation (implied by 'Create'), side effects, or error handling. This leaves significant gaps for a tool that likely modifies system state.

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

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

The description is extremely concise with two parts: the action ('Create a new organization') and usage note ('rarely needed'). Every word earns its place, and it is front-loaded with the core purpose. There is no wasted text or redundancy.

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

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

Given the tool's complexity (a mutation with no annotations and no output schema), the description is minimally adequate. It states the purpose and usage frequency but lacks details on behavioral traits, return values, or error cases. For a creation tool, more context would be helpful, but it meets the basic threshold.

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

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

The schema description coverage is 100%, with the parameter 'name' fully documented in the schema. The description does not add any parameter-specific details beyond what the schema provides, such as format constraints or examples. With high schema coverage, the baseline score of 3 is appropriate as the description doesn't compensate but doesn't need to.

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

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

The description clearly states the verb ('Create') and resource ('a new organization'), making the purpose specific and understandable. It distinguishes from siblings like 'org_list' by indicating creation rather than listing. However, it doesn't fully differentiate from other creation tools like 'project_create' or 'ticket_create' beyond the resource type.

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

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

The description provides explicit guidance with 'rarely needed', which helps the agent understand this is for infrequent use cases. It implies context for when to use it (e.g., initial setup), but does not specify alternatives or exclusions, such as when to use 'org_list' instead or prerequisites for creation.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It states this is a list operation, implying read-only behavior, but doesn't mention permissions, rate limits, pagination, or what happens if no organizations exist. For a tool with zero annotation coverage, this leaves significant gaps in understanding its behavior.

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

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

The description is two short sentences with zero waste: it states the purpose and adds a useful contextual note. It's appropriately sized and front-loaded, making it efficient and easy to parse.

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

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

Given the tool's simplicity (0 parameters, no output schema, no annotations), the description is adequate but has clear gaps. It explains what the tool does but lacks details on behavioral aspects like response format or error handling. For a basic list tool, this is minimally viable but could be more complete.

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

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

The input schema has 0 parameters with 100% coverage, so no parameter documentation is needed. The description adds no parameter information, which is acceptable here. A baseline of 4 is appropriate since the schema fully handles the parameter semantics, and the description doesn't need to compensate.

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

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

The description clearly states the verb ('List') and resource ('organizations'), making the purpose specific and understandable. However, it doesn't explicitly differentiate from sibling tools like 'project_list' or 'ticket_list' beyond the resource type, which prevents a perfect score.

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

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

The description includes implied usage context with 'Usually only one org exists,' suggesting this tool is for basic listing when multiple organizations are unlikely. However, it lacks explicit guidance on when to use this versus alternatives like 'org_create' or other list tools, and no exclusions are provided.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It states the tool creates a project, implying a write/mutation operation, but fails to describe permissions needed, whether creation is idempotent, error handling, or what the response includes (e.g., project ID). This is a significant gap for a mutation tool with zero annotation coverage.

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

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

The description is a single, efficient sentence with zero waste. It is front-loaded with the key action and context, making it easy to parse quickly without unnecessary details.

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

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

Given the complexity of a creation tool with no annotations and no output schema, the description is incomplete. It lacks behavioral details (e.g., permissions, response format) and usage guidelines, which are critical for an AI agent to invoke this tool correctly in a real-world context.

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

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

Schema description coverage is 100%, so the schema already documents all four parameters (org_id, name, repo_path, description) and their required status. The description adds no additional meaning beyond implying 'org_id' is needed for context, which is redundant with the schema. Baseline 3 is appropriate as the schema does the heavy lifting.

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

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

The description clearly states the action ('Create a new project') and the resource ('under an organization'), which is specific and actionable. However, it does not explicitly differentiate from sibling tools like 'project_list' or 'org_create', which would require mentioning what makes this tool unique for project creation.

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

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

The description provides no guidance on when to use this tool versus alternatives. It does not mention prerequisites (e.g., needing an existing organization), exclusions, or comparisons to siblings like 'org_create' or 'project_list', leaving the agent to infer usage context.

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

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

With no annotations provided, the description carries full burden but only states the basic action ('List projects'). It doesn't disclose behavioral traits such as pagination, sorting, default limits, authentication requirements, rate limits, or what happens if org_id is omitted. This leaves significant gaps for a tool that likely returns multiple items.

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

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

The description is extremely concise with just one sentence, front-loaded with the domain context and core action. There is zero wasted verbiage, making it efficient for an AI agent to parse, though this conciseness comes at the cost of completeness.

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

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

Given no annotations, no output schema, and a simple input schema, the description is incomplete. It lacks details on return format (e.g., list structure, fields), error conditions, or behavioral expectations like pagination. For a list tool with potential complexity in output, this is inadequate despite the simple parameter set.

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

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

Schema description coverage is 100%, with the schema fully documenting the org_id parameter. The description adds minimal value beyond the schema by implying the org_id context ('in an organization'), but doesn't provide additional syntax, format details, or usage examples. Baseline 3 is appropriate as the schema does the heavy lifting.

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

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

The description clearly states the verb ('List') and resource ('projects'), with the context 'PROJECT MANAGEMENT' providing domain specificity. It distinguishes from siblings like project_create (creation) and org_list (different resource), though it doesn't explicitly differentiate from other list tools like note_list or task_list.

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

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

The description provides no guidance on when to use this tool versus alternatives like org_list (for organizations) or other list tools. It mentions 'in an organization' which hints at the org_id parameter context, but offers no explicit when/when-not instructions or named alternatives for similar operations.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It effectively describes what the tool returns ('summary of organizations, projects, and tickets'), output characteristics ('reduce output size' warning), and filtering behavior. However, it doesn't mention potential rate limits, authentication needs, or error conditions, leaving some behavioral aspects uncovered.

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

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

The description is well-structured with clear sections (purpose statement, usage guidelines, return information, parameter advice). Every sentence earns its place by providing specific guidance without redundancy. The information is front-loaded with the core purpose stated first, followed by practical usage scenarios.

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

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

Given the tool's moderate complexity (3 parameters, no output schema, no annotations), the description provides good contextual coverage. It explains the tool's purpose, when to use it, what it returns, and includes a practical tip about output size. The main gap is the lack of output format details, but this is partially compensated by the clear behavioral description of what the summary contains.

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

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

The input schema has 100% description coverage, providing clear documentation for all 3 parameters. The description adds minimal parameter semantics beyond the schema, only mentioning 'Use project_id filter to reduce output' which slightly reinforces the schema's 'recommended to reduce output size' note. This meets the baseline expectation when schema coverage is high.

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

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

The description clearly states the tool's purpose: 'Get project roadmap showing work status' with specific verbs ('get', 'showing') and resources ('project roadmap', 'work status'). It distinguishes itself from sibling tools like task_list, ticket_list, or project_list by focusing on a comprehensive status overview rather than simple listings.

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

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

The description provides explicit usage guidelines with a dedicated 'USE THIS TOOL WHEN:' section listing 5 specific scenarios (e.g., user asks about progress, TPM status, pending work, starting sessions, completing work). It clearly differentiates when to use this tool versus alternatives by emphasizing its role for status overviews rather than individual task/ticket operations.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. While it mentions this is a creation tool, it doesn't describe what happens upon creation (e.g., whether a task ID is returned, if there are permission requirements, rate limits, or how it interacts with the parent ticket). For a mutation tool with zero annotation coverage, this is a significant gap in behavioral context.

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

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

The description is efficiently structured with a clear purpose statement followed by bullet-point usage guidelines. Every sentence earns its place by providing specific guidance without unnecessary elaboration. It's appropriately sized and front-loaded with the most important information.

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

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

For a creation tool with no annotations and no output schema, the description provides good purpose and usage guidance but lacks behavioral details about what happens after creation. The schema covers parameters well, but the description doesn't compensate for the missing output information or permission/rate limit context that would be helpful for a mutation tool.

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

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

Schema description coverage is 100%, so the schema already documents all 6 parameters thoroughly with descriptions and enum values. The description doesn't add any parameter-specific information beyond what's in the schema, so it meets the baseline of 3 where the schema does the heavy lifting.

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

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

The description clearly states the action ('Create a task'), the resource ('sub-item under a ticket'), and the domain context ('PROJECT MANAGEMENT (TPM)'). It distinguishes this tool from sibling tools like 'ticket_create' or 'project_create' by specifying it creates tasks under tickets rather than standalone items.

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

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

The description includes an explicit 'USE THIS TOOL WHEN' section with three specific scenarios: breaking down tickets into smaller tasks, adding implementation steps, and creating work breakdown structures. This provides clear guidance on when to use this tool versus alternatives like 'ticket_update' or 'note_add'.

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

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

No annotations are provided, so the description carries the full burden. It implies a read-only operation ('Get full details'), but doesn't explicitly state behavioral traits like permissions required, error handling, or response format. It adds some context about the type of details returned, but lacks comprehensive behavioral disclosure for a tool with no annotation coverage.

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

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

The description is appropriately sized and front-loaded: the first sentence states the core purpose, and subsequent sentences provide essential usage guidelines without redundancy. Every sentence earns its place by adding distinct value (purpose, details, when to use, alternatives).

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

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

Given the tool's moderate complexity (single parameter, no output schema, no annotations), the description is mostly complete: it covers purpose, usage, and distinguishes from siblings. However, it lacks details on behavioral aspects (e.g., error cases, response structure) that would be helpful since no annotations or output schema exist, leaving minor gaps.

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

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

Schema description coverage is 100% for the single parameter (task_id), so the baseline is 3. The description adds value by clarifying the tool's scope ('ONE specific task'), which reinforces the parameter's purpose, but doesn't provide additional semantic details beyond what the schema already documents (e.g., format examples are in the schema).

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

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

The description clearly states the tool's purpose with specific verb ('Get full details') and resource ('ONE specific task'), distinguishing it from siblings like task_list (multiple tasks) and ticket_get (overview). It explicitly mentions what details are retrieved: metadata, files_to_modify, technical_notes.

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

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

The description provides explicit guidance on when to use this tool ('only when you need deep task details') and when to use alternatives ('Prefer ticket_get for overview'). It also clarifies the context: 'drill into a single task's implementation details' versus other tools for different purposes.

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

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

No annotations are provided, so the description carries the full burden. It mentions the return fields (id, ticket_id, status) and hints at pagination through the schema, but lacks details on permissions, rate limits, error handling, or whether it's read-only. The description adds some context but is incomplete for behavioral transparency.

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

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

The description is two sentences with zero waste: the first states the purpose and return fields, the second provides usage guidance. It is front-loaded and appropriately sized, with every sentence adding value.

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

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

Given the tool's complexity (list operation with filtering/pagination), no annotations, and no output schema, the description is fairly complete: it covers purpose, return fields, and sibling differentiation. However, it lacks details on behavioral aspects like permissions or error handling, which would be beneficial for full completeness.

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

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

Schema description coverage is 100%, so the schema fully documents all 4 parameters. The description does not add any parameter-specific information beyond what the schema provides, such as syntax or format details, meeting the baseline for high coverage.

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

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

The description clearly states the verb ('List') and resource ('task IDs with status'), specifying it returns only id, ticket_id, and status. It distinguishes from sibling 'task_get' by noting that tool provides details, making the purpose specific and differentiated.

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

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

The description explicitly states when to use this tool ('List task IDs with status') and when to use an alternative ('use task_get for details'), providing clear guidance on tool selection relative to siblings.

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

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

No annotations are provided, so the description carries full burden. While 'Update' implies mutation, the description lacks critical behavioral details: it doesn't specify what permissions are required, whether updates are reversible, if partial updates are allowed, what happens to unspecified fields, or what the response contains. For a mutation tool with zero annotation coverage, this is a significant gap in transparency.

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

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

The description is perfectly concise with two clear sentences that each earn their place. The first states the purpose, the second provides usage guidance. No wasted words, well-structured, and front-loaded with the core functionality.

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

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

Given this is a mutation tool with 6 parameters, no annotations, and no output schema, the description is minimally adequate. It covers purpose and basic usage but lacks important context about behavioral implications, error conditions, and response format. The high schema coverage helps, but for a write operation, more behavioral disclosure would be beneficial.

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

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

Schema description coverage is 100%, so the schema already documents all 6 parameters thoroughly with descriptions and enums. The description adds minimal value beyond the schema - it mentions 'status or details' which aligns with parameters but doesn't provide additional context about parameter interactions, dependencies, or usage patterns. Baseline 3 is appropriate when schema does the heavy lifting.

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

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

The description clearly states the tool's purpose with 'Update a task's status or details' - a specific verb (update) and resource (task). It distinguishes from siblings like task_create (create) and task_get (retrieve), though it doesn't explicitly mention all sibling differences. The PROJECT MANAGEMENT (TPM) context helps but isn't essential to the core purpose.

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

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

The description provides clear usage context with 'Use when completing or updating task progress.' This gives practical guidance on when to invoke the tool. However, it doesn't explicitly mention when NOT to use it (e.g., vs task_create for new tasks) or name specific alternatives, though the context implies distinction from other task_* tools.

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

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

With no annotations provided, the description carries full burden and does well by explaining ID auto-generation behavior ({PREFIX}-{NNN} format, auto-incrementing), optional prefix parameter behavior, and default behavior when prefix is omitted. It doesn't mention permissions, rate limits, or error conditions, but provides substantial operational context.

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

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

The description is well-structured with clear sections (PROJECT MANAGEMENT, USE THIS TOOL WHEN, ID AUTO-GENERATION, OPTIONAL PREFIX PARAMETER) and uses bullet points effectively. While somewhat lengthy, every section adds value and the information is front-loaded with the core purpose and usage guidelines.

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

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

For a creation tool with 8 parameters, 100% schema coverage, but no annotations or output schema, the description provides excellent context about when to use it, behavioral details (ID generation, prefix logic), and parameter semantics. It could benefit from mentioning what happens on success/failure or return values, but covers most essential aspects well.

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

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

With 100% schema description coverage, the baseline is 3. The description adds significant value by explaining the prefix parameter's purpose and providing specific examples (FEAT, ISSUE, TASK, INFRA, DOC) that clarify categorization intent beyond the schema's technical description. It also explains the relationship between prefix and project_id when prefix is omitted.

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

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

The description explicitly states the tool creates new tickets, epics, or issues to track work, specifying the verb (create) and resource (ticket/epic/issue). It distinguishes from siblings like ticket_update, ticket_get, and task_create by focusing on creation of high-level work items.

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

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

The description provides explicit guidance on when to use this tool with multiple concrete examples (e.g., 'User says :TPM: Add X feature to the roadmap', 'Breaking down work into trackable items'). It also specifies a prerequisite to 'Use roadmap_view first to get the project_id' and distinguishes tickets as high-level work items compared to other tools.

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

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

No annotations are provided, so the description carries the full burden. It discloses behavioral traits such as the default behavior for the 'detail' parameter and warnings about using 'full' detail. However, it lacks information on permissions, rate limits, or error handling, which are important for a read operation tool.

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

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

The description is well-structured and front-loaded with the purpose, followed by important usage guidelines. Every sentence earns its place by providing critical information without redundancy, making it efficient and easy to parse.

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

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

Given the tool's complexity (simple read operation with 2 parameters), 100% schema coverage, and no output schema, the description is mostly complete. It covers purpose, key parameter semantics, and usage guidelines. However, it could benefit from mentioning the return format or any limitations, slightly reducing completeness.

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

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

Schema description coverage is 100%, so the baseline is 3. The description adds value by emphasizing the importance of the 'detail' parameter, explaining when to use 'full' vs. default 'summary', and reinforcing the schema's guidance. This goes beyond the schema's enum and default values, providing practical usage context.

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

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

The description clearly states the tool's purpose: 'Get info about a ticket and its tasks.' It specifies the verb ('Get') and resource ('ticket and its tasks'), making it easy to understand. However, it doesn't explicitly differentiate from sibling tools like 'ticket_list' or 'ticket_search', which is why it doesn't reach a score of 5.

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

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

The description provides explicit guidance on when to use this tool vs. alternatives: it advises to use the default 'summary' detail for most queries and only use 'full' when explicitly asked for all details. This directly addresses usage scenarios and parameter selection, offering clear when-to-use and when-not-to-use instructions.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It mentions the return format ('Returns id, status, priority only') which is valuable, but doesn't address important behavioral aspects like pagination behavior (implied by offset parameter), rate limits, authentication requirements, or error conditions. The description adds some context but leaves significant gaps.

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

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

The description is extremely concise (two sentences) with zero wasted words. The first sentence establishes purpose and scope, the second provides crucial usage guidance. Every element earns its place and the information is front-loaded appropriately.

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

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

For a list tool with 4 parameters, 100% schema coverage, but no annotations and no output schema, the description provides adequate but incomplete context. It covers purpose and sibling differentiation well, but lacks behavioral details about pagination, rate limits, or error handling that would be helpful given the absence of annotations.

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

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

Schema description coverage is 100%, so the schema already fully documents all 4 parameters. The description doesn't add any parameter-specific information beyond what's in the schema. It mentions filtering by 'status/priority' but priority isn't actually a parameter in the schema. Baseline 3 is appropriate when the schema does all the work.

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

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

The description clearly states the tool's purpose with specific verb ('List') and resource ('ticket IDs'), and distinguishes it from sibling tools by mentioning 'use ticket_get for details'. It explicitly lists what fields are returned (id, status, priority only), making the scope unambiguous.

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

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

The description provides explicit guidance on when to use this tool versus alternatives: 'use ticket_get for details' indicates this is for summary-level information, while ticket_get is for detailed views. This directly addresses sibling tool differentiation without needing to mention all alternatives.

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

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

With no annotations provided, the description carries full burden and does well by disclosing key behavioral traits: it searches title and description, supports prefix matching, is case-insensitive, and all filters are combinable. It doesn't mention pagination behavior beyond the limit parameter, rate limits, or authentication requirements, but provides substantial operational context.

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

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

The description is well-structured with clear sections, front-loading the core purpose, then providing usage guidelines, then behavioral details. Every sentence earns its place - no redundant information, no fluff. The bullet points make it scannable while remaining concise.

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

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

For a search tool with no annotations and no output schema, the description provides good context about what the tool does, when to use it, and key behavioral characteristics. It could be more complete by describing the return format (what fields are included in results) or pagination behavior beyond the limit parameter, but covers the essential operational aspects well.

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

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

Schema description coverage is 100%, so the schema already documents all 6 parameters thoroughly. The description adds minimal parameter-specific information beyond what's in the schema - it mentions that searches are in title/description and filters are combinable, but doesn't provide additional semantic context about individual parameters. Baseline 3 is appropriate when schema does the heavy lifting.

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

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

The description clearly states the tool searches tickets by keyword, specifying it searches title and description fields. It distinguishes itself from sibling tools like ticket_list (which presumably lists without search) and ticket_get (which gets specific tickets). The phrase 'Search tickets by keyword' provides specific verb+resource combination.

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

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

The description includes an explicit 'USE THIS TOOL WHEN:' section with three bullet points providing clear guidance on when to use this tool. It gives specific examples of user queries ('find tickets about X') and use cases (searching by keywords, discovering across projects), which helps distinguish it from alternatives like ticket_list.

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

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

With no annotations provided, the description carries full burden. It clearly indicates this is a mutation tool ('Update'), specifies what fields can be modified (status, priority, details), and mentions the prerequisite of finding ticket_id via roadmap_view. However, it doesn't disclose potential side effects, permission requirements, or rate limits that would be helpful for a mutation operation.

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

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

The description is well-structured with clear sections (purpose statement, usage guidelines, prerequisite). Most sentences earn their place by providing concrete value, though the usage examples could be slightly more concise. The information is front-loaded with the core purpose stated first.

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

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

For a mutation tool with 7 parameters, 100% schema coverage, and no output schema, the description provides strong usage context and distinguishes from siblings. It covers when to use the tool and references the prerequisite tool. The main gap is lack of information about what the tool returns or confirmation of successful updates.

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

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

Schema description coverage is 100%, providing complete parameter documentation. The description adds minimal value beyond the schema by mentioning 'status, priority, or details' and referencing 'tags or assignees' in usage examples, but doesn't provide additional semantic context about parameter interactions or constraints. This meets the baseline for high schema coverage.

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

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

The description clearly states the tool's purpose with specific verbs ('Update a ticket's status, priority, or details') and identifies the resource ('ticket'). It distinguishes from siblings like ticket_create (create vs update), ticket_get (retrieve vs modify), and roadmap_view (view vs update).

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

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

The description provides explicit usage guidelines with concrete examples ('User says "I just finished implementing X" - mark related ticket as done'), clear when-to-use scenarios ('Marking work as in-progress, done, or blocked'), and a specific alternative directive ('Use roadmap_view first to find the ticket_id'). This gives comprehensive guidance on tool selection.

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