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

With no annotations provided, the description carries full burden for behavioral disclosure. It mentions 'comprehensive analysis' but doesn't describe what that analysis produces (e.g., report format, visualizations, metrics), whether it's computationally intensive, if there are rate limits, or what permissions might be required. For a 5-parameter analysis tool with no annotation coverage, this leaves significant behavioral 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 a single, efficient sentence that gets straight to the point without unnecessary words. It's appropriately sized for what it communicates, though what it communicates is limited. Every word earns its place in conveying the tool's general purpose.

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 5-parameter analysis tool with no annotations and no output schema, the description is insufficiently complete. It doesn't explain what the analysis produces, how results are formatted, whether there are performance considerations, or how this differs from similar sibling tools. The agent would need to guess about the tool's behavior and output based solely on the parameter schema.

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

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

Schema description coverage is 100%, so all parameters are documented in the schema. The description adds no additional parameter semantics beyond what's already in the structured fields. It doesn't explain relationships between parameters (e.g., how 'threshold' interacts with 'limit') or provide usage examples. Baseline 3 is appropriate when the schema does all the parameter documentation 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 states the tool performs 'comprehensive analysis of cross-module dependencies and coupling', which provides a general purpose but lacks specificity about what 'comprehensive analysis' entails. It distinguishes from siblings like 'get_module_dependencies' by implying deeper analysis, but doesn't clearly articulate the exact verb+resource combination beyond the vague 'analysis'.

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

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

No guidance is provided about when to use this tool versus alternatives like 'get_module_dependencies', 'find_cross_module_calls', or 'analyze_type_relationships'. The description doesn't mention any prerequisites, exclusions, or comparative contexts that would help an agent choose between these similar-sounding analysis 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 of behavioral disclosure. It mentions analyzing 'call count and signature complexity' but doesn't describe what the analysis entails, how results are returned, whether it's read-only or has side effects, or any constraints like performance or data limits. For a 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 a single, efficient sentence that front-loads the core purpose without unnecessary details. It's appropriately sized for the tool's complexity, with no wasted words. However, it could be slightly more structured by explicitly separating purpose from scope for better 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 the tool's moderate complexity (3 parameters, no output schema, no annotations), the description is minimally adequate. It states what the tool does but lacks details on behavior, output format, and usage context. Without annotations or output schema, more completeness is needed to fully guide an agent, but it meets a basic threshold for a read-oriented analysis 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?

The input schema has 100% description coverage, with clear documentation for all three parameters. The description adds no additional parameter semantics beyond what's in the schema, such as explaining 'call count' or 'signature complexity' in relation to the parameters. Since schema coverage is high, the baseline score of 3 is appropriate, as the description doesn't compensate but doesn't need to given the schema's completeness.

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: 'Analyze function complexity metrics including call count and signature complexity.' It specifies the verb ('analyze'), resource ('function complexity metrics'), and scope ('call count and signature complexity'). However, it doesn't explicitly differentiate from sibling tools like 'get_function_details' or 'get_most_called_functions' that might overlap in analyzing functions, missing full sibling distinction.

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

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

The description provides no guidance on when to use this tool versus alternatives. With many sibling tools like 'get_most_called_functions' or 'get_function_details' that might handle similar analyses, there's no indication of context, prerequisites, or exclusions. Usage is implied only by the purpose, lacking explicit when/when-not statements.

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 'analyze' suggests a read-only operation, the description doesn't clarify whether this is a computationally intensive analysis, whether it requires specific permissions, what format the results take, or any rate limits. For a tool with 4 parameters and no annotation coverage, this represents a significant gap in 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 a single, efficient sentence that clearly states the tool's purpose with zero wasted words. It's appropriately sized for a tool with this functionality and gets straight to the point without unnecessary elaboration or preamble.

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 analyzing imports/dependencies, the lack of annotations, and no output schema, the description is insufficiently complete. It doesn't explain what the analysis produces (statistics? graphs? lists?), how results are structured, or what 'patterns' means in this context. With many similar sibling tools available, the description fails to provide enough context for an agent to understand when and how to use this specific tool effectively.

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 parameters thoroughly. The description adds no additional parameter semantics beyond what's in the schema - it doesn't explain how parameters interact, provide examples of valid 'import_pattern' values, or clarify the relationship between 'module_name' and 'import_pattern'. With complete schema coverage, the baseline score of 3 is appropriate.

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

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

The description clearly states the tool's purpose: 'Analyze import patterns and dependencies for modules' - a specific verb ('analyze') and resource ('import patterns and dependencies for modules'). It distinguishes from some siblings like 'find_unused_imports' (which focuses on unused imports) and 'get_import_details' (which might provide raw data rather than analysis), but doesn't explicitly differentiate from all similar tools like 'analyze_cross_module_dependencies'.

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. With many sibling tools related to imports and dependencies (e.g., 'analyze_cross_module_dependencies', 'get_import_details', 'find_unused_imports'), there's no indication of when this specific analysis tool is appropriate versus those other options. The description simply states what it does without contextual usage information.

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 mentions 'deep' analysis but doesn't specify what that entails—such as output format, performance implications, or side effects. For a tool with 5 parameters and no output schema, this is inadequate, as it leaves critical behavioral traits undefined.

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 no wasted words, making it appropriately concise. However, it lacks front-loading of critical details like differentiation from siblings or behavioral context, which slightly reduces its effectiveness despite the brevity.

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

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

Given the tool's complexity (5 parameters, no annotations, no output schema) and rich sibling set, the description is incomplete. It doesn't explain what 'analyze' entails in terms of output or behavior, nor does it guide usage relative to alternatives. This leaves significant gaps for an agent to operate effectively.

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 5 parameters. The description adds no additional meaning beyond the schema, such as explaining how parameters interact or typical use cases. This meets the baseline of 3, as the schema does the heavy lifting, but the description doesn't enhance understanding.

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 analyzing type relationships and dependencies, which is clear but vague. It specifies 'deep' analysis but doesn't differentiate from siblings like 'get_type_dependencies' or 'build_type_dependency_graph' in terms of scope or methodology. The verb 'analyze' is generic compared to more specific sibling verbs like 'get', 'build', or 'find'.

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

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

No explicit guidance on when to use this tool versus alternatives is provided. The description doesn't mention prerequisites, context, or exclusions, leaving the agent to infer usage from the name alone. With many sibling tools for dependency analysis, this lack of differentiation is a significant gap.

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 mentions 'analyze' but doesn't specify what the analysis entails (e.g., returns usage counts, locations, patterns), whether it's read-only or has side effects, or any performance considerations. This leaves significant gaps in understanding the tool's 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 a single, clear sentence: 'Analyze how types are used throughout the codebase'. It is front-loaded with the core purpose, has zero wasted words, and is appropriately sized for the tool's complexity, making it easy for an agent 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 complexity (4 parameters, no annotations, no output schema), the description is incomplete. It lacks details on what the analysis returns, how results are structured, or any behavioral traits (e.g., performance, side effects). This makes it insufficient for an agent to fully understand how to use the tool effectively in 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?

