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 'extract and analyze', implying a read-only operation, but doesn't specify if it requires specific permissions, what the analysis entails (e.g., output format, depth), or any rate limits. This is a significant gap for a tool with potential complexity.

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 directly states the tool's purpose without unnecessary elaboration, 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 analyzing business rules from check constraints, no annotations, and no output schema, the description is incomplete. It doesn't explain what the analysis outputs (e.g., a report, summary, or detailed breakdown), leaving the agent uncertain about the tool's behavior and results.

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

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

The schema description coverage is 100%, so the schema already documents all 4 parameters with clear descriptions. The description adds no additional meaning beyond what's in the schema, such as explaining how parameters interact or default behaviors. 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 verb 'extract and analyze' and the resource 'business rules from check constraints', making the purpose understandable. However, it doesn't explicitly differentiate from sibling tools like 'list_constraints' or 'list_default_constraints', which might also involve constraints but with different scopes or outputs.

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 'list_constraints' (which might list constraints without analysis) or 'analyze_database_size' (which focuses on size metrics), leaving the agent to infer usage from context 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. It mentions 'comprehensive database size information' but doesn't disclose behavioral traits such as whether this is a read-only operation, potential performance impact on the database, authentication requirements implied by connection parameters, or output format. For a tool with connection 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 that front-loads the core purpose ('Get comprehensive database size information') and adds a clarifying detail ('including data and log file sizes'). There is zero waste, and 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 database analysis tools, no annotations, and no output schema, the description is incomplete. It lacks details on behavioral aspects (e.g., read-only vs. write, performance impact), usage context compared to siblings, and what the output entails. For a tool with connection parameters and in a server with many similar tools, this minimal description leaves too many gaps 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 schema fully documents the two parameters (connectionString and connectionName). The description adds no parameter-specific information beyond implying a database context. Since the schema does the heavy lifting, 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 'database size information', specifying it includes 'data and log file sizes'. It distinguishes itself from siblings like analyze_index_usage or analyze_table_stats by focusing on size metrics rather than performance or structure. However, it doesn't explicitly contrast with tools like list_databases, which might also provide size-related info.

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_databases or analyze_table_stats that might overlap in providing database metrics, there's no indication of specific use cases, prerequisites, or exclusions. This leaves the agent to guess 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 'Get data distribution patterns' but doesn't specify whether this is a read-only operation, what permissions are required, how it handles large datasets, or what the output format looks like. For a database analysis tool with zero annotation coverage, this leaves critical behavioral traits unclear.

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

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

The description is a single, efficient sentence that front-loads the core purpose without unnecessary details. It avoids redundancy and waste, though it could be slightly more structured by explicitly mentioning the database context implied by the parameters.

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 database analysis tool with 6 parameters, no annotations, and no output schema, the description is incomplete. It lacks details on behavioral traits, usage context, and output format, which are essential for an agent to effectively invoke this tool in a database environment with many sibling alternatives.

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

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

The schema description coverage is 100%, meaning all parameters are documented in the input schema. The description adds no specific parameter semantics beyond implying analysis of columns for data quality, which is already covered by the tool's purpose. This meets the baseline score 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 tool's purpose as 'Get data distribution patterns for columns to understand data quality and patterns', which specifies the verb ('Get'), resource ('data distribution patterns for columns'), and goal ('understand data quality and patterns'). However, it doesn't explicitly differentiate this from sibling tools like 'analyze_table_stats' or 'sample_data', which might 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. With many sibling tools focused on database analysis (e.g., 'analyze_table_stats', 'sample_data', 'describe_table'), there's no indication of specific contexts, prerequisites, or exclusions for this tool, leaving the agent to infer usage from 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 shows 'detailed index usage statistics' but doesn't describe what 'detailed' entails, the format of output, whether it's read-only or has side effects, or any performance or permission considerations. For a tool with 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 that front-loads the core purpose without unnecessary words. It directly states what the tool does and its goal, making it easy to parse quickly. Every part of the sentence 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?

Given the complexity of analyzing database indexes and the lack of annotations and output schema, the description is incomplete. It doesn't explain what 'detailed statistics' include, how results are presented, or any behavioral aspects like read-only nature or potential performance impact. For a tool with 5 parameters and no structured output info, 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 input schema fully documents all 5 parameters. The description adds no additional meaning about parameters beyond what's in the schema, such as explaining interactions between 'connectionString' and 'connectionName' or clarifying 'unused' criteria. 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: 'Show detailed index usage statistics to identify unused or underutilized indexes.' It specifies the verb ('show'), resource ('index usage statistics'), and goal ('identify unused or underutilized indexes'). However, it doesn't explicitly differentiate from sibling tools like 'list_indexes' or 'find_missing_indexes,' which prevents a perfect score.

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

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

