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

Annotations provide readOnlyHint=true, indicating a safe read operation. The description adds that it 'returns a list of services objects', which gives basic behavioral context about the return format. However, it doesn't disclose important traits like whether the search is exact or partial, case-sensitive, or if there are rate limits or authentication requirements beyond what annotations imply.

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 brief and front-loaded with the core purpose. The param and return annotations are structured but could be more integrated. No wasted sentences, though it could be slightly more polished (e.g., combining the lines into a cohesive paragraph).

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 0% schema coverage, no output schema, and annotations only covering read-only status, the description is incomplete. It lacks details on search behavior, result format (beyond 'list of services objects'), error conditions, and how it differs from siblings. For a search tool with undocumented parameters, more context is needed.

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

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

Schema description coverage is 0%, so the schema provides no parameter documentation. The description adds minimal semantics: ':param query: the name to search against' explains what the parameter represents, but doesn't clarify search behavior (e.g., exact match, substring), format expectations, or examples. This partially compensates but leaves significant 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: 'Search for a service by name' - a specific verb ('Search') and resource ('service') with a key constraint ('by name'). However, it doesn't explicitly differentiate from sibling tools like 'get_services_by_team' or 'get_all_teams', which might also retrieve services through different mechanisms.

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 doesn't mention sibling tools like 'get_services_by_team' (which filters by team rather than name) or 'get_all_teams' (which might return all services without filtering), leaving the agent to infer usage context from tool names alone.

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

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

Annotations already declare readOnlyHint=true, so the agent knows this is a safe read operation. The description adds minimal behavioral context beyond this by specifying the return type ('array of teams objects'), but doesn't mention potential limitations like pagination, rate limits, or authentication needs. With annotations covering safety, a 3 is appropriate as it adds some value but not rich behavioral details.

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

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

The description is two short sentences with no wasted words, efficiently stating the purpose and return value. However, the formatting with a colon before 'return' is slightly awkward, and it could be more polished, preventing a perfect score.

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, read-only, no output schema), the description is adequate but minimal. It covers the basic purpose and return type, but lacks details on error handling, response format beyond 'array of teams objects', or integration with sibling tools. For a straightforward list tool, this is acceptable but not comprehensive.

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

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

The input schema has 0 parameters with 100% coverage, so the schema fully documents the absence of parameters. The description doesn't need to add parameter information, and it correctly doesn't mention any. Baseline for 0 parameters is 4, as it avoids unnecessary details.

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

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

The description clearly states the verb ('Returns') and resource ('all teams from the service atlas api'), making the purpose unambiguous. It distinguishes from siblings like 'get_teams_by_service' by indicating it returns ALL teams without filtering. However, it doesn't explicitly contrast with all sibling tools, so it's not a perfect 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 it returns 'all teams', suggesting this should be used when a complete list is needed rather than filtered results. However, it doesn't explicitly state when to use this vs. alternatives like 'get_teams_by_service' or provide any exclusion criteria, leaving some ambiguity.

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?

Annotations indicate readOnlyHint=true, which the description aligns with by using 'Gets' (implying a read operation). The description adds value by specifying the report's content ('all services with open debts' and 'count of debts'), which isn't covered by annotations. However, it lacks details on behavioral traits like pagination, rate limits, or error handling, leaving gaps despite the annotations providing basic safety information.

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

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

The description is a single sentence that states the purpose, which is appropriately concise for a simple tool. However, it includes a trailing ':return:' that adds no value and disrupts clarity. The structure is front-loaded with the main action, but the extraneous text slightly reduces 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 the tool's simplicity (0 parameters, read-only annotation, no output schema), the description is adequate but minimal. It explains what the tool returns (a report with services and debt counts), which is necessary since there's no output schema. However, it doesn't cover potential complexities like report format, sorting, or filtering, leaving room for improvement in guiding an agent's expectations.

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 absence of inputs. The description doesn't need to add parameter details, and it correctly avoids mentioning any. This meets the baseline for tools with no parameters, as it doesn't mislead or create confusion about inputs.

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: 'Gets a report of all services that have open debts and a count of the number of debts associated with them.' It specifies the verb ('Gets'), resource ('report'), and scope ('all services with open debts'), distinguishing it from siblings like 'get_debts_for_service' (which focuses on a specific service). However, it doesn't explicitly contrast with 'find_service_by_name' or 'get_services_by_team', which could provide more differentiation.

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

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

The description provides no guidance on when to use this tool versus alternatives. It doesn't mention when to prefer 'get_debt' over 'get_debts_for_service' (e.g., for aggregated vs. detailed views) or other siblings like 'get_all_teams' or 'get_services_by_team'. Without such context, an agent might struggle to select the appropriate tool for specific scenarios.

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?

Annotations indicate readOnlyHint=true, which the description doesn't contradict. The description adds minimal behavioral context beyond annotations—it specifies the tool retrieves debts 'for a specific service', but doesn't disclose details like return format, pagination, error handling, or authentication requirements. With annotations covering safety, the description provides basic scope but lacks rich behavioral details.

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

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

The description is under-specified rather than concise. It consists of a brief statement followed by incomplete Python-style docstring fragments (':param service_id:' and ':return:'), which are wasted space without adding value. The structure is poor, with the second line being non-functional and not front-loaded with 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?

Given the tool has no output schema and annotations only cover read-only status, the description is incomplete. It doesn't explain what 'debts' entail (e.g., amounts, statuses, dates) or the return structure, leaving the agent guessing. For a tool with one parameter and no schema descriptions, more context is needed to be adequately helpful.

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

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