The input schema has 100% description coverage, clearly documenting all four parameters. The description adds no additional parameter semantics beyond what's in the schema (e.g., it doesn't explain how 'type_name' and 'module_name' interact or what 'usage' means in context). With high schema coverage, a baseline score of 3 is appropriate as the description doesn't compensate but doesn't detract either.

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: 'Analyze how types are used throughout the codebase'. It specifies the verb ('analyze') and resource ('types'), making it understandable. However, it doesn't explicitly differentiate from sibling tools like 'analyze_type_relationships' or 'get_type_details', which could provide similar type-related insights.

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. With many sibling tools available (e.g., 'analyze_type_relationships', 'get_type_details', 'list_types'), there is no indication of when this analysis is preferred or what specific use cases it addresses, leaving the agent to guess based on the name alone.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It mentions building a 'comprehensive' graph but doesn't specify output format, performance implications, whether it's read-only or mutative, or any constraints like rate limits. For a tool with 4 parameters and no annotations, this leaves critical behavioral traits undocumented.

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 directly states the tool's purpose without unnecessary words. It's front-loaded with the core action and resource, 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 complexity of building a dependency graph with 4 parameters, no annotations, and no output schema, the description is incomplete. It doesn't explain what the output looks like, how to interpret the graph, or any prerequisites or limitations, leaving significant gaps for the agent to operate effectively.

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 parameters thoroughly. The description adds no additional meaning about parameters beyond implying a graph-building process, which is redundant with the schema. Baseline 3 is appropriate when the schema does the heavy lifting, but no extra value is added.

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 ('Build') and resource ('comprehensive type dependency graph showing relationships between types'), providing a specific purpose. However, it doesn't explicitly differentiate from sibling tools like 'get_type_dependencies' or 'analyze_type_relationships', which appear related, so it doesn't reach the highest 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. With many sibling tools like 'get_type_dependencies' and 'analyze_type_relationships' that seem overlapping, the lack of context for tool selection is a significant gap, leaving the agent to guess based on 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?

No annotations are provided, so the description carries full burden. It mentions 'enhanced' and 'advanced options' but doesn't explain what these entail—such as output format details, performance implications, or any limitations. This is inadequate for a tool with 6 parameters and no output schema, failing to disclose key behavioral traits.

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 no wasted words. It's front-loaded with the core action, though it could be more specific. The brevity is appropriate, but it lacks structural elements like bullet points that might aid 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 the tool's complexity (6 parameters, no output schema, no annotations), the description is incomplete. It doesn't explain what 'enhanced' means, what the output looks like, or how it differs from siblings. This leaves significant gaps for an agent to understand and use the tool effectively.

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 6 parameters. The description adds no additional meaning beyond the schema, as it doesn't clarify parameter interactions or provide examples. Baseline 3 is appropriate since the schema does the heavy lifting, but no extra value is added.

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 'Generate enhanced function call graphs with advanced options' states the action (generate) and resource (function call graphs) but is vague about what 'enhanced' means and how it differs from the sibling tool 'get_function_call_graph'. It doesn't specify what makes it 'enhanced' or what 'advanced options' entail, leaving the purpose unclear compared to 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 provides no guidance on when to use this tool versus alternatives like 'get_function_call_graph' or other analysis tools. It doesn't mention prerequisites, use cases, or exclusions, leaving the agent with no context for selection among the many sibling 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 the full burden of behavioral disclosure. It mentions 'execute' which implies a read operation but doesn't clarify if it's read-only, has side effects, requires specific permissions, or has rate limits. The description lacks details on return format, error handling, or performance characteristics for complex queries.

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 functionality without unnecessary words. Every part of the description contributes to understanding the tool's purpose, making it appropriately 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 tool with complex nested parameters (as indicated by context signals) and no annotations or output schema, the description is insufficient. It doesn't explain what constitutes 'advanced conditions,' how joins work, what the tool returns, or error scenarios. Given the complexity and lack of structured documentation, more context is needed for effective use.

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 the single 'query' parameter with its nested structure. The description adds minimal value beyond the schema by mentioning 'JSON-based queries with joins and advanced conditions,' which aligns with but doesn't significantly expand upon the schema's documentation of conditions and joins.

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 as executing 'complex JSON-based queries with joins and advanced conditions,' which is a specific verb+resource combination. However, it doesn't explicitly differentiate from sibling tools like 'execute_query' or 'execute_custom_query,' leaving some ambiguity about when to choose this specific advanced version.

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 'execute_query' or 'execute_custom_query' from the sibling list. It mentions 'complex' queries but doesn't define what makes a query complex enough to warrant this tool, nor does it 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 for behavioral disclosure. While it mentions executing SQL queries with parameters, it doesn't cover important aspects like: what type of SQL is supported (e.g., SELECT only or also DML), whether queries are read-only or can modify data, authentication requirements, rate limits, error handling, or result format. The description is too minimal for a potentially powerful database query tool.

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

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

The description is extremely concise - a single sentence that communicates the core functionality without any wasted words. It's front-loaded with the main purpose and efficiently includes the parameter capability. Every word earns its place.

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

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

For a tool that executes custom SQL queries (potentially powerful and risky), the description is inadequate. With no annotations, no output schema, and multiple sibling tools offering similar query functionality, the description should provide more context about limitations, safety considerations, and differentiation from alternatives. The current description leaves too many important questions unanswered.

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 three parameters thoroughly. The description adds minimal value by mentioning 'with parameters' which aligns with the schema's 'parameters' field, but doesn't provide additional context about parameter syntax, best practices, or limitations beyond what the schema already specifies.

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 ('Execute custom SQL queries') and target resource ('on the code database'), specifying the verb+resource combination. However, it doesn't distinguish this tool from its sibling 'execute_query' or 'execute_advanced_query', which appear to offer similar functionality based on their names.

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

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

The description provides no guidance on when to use this tool versus alternatives like 'execute_query' or 'execute_advanced_query' from the sibling list. It mentions 'with parameters' but doesn't explain when parameterized queries are needed or what distinguishes this tool from other query execution options.

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 states the tool executes queries but doesn't disclose behavioral traits such as whether it's read-only or mutating, what permissions are required, potential rate limits, or what happens on errors. The mention of 'basic SQL query' hints at limitations but doesn't specify them.

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 states the core purpose without unnecessary words. It's front-loaded and wastes no space, 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 no annotations and no output schema, the description is incomplete for a tool that executes queries. It doesn't explain what 'basic' means, what the output looks like, or any constraints or side effects. For a query execution tool with multiple siblings, this leaves significant gaps in understanding.

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 adds no meaning beyond the schema—it doesn't explain what 'basic SQL query' entails in terms of allowed query types or filter usage. With high schema coverage, the baseline score of 3 is appropriate.

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

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

The description clearly states the action ('execute') and target ('basic SQL query on the code database'), which distinguishes it from sibling tools like 'execute_advanced_query' or 'execute_custom_query'. However, it doesn't specify what constitutes a 'basic' query versus advanced/custom alternatives, leaving some ambiguity.

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 'execute_advanced_query' or 'execute_custom_query'. It mentions 'basic SQL query' but doesn't define what makes a query basic or when to choose this over other query-related tools in the sibling list.

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

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