The description provides no guidance on when to use this tool versus alternatives. It doesn't mention sibling tools like 'list_indexes' (which might list indexes without usage stats) or 'find_missing_indexes' (which might suggest new indexes), nor does it specify prerequisites or contexts for usage. This leaves the agent without clear 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. It mentions 'find columns with high null percentages' and 'analyze null patterns,' but doesn't specify what constitutes 'high' (though the schema hints at a default threshold), how results are returned, whether it's read-only or has side effects, or any performance considerations. For a tool with 4 parameters and no annotations, 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 extremely concise and front-loaded: 'Find columns with high null percentages and analyze null patterns.' It uses a single, efficient sentence that directly states the tool's function without any redundant information, making it easy to parse and understand 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 behavioral traits, output format, error handling, or how it differs from sibling tools. While the schema covers parameters well, the description doesn't compensate for missing annotations or output information, leaving gaps in understanding the tool's full context.

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

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

The schema description coverage is 100%, with all parameters well-documented in the input schema (e.g., connectionString, minNullPercentage). The description adds no additional parameter semantics beyond what's in the schema, such as explaining interactions between parameters or usage nuances. According to the rules, with high schema coverage, the baseline is 3, which is appropriate 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 clearly states the tool's purpose: 'Find columns with high null percentages and analyze null patterns.' It specifies the verb ('find' and 'analyze') and resource ('columns'), making the intent unambiguous. However, it doesn't explicitly differentiate from siblings like 'analyze_data_distribution' or 'analyze_table_stats,' which might also involve data quality analysis, leaving some ambiguity about its unique role.

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 focused on database analysis (e.g., 'analyze_data_distribution,' 'analyze_table_stats'), there's no indication of specific scenarios, prerequisites, or exclusions. This lack of context could lead to confusion about selecting the right tool for null-related tasks.

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. While 'Get' implies a read-only operation, the description doesn't address important behavioral aspects like whether this requires specific database permissions, if it's a heavy operation that might impact performance, what format the statistics are returned in, or if there are any rate limits. The description is minimal and lacks behavioral context.

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

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

The description is extremely concise - a single sentence that efficiently communicates the core purpose without any wasted words. It's front-loaded with the essential information and contains no unnecessary elaboration or repetition.

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 (database analysis with 4 parameters), lack of annotations, and absence of an output schema, the description is insufficiently complete. It doesn't explain what the output looks like, what statistics are included, how results are formatted, or any behavioral considerations. For a database analysis tool with no structured output documentation, the description should provide more context about the return values and operational characteristics.

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 parameter information beyond what's in the schema - it doesn't explain how parameters interact, which combinations are valid, or provide usage examples. 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 with specific verbs ('Get table row counts, size information, and last update statistics'), identifying the resource (table statistics) and what information is retrieved. However, it doesn't explicitly differentiate from sibling tools like 'describe_table' or 'analyze_data_distribution', which might provide 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?

No guidance is provided on when to use this tool versus alternatives. With many sibling tools available (e.g., 'describe_table', 'analyze_data_distribution', 'list_tables'), the description offers no context about when this specific statistical analysis tool is appropriate or what distinguishes it from other 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 states this is a read operation ('Get'), but doesn't describe authentication needs (e.g., via connectionString or connectionName), potential rate limits, error handling, or what the output format looks like (e.g., JSON structure). For a tool with database access and 5 parameters, this leaves significant gaps.

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

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

The description is a single, efficient sentence that front-loads the core purpose ('Get detailed information about a specific stored procedure') and adds specific details ('including parameters and definition'). There is zero waste, and 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?

Given no annotations, no output schema, and 5 parameters (with 100% schema coverage), the description is minimally adequate. It covers the purpose but lacks behavioral context (e.g., authentication, output format) and usage guidelines versus siblings. For a database metadata tool with multiple similar siblings, 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 5 parameters with descriptions and defaults. The description adds no additional parameter semantics beyond implying that 'parameters and definition' are retrieved, which aligns with the 'includeDefinition' parameter but doesn't provide extra 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 verb ('Get') and resource ('detailed information about a specific stored procedure'), specifying what information is retrieved ('parameters and definition'). It distinguishes from siblings like 'list_stored_procedures' (which lists names) and 'get_stored_procedure_definition' (which might only return the definition), but doesn't explicitly name these alternatives.

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

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

The description implies usage for retrieving detailed metadata about a specific stored procedure, but provides no explicit guidance on when to use this tool versus alternatives like 'get_stored_procedure_definition' or 'get_all_stored_procedure_definitions'. It doesn't mention prerequisites, exclusions, or specific contexts.

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 information (a read operation), but does not mention permissions required, rate limits, whether it's safe for production use, or what the output format looks like. For a tool with zero 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 ('Get detailed schema information') and specifies key details (table, columns, data types, constraints). There is no wasted verbiage, and every word contributes to understanding the tool's function.

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, 1 required) and lack of annotations or output schema, the description is adequate but incomplete. It covers the basic purpose and parameters indirectly via the schema, but fails to address behavioral aspects like safety, permissions, or output format, which are important for a database tool.

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

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