Schema description coverage is 0%, so the description must compensate. It mentions ':param service_id:' but adds no semantic meaning—it doesn't explain what a service_id is, its format, or where to obtain it. The description fails to clarify the parameter's role or constraints, leaving it undocumented beyond the schema's type information.

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

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

The description states the tool's purpose as 'Gets the debts for a specific service', which is a clear verb+resource combination. However, it doesn't distinguish this tool from its sibling 'get_debt', leaving ambiguity about whether this tool retrieves multiple debts for a service while 'get_debt' retrieves a single debt by ID. The purpose is understandable but lacks sibling differentiation.

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

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

The description provides no guidance on when to use this tool versus alternatives like 'get_debt' or 'get_services_by_team'. It doesn't mention prerequisites, such as needing a valid service_id, or contextual factors like whether this is for reporting or payment processing. Usage is implied by the parameter name but not explicitly stated.

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

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

Annotations provide readOnlyHint=true, indicating this is a safe read operation. The description adds useful behavioral context about date inclusivity/exclusivity and return format ('list of releases'), which goes beyond annotations. However, it doesn't mention potential limitations like pagination, rate limits, or authentication needs, leaving some behavioral aspects unclear.

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 with the main purpose. The parameter documentation is necessary given the schema coverage gap. However, the ':param' and ':return' formatting is slightly verbose and could be more integrated, though it remains clear and efficient.

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

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

Given the tool's moderate complexity (2 required parameters, read-only operation) and the presence of an output schema, the description is reasonably complete. It covers purpose, parameters, and return type. The main gap is lack of sibling differentiation, but overall it provides sufficient context for an agent to use the tool correctly.

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

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

With 0% schema description coverage, the description fully compensates by providing detailed parameter semantics. It specifies both parameters ('start' and 'end'), their required formats ('YYYY-MM-DD'), and clarifies their behavior (inclusive vs exclusive). This adds significant value beyond the bare 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 a specific verb ('Get') and resource ('list of releases'), and specifies the date range constraint. However, it doesn't differentiate from sibling tools like 'get_all_teams' or 'get_debts_for_service' which might also retrieve data, so it doesn't fully distinguish itself from alternatives.

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

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

The description implies usage by specifying date range filtering, but doesn't explicitly state when to use this tool versus alternatives like 'get_all_teams' or 'get_debts_for_service'. There's no guidance on prerequisites, exclusions, or specific scenarios where this tool is preferred over others.

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

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

The annotations include readOnlyHint: true, indicating this is a safe read operation. The description adds that it 'returns a list of services' and mentions the return type ('array of services objects from the api'), which provides useful context beyond the annotations. However, it lacks details on rate limits, error handling, or pagination, which would enhance 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 concise and front-loaded, stating the core purpose in the first sentence. The additional parameter and return details are brief and relevant. However, the colon formatting for ':param' and ':return' is slightly verbose and could be integrated more smoothly into the text.

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

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

Given the tool's low complexity (1 parameter, no output schema), the description is adequate but has gaps. It covers the basic operation and parameter, but lacks output details (e.g., what fields 'services objects' include) and doesn't leverage context from sibling tools. With annotations providing safety info, it meets minimum viability but isn't fully comprehensive.

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

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

With schema description coverage at 0%, the description carries the full burden for parameter documentation. It explains 'team_id' as a 'guid for the team', adding semantic meaning not in the schema. Since there's only one parameter, this is sufficient, but a perfect score would require more detail like format examples or constraints.

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: 'returns a list of services for a team based on id'. It specifies the verb ('returns'), resource ('services'), and scope ('for a team'), making the function understandable. However, it doesn't explicitly differentiate from sibling tools like 'get_teams_by_service' or 'find_service_by_name', which would be needed for 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 provides no guidance on when to use this tool versus alternatives. It doesn't mention sibling tools like 'get_all_teams' or 'get_teams_by_service', nor does it specify prerequisites or contexts for usage. This leaves the agent without clear direction on tool selection.

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

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

Annotations provide readOnlyHint=true, indicating a safe read operation. The description adds that it returns 'a list of teams objects', giving some output context, but doesn't detail pagination, error handling, or auth needs. With annotations covering safety, this adds minimal behavioral value beyond what's structured.

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 brief and front-loaded with the core purpose, using two sentences efficiently. However, the formatting with ':param' and ':return' is slightly verbose for MCP standards, and it could be more polished without sacrificing clarity.

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

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

Given 1 parameter, no output schema, and annotations covering read-only safety, the description is minimally adequate. It explains the parameter and return type, but lacks details on output structure or error cases. For a simple lookup tool, this meets basic needs but leaves gaps in full 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 0%, so the description must compensate. It explains 'service_id' as 'the guid for the service', clarifying its format and purpose beyond the schema's type. With only one parameter, this is sufficient to achieve a high score, though not exhaustive.

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 ('Gets a list of teams') and resource ('that own a service'), with a specific parameter (service_id). It distinguishes from siblings like 'get_all_teams' (no filtering) and 'get_services_by_team' (inverse relationship), but doesn't explicitly name alternatives. This makes it clear but not fully differentiated.

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

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

No guidance is provided on when to use this tool versus alternatives. For example, it doesn't specify if this should be used instead of 'get_all_teams' when filtering by service, or how it relates to 'find_service_by_name' for lookup workflows. The description implies usage through the parameter but lacks explicit context or exclusions.

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