No annotations are provided, so the description carries the full burden. It states what the tool does but lacks behavioral details such as how patterns are matched (e.g., exact vs. fuzzy), performance implications, error handling, or output format. For a search tool with no 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 a single, efficient sentence with zero waste. It is front-loaded and appropriately sized for its purpose, making it easy for an agent to parse quickly without unnecessary elaboration.

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 search tool with 4 parameters, the description is incomplete. It lacks details on behavioral traits, return values, and usage context, which are crucial for an agent to effectively invoke this tool without trial and error.

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 parameters. The description adds no additional meaning beyond the schema, such as examples or constraints on pattern syntax. Baseline 3 is appropriate when the schema does the heavy lifting, but no extra value is provided.

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: 'Find recurring code patterns across functions' with a specific verb ('Find') and resource ('recurring code patterns'). It distinguishes from siblings like 'pattern_match_code' by focusing on patterns 'across functions' rather than general pattern matching, though it doesn't explicitly contrast with all similar tools.

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. With many sibling tools like 'find_similar_functions' and 'pattern_match_code', the description lacks explicit context, prerequisites, or exclusions, leaving the agent to infer usage based on the name alone.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It states the tool finds function calls across modules but doesn't explain key behaviors: what format the results are in, whether it's a read-only operation, if there are rate limits, or how it handles large codebases. For a tool with no annotations, this leaves significant gaps in understanding its operational traits.

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

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

The description is a single, concise sentence: 'Find function calls that cross module boundaries.' It is front-loaded with the core purpose, has no redundant words, and efficiently communicates the tool's intent without unnecessary elaboration. Every part of the sentence earns its place by defining the action and scope.

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 analyzing cross-module calls and the lack of annotations and output schema, the description is incomplete. It doesn't address behavioral aspects like result format, pagination, or error handling, which are crucial for a tool that likely processes code analysis queries. With no structured data to compensate, the description should provide more context to be fully helpful for an 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?

The input schema has 100% description coverage, clearly documenting all three parameters (source_module, target_module, limit) with their types and optionality. The description adds no additional semantic context beyond what the schema provides, such as examples of module patterns or usage scenarios. Given the high schema coverage, a baseline score of 3 is appropriate, as the schema adequately covers parameter details without extra value from the description.

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

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

The description clearly states the tool's purpose: 'Find function calls that cross module boundaries.' It specifies the verb ('Find') and resource ('function calls') with a clear scope ('cross module boundaries'). However, it doesn't explicitly distinguish this tool from similar siblings like 'analyze_cross_module_dependencies' or 'get_function_callers,' which might also involve cross-module analysis, leaving some ambiguity.

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. With many sibling tools related to function calls, modules, and dependencies (e.g., 'analyze_cross_module_dependencies,' 'get_function_callers'), there is no indication of specific use cases, prerequisites, or exclusions. This lack of context makes it challenging for an agent to select this tool appropriately among the options.

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 states what the tool does but doesn't disclose behavioral traits: no information about permissions needed, rate limits, whether it's read-only or has side effects, what happens with invalid locations, or the format/scope of returned elements. For a tool with 4 parameters and no annotation coverage, this is a significant gap.

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

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

The description is a single, efficient sentence that front-loads the core purpose. Every word earns its place: 'Find' (action), 'code elements' (target), specific examples in parentheses, and 'by source location' (method). No wasted words or redundant 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 no annotations, no output schema, and 4 parameters, the description is incomplete. It doesn't explain what the tool returns (structure of found elements), error conditions, or behavioral constraints. For a location-based lookup tool in a code analysis context, users need to know what 'find' means precisely—does it return the element at that exact line, nearby elements, or something else?

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 parameters thoroughly. The description adds minimal value beyond the schema by implying the tool searches for code elements at specific locations, but doesn't provide additional context about parameter interactions, edge cases, or search behavior. 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 action ('find') and target resources ('code elements') with specific examples (functions, types, classes, imports) and the search method ('by source location'). It distinguishes from siblings by focusing on location-based lookup rather than analysis, search, or dependency tools. However, it doesn't explicitly contrast with the most similar sibling 'get_location_context'.

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. With many sibling tools for finding/searching code elements (e.g., search_functions, search_types, get_location_context), there's no indication of when location-based lookup is preferred over pattern-based search or when to use this versus 'get_location_context'. Usage context is implied but not stated.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It states what the tool does but lacks critical behavioral details: it doesn't explain how similarity is calculated (e.g., algorithm, metrics), what 'signature and code' entails, whether results are ranked, if there are rate limits, or what the output format looks like. For a tool with no annotations, this is insufficient.

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 directly states the tool's purpose without redundancy. It's front-loaded with the core functionality and uses clear terminology. Every word earns its place, making it highly concise and well-structured.

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

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

Given the complexity of similarity analysis, lack of annotations, and no output schema, the description is incomplete. It doesn't address behavioral aspects like algorithm details, result format, or error handling. For a tool with 4 parameters and no structured output guidance, more context is needed to help the agent use it effectively.

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 parameters thoroughly. The description adds no additional meaning beyond what's in the schema—it doesn't clarify parameter interactions, provide examples, or explain semantics like how 'similarity_threshold' applies to 'signature and code'. Baseline 3 is appropriate when the schema does the heavy lifting.

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

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

The description clearly states the tool's purpose: 'Find functions similar to a given function based on signature and code'. It specifies the verb ('Find'), resource ('functions'), and criteria ('similar to a given function based on signature and code'). However, it doesn't explicitly differentiate from sibling tools like 'group_similar_functions' or 'find_code_patterns', which appear related.

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 'group_similar_functions' or 'find_code_patterns', nor does it specify prerequisites, exclusions, or contextual usage scenarios. The agent must infer usage from the purpose alone.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It states the tool 'finds potentially unused imports' but doesn't explain what 'potentially' means, how accuracy is determined, whether it's a read-only analysis, performance implications, or output format. This leaves significant gaps in understanding the tool's 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 a single, efficient sentence that directly states the tool's purpose without unnecessary words. It's front-loaded and wastes no space, making it easy for an agent to parse quickly while conveying 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 the tool's complexity (analyzing code for unused imports) and lack of annotations and output schema, the description is insufficient. It doesn't cover behavioral traits, result interpretation, or error handling, leaving the agent with incomplete context for effective tool invocation in a code analysis environment.

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, clearly documenting all three parameters (module_name, package_pattern, limit) with their types and optionality. The description adds no additional parameter semantics beyond what the schema provides, so it meets the baseline score for high schema coverage without compensating value.

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 ('find') and resource ('unused imports in modules'), making it immediately understandable. However, it doesn't explicitly differentiate from sibling tools like 'analyze_imports' or 'get_import_details', which might have overlapping functionality, preventing 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 like 'analyze_imports' or 'get_import_details', nor does it mention prerequisites or exclusions. It lacks context for selection among the many analysis-focused siblings, leaving the agent with minimal usage direction.

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. The description mentions generating 'all necessary import statements,' which implies a read-only or analysis operation, but it does not clarify if this involves data mutation, requires specific permissions, has rate limits, or describes the output format. For a tool with zero annotation coverage, this is insufficient, warranting a score of 2.

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, clear sentence that efficiently conveys the tool's purpose without unnecessary words. It is front-loaded with the core action and resource, making it easy to understand at a glance. This is an example of optimal conciseness and structure.

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

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