Schema description coverage is 100%, so the input schema already documents all parameters thoroughly. The description does not add any parameter-specific details beyond what the schema provides (e.g., it doesn't clarify parameter interactions or provide examples). 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 verb 'Get' and the resource 'detailed schema information for a specific table', specifying what information is retrieved (columns, data types, constraints). It distinguishes from siblings like 'list_tables' (which lists names) and 'analyze_table_stats' (which provides performance metrics), making the purpose specific and differentiated.

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

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

The description implies usage for obtaining schema details of a table, but does not explicitly state when to use this tool versus alternatives like 'list_tables' (for names only) or 'get_relationships' (for foreign keys). It provides basic context but lacks explicit guidance on exclusions 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?

With no annotations provided, the description carries full burden but only states what information is retrieved without disclosing behavioral traits like whether this is a read-only operation, potential performance impact, authentication requirements, or error handling. It mentions 'detailed information' but doesn't specify format or limitations.

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 trigger') and adds specific details ('including its definition and events') without unnecessary elaboration. Every word serves a clear purpose 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?

For a read operation with 4 parameters (1 required) and 100% schema coverage but no output schema or annotations, the description is minimally adequate. It states what the tool does but lacks information about return format, error conditions, or behavioral constraints that would be important for agent usage. The absence of output schema means the description should ideally address return values.

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 thoroughly. The description doesn't add any parameter-specific information beyond what's in the schema, maintaining the baseline score of 3. It implies 'triggerName' is central but doesn't elaborate on parameter interactions.

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 trigger'), specifying what information is retrieved ('including its definition and events'). It distinguishes from siblings like 'list_triggers' (which lists triggers) by focusing on detailed description of a single trigger, 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?

The description implies usage when detailed trigger information is needed, but doesn't explicitly state when to use this tool versus alternatives like 'list_triggers' or other describe_* tools. It provides some context through the parameter 'triggerName' requirement, but lacks explicit guidance on 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?

No annotations are provided, so the description carries full burden. While it mentions what information is retrieved (definition and dependencies), it doesn't disclose important behavioral traits like whether this is a read-only operation, what permissions are required, whether it connects to a live database, potential performance impact, error handling, or output format. For a database tool with zero annotation coverage, 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 communicates the core purpose without any wasted words. It's front-loaded with the main action and follows with specific details. Every word earns its place in conveying what the tool does.

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 database analysis tool with 5 parameters and no annotations or output schema, the description is insufficient. It doesn't address important contextual aspects like required permissions, connection requirements, performance considerations, error conditions, or what the detailed information output looks like. Given the complexity of database operations and the lack of structured metadata, the description should provide more complete guidance for safe and 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 5 parameters thoroughly. The description doesn't add any parameter semantics beyond what's in the schema - it doesn't explain parameter relationships, provide examples, or clarify edge cases. With complete schema coverage, the baseline is 3 even without additional parameter information in 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 verb ('Get detailed information') and resource ('a specific view') with specific details about what information is retrieved ('its definition and dependencies'). It distinguishes from siblings like describe_table or describe_stored_procedure by focusing specifically on views. However, it doesn't explicitly differentiate from list_views which might be a similar sibling 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 provides no guidance on when to use this tool versus alternatives. It doesn't mention when to use describe_view versus describe_table, describe_stored_procedure, or list_views. There's no indication of prerequisites, typical use cases, or scenarios where this tool is preferred over other analysis 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 of behavioral disclosure. It states what the tool does but doesn't describe how it behaves: e.g., whether it scans all tables, returns a list or summary, has performance implications, requires specific permissions, or handles errors. For a tool with database access 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: 'Identify common audit trail patterns (created/modified dates, user tracking)'. It's front-loaded with the core purpose and uses parentheses for clarification without unnecessary elaboration. 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 tool's complexity (database analysis with 3 parameters), lack of annotations, and no output schema, the description is incomplete. It doesn't explain what the tool returns (e.g., a list of columns, a report), behavioral traits like side effects or performance, or how it integrates with siblings. For a tool in this context, 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?

Schema description coverage is 100%, so the schema already documents all three parameters (connectionString, connectionName, schema) with their types and descriptions. The description adds no parameter-specific information beyond what's in the schema, such as examples or constraints. 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: 'Identify common audit trail patterns (created/modified dates, user tracking)'. It specifies the verb 'identify' and the resource 'audit trail patterns', making it distinct from sibling tools that analyze constraints, indexes, or describe objects. However, it doesn't explicitly differentiate from similar analysis tools like 'analyze_null_patterns' or 'find_computed_columns' beyond the audit focus.

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 prerequisites (e.g., needing a database connection), exclusions (e.g., not for non-SQL Server databases), or comparisons to siblings like 'analyze_table_stats' or 'find_computed_columns'. Usage is implied only by the tool's name and purpose, lacking explicit 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 the full burden of behavioral disclosure. It adds value by specifying 'automatic limit (top 20 rows)', which is a key constraint not in the schema. However, it lacks details on permissions, error handling, or response format, leaving gaps for a tool that executes custom 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. Every word earns its place, with no redundancy or waste, 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 executing custom SQL queries, no annotations, and no output schema, the description is incomplete. It covers the basic action and a limit but misses critical details like security implications, result formatting, or error scenarios. It's minimally adequate but has clear gaps for this type of 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 schema description coverage is 100%, so the schema already documents all parameters thoroughly. The description doesn't add any meaning beyond what's in the schema, such as clarifying parameter interactions or usage examples. Baseline 3 is appropriate as the schema does the heavy lifting.

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

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

The description clearly states the tool's purpose: 'Execute a custom SQL SELECT query with automatic limit (top 20 rows)'. It specifies the verb ('Execute'), resource ('SQL SELECT query'), and key behavior ('automatic limit'). However, it doesn't explicitly differentiate from sibling tools like 'sample_data' or 'describe_table', which might also retrieve data but with different approaches.

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 'sample_data' for limited data retrieval without custom queries or 'describe_table' for metadata. There's no context on prerequisites, such as needing a connection, or exclusions like avoiding non-SELECT queries.

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 the tool lists computed columns and formulas, but fails to describe key behaviors like whether it requires database permissions, if it's read-only, potential performance impacts, or output format details, which are critical for safe and effective use.

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 front-loaded with the main action, making it easy to parse, though it could be slightly more structured by including usage hints.

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 database tools and lack of annotations or output schema, the description is insufficient. It does not cover behavioral aspects like safety, performance, or output format, and while parameters are documented in the schema, the overall context for proper tool selection and invocation is incomplete.

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 already documents all parameters thoroughly. The description does not add any additional meaning or context beyond what the schema provides, such as explaining how parameters interact or typical use cases, resulting in a baseline score.

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

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

The description clearly states the action ('List computed columns and their formulas') and the resource ('computed columns'), making the purpose evident. However, it does not explicitly differentiate from sibling tools like 'describe_table' or 'list_ables', which might also provide column information, so it misses 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. It lacks context such as whether it's for auditing, debugging, or schema analysis, and does not mention any prerequisites or exclusions, 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 the tool identifies tables 'automatically based on table patterns,' which hints at heuristic analysis, but doesn't explain what constitutes a lookup table, how patterns are defined, or what the output format is. For a tool with no annotations and no output schema, this leaves significant gaps in understanding its behavior and results.

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: 'Identify reference/lookup tables automatically based on table patterns.' It is front-loaded with the core purpose, has zero wasted words, and is appropriately sized for the tool's complexity. Every part of the sentence contributes directly to understanding the tool's function.

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 identifying lookup tables heuristically, no annotations, and no output schema, the description is incomplete. It doesn't explain what the tool returns (e.g., a list of table names, patterns found), how it handles errors, or any behavioral nuances like performance implications. For a tool with 4 parameters and no structured output guidance, more context is needed to fully understand its 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 input schema has 100% description coverage, so the schema fully documents all parameters (connectionString, connectionName, schema, maxRows). The description adds no additional parameter semantics beyond what's in the schema, such as examples of table patterns or how maxRows influences identification. With high schema coverage, the baseline score of 3 is appropriate, as the description doesn't compensate but doesn't need to heavily.

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: 'Identify reference/lookup tables automatically based on table patterns.' It specifies the verb ('identify'), resource ('reference/lookup tables'), and method ('based on table patterns'), which distinguishes it from generic table listing tools. However, it doesn't explicitly differentiate from all sibling tools like 'list_tables' or 'analyze_table_stats' beyond the pattern-based identification focus.

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 prerequisites, such as needing a database connection, or compare it to sibling tools like 'list_tables' for general listing or 'analyze_table_stats' for analysis. The context is implied through the tool name and description but lacks explicit 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 the full burden of behavioral disclosure. It mentions 'potentially missing indexes' and 'query execution patterns,' hinting at analysis based on performance data, but lacks details on permissions, data sources, computational cost, or output format. For a tool with zero annotation coverage, this is insufficient to inform safe and effective use.

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. It's appropriately sized for the tool's complexity, with every part contributing to 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 lack of annotations and output schema, the description is incomplete for a tool that analyzes database performance. It doesn't cover behavioral aspects like data access, potential side effects, or result interpretation, leaving gaps that could hinder an agent's ability to use it effectively in context with sibling tools.

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

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

The schema description coverage is 100%, so the input schema fully documents all four parameters. The description adds no additional parameter semantics beyond what's in the schema, such as explaining how 'minImpact' relates to index recommendations. This meets the baseline for high schema coverage but 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 clearly states the tool's purpose: 'Identify potentially missing indexes based on query execution patterns.' It specifies the verb ('identify') and resource ('missing indexes') with the context of 'query execution patterns.' However, it doesn't explicitly differentiate from sibling tools like 'analyze_index_usage' or 'list_indexes,' which prevents a perfect score.

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

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

The description provides no guidance on when to use this tool versus alternatives. It doesn't mention sibling tools like 'analyze_index_usage' for existing index analysis or 'list_indexes' for inventory, nor does it specify prerequisites or exclusions. This leaves the agent without context for tool selection.

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

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

With no annotations provided, the description carries full burden but offers minimal behavioral insight. It states the tool retrieves definitions but doesn't disclose critical traits like whether it's read-only (implied but not explicit), potential performance impact, authentication needs (only hinted via connection parameters), or output format (e.g., SQL text). 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 without unnecessary words. Every part ('Get complete SQL definitions for all stored procedures in a schema') directly contributes to understanding, making it optimally 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 tool's complexity (5 parameters, no annotations, no output schema), the description is insufficiently complete. It lacks details on behavioral traits (e.g., safety, performance), output format, or usage context relative to siblings. While the schema covers parameters, the description fails to compensate for missing annotations and output schema, leaving gaps 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 parameters are well-documented in the schema itself. The description adds no additional parameter semantics beyond implying scope ('all stored procedures in a schema'), which aligns with the 'schema' parameter but doesn't elaborate on interactions like default values or constraints. This meets the baseline for high schema coverage.

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

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

The description clearly states the action ('Get complete SQL definitions') and resource ('all stored procedures in a schema'), making the purpose immediately understandable. However, it doesn't explicitly differentiate from sibling tools like 'get_stored_procedure_definition' (singular) or 'get_multiple_stored_procedure_definitions', which handle specific procedures rather than all in a schema.

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

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

The description provides no guidance on when to use this tool versus alternatives. It doesn't mention sibling tools like 'get_stored_procedure_definition' for single procedures, 'get_multiple_stored_procedure_definitions' for a subset, or 'list_stored_procedures' for metadata only, leaving the agent to infer usage from tool names alone.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It states the tool retrieves definitions but doesn't mention whether this is a read-only operation (implied by 'Get'), potential side effects (e.g., database load), authentication needs (hinted by connection parameters but not explicit), or output format (e.g., SQL text, metadata inclusion). This leaves significant gaps for a tool that interacts with a database.

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 complete SQL definitions for multiple stored procedures at once') with zero wasted words. It avoids redundancy and is 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?

Given the tool's complexity (database interaction, 5 parameters) and lack of annotations and output schema, the description is insufficient. It doesn't explain the return format (e.g., structured data vs. raw SQL), error handling, or behavioral constraints (e.g., read-only nature, connection requirements). For a tool with no structured safety or output information, more descriptive 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 fully documents all 5 parameters. The description adds no additional meaning beyond what's in the schema (e.g., it doesn't clarify parameter interactions or default behaviors). The baseline score of 3 is appropriate since the schema does the heavy lifting, but the description doesn't compensate with extra context.

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

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