Given the tool's moderate complexity (4 parameters, no output schema, and no annotations), the description is minimally adequate. It states what the tool does but lacks details on behavioral traits, usage context, or output expectations. Without annotations or an output schema, the description should do more to compensate, but it only meets the bare minimum, resulting in a score of 3.

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, meaning all parameters are documented in the schema itself. The description does not add any additional meaning, syntax details, or examples beyond what the schema provides (e.g., it doesn't explain how 'element_name' and 'source_module' interact). With high schema coverage, the baseline score is 3, as the description adds no extra value for parameters.

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: 'Generate all necessary import statements for a function or code element.' It specifies the verb ('generate') and resource ('import statements'), and the scope ('for a function or code element') is clear. However, it does not explicitly differentiate this tool from sibling tools like 'analyze_imports' or 'find_unused_imports', which reduces the score from a 5 to a 4.

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

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

The description provides no guidance on when to use this tool versus alternatives. It does not mention sibling tools like 'analyze_imports' or 'find_unused_imports', nor does it specify prerequisites, exclusions, or contextual cues for usage. This lack of comparative or situational advice results in a low score of 2.

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 what information is returned ('methods and instances') but doesn't disclose behavioral aspects like whether this is a read-only operation, if it requires specific permissions, how it handles missing classes, or what the output format looks like. For a tool with 3 parameters and no output schema, this is insufficient.

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 purpose. Every word earns its place, with no redundant or vague phrasing. It's appropriately sized for a straightforward retrieval tool.

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 3 parameters, 100% schema coverage, no output schema, and no annotations, the description is minimally adequate. It states what the tool does but lacks behavioral context and usage guidance. For a tool in a complex sibling set with many alternatives, more completeness would be 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 100%, so the schema fully documents all parameters. The description adds no additional parameter semantics beyond implying that 'methods and instances' relate to the 'include_instances' parameter. This meets the baseline of 3 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 verb 'Get' and resource 'detailed information about a specific class', specifying what information is included ('methods and instances'). It distinguishes from siblings like 'list_classes' which likely provides only names, but doesn't explicitly differentiate from 'get_type_details' which might overlap in functionality.

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_type_details', 'search_classes', or 'list_classes'. It doesn't mention prerequisites, exclusions, or comparative contexts, leaving the agent to infer usage from the tool name alone.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It mentions 'comprehensive statistics' but doesn't specify what data is returned, whether it's read-only (implied by 'get'), performance implications, or any limitations. For a tool with no 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 a single, efficient sentence that directly states the tool's purpose without unnecessary words. It is appropriately sized and front-loaded, 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 lack of annotations and output schema, the description is incomplete. It doesn't explain what 'comprehensive statistics' entails, how results are structured, or any behavioral traits. For a tool in a complex domain with many siblings, more context is needed to guide effective usage.

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 for its single parameter 'include_details', which is well-documented in the schema. The description doesn't add any parameter-specific information beyond the schema, but with only one parameter and high schema coverage, the baseline is strong. No additional value is needed from the description here.

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 'Get comprehensive statistics about the codebase', which is a clear verb+resource combination. However, it lacks specificity about what kind of statistics (e.g., lines of code, complexity metrics, dependency counts) and doesn't distinguish it from sibling tools like 'analyze_function_complexity' or 'get_most_called_functions' that also provide statistical insights.

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. With many sibling tools focused on specific analyses (e.g., 'analyze_function_complexity', 'get_most_called_functions'), the description offers no context about whether this is a general overview tool or how it complements others, leaving the agent to guess based on the name alone.

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

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

No annotations are provided, so the description carries full burden for behavioral disclosure. It states what the tool does but lacks critical details: it doesn't specify if this is a read-only operation, what the output format looks like (e.g., list of function names, structured data), whether there are rate limits, or if it requires specific permissions. For a tool with no 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 a single, efficient sentence that front-loads the core purpose without unnecessary words. Every part earns its place by clearly stating the action and target, 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 complexity of code analysis tools and the lack of annotations and output schema, the description is incomplete. It doesn't explain return values, error conditions, or behavioral traits like pagination or performance limits. For a tool with 3 parameters and many siblings, more context is needed to guide effective use.

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 clear parameter descriptions in the schema (e.g., 'function_name' as the name of the function, 'limit' with a default). The description adds no additional semantic context beyond implying the tool uses 'function_name' as input, so it meets the baseline of 3 where the schema does the heavy lifting without extra value from the description.

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

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

The description clearly states the tool's purpose with a specific verb ('Get') and resource ('functions called by a specific function'), making it immediately understandable. However, it doesn't explicitly differentiate from similar sibling tools like 'get_function_callers' (which gets callers rather than callees) or 'get_function_call_graph' (which might provide broader relationship data), missing full 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. With many sibling tools for code analysis (e.g., 'get_function_callers', 'enhanced_function_call_graph', 'find_cross_module_calls'), there's no indication of context, prerequisites, or comparisons, leaving the agent to guess based on 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?

With no annotations provided, the description carries full burden for behavioral disclosure. It states what the tool does but doesn't describe important behavioral aspects: whether results are paginated (given the 'limit' parameter), what format the returned callers are in (function names, full signatures, etc.), whether it includes indirect callers, or if there are any performance considerations for large codebases.

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, clear sentence that states the tool's purpose without any unnecessary words. It's perfectly front-loaded with the core functionality and wastes no space on redundant 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 read-only query tool with good schema coverage but no output schema, the description is minimally complete. It tells what the tool does but doesn't address important contextual questions about result format, scope (direct vs indirect callers), or relationship to similar tools. The absence of an output schema means the description should ideally provide more about what gets returned.

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 three parameters thoroughly. The description doesn't add any additional parameter semantics beyond what's in the schema - it doesn't explain how 'module_name' affects the search, what happens when it's omitted, or provide examples of valid 'function_name' formats. 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 verb ('Get') and resource ('all functions that call a specific function'), making the purpose immediately understandable. However, it doesn't explicitly differentiate from sibling tools like 'get_function_callees' (which would show functions called by a specific function) or 'find_cross_module_calls' (which might have overlapping functionality), so it doesn't achieve full 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. With many sibling tools for code analysis (like 'get_function_callees', 'get_function_call_graph', 'find_cross_module_calls'), there's no indication of when this specific caller-focused tool is preferred over other dependency analysis 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 but only states what the tool does, not how it behaves. It doesn't disclose performance characteristics, error conditions, data sources, or what happens with invalid inputs. The description is functional but lacks behavioral context needed for a tool with 5 parameters.

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 clearly communicates the core functionality. Every word earns its place with no redundancy or unnecessary elaboration. It's appropriately sized for the tool's complexity.

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

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

For a tool with 5 parameters, no annotations, and no output schema, the description is insufficient. It doesn't explain what the output looks like (hierarchy format, data structure), doesn't mention performance considerations for large codebases, and provides no context about data sources or limitations. The description is functional but lacks completeness for effective tool selection.

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 5 parameters. The description mentions 'what functions this function calls and what calls it' which aligns with include_callees and include_callers parameters, but adds no additional semantic context beyond what the schema already provides.

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

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

The description clearly states the tool's purpose with specific verbs ('get function call hierarchy') and resources ('functions'), distinguishing it from siblings like get_function_callees and get_function_callers by combining both directions in one tool.

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

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

The description implies usage for analyzing function call relationships but doesn't explicitly state when to use this tool versus alternatives like enhanced_function_call_graph or separate get_function_callees/get_function_callers tools. No explicit exclusions or prerequisites 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 full burden. It states the tool retrieves context but doesn't disclose behavioral traits like whether it's read-only, what format the output is in, potential performance implications, or error conditions. This is inadequate for a tool with 5 parameters and no output schema.

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

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

The description is a single, efficient sentence that front-loads the core purpose. Every word earns its place with no redundancy or fluff, 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 complexity (5 parameters, no output schema, no annotations), the description is incomplete. It doesn't explain what 'complete context' entails in practice, how results are structured, or usage trade-offs. This leaves significant gaps for an agent to understand the tool's behavior and output.

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

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

Schema description coverage is 100%, so parameters are well-documented in the schema. The description adds no additional meaning beyond implying 'function_name' is required and that context includes 'types and functions', which aligns with schema parameters like 'include_local_definitions'. 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 ('Get') and resource ('complete context for a function'), specifying what it retrieves ('all used types and functions'). It distinguishes from siblings like 'get_function_details' or 'get_function_callers' by focusing on comprehensive context rather than specific aspects, though it doesn't 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.

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

No guidance on when to use this tool versus alternatives is provided. With many sibling tools for function analysis (e.g., 'get_function_details', 'get_function_callees'), the description lacks context on scenarios where this comprehensive context tool is preferred over more targeted ones.

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 states it 'gets' information, implying a read operation, but doesn't disclose behavioral traits like what 'detailed information' includes, whether it requires specific permissions, rate limits, or error handling. This is inadequate 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 a single, efficient sentence with zero waste. It's front-loaded and appropriately sized for a simple retrieval tool, 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 (2 parameters, no output schema, no annotations), the description is minimally adequate but has clear gaps. It doesn't explain what 'detailed information' entails or how it differs from sibling tools, leaving the agent to infer usage 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 fully documents both parameters. The description adds no meaning beyond the schema, as it doesn't explain parameter interactions (e.g., how module_name affects results) or provide examples. 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 verb ('Get') and resource ('detailed information about a specific function'), making the purpose unambiguous. However, it doesn't differentiate from siblings like 'get_function_callees' or 'get_function_callers' which also retrieve function-related information but with different scopes.

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. With many sibling tools like 'get_function_callees' and 'get_function_context', the description lacks context about whether this is for basic metadata, when to choose it over more specialized tools, or any prerequisites.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It states the tool retrieves functions but doesn't mention whether this is a read-only operation, what permissions are required, how errors are handled (e.g., invalid module names), or the format of the output (e.g., list of names vs. structured data). For a tool with no annotation coverage, this leaves significant behavioral 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 a single, efficient sentence that front-loads the core purpose without unnecessary words. Every part of the sentence ('Get all functions defined in a specific module') directly contributes to understanding the tool's function, with zero waste.

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 is minimally adequate. It covers the basic purpose but lacks details on behavioral traits, output format, and usage context. With no output schema, the agent must infer return values, which the description doesn't address, leaving 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%, with clear documentation for all three parameters (module_name, limit, include_signatures). The description adds no additional parameter semantics beyond what the schema provides, such as explaining module name formats or signature details. Baseline 3 is appropriate when the schema does the heavy lifting.

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

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

The description clearly states the action ('Get all functions') and target resource ('in a specific module'), making the purpose immediately understandable. It doesn't explicitly differentiate from sibling tools like 'list_functions' or 'search_functions' (which don't exist in the sibling list), but given the sibling tools focus on analysis, dependencies, and searching rather than direct listing, the distinction is somewhat implied though not explicitly stated.

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

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

The description provides no guidance on when to use this tool versus alternatives. It doesn't mention sibling tools like 'list_modules' (for listing modules first) or 'get_function_details' (for detailed function info), nor does it specify prerequisites such as needing a valid module name. The usage context is implied but not articulated.

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 mentions 'detailed information' but does not specify what details are included, the format of the output, or any constraints like rate limits or permissions needed. This leaves significant gaps in understanding the tool's 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 a single, clear sentence with no wasted words. It is front-loaded and efficiently conveys the core purpose without unnecessary elaboration, making it 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 lack of annotations and output schema, the description is incomplete for a tool that retrieves 'detailed information'. It does not explain what details are returned, how they are structured, or any behavioral traits, leaving the agent with insufficient context to use the tool effectively.

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 both parameters fully. The description adds no additional meaning beyond what the schema provides, such as examples or usage context for the parameters. Baseline score of 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 ('Get detailed information') and resource ('imports in a module'), making the purpose understandable. However, it does not explicitly differentiate from sibling tools like 'analyze_imports' or 'get_import_graph', which might have overlapping functionality, so it lacks specific sibling distinction.

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

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

The description provides no guidance on when to use this tool versus alternatives. With many sibling tools related to imports and modules (e.g., 'analyze_imports', 'get_import_graph'), there is no indication of context, exclusions, or prerequisites for usage.

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

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