The description clearly states the action ('Get complete SQL definitions') and resource ('multiple stored procedures at once'), making the purpose immediately understandable. It distinguishes from the sibling 'get_stored_procedure_definition' by specifying 'multiple... at once' and from 'get_all_stored_procedure_definitions' by implying selective retrieval rather than fetching all. However, it doesn't explicitly name these distinctions.

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_stored_procedure_definition' (single procedure) or 'get_all_stored_procedure_definitions' (all procedures). It lacks context about prerequisites (e.g., connection setup) or typical use cases (e.g., batch analysis), leaving the agent to infer usage from 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 what the tool does but lacks details on behavior: it doesn't specify if this is a read-only operation, what the output format looks like, whether it requires specific permissions, or if there are rate limits. For a database query tool with zero annotation coverage, this is a significant gap.

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

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

The description is a single, efficient sentence that directly states the tool's purpose without any fluff or redundancy. It's appropriately sized and front-loaded, 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 complexity (a database metadata query with 3 parameters), no annotations, and no output schema, the description is minimally complete. It states the core function but lacks behavioral context and output details, which are important for an agent to use the tool effectively. It's adequate but has clear gaps in guidance and transparency.

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

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

The schema description coverage is 100%, so the schema already documents all three parameters with clear descriptions. The description adds no additional meaning beyond what's in the schema, such as explaining how parameters interact or providing examples. Baseline 3 is appropriate when the schema handles parameter documentation adequately.

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 'foreign key relationships between tables in the database', making the purpose specific and understandable. However, it doesn't explicitly differentiate from sibling tools like 'list_constraints' or 'list_indexes' which might also involve database metadata, though the focus on foreign keys is reasonably distinct.

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 prerequisites, such as needing a valid connection, or compare to sibling tools like 'list_constraints' that might include foreign keys. This leaves the agent to infer usage from 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. It states it retrieves source code but does not disclose behavioral traits such as read-only nature, potential permissions needed, error handling, or output format details. This is a significant gap 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 front-loads the core purpose ('Get the complete SQL query/definition of a stored procedure') and adds clarifying detail ('this is the actual source code'). There is zero waste, making it appropriately sized 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 no annotations, no output schema, and a tool that retrieves source code (which may involve permissions and formatting), the description is incomplete. It lacks behavioral context, output details, and usage guidelines, making it inadequate for a tool with 5 parameters and sibling alternatives.

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. The description does not add meaning beyond what the schema provides, such as explaining parameter interactions or default behaviors. 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 ('complete SQL query/definition of a stored procedure'), specifying it retrieves the actual source code. It distinguishes from siblings like 'describe_stored_procedure' (likely metadata) and 'get_all_stored_procedure_definitions' (multiple procedures).

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 retrieving source code, but does not explicitly state when to use this vs. alternatives like 'describe_stored_procedure' or 'get_all_stored_procedure_definitions'. It lacks guidance on prerequisites or exclusions, leaving usage context implied rather than explicit.

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

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

With no annotations provided, the description carries full burden but only states the action without behavioral details. It doesn't disclose whether this is a read-only operation, if it requires specific permissions, how results are formatted, or any rate limits. For a tool with zero annotation coverage, 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 with zero waste. It front-loads the core purpose ('List all available named database connections') and adds necessary context ('configured in the server') without redundancy, 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 tool's low complexity (0 parameters, no output schema) and lack of annotations, the description is minimally adequate. It states what the tool does but misses behavioral context like response format or usage constraints. For a simple list tool, it's viable but has clear 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?

The input schema has 0 parameters with 100% coverage, so no parameter documentation is needed. The description appropriately adds no parameter details, maintaining focus on the tool's purpose. Baseline 4 is applied as it compensates adequately for the lack of 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 specific action ('List all available') and resource ('named database connections configured in the server'), distinguishing it from siblings like list_databases or list_tables which list different resources. It precisely communicates what the tool does without 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 implies usage context by specifying 'configured in the server,' suggesting it's for retrieving pre-set connections. However, it lacks explicit guidance on when to use this versus alternatives like test_connection or other list_* tools, leaving some ambiguity for the agent.

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 lists constraints 'across tables in the database', implying a read-only operation, but doesn't disclose behavioral traits like whether it requires specific permissions, returns paginated results, or has rate limits. For a tool with zero annotation coverage, this is a significant gap.

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

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