No annotations are provided, so the description carries full burden. It mentions 'generate' and 'graph' but doesn't disclose behavioral traits such as output format (e.g., visual graph, JSON data), performance considerations, error handling, or whether it's read-only or has side effects. For a tool with 4 parameters and no annotations, 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 a single, efficient sentence with zero waste. It's front-loaded with the core purpose and appropriately sized for the tool's complexity. Every word earns its place without 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 4 parameters, no annotations, and no output schema, the description is incomplete. It doesn't address what the output looks like (e.g., graph format), how to interpret results, or any limitations (e.g., graph size constraints implied by 'limit' parameter). For a tool generating visualizations or complex data, 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 100%, so the schema already documents all 4 parameters with descriptions and defaults. The description adds no additional meaning beyond what's in the schema (e.g., it doesn't explain how parameters interact or provide examples). 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 'Generate module import relationship graph' clearly states the action (generate) and resource (module import relationship graph). It distinguishes from siblings like 'analyze_imports' or 'get_module_dependencies' by specifying a graph output rather than analysis or dependency listing. However, it doesn't explicitly differentiate from 'build_type_dependency_graph' or 'enhanced_function_call_graph' which might produce similar visualizations.

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. With many sibling tools related to imports, dependencies, and graphs (e.g., 'analyze_imports', 'get_module_dependencies', 'build_type_dependency_graph'), there is no indication of specific use cases, prerequisites, or comparisons. Usage is implied by the 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?

No annotations are provided, so the description carries the full burden of behavioral disclosure. The description only states it 'gets comprehensive context' without detailing what 'comprehensive' entails, how the context is structured, any limitations (e.g., file size, supported languages), or potential side effects. This leaves significant gaps in understanding the tool's 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 a single, clear sentence that is front-loaded with the main action. It is appropriately concise without unnecessary words, though it could be more specific to improve utility without adding length.

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 tool with 4 parameters, no annotations, and no output schema, the description is incomplete. It fails to explain what 'comprehensive context' means in terms of output, how it differs from sibling tools, or any behavioral nuances, making it inadequate for effective agent use.

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 input schema fully documents all parameters. The description adds no additional meaning beyond the schema, such as explaining how 'context_radius' interacts with 'include_dependencies' or what 'comprehensive context' includes. With high schema coverage, the baseline score of 3 is appropriate.

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

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

The description states the tool 'Get comprehensive context around a source location', which provides a general purpose but lacks specificity. It mentions 'source location' but doesn't clarify what type of context (e.g., code context, dependencies, relationships) or distinguish it from similar sibling tools like 'get_function_context' or 'find_element_by_location'. The purpose is understandable but vague.

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

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

No explicit guidance is provided on when to use this tool versus alternatives. The description does not mention any prerequisites, exclusions, or comparisons to sibling tools such as 'get_function_context' or 'find_element_by_location', leaving the agent to infer usage based on the tool name alone.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It mentions 'analyze' but doesn't specify whether this is a read-only operation, what the output format might be, or any constraints like rate limits or permissions. This leaves significant gaps for a tool with 3 parameters and no output schema.

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

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

The description is a single, efficient sentence with zero waste. It's appropriately sized and front-loaded, making it easy to parse without unnecessary elaboration.

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 (3 parameters, no output schema, no annotations) and rich sibling context, the description is incomplete. It doesn't address behavioral traits, output expectations, or usage differentiation, leaving an agent with insufficient information to invoke it correctly beyond basic parameter input.

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 3 parameters. The description adds no additional meaning beyond the schema, such as explaining how 'include_imports' and 'include_dependents' interact or what 'analyze' entails. Baseline 3 is appropriate when the schema does the heavy lifting.

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

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

The description 'Analyze module dependencies and imports' states the tool's purpose with a clear verb ('analyze') and target ('module dependencies and imports'), but it's vague about scope and doesn't differentiate from siblings like 'get_module_details', 'get_import_details', or 'analyze_imports'. It lacks specificity about what kind of analysis is performed.

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. With many sibling tools for dependency and import analysis (e.g., 'analyze_imports', 'get_import_details', 'get_type_dependencies'), the description offers no context, prerequisites, or exclusions to help an agent choose appropriately.

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 tool retrieves 'detailed information' including 'function counts and statistics', but doesn't specify what other details might be included, whether it's a read-only operation, potential performance impacts, error conditions, or output format. This leaves significant gaps for a tool that likely queries a codebase.

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 purpose ('Get detailed information about a specific module') and adds specific details ('including function counts and statistics'). There's no wasted wording, and it's appropriately sized for a simple lookup tool.

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 code analysis tool with no annotations and no output schema, the description is incomplete. It hints at the return content ('function counts and statistics') but doesn't fully explain what 'detailed information' entails, the structure of the output, or behavioral aspects like error handling. This is inadequate for guiding an agent in a rich sibling toolset.

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 single parameter 'module_name' fully documented in the schema as 'Name of the module'. The description doesn't add any meaning beyond this, such as format examples (e.g., case sensitivity, module path conventions) or constraints. Baseline 3 is appropriate since 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 'Get' and resource 'detailed information about a specific module', specifying it includes 'function counts and statistics'. It distinguishes from siblings like 'list_modules' (which likely lists modules without details) and 'get_module_dependencies' (which focuses on dependencies rather than internal statistics), but doesn't explicitly contrast them.

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

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

The description provides no guidance on when to use this tool versus alternatives. It doesn't mention when to choose it over siblings like 'get_code_statistics' (which might provide broader statistics) or 'get_functions_by_module' (which might list functions without counts), nor does it specify prerequisites or exclusions for usage.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It states what the tool does but doesn't reveal critical traits: whether it's read-only or has side effects, what data source it queries (e.g., static analysis vs. runtime), how it handles ties in frequency, or if there are rate limits. For a 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 a single, efficient sentence with zero waste. It's front-loaded with the core purpose and uses clear language. Every word earns its place, making it easy to parse quickly without unnecessary elaboration.

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 analyzing function calls and the lack of annotations and output schema, the description is incomplete. It doesn't explain what 'most frequently called' means (e.g., based on static analysis, runtime data, or historical usage), the format of the return value, or any prerequisites. For a tool with rich sibling context and no structured output, more detail is needed to be fully 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?

The input schema has 100% description coverage, with the 'limit' parameter clearly documented. The description doesn't add any parameter-specific details beyond what the schema provides, such as typical use cases for the limit or constraints on its values. With high schema coverage, the baseline score of 3 is appropriate as the description doesn't compensate but also doesn't detract.

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

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

The description clearly states the verb 'Get' and the resource 'most frequently called functions', making the purpose evident. It distinguishes from siblings like 'get_function_callees' or 'get_function_callers' by focusing on frequency ranking rather than direct call relationships. However, it doesn't specify the scope (e.g., within a module, project-wide) which could further differentiate it.

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. With many sibling tools like 'get_function_call_graph', 'analyze_function_complexity', and 'get_code_statistics', there's no indication of whether this is for performance analysis, debugging, or code review. It lacks explicit when/when-not instructions or named 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?

No annotations are provided, so the description carries the full burden. It mentions 'Get all nested type definitions' but doesn't disclose behavioral traits like whether this is a read-only operation, potential performance impacts, rate limits, or what the output format looks like. This leaves significant gaps for a tool with 4 parameters.

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's front-loaded and appropriately sized for the tool's complexity, 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 no annotations and no output schema, the description is incomplete. It doesn't explain what 'nested type definitions' are, how results are structured, or any behavioral context. For a tool with 4 parameters in a complex domain (type analysis), this leaves too many unknowns for effective use.

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 parameters fully. The description adds no meaning beyond the schema, such as explaining how 'type_names' relate to 'nested' definitions or what 'exclude_pattern' might filter. 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 states the action ('Get') and resource ('nested type definitions for specified types'), but it's vague about what 'nested type definitions' entail and doesn't differentiate from siblings like 'get_type_details' or 'get_type_dependencies'. It provides a basic purpose but lacks specificity.

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 such as 'get_type_details' or 'analyze_type_relationships'. The description implies usage for analyzing types but offers no context, exclusions, or prerequisites for 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?

No annotations are provided, so the description carries the full burden of behavioral disclosure. 'Analyze' suggests a read-only operation, but the description doesn't clarify permissions, rate limits, output format, or side effects. It lacks details on what 'analyze' entails—whether it returns a graph, list, or summary—which is critical for a tool with no output schema.

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

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

The description is a single, efficient sentence with zero wasted words. It's front-loaded with the core purpose ('Analyze type dependencies and relationships'), making it easy to parse. Every word earns its place, achieving optimal conciseness for such a brief statement.

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 (4 parameters, no annotations, no output schema) and rich sibling context, the description is incomplete. It doesn't explain the output format, behavioral constraints, or differentiation from similar tools, leaving significant gaps for the agent to infer. For a dependency analysis tool with no structured output guidance, this is inadequate.

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 thoroughly. The description adds no additional meaning beyond the schema, such as explaining how 'depth' affects traversal or what 'include_dependents' implies in practice. With high schema coverage, the baseline score of 3 is appropriate, as the description doesn't compensate but also doesn't detract.

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

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

The description 'Analyze type dependencies and relationships' clearly states the tool's purpose with a specific verb ('analyze') and target ('type dependencies and relationships'), which is better than a tautology. However, it doesn't distinguish this tool from several similar siblings like 'analyze_type_relationships', 'analyze_cross_module_dependencies', or 'build_type_dependency_graph', leaving ambiguity about what makes this tool unique.

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. With multiple sibling tools focused on type analysis (e.g., 'analyze_type_relationships', 'get_type_details', 'build_type_dependency_graph'), there's no indication of context, prerequisites, or exclusions. This forces the agent to guess based on 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?

No annotations are provided, so the description carries full burden. It mentions what information is included ('constructors and fields') but doesn't disclose behavioral aspects like whether this is a read-only operation, what format the output takes, potential performance considerations, or error conditions. The description is minimal and lacks 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 a single, efficient sentence that gets straight to the point. There's no wasted verbiage or unnecessary elaboration. However, it could be slightly more front-loaded with distinguishing context given the many sibling tools.

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

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

For a tool with 4 parameters, no annotations, and no output schema, the description is inadequate. It doesn't explain what 'detailed information' means beyond constructors and fields, doesn't describe the return format, and provides no context about the tool's role within the broader ecosystem of type analysis tools. The agent would struggle to use this effectively without trial and error.

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 parameters. The description adds minimal value beyond the schema - it mentions 'constructors and fields' which aligns with the boolean parameters, but doesn't provide additional context about what those details include or why they might be useful. 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 action ('Get detailed information') and resource ('about a specific type'), specifying what details are included ('constructors and fields'). However, it doesn't differentiate from sibling tools like 'get_class_details' or 'get_type_dependencies', which could cause confusion about when to choose this tool over those 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 provides no guidance on when to use this tool versus alternatives. With many sibling tools like 'get_class_details', 'get_type_dependencies', and 'list_types', the agent has no indication of whether this is for basic type metadata, structural details, or relationship analysis. No exclusions or prerequisites are mentioned.

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 mentions grouping functions by similarity but doesn't explain what 'similarity' means (e.g., code structure, naming, dependencies), how groups are formed, whether this is a read-only analysis or modifies data, or what the output looks like. For a tool with no 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 a single, efficient sentence that directly states the tool's purpose without unnecessary words. It's appropriately sized and front-loaded, making it easy to understand at a glance.

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 similarity-based grouping tool with no annotations and no output schema, the description is insufficient. It doesn't explain the similarity metric, grouping methodology, output format, or performance considerations. For a tool that likely involves algorithmic analysis, more context is needed to use it effectively.

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 thoroughly. The description doesn't add any parameter-specific information beyond what's in the schema (e.g., it doesn't clarify how 'similarity_threshold' relates to the grouping algorithm). With high schema coverage, the baseline score of 3 is appropriate as the description doesn't compensate but doesn't detract either.

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: 'Group functions by similarity to identify common patterns.' This specifies the verb ('group'), resource ('functions'), and goal ('identify common patterns'). However, it doesn't explicitly differentiate from the sibling tool 'find_similar_functions,' which appears related but has a different purpose (finding vs. grouping).

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. With sibling tools like 'find_similar_functions' and 'find_code_patterns' that might overlap in functionality, there's no indication of when this grouping approach is preferred or what prerequisites might be needed.

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 'gets' class definitions with filtering, implying a read-only operation, but doesn't cover critical aspects like pagination behavior (beyond the 'limit' parameter in schema), error handling, or performance characteristics. The description is minimal and lacks behavioral depth.

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 purpose ('Get class definitions') and adds essential filtering details. There is no wasted verbiage, making it highly concise and well-structured for quick comprehension.

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 is minimally adequate. It covers the basic purpose and filtering but lacks details on output format, error cases, or integration with sibling tools. Without annotations or an output schema, more context would be beneficial for effective agent use.

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 mentions filtering by 'module or pattern', which aligns with the 'module_name' and 'pattern' parameters in the schema. However, with 100% schema description coverage, the schema already documents all three parameters well. The description adds marginal value by summarizing the filtering options but doesn't provide additional semantics beyond what the schema offers.

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 ('class definitions'), and it mentions filtering capabilities. However, it doesn't explicitly differentiate from sibling tools like 'search_classes' or 'list_types', which appear to have overlapping functionality.

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 'search_classes' or 'list_types' from the sibling list. It mentions filtering by module or pattern but doesn't specify scenarios or exclusions, 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 for behavioral disclosure. It states it retrieves a list but doesn't mention pagination behavior, sorting, what 'all modules' means (active, archived, etc.), authentication requirements, rate limits, or error conditions. This leaves significant gaps for a read operation.

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

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

The description is a single, efficient sentence that directly states the tool's purpose without unnecessary words. It's appropriately front-loaded and every word earns its place in conveying 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?

For a tool with no annotations, no output schema, and many sibling alternatives, the description is insufficient. It doesn't explain what a 'module' represents in this context, what fields are returned, how results are structured, or how it differs from similar tools like 'search_modules' or 'get_module_details'.

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, with the single parameter 'limit' clearly documented. The description doesn't add any parameter-specific information beyond what's in the schema, so it meets the baseline for high schema coverage without compensating value.

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 ('Get list') and resource ('all modules in the database'), making the purpose unambiguous. However, it doesn't explicitly differentiate from sibling tools like 'search_modules' or 'get_module_details', which would require more specific scope definition.

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 'search_modules' or 'get_module_details'. There's no mention of prerequisites, limitations, or comparative context with the many sibling analysis tools available.

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 mentions 'support for different type categories' but doesn't explain what 'Get' entails—e.g., whether it's a read-only operation, if it returns a list or structured data, pagination behavior, or error handling. For a tool with no annotations, this is insufficient.

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 purpose. It avoids redundancy and wastes no words, though it could be slightly more structured by explicitly separating filtering options.

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, the description is incomplete. It doesn't explain what the tool returns (e.g., a list of type names, detailed objects), how results are formatted, or any behavioral traits like rate limits. For a tool with 4 parameters and no structured output info, this leaves significant 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%, so the schema fully documents all parameters. The description adds minimal value by hinting at filtering ('by module or pattern' and 'different type categories'), but doesn't provide additional semantics beyond what the schema already specifies. 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: 'Get types by module or pattern with support for different type categories.' It specifies the verb ('Get') and resource ('types'), and mentions filtering capabilities. However, it doesn't explicitly differentiate from sibling tools like 'search_types' or 'get_type_details,' 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 provides no guidance on when to use this tool versus alternatives. It doesn't mention sibling tools like 'search_types' or 'get_type_details,' nor does it specify contexts, prerequisites, or exclusions. This leaves the agent without clear usage 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 offers minimal behavioral insight. It mentions 'advanced pattern matching' but doesn't disclose what makes it advanced, performance characteristics, rate limits, authentication needs, or what the output looks like. For a tool with complex nested parameters and no output schema, this leaves significant gaps in understanding how the tool behaves.

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 gets straight to the point without unnecessary words. However, given the tool's complexity and the lack of annotations/output schema, this brevity comes at the cost of completeness rather than representing optimal conciseness.

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

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

For a complex tool with 3 parameters (including nested objects), no annotations, no output schema, and many sibling alternatives, the description is insufficient. It doesn't explain what 'advanced' means, what constitutes a successful match, how results are returned, or how this differs from simpler pattern matching tools. The agent would struggle to use this effectively without trial and error.

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 parameters and their purposes. The description adds no additional parameter semantics beyond what's already in the schema descriptions. The baseline score of 3 reflects adequate coverage through the schema alone, with no value added by the description.

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

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

The description 'Advanced pattern matching to find code structures' states a general purpose but lacks specificity about what constitutes 'advanced' or what 'code structures' means. It distinguishes itself from siblings like 'find_code_patterns' by emphasizing 'advanced' matching, but doesn't clearly articulate the unique verb+resource combination beyond basic pattern matching.

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 like 'find_code_patterns', 'execute_advanced_query', or other analysis tools. The description implies it's for pattern matching but doesn't specify contexts, prerequisites, or exclusions that would help an agent choose appropriately among the many sibling 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 of behavioral disclosure. While it mentions searching and filtering, it doesn't describe important behaviors like whether results are paginated, what format they return, if there are rate limits, or how the search pattern matching works (exact, substring, regex). This is inadequate for a search 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 a single, efficient sentence that communicates the core functionality without any wasted words. It's appropriately sized for a search tool and front-loads the 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 complexity of a search operation with three parameters, no annotations, and no output schema, the description is insufficient. It doesn't explain what the search returns, how results are structured, or important behavioral aspects like case sensitivity or matching algorithms. The description should provide more context for effective tool use.

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 three parameters. The description adds minimal value by mentioning 'name pattern' and 'module filtering', which aligns with the schema's 'pattern' and 'module_pattern' parameters but doesn't provide additional semantic context beyond what's in the schema descriptions.

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

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

The description clearly states the tool's purpose: 'Search for classes by name pattern with module filtering'. It specifies the verb ('search'), resource ('classes'), and key constraints ('by name pattern with module filtering'). However, it doesn't explicitly differentiate from sibling tools like 'list_classes' or 'search_types', 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 provides no guidance on when to use this tool versus alternatives. With many sibling tools like 'list_classes', 'search_types', and 'get_class_details', there's no indication of when this search tool is preferred over those options or what specific scenarios it addresses.

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 for behavioral disclosure. While 'Search' implies a read-only operation, it doesn't address important aspects like performance characteristics, result format, pagination behavior, or whether the search is case-sensitive. The description provides minimal behavioral context beyond the basic operation.

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

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

The description is a single, efficient sentence that gets straight to the point with zero wasted words. It's appropriately sized for a simple search tool and front-loads the essential information without unnecessary elaboration.

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 relatively simple search tool with good schema coverage but no annotations or output schema, the description provides the basic operation but lacks important context. It doesn't explain what constitutes a 'function' in this system, what format results will be in, or how this tool relates to the many similar tools in the sibling list, leaving significant gaps for an agent to navigate this complex tool ecosystem.

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 both parameters. The description mentions 'name pattern' which aligns with the 'pattern' parameter but adds no additional semantic context 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 ('Search') and resource ('functions') with the specific mechanism ('by name pattern'), making the purpose immediately understandable. However, it doesn't explicitly differentiate from sibling tools like 'search_classes', 'search_modules', or 'search_types' which follow similar patterns for different resource types.

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 'find_similar_functions', 'pattern_match_code', or other search-related siblings. There's no mention of use cases, prerequisites, or exclusions that would help an agent choose between similar tools in this extensive toolset.

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 searches by name pattern but doesn't describe what 'search' entails (e.g., returns partial matches, supports wildcards as hinted in the schema, or handles case sensitivity). It lacks details on output format, pagination, error handling, or performance considerations, leaving 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 a single, efficient sentence that directly states the tool's purpose without unnecessary words. It's front-loaded with the core action ('Search for modules'), making it easy to parse. There's no redundancy or fluff, earning its place as a concise and well-structured summary.

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 lack of annotations and output schema, the description is incomplete for a search tool. It doesn't explain what the search returns (e.g., module names, details, or IDs), how results are ordered, or any limitations (e.g., max pattern length). With 2 parameters and no structured output information, more context is needed to guide 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%, with clear documentation for both parameters ('pattern' and 'limit'), including default values and constraints. The description adds minimal value beyond the schema by implying the search is based on name patterns, but it doesn't elaborate on pattern syntax or usage examples. This meets the baseline of 3 since the schema adequately covers parameter semantics.

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 ('Search for modules') and the target resource ('modules'), with the specific criterion 'by name pattern'. It distinguishes from siblings like 'list_modules' by specifying a search operation rather than a simple listing. However, it doesn't explicitly differentiate from other search tools like 'search_classes' or 'search_functions' 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 no guidance on when to use this tool versus alternatives. It doesn't mention when to prefer 'search_modules' over 'list_modules' (e.g., for filtered results vs. all modules), nor does it reference other search tools like 'search_classes' or 'search_functions' for different resource types. There's no context about prerequisites, exclusions, or typical use cases.

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 'search' implies a read-only operation, the description doesn't mention important behavioral aspects like pagination behavior, rate limits, authentication requirements, result format, or what 'advanced filtering' specifically entails beyond the parameters.

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 - a single sentence that efficiently communicates the core functionality. There's no wasted language, and it's appropriately sized for what it needs to convey.

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 search tool with 4 parameters, no annotations, and no output schema, the description is insufficient. It doesn't explain what 'types' refers to in this context, what format results will be returned in, or how the search pattern matching works. For a tool with no output schema, some indication of return values would be 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 100%, so the schema already documents all parameters thoroughly. The description adds minimal value beyond what's in the schema - it mentions 'advanced filtering' which aligns with the parameters but doesn't provide additional semantic context. 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 a specific verb ('Search') and resource ('types'), and mentions advanced filtering. However, it doesn't explicitly differentiate this tool from sibling tools like 'list_types' or 'search_classes', which appear to offer similar functionality.

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. With many sibling tools available (like 'list_types', 'search_classes', 'get_type_details'), there's no indication of when this search tool is preferred or what distinguishes it from other listing/searching tools.

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