The description is a single, efficient sentence with zero waste. It's front-loaded with the core purpose and includes essential details like constraint types, making it appropriately sized for its function.

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 with full schema coverage and no output schema, the description is adequate but has clear gaps. It doesn't explain return values or behavioral aspects like error handling, which is needed for a tool with no annotations. It's minimal viable but lacks depth for full contextual 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 already documents all parameters. The description adds no meaning beyond the schema, such as explaining how parameters interact (e.g., using connectionString vs. connectionName) or providing 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 ('List') and resource ('all constraints'), specifying constraint types like check, unique, and foreign key. It distinguishes from siblings like 'list_default_constraints' by covering all constraint types, but doesn't explicitly contrast with other constraint-related 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. It doesn't mention when to prefer 'list_default_constraints' for default constraints only or 'analyze_check_constraints' for deeper analysis, nor does it specify prerequisites like needing a connection.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It states it lists databases but doesn't mention whether this requires specific permissions, what the output format looks like (e.g., list of names, details), if it's paginated, or if it includes system databases. For a read operation with zero annotation coverage, this leaves significant gaps.

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

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

The description is a single, efficient sentence that front-loads the core purpose ('List all databases...'). There is no wasted verbiage or redundant information, 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 no annotations and no output schema, the description is incomplete for a tool with 2 parameters. It doesn't explain what 'available' means (e.g., accessible vs. all), the return format, or error conditions. For a database listing tool in a complex SQL environment, 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%, so the input schema already fully documents both parameters (connectionString and connectionName). The description adds no additional parameter semantics beyond what's in the schema, such as examples or constraints. Baseline 3 is appropriate when the schema does all the work.

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

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

The description clearly states the verb ('List') and resource ('all databases available on the SQL Server instance'), making the purpose immediately understandable. However, it doesn't explicitly differentiate from sibling tools like 'list_tables', 'list_views', or 'list_connections', which also list resources but at different granularities.

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. For example, it doesn't mention whether this is for inventory purposes, connection validation, or as a prerequisite for other operations like 'analyze_database_size'. No exclusions or prerequisites are 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 it's a list operation, implying read-only behavior, but doesn't cover aspects like permissions needed, rate limits, output format, or pagination. 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 directly states the tool's purpose without any fluff or redundancy. It's appropriately sized and front-loaded, 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 complexity of a database tool with 4 parameters and no output schema or annotations, the description is incomplete. It doesn't explain what 'default value constraints' entail, how results are returned, or any behavioral nuances, leaving gaps for the agent to infer or fail.

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, documenting all 4 parameters clearly. The description adds no additional meaning beyond the schema, such as explaining interactions between parameters or default behaviors. With high schema coverage, the baseline score of 3 is appropriate as the schema does the heavy lifting.

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

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

The description clearly states the verb 'List' and the resource 'default value constraints and their definitions', making the purpose evident. However, it doesn't explicitly differentiate from sibling tools like 'list_constraints' or 'analyze_check_constraints', which might have overlapping scopes, so it lacks sibling distinction for a perfect score.

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

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

The description provides no guidance on when to use this tool versus alternatives. With siblings like 'list_constraints' and 'analyze_check_constraints', there's no indication of context, exclusions, or prerequisites, 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?

No annotations are provided, so the description carries full burden. It states it's a list operation, implying read-only behavior, but doesn't disclose any behavioral traits such as permissions needed, rate limits, pagination, or what the output format looks like (e.g., list of names vs. detailed metadata). This is a significant gap 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 appropriately sized and front-loaded, clearly stating the tool's purpose 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 4 parameters, the description is incomplete. It adequately states what the tool does but lacks crucial context like behavioral traits, output format, or usage guidelines, making it insufficient for an agent to fully understand how to invoke it correctly.

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

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

Schema description coverage is 100%, so the schema fully documents all 4 parameters. The description adds no additional parameter semantics beyond what's in the schema (e.g., it doesn't explain how connectionString vs. connectionName interact or default behaviors). 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 ('List') and resource ('user-defined functions') with specific types mentioned ('scalar, table-valued, etc.'). It distinguishes from siblings like list_tables or list_stored_procedures by focusing on functions, but doesn't explicitly differentiate from potential overlapping tools like list_user_defined_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?

No guidance on when to use this tool versus alternatives is provided. The description doesn't mention prerequisites, context for usage, or comparison with sibling tools like describe_stored_procedure or execute_query that might relate to functions.

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 'usage statistics and detailed information', which hints at read-only behavior and output content, but fails to disclose critical aspects like whether this is a safe read operation, potential performance impact, authentication needs, or rate limits. For a database tool with zero annotation coverage, 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 redundancy or wasted space, 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 5 parameters with full schema coverage but no annotations and no output schema, the description is minimally adequate. It states the purpose and output scope but lacks behavioral context and usage guidance, leaving gaps in completeness for a tool that interacts with a database system.

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 parameter-specific information beyond implying filtering by table and inclusion of usage stats, which is already covered in the schema. 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 ('List all indexes') and resource ('on tables'), specifying the scope with 'with usage statistics and detailed information'. It distinguishes from basic listing tools but doesn't explicitly differentiate from sibling tools like 'analyze_index_usage' or 'find_missing_indexes', which prevents a perfect score.

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

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

No guidance is provided on when to use this tool versus alternatives. With many sibling tools like 'analyze_index_usage' and 'find_missing_indexes', the description lacks explicit context or exclusions, leaving the agent to infer usage 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 the full burden of behavioral disclosure. It mentions listing 'basic information' but doesn't specify what that includes (e.g., names, schemas, creation dates), whether it's paginated, requires authentication via connection parameters, or has any rate limits. This leaves significant gaps for a tool with multiple 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 front-loads the core purpose without unnecessary words. Every part earns its place by specifying the action and resources, 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 (4 parameters, no annotations, no output schema), the description is incomplete. It lacks behavioral details like output format, authentication needs, or error handling, and doesn't guide usage among siblings. This is inadequate for a tool that interacts with databases and has multiple configuration options.

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 parameter semantics beyond implying a scope ('all stored procedures, functions'), which aligns with but doesn't enhance the schema's 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 ('List') and resources ('stored procedures, functions, and their basic information'), making the purpose immediately understandable. However, it doesn't explicitly differentiate from sibling tools like 'list_functions', 'get_all_stored_procedure_definitions', or 'search_stored_procedures_by_content', which offer similar or 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?

No guidance is provided on when to use this tool versus alternatives. With many sibling tools like 'list_functions', 'get_all_stored_procedure_definitions', and 'search_stored_procedures_by_content', the description lacks context on its specific use case, prerequisites, or exclusions, leaving the agent to infer 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 it's a listing operation, which implies read-only behavior, but doesn't mention any side effects, performance characteristics, authentication needs, or what the output looks like (e.g., format, pagination). For a tool with zero annotation coverage, this leaves significant gaps in understanding how it 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 directly states the tool's purpose without any wasted words. It's 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 complexity (a database listing tool with 3 parameters), lack of annotations, and no output schema, the description is incomplete. It doesn't explain what the output contains (e.g., table names, metadata), how results are formatted, or any behavioral constraints, 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 input schema fully documents all three parameters (connectionString, connectionName, schema) with their descriptions. The description adds no additional parameter information beyond what's in the schema, which is acceptable given the high coverage, resulting in the baseline score of 3.

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

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

The description clearly states the verb ('List') and resource ('all tables in the connected database'), making the purpose immediately understandable. However, it doesn't explicitly differentiate from sibling tools like 'list_databases' or 'list_views', which are conceptually similar listing operations, 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 'describe_table', 'list_databases', and 'list_views' that might serve related purposes, there's no indication of context, prerequisites, or exclusions for this specific listing operation.

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 whether this is a read-only operation, what permissions are needed, whether results are paginated, what format the output takes, or any rate limits. For a database query tool with zero 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 states the core purpose upfront with no wasted words. It's appropriately sized for a straightforward list operation and gets directly to the point.

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 database query tool with 4 parameters, no annotations, and no output schema, the description is insufficient. It doesn't explain what information is returned about each trigger, how results are structured, whether there are performance considerations for large databases, or what happens when no triggers exist. The description should provide more context given the complexity of the operation.

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 mentions 'associated tables' which relates to the tableName parameter for filtering, but doesn't add meaningful semantic context beyond what the schema already provides. The baseline of 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 verb 'List' and the resource 'all triggers in the database', specifying they come 'with their associated tables'. It distinguishes from generic list tools by focusing on triggers, but doesn't explicitly differentiate from sibling 'describe_trigger' which might provide detailed information about a single trigger.

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 'describe_trigger' (for detailed info on a single trigger) or other list tools. The description mentions filtering by table name but doesn't explain when this filtering is appropriate or how it compares to other filtering 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?

With no annotations, the description carries full burden but only states the action without behavioral details. It doesn't disclose if this is a read-only operation, potential performance impacts, authentication needs, or output format, which are critical for a tool with 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 front-loaded and appropriately sized for a simple listing tool, 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 tool has 3 parameters, no annotations, and no output schema, the description is incomplete. It lacks behavioral context, usage guidance, and details on what 'definitions' include, leaving 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 fully documents the three optional parameters. The description adds no parameter-specific information beyond implying a scope for 'user-defined data types', maintaining the baseline score.

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

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

The description clearly states the verb ('List') and resource ('user-defined data types and their definitions'), making the purpose unambiguous. However, it doesn't differentiate from siblings like 'list_functions' or 'list_tables' beyond the specific resource type, missing explicit 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?

No guidance is provided on when to use this tool versus alternatives. It doesn't mention prerequisites, context, or exclusions, leaving the agent to infer usage from the name and description 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 it's a listing operation, implying it's likely read-only and non-destructive, but doesn't confirm this or add context like authentication needs, rate limits, or what 'basic information' entails. The description is minimal and lacks behavioral details beyond the core action.

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, and every part of the sentence contributes to understanding the tool's function.

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 (listing database views with 4 optional parameters), no annotations, and no output schema, the description is minimally adequate. It covers the basic purpose but lacks details on behavior, usage context, or output format, leaving gaps that could hinder an agent's effective use without further inference or trial.

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

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

The schema description coverage is 100%, so the schema fully documents all four parameters. The description adds no parameter-specific information beyond what's in the schema, such as explaining interactions between parameters or clarifying 'basic information'. This meets the baseline of 3, as the schema handles the heavy lifting without additional 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 verb ('List') and resource ('views in the database') with scope ('all views' and 'basic information'), making the purpose specific and actionable. However, it doesn't explicitly differentiate from sibling tools like 'describe_view' or 'list_tables', which would require mentioning what distinguishes listing views from describing or listing other database objects.

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 'describe_view' (for detailed view info) or 'list_tables' (for listing tables instead), nor does it specify prerequisites or contexts for usage, leaving the agent without explicit direction on tool selection.

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

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

No annotations are provided, so the description carries full burden. It mentions default behavior ('top 10 rows by default') but omits critical details: whether this is a read-only operation, potential performance impact on large tables, authentication needs via connection parameters, or error handling. For a data retrieval tool with zero annotation coverage, 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?

Single sentence, front-loaded with core purpose, zero waste. Every word earns its place by specifying the action, resource, and default behavior efficiently.

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 data retrieval tool with 5 parameters, no annotations, and no output schema, the description is inadequate. It lacks information on return format (e.g., row structure), error conditions, or behavioral constraints like rate limits or side effects, leaving significant gaps for an agent to use it correctly.

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

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

Schema description coverage is 100%, so the schema fully documents all 5 parameters. The description adds minimal value beyond the schema—it implies the 'limit' parameter defaults to 10 but doesn't elaborate on parameter interactions or usage scenarios. 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 ('Retrieve sample data') and resource ('from a table'), with specific scope ('top 10 rows by default'). It doesn't explicitly differentiate from siblings like 'describe_table' or 'execute_query', but the sampling focus is reasonably distinct.

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 like 'describe_table' (for schema) or 'execute_query' (for custom queries). The description implies quick data preview but lacks explicit context or exclusions.

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

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 indicates a search operation, it lacks details on permissions needed, rate limits, whether it's read-only or has side effects, or what the results format looks like. This is a significant gap 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 front-loads the core purpose without unnecessary words. Every part of the sentence earns its place by specifying the action, target, 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 no annotations and no output schema, the description is adequate for a search tool but lacks completeness. It does not cover behavioral aspects like safety, performance implications, or result format, which are important for an agent to use it correctly without structured guidance.

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 does not add any additional meaning beyond what the schema provides, such as explaining search pattern syntax or connection precedence. 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 with a specific verb ('Search') and resource ('stored procedures'), and distinguishes it from siblings by specifying the search scope ('by content' or 'in their SQL definition'). This differentiates it from tools like 'list_stored_procedures' or 'get_stored_procedure_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 implies usage for searching stored procedures based on content, but does not explicitly state when to use this tool versus alternatives like 'get_all_stored_procedure_definitions' or 'describe_stored_procedure'. 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?

With no annotations provided, the description carries the full burden of behavioral disclosure. It states the tool tests connections and returns server information, but doesn't describe what 'basic server information' includes, whether it performs actual queries or just pings, error handling, timeouts, or authentication requirements. For a connection-testing tool with zero 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 earns its place: 'Test the database connection' defines the action, and 'return basic server information' clarifies the outcome. There's zero waste or redundancy.

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

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

Given the tool's low complexity (2 optional parameters, no output schema, no annotations), the description is minimally adequate. It covers the purpose but lacks details on behavior, output format, and usage context. Without annotations or output schema, the agent has incomplete information about what 'basic server information' entails or how to interpret results.

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

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

The description adds no parameter-specific information beyond what's in the input schema, which has 100% coverage with clear descriptions for both parameters. The baseline score of 3 is appropriate since the schema adequately documents parameters, and the description doesn't need to compensate, but it also doesn't enhance understanding of parameter usage or interactions.

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: 'Test the database connection and return basic server information.' It specifies the verb ('test') and resource ('database connection'), and distinguishes itself from sibling tools by focusing on connection testing rather than analysis or listing operations. However, it doesn't explicitly differentiate from 'list_connections' which might be a related sibling.

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 prerequisites, appropriate contexts, or compare it to sibling tools like 'list_connections' or 'execute_query' for connection validation. 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.