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

The description adds valuable behavioral context beyond annotations. While annotations indicate read-only, non-destructive, and idempotent operations, the description specifies that it analyzes only user/custom tables and excludes MySQL system tables by default, and mentions it's based on MySQLTuner's analysis. This provides practical implementation details that annotations don't cover.

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

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

The description is well-structured and efficiently written. It starts with the core purpose, lists specific checks in bullet points, adds important notes about scope limitations, and credits the methodology source. Every sentence adds value without redundancy, making it easy to scan and understand.

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 (analyzing database columns for overflow), the description provides good context about what it analyzes and its limitations. With comprehensive annotations covering safety and behavior, and no output schema needed for this diagnostic tool, the description is mostly complete. It could slightly improve by mentioning the format of results or typical use cases.

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

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

With 100% schema description coverage, the input schema already fully documents both parameters (warning_threshold_pct and schema_name). The description doesn't add any parameter-specific information beyond what's in the schema, so it meets the baseline expectation without providing extra semantic context.

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

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

The description clearly states the tool's purpose: analyzing auto-increment columns for potential overflow. It specifies what checks are performed (current vs maximum value, usage percentage, tables approaching overflow) and distinguishes itself from siblings by focusing on auto-increment analysis rather than other database aspects like security, queries, or replication.

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

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

The description provides clear context on when to use this tool: for analyzing auto-increment overflow risks in user/custom tables. It explicitly excludes MySQL system tables by default, which helps define its scope. However, it doesn't explicitly mention when NOT to use it or name specific alternatives among the sibling tools for 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?

The description adds valuable behavioral context beyond annotations: it specifies that system tables are excluded during schema/table analysis and mentions reliance on sys schema views when available. While annotations already indicate read-only, non-destructive, and idempotent behavior, the description provides implementation details that help the agent understand scope and data sources.

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

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

The description is well-structured and efficiently organized: it starts with the core purpose, lists specific analysis areas in bullet points, then adds important notes about exclusions and implementation. Every sentence earns its place with no redundant information.

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

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

For a read-only analysis tool with comprehensive annotations and full parameter documentation, the description provides good contextual completeness. It covers what the tool analyzes, important exclusions, and implementation details. The main gap is the lack of output schema, but the description compensates somewhat by listing analysis areas that hint at 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?

With 100% schema description coverage, the input schema already fully documents all three parameters. The description doesn't add any additional parameter semantics beyond what's in the schema, so it meets the baseline expectation but doesn't provide extra value regarding parameter usage or implications.

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 performs 'Detailed analysis of InnoDB buffer pool usage' with specific analysis areas listed (allocation by schema/table, page types, hit ratios, memory patterns, sizing recommendations). It distinguishes from siblings by focusing specifically on buffer pool analysis rather than other database components like transactions, queries, or security.

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

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

The description provides clear context about when to use this tool (for analyzing buffer pool usage) and includes an important exclusion note about system tables. However, it doesn't explicitly mention when NOT to use it or name specific alternative tools for related but different analyses.

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

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

The annotations already declare readOnlyHint=true, destructiveHint=false, and idempotentHint=true, covering safety and idempotency. The description adds valuable context beyond annotations by specifying what gets analyzed (long-running transactions, lock waits, deadlock history, etc.), which helps the agent understand the scope and nature of the analysis operation. No contradiction with annotations exists.

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

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

The description is efficiently structured with a clear opening statement, a bulleted list of analysis categories for quick scanning, and a closing sentence about purpose. Every sentence earns its place without redundancy, and the information is front-loaded for immediate understanding.

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

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

Given the tool's complexity (analyzing multiple transaction aspects), rich annotations (covering safety and idempotency), and 100% schema coverage, the description provides good contextual completeness. It clearly explains what the tool analyzes and why. The main gap is the lack of an output schema, but the description compensates somewhat by listing analysis categories that hint at 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%, with both parameters ('include_queries' and 'min_duration_sec') well-documented in the schema. The description doesn't add any parameter-specific information beyond what the schema provides, so it meets the baseline of 3 where the schema does the heavy lifting.

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

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

The description clearly states the specific action ('analyze') and resource ('InnoDB transactions and locking'), then lists five concrete analysis categories. It explicitly distinguishes this tool from siblings like 'analyze_query' or 'get_innodb_status' by focusing specifically on transaction and locking analysis rather than general queries or status.

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

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

The description provides clear context about when to use this tool ('Helps identify transaction-related performance issues'), which differentiates it from siblings focused on other aspects like security, storage engines, or user privileges. However, it doesn't explicitly state when NOT to use it or name specific alternative tools for overlapping concerns.

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

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

Annotations already indicate readOnlyHint=true, idempotentHint=true, and destructiveHint=false, but the description adds critical behavioral context with the WARNING about query execution when analyze=true, which is not covered by annotations. It also mentions version-specific features (MySQL 5.6+, 8.0.18+), enhancing transparency beyond the structured data.

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

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

The description is well-structured and front-loaded with the core purpose, followed by bullet points detailing analysis aspects and version-specific usage notes, ending with a critical warning. Every sentence adds value without redundancy, making it efficient and easy to parse.

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

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

Given the complexity of query analysis and the lack of an output schema, the description does a good job covering what the tool analyzes (execution plan, index usage, etc.) and behavioral nuances (version support, warning). However, it could be more complete by briefly mentioning the return format or typical output structure, though annotations help mitigate this gap.

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

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

With 100% schema description coverage, the input schema already documents all parameters thoroughly. The description adds minimal value by implicitly linking 'analyze' to EXPLAIN ANALYZE and 'format' to output options, but does not provide significant additional semantics beyond what the schema descriptions already state.

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 ('analyze a MySQL query's execution plan using EXPLAIN') and resource ('MySQL query'), distinguishing it from sibling tools like analyze_statements or get_slow_queries by focusing on execution plan analysis rather than performance monitoring or error detection.

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

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

The description provides clear context for when to use specific features (e.g., 'Supports EXPLAIN FORMAT=JSON for MySQL 5.6+', 'Use EXPLAIN ANALYZE (MySQL 8.0.18+)'), but does not explicitly state when to use this tool versus alternatives like get_index_recommendations or find_unused_indexes for similar optimization 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?

Annotations already provide readOnlyHint=true, destructiveHint=false, and idempotentHint=true, indicating a safe, non-destructive operation. The description adds valuable context by specifying the 8 security checks performed and noting it's based on MySQLTuner's function, which clarifies scope and methodology beyond the annotations' safety profile.

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

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

The description is front-loaded with the core purpose, followed by a bulleted list of checks for clarity, and ends with implementation context. Every sentence earns its place by adding specific value without redundancy, making it efficiently structured and appropriately sized.

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 (security analysis with 8 checks), rich annotations (covering safety and idempotency), and no output schema, the description is mostly complete. It details the checks performed and implementation basis, though it could benefit from mentioning output format or interpretation guidance to fully compensate for the lack of output schema.

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

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

Schema description coverage is 100%, with the single parameter 'include_user_list' fully documented in the schema. The description does not add any parameter-specific information beyond what the schema provides, so it meets the baseline of 3 for high schema coverage without compensating value.

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

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

The description clearly states the specific action ('Perform comprehensive MySQL security analysis') and lists 8 distinct security checks, making the purpose highly specific. It distinguishes itself from sibling tools like 'analyze_user_privileges' or 'check_database_health' by focusing exclusively on security aspects rather than performance, privileges, or general health.

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 in security assessment contexts but does not explicitly state when to use this tool versus alternatives. While it lists specific checks, it lacks guidance on prerequisites, timing, or comparisons to sibling tools like 'analyze_user_privileges' or 'check_database_health' for overlapping concerns.

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

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

Annotations already declare readOnlyHint=true, destructiveHint=false, idempotentHint=true, and openWorldHint=false. The description adds valuable context beyond annotations: requires performance_schema enabled, excludes system schema queries, and is based on MySQLTuner's analysis. No contradiction with annotations exists.

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

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

The description is well-structured and appropriately sized: it starts with the core purpose, lists analysis areas in bullet points, provides implementation context (MySQLTuner-based), states prerequisites, and adds an important exclusion note. Every sentence adds value with zero waste.

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

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

Given the tool's complexity (analyzing SQL statements with multiple metrics), the description is quite complete: it explains what's analyzed, prerequisites, exclusions, and context. However, without an output schema, it doesn't describe the return format (e.g., structure of analysis results), leaving a minor gap.

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

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

Schema description coverage is 100%, so the schema already fully documents all 4 parameters. The description doesn't add parameter-specific details beyond what the schema provides, maintaining the baseline score of 3 for high schema coverage.

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

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

The description clearly states the tool analyzes SQL statements from performance_schema/sys schema, listing specific analysis areas (statement digest summaries, execution times, row ratios, error rates, expensive queries). It distinguishes from siblings like 'get_slow_queries' or 'get_statements_with_errors' by providing comprehensive analysis rather than focused subsets.

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

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

The description provides clear context: requires performance_schema enabled, excludes queries against MySQL system schemas to focus on user/application queries. However, it doesn't explicitly state when to use this vs. alternatives like 'get_slow_queries' or 'analyze_query', though the comprehensive nature is implied.

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

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

Annotations already indicate read-only, non-destructive, and idempotent behavior. The description adds valuable context beyond this: it specifies that analysis excludes MySQL system tables by default, mentions it's based on MySQLTuner's patterns, and lists the types of information provided (e.g., engine status, table counts, metrics, recommendations). This enhances understanding without contradicting annotations.

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

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

The description is well-structured and front-loaded: it starts with the core purpose, lists key outputs in bullet points, adds important notes, and cites the source pattern. Every sentence adds value without redundancy, making it efficient and easy to parse.

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

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

Given the tool's moderate complexity (analysis with optional filtering), rich annotations (read-only, idempotent), and no output schema, the description is largely complete. It covers purpose, outputs, exclusions, and context. A slight gap is the lack of explicit output format details, but the bullet points provide enough semantic understanding for an agent to use it effectively.

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

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

Schema description coverage is 100%, so the input schema fully documents the two parameters (include_table_details and schema_name). The description doesn't add specific parameter details beyond what's in the schema, but it implies the scope of analysis (user tables, optional schema filtering), aligning with the schema. Baseline 3 is appropriate as the schema handles parameter documentation.

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

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

The description clearly states the tool's purpose: 'Analyze storage engine usage and statistics for user tables.' It specifies the verb ('analyze') and resource ('storage engine usage and statistics for user tables'), and distinguishes it from siblings by focusing on storage engines rather than other MySQL components like indexes, queries, or replication.

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

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

The description provides clear context for when to use this tool: for analyzing storage engines in MySQL, with a note that it excludes system tables by default. It doesn't explicitly state when not to use it or name alternatives among siblings, but the focus on storage engines implies it's not for other analysis types like 'analyze_query' or 'get_slow_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?

Annotations provide readOnlyHint=true, destructiveHint=false, openWorldHint=false, and idempotentHint=true, covering safety and idempotency. The description adds value by specifying what the tool 'shows' (privilege levels) and its purpose (identifying issues), which complements annotations without contradiction. However, it doesn't detail rate limits, auth needs, or output format.

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

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

The description is appropriately sized and front-loaded, starting with the core purpose, followed by a bulleted list of outputs, and ending with the utility. Every sentence adds value without redundancy, making it efficient and well-structured for quick understanding.

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

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

Given the tool's moderate complexity (2 parameters, no output schema), annotations cover safety and idempotency, and the description details outputs and purpose. It's mostly complete but could improve by specifying return format or examples. Without an output schema, some ambiguity remains, but it's sufficient for basic use.

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

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

Schema description coverage is 100%, with clear parameter descriptions in the schema. The description doesn't add meaning beyond the schema, as it omits parameter details. With high schema coverage, the baseline score of 3 is appropriate, as the description doesn't compensate but doesn't need to given the schema's completeness.

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

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

The description clearly states the tool's purpose with specific verbs ('analyze privileges') and resources ('user or all users'), and distinguishes it from siblings by focusing on privilege analysis rather than performance, health, or other database aspects. It lists the specific privilege levels examined, making the scope explicit.

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 identifying 'excessive or missing privileges,' suggesting it's for security auditing, but lacks explicit guidance on when to use this tool versus alternatives like 'analyze_security' or 'check_database_health.' No exclusions or prerequisites are mentioned, leaving usage context somewhat vague.

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

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

Annotations already provide key behavioral hints (readOnlyHint: true, destructiveHint: false, idempotentHint: true), so the bar is lower. The description adds valuable context by explaining what wait events are and what they help identify (e.g., lock contention patterns, resource saturation), which goes beyond the annotations and aids in understanding the tool's scope and output implications.

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

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

The description is well-structured and front-loaded with the core purpose, followed by bullet points that efficiently detail wait event types and analysis benefits. Every sentence earns its place by adding clarity without redundancy, making it easy to scan and understand.

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

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

Given the tool's complexity (analyzing wait events for bottlenecks), annotations cover safety (read-only, non-destructive), and schema fully documents parameters, the description provides good context on what the tool analyzes and why. However, there is no output schema, and the description does not specify return format or data structure, leaving a minor gap in completeness.

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

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

Schema description coverage is 100%, with clear descriptions for both parameters (event_category with enum values, top_n with default). The description does not add specific parameter semantics beyond the schema, but it lists event categories (e.g., lock waits, I/O waits) that align with the enum, providing some contextual reinforcement. Baseline 3 is appropriate given high schema coverage.

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

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

The description clearly states the tool's purpose: 'Analyze MySQL wait events to identify bottlenecks.' It specifies the verb ('analyze'), resource ('MySQL wait events'), and goal ('identify bottlenecks'), which distinguishes it from sibling tools that focus on other MySQL aspects like queries, indexes, or replication.

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

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

The description implies usage by listing what wait events indicate and what they help identify (e.g., I/O bottlenecks, lock contention), but it does not explicitly state when to use this tool versus alternatives like 'analyze_query' or 'get_slow_queries'. No exclusions or direct comparisons to sibling tools are provided.

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

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

Annotations already indicate read-only, non-destructive, and idempotent behavior, which the description does not contradict. The description adds valuable context beyond annotations by specifying what gets analyzed (e.g., buffers, utilization) and the methodology (MySQLTuner), though it could mention rate limits or authentication needs more explicitly.

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

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

The description is well-structured and front-loaded with the main purpose, followed by bullet points for analysis details and a concluding sentence. It avoids unnecessary fluff, though it could be slightly more concise by integrating the bullet points into flowing text.

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

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

Given the tool's complexity and lack of output schema, the description provides good coverage of what the tool does and its methodology. It could improve by hinting at output format or recommendations structure, but it adequately complements the rich annotations and schema for a non-mutative analysis tool.

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

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

Schema description coverage is 100%, so the schema fully documents the two parameters. The description does not add specific parameter details beyond what the schema provides, such as explaining when to use 'physical_memory_gb' versus system detection. Baseline 3 is appropriate as the schema handles the heavy lifting.

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

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

The description clearly states the tool calculates MySQL memory usage and provides recommendations, specifying it analyzes per-thread buffers, global server buffers, maximum potential usage, and current utilization. It distinguishes itself from siblings like 'get_memory_by_host' or 'get_table_memory_usage' by focusing on configuration analysis and recommendations rather than raw data retrieval.

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 identifying memory-related configuration issues, but does not explicitly state when to use this tool versus alternatives like 'analyze_buffer_pool' or 'get_memory_by_host'. It provides some context (e.g., based on MySQLTuner's methodology) but lacks clear 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?

Annotations already provide readOnlyHint=true, destructiveHint=false, and idempotentHint=true, covering safety and idempotency. The description adds valuable context beyond annotations by specifying what gets analyzed (plugin status, configuration, events, compliance) and listing supported audit systems (MySQL Enterprise, MariaDB, Percona), which helps the agent understand scope and compatibility.

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

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

The description is well-structured and front-loaded, starting with the core purpose followed by bullet points for analysis areas and a final sentence on supported systems. Every sentence adds value without redundancy, making it efficient and easy to parse.

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

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

Given the tool's complexity (analyzing multiple audit systems) and rich annotations (readOnly, idempotent, etc.), the description is mostly complete. It covers what the tool does and its scope, though it lacks details on output format or error handling, which could be useful since there's no output schema.

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

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

The tool has 0 parameters with 100% schema description coverage, so no parameter documentation is needed. The description appropriately focuses on functionality rather than parameters, earning a baseline score of 4 for not adding unnecessary information.

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

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

The description clearly states the tool's purpose with specific verbs ('check', 'analyzes') and resources ('MySQL audit log configuration and status'), listing four distinct analysis areas. It distinguishes from sibling tools by focusing specifically on audit logs rather than general health, queries, or other database components.

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 through the analysis areas listed (audit plugin status, configuration, events, compliance), suggesting this tool is for audit-related diagnostics. However, it doesn't explicitly state when to use this versus alternatives like 'analyze_security' or 'check_database_health', nor does it provide exclusions or prerequisites.

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

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

Annotations already declare readOnlyHint=true, destructiveHint=false, and idempotentHint=true, covering safety aspects. The description adds valuable context about what gets analyzed (specific MySQL components) and mentions it's 'based on MySQLTuner analysis concepts', which provides implementation context. However, it doesn't mention rate limits, authentication needs, or performance impact.

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

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

The description is appropriately sized with clear bullet points listing analyzed aspects. It's front-loaded with the main purpose and efficiently structured, though the final sentence about MySQLTuner could be integrated more seamlessly.

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

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

For a read-only diagnostic tool with good annotations and no output schema, the description provides comprehensive context about what gets analyzed and the return format (health score with breakdown). It could benefit from mentioning the format of recommendations or score range, but covers most essential aspects given the tool's complexity.

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 fully documented in the schema. The description doesn't add any parameter-specific information beyond what's in the schema (include_recommendations and verbose). This meets the baseline expectation when schema coverage is complete.

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

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

The description clearly states the tool performs a 'comprehensive MySQL database health check' with specific aspects analyzed (connection statistics, buffer pool, InnoDB metrics, etc.). It distinguishes from sibling tools by covering multiple areas rather than focusing on specific components like 'analyze_buffer_pool' or 'get_replication_status'.

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 this tool should be used for broad health assessment rather than specific analyses, but doesn't explicitly state when to choose it over alternatives like 'review_settings' or 'calculate_memory_usage'. It provides clear context about what it analyzes but lacks explicit exclusion criteria 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?

Annotations already indicate read-only, non-destructive, and idempotent behavior. The description adds valuable context beyond annotations: it specifies that analysis is based on information_schema and performance_schema statistics, excludes MySQL system tables, and details what 'unused' means (zero/few reads since server start). No contradiction with annotations exists.

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

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

The description is well-structured and front-loaded with the core purpose, followed by bullet points for identification and benefits, and a note with exclusions. Every sentence adds value without redundancy, making it efficient and easy to scan.

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, rich annotations (covering safety and idempotency), and full schema coverage, the description is largely complete. It explains the analysis scope, benefits, and data sources. However, without an output schema, it could briefly hint at return format (e.g., list of indexes with metrics) for better completeness.

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

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

Schema description coverage is 100%, so the schema fully documents all parameters. The description does not add specific parameter semantics beyond what the schema provides (e.g., it mentions analyzing user tables but doesn't elaborate on schema_name usage). Baseline 3 is appropriate as the schema carries the parameter documentation burden.

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 ('find', 'identifies') and resources ('unused and duplicate indexes in MySQL user tables'). It distinguishes from siblings by focusing on index analysis rather than queries, replication, or other database aspects, and explicitly excludes system tables.

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

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

The description provides clear context for when to use this tool: for analyzing user/custom tables to identify unused/duplicate indexes, with benefits like reducing storage and improving performance. However, it does not explicitly state when not to use it or name specific alternatives among siblings (e.g., get_index_stats for general index statistics).

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

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

Annotations already provide comprehensive behavioral hints (read-only, non-destructive, idempotent, closed-world). The description adds useful context about what types of queries are shown (running, long-running, blocked, idle transactions) and the real-time monitoring aspect, but doesn't disclose additional behavioral traits like rate limits, authentication needs, or what 'active' specifically means operationally.

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

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

The description is perfectly structured with a clear purpose statement, bulleted list of what it shows, and a 'Useful for' section - all in 7 concise sentences that each earn their place. No wasted words 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?

For a read-only monitoring tool with good annotations and full parameter coverage, the description provides adequate context about what information is returned and use cases. However, without an output schema, it could benefit from more detail about the return format (e.g., structured data vs plain text, typical fields included).

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

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

With 100% schema description coverage, the schema already fully documents both parameters. The description doesn't add any parameter-specific information beyond what's in the schema, so it meets the baseline of 3 where the schema does the heavy lifting for parameter documentation.

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

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

The description clearly states the tool's purpose with a specific verb ('Get') and resource ('currently active queries in MySQL'), and distinguishes it from siblings by focusing on real-time monitoring rather than historical analysis (unlike get_slow_queries) or specific analysis types (unlike analyze_query).

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 'Useful for' section provides clear context about when to use this tool (identifying performance issues, finding blocking transactions, real-time monitoring), but doesn't explicitly state when NOT to use it or name specific alternatives among the many sibling tools.

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

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

Annotations already indicate read-only, non-destructive, and idempotent behavior. The description adds valuable context beyond this: it specifies that the tool excludes MySQL system tables by default and analyzes only user/custom tables, which is not covered by annotations. No contradiction with annotations exists.

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

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

The description is well-structured and front-loaded with the core purpose in the first sentence. Each subsequent sentence adds necessary context (causes of fragmentation, scope exclusions, impact) without redundancy. It is appropriately sized and wastes no words.

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 (analyzing fragmentation with filtering parameters), the description is mostly complete. It covers purpose, usage context, and behavioral details like table exclusions. However, without an output schema, it does not describe the return format (e.g., what data is included in results), leaving a minor gap.

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

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

The input schema has 100% description coverage, providing clear details for all four parameters (e.g., thresholds, filters, limits). The description does not add any parameter-specific information beyond what the schema already documents, so it meets the baseline score of 3 for high schema coverage.

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

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

The description clearly states the tool's purpose: 'Find user tables with significant fragmentation.' It specifies the resource (user tables) and the action (find), and distinguishes itself from siblings by focusing on fragmentation analysis rather than other MySQL diagnostics like indexes, queries, or replication.

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

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

The description provides clear context for when to use the tool by explaining what causes fragmentation (deletions, updates, VARCHAR/TEXT modifications) and the impact (wasted disk space, slow queries). However, it does not explicitly state when not to use it or name alternatives among the sibling tools, such as 'get_table_stats' for general table analysis.

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

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

Annotations cover read-only, non-destructive, and idempotent properties, but the description adds valuable context by detailing what the tool analyzes (e.g., cluster membership, node status, flow control, replication health, certification conflicts), which helps the agent understand the scope and output without contradicting annotations.

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

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

The description is front-loaded with the core purpose, followed by a bulleted list of analyses and a clear applicability statement. Every sentence earns its place by providing essential information without redundancy, making it efficient 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 (analyzing multiple cluster aspects), no output schema, and rich annotations, the description is largely complete by detailing analysis areas. However, it could slightly improve by hinting at the output format (e.g., structured data or metrics), but it's adequate for 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?

With 0 parameters and 100% schema description coverage, the baseline is 4. The description compensates by implicitly confirming no inputs are needed, as it focuses on what the tool analyzes rather than requiring parameters, adding clarity beyond the empty schema.

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

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

The description clearly states the specific action ('Get Galera cluster status') and resource ('for MariaDB/Percona XtraDB Cluster'), with explicit differentiation from sibling tools like 'get_group_replication_status' and 'get_replication_status' by specifying it's 'Only applicable to Galera-enabled MySQL variants.'

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?

It provides explicit when-to-use guidance by stating 'Only applicable to Galera-enabled MySQL variants,' which distinguishes it from non-Galera MySQL tools and sibling tools like 'get_group_replication_status' or 'get_replication_status' that might target different replication systems.

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

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

The description adds valuable context beyond annotations by specifying the analysis scope (membership, roles, channels, etc.) and the MySQL Group Replication requirement. Annotations already cover safety (readOnlyHint=true, destructiveHint=false), so the bar is lower, but the description provides useful operational context without contradicting annotations.

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

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

The description is efficiently structured: the first sentence states the core purpose, followed by a bulleted list of analysis areas, and ends with a critical usage constraint. Every sentence earns its place with no wasted words, making it easy to scan and understand.

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 parameterless tool with rich annotations (readOnlyHint, idempotentHint) but no output schema, the description provides good context on what it analyzes and when to use it. It could slightly improve by hinting at the return format (e.g., structured data vs. raw text), but it's largely complete given the tool's complexity.

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

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

With 0 parameters and 100% schema description coverage, the baseline is 4. The description doesn't need to explain parameters, but it implicitly confirms no inputs are required by focusing on the analysis output, which is appropriate for this parameterless tool.

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 ('Get MySQL Group Replication status') and resource ('MySQL Group Replication'), distinguishing it from siblings like 'get_replication_status' (which likely covers standard replication) and 'get_galera_status' (a different clustering technology). The detailed analysis scope further clarifies its unique 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 explicitly states when to use this tool ('Only applicable to MySQL with Group Replication enabled'), providing clear context for its application. This distinguishes it from alternatives like general replication or Galera tools, though it doesn't name specific siblings as 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?

Annotations already provide important behavioral hints (readOnlyHint: true, idempotentHint: true, destructiveHint: false), indicating a safe, non-modifying operation. The description adds valuable context beyond this: it explains what the tool analyzes (full table scans, inefficient index use), what it recommends (composite indexes), how it prioritizes (by potential impact), and its data sources (performance_schema statistics). This enriches understanding without contradicting annotations.

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

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

The description is well-structured and appropriately sized. It front-loads the core purpose, then details the analysis approach in bullet points, and adds important notes and comparisons. Every sentence adds value, though the final comparison to MySQLTuner could be slightly trimmed without losing essential information.

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

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

Given the tool's complexity (AI-powered index analysis with 4 parameters) and rich annotations, the description provides good contextual completeness. It explains the analysis methodology, scope limitations, and data sources. However, without an output schema, it doesn't detail the return format (e.g., structure of recommendations), leaving a minor gap in full 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 input schema already documents all parameters thoroughly. The description doesn't add specific parameter semantics beyond what's in the schema (e.g., it doesn't explain how 'min_improvement_percent' relates to the analysis). However, it implies the scope of analysis (user tables, query patterns) which contextualizes parameter usage. Baseline 3 is appropriate given high schema coverage.

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

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

The description clearly states the tool's purpose with specific verbs ('Get AI-powered index recommendations', 'Analyzes query patterns') and resources ('MySQL user tables', 'performance_schema'). It distinguishes from siblings by focusing specifically on index recommendations rather than general analysis, health checks, or other MySQL diagnostics like 'get_index_stats' or 'find_unused_indexes'.

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

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

The description provides clear context about when to use this tool ('analyzes query patterns from performance_schema to recommend indexes') and what it excludes ('only analyzes user/custom tables and excludes MySQL system tables'). However, it doesn't explicitly mention when NOT to use it or name specific alternatives among the sibling tools, such as 'find_unused_indexes' for different index analysis.

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

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

Annotations already indicate read-only, non-destructive, and idempotent behavior, but the description adds valuable context by specifying the exclusion of system tables and detailing the types of metrics returned (e.g., cardinality, size, efficiency). This enhances transparency beyond what annotations provide, though it doesn't cover aspects like rate limits or authentication needs.

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

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

The description is well-structured and front-loaded, starting with the core purpose, followed by bullet points of returns and helps, and ending with a critical note. Every sentence adds value without redundancy, making it efficient and easy to parse.

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

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

Given the tool's complexity and the absence of an output schema, the description does a good job of outlining what metrics are returned and what issues it helps identify. However, it could be more complete by briefly mentioning the format of the output or any limitations, though the annotations and schema coverage mitigate this gap.

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

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

With 100% schema description coverage, the input schema fully documents all three parameters, including their types, descriptions, and enums for 'order_by.' The description does not add any parameter-specific details beyond what the schema provides, so it meets 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 explicitly states the action ('Get detailed index statistics') and the target ('for MySQL user tables'), clearly distinguishing it from sibling tools like 'get_table_stats' or 'find_unused_indexes' by focusing specifically on index-level metrics rather than table-level statistics or unused index detection.

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

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

The description provides clear context by specifying that it 'only analyzes user/custom tables and excludes MySQL system tables,' which helps guide when to use it. However, it does not explicitly mention when to choose this tool over alternatives like 'find_unused_indexes' or 'get_index_recommendations,' which are related sibling tools.

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

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

Annotations already provide readOnlyHint=true, destructiveHint=false, idempotentHint=true, and openWorldHint=false, covering safety and idempotency. The description adds valuable context beyond this by detailing what gets analyzed (e.g., actionable recommendations for optimization, specific metrics like hit ratios and contention), though it doesn't mention rate limits or auth needs, which are not critical here.

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

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

The description is well-structured and front-loaded, starting with the core purpose, followed by a bulleted list of parsed elements, and ending with context and recommendations. Every sentence earns its place by providing specific details without redundancy, making it efficient and easy to scan.

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

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

Given the tool's complexity (analyzing multiple InnoDB metrics), annotations cover safety aspects, and schema fully describes parameters. The description adds comprehensive analysis details and optimization context, compensating for the lack of output schema. However, it could slightly improve by hinting at output format or linking to sibling tools for deeper analysis.

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

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

Schema description coverage is 100%, with clear descriptions for both parameters (include_raw_output and detailed_analysis). The description doesn't add meaning beyond the schema, as it focuses on analysis content rather than parameter usage. With high schema coverage, the baseline score of 3 is appropriate, as the schema adequately documents parameters without extra description input.

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

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

The description explicitly states the tool 'Analyze InnoDB engine status from SHOW ENGINE INNODB STATUS' with a specific verb ('analyze') and resource ('InnoDB engine status'), clearly distinguishing it from sibling tools like analyze_buffer_pool or analyze_innodb_transactions by covering comprehensive InnoDB metrics including buffer pool, logs, transactions, deadlocks, and I/O.

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 listing what it parses (e.g., buffer pool statistics, deadlock information) and mentions it's 'Based on MySQLTuner's InnoDB analysis patterns,' suggesting it's for optimization scenarios. However, it lacks explicit guidance on when to use this tool versus alternatives like analyze_innodb_transactions or get_table_stats, which could overlap in some areas.

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

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

Annotations already provide readOnlyHint=true, destructiveHint=false, idempotentHint=true, and openWorldHint=false, covering safety and idempotency. The description adds valuable behavioral context beyond annotations: it specifies the data sources ('Uses sys schema or performance_schema'), reveals a system dependency ('Requires performance_schema memory instrumentation enabled'), and clarifies the breakdown dimensions (host, user, event type). No contradiction with annotations exists.

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

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

The description is perfectly structured and concise: four brief sentences with zero waste. The first sentence states the core purpose, the next three bullet points clarify what data it shows, and the final sentence provides a critical prerequisite. Every sentence earns its place by adding distinct value.

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

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

Given the tool's moderate complexity (memory analysis with system dependencies), rich annotations (covering safety and behavior), and 100% schema coverage, the description is largely complete. It explains the tool's purpose, data sources, breakdown dimensions, and prerequisites. The main gap is the lack of an output schema, but the description compensates somewhat by detailing what data will be returned. For a read-only analysis tool, this is sufficient though not exhaustive.

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

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

Schema description coverage is 100%, with both parameters well-documented in the schema (group_by with enum values and default, limit with description and default). The description doesn't add any parameter-specific semantics beyond what the schema already provides. According to scoring rules, when schema coverage is high (>80%), the baseline is 3 even without parameter info 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 tool's purpose: 'Get memory usage breakdown by host or user' with specific details about what data it shows (memory allocated per host, per user, by event/operation type). It distinguishes itself from siblings like 'calculate_memory_usage' and 'get_table_memory_usage' by focusing on host/user-level breakdowns rather than overall calculations or table-specific usage. However, it doesn't explicitly contrast with all memory-related siblings.

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

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

The description provides clear context for when to use this tool: when you need memory breakdowns by host, user, or event type. It explicitly states the prerequisite 'Requires performance_schema memory instrumentation enabled,' which is valuable usage guidance. However, it doesn't explicitly mention when NOT to use it or name specific alternatives among the sibling tools.

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

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

Annotations already provide key behavioral traits: readOnlyHint=true, destructiveHint=false, idempotentHint=true, and openWorldHint=false. The description adds value by specifying what is analyzed (e.g., replication errors, binary log configuration) and compatibility with MySQL/MariaDB, which offers context beyond annotations. However, it does not disclose additional behavioral aspects like rate limits, authentication needs, or error handling, keeping the score at a baseline level with some added 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 appropriately sized and front-loaded, starting with the core purpose ('Get MySQL replication status and health') followed by a bulleted list of analyses and a compatibility note. Every sentence earns its place by providing essential information without redundancy, and the structure is clear and efficient, making it easy for an AI agent 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 (analyzing replication status across multiple aspects), the annotations provide good behavioral coverage (read-only, idempotent, etc.), and the schema fully describes the single parameter. The description adds meaningful context on what is analyzed and compatibility, compensating for the lack of an output schema. However, it could be more complete by mentioning output format or typical use cases, slightly limiting the score.

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

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

The input schema has 100% description coverage, with the single parameter 'check_all_channels' fully documented in the schema. The description does not add any parameter-specific information beyond what the schema provides, such as explaining when to set the parameter to true or false. Given the high schema coverage, the baseline score of 3 is appropriate, as the description does not compensate but also does not need to given the schema's completeness.

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

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

The description clearly states the tool's purpose with specific verbs ('Get', 'Analyzes') and resources ('MySQL replication status and health'), and distinguishes it from siblings by focusing on replication rather than other database aspects like queries, indexes, or storage. The explicit mention of analyzing master/source status, slave/replica status, errors, binary log configuration, and semi-sync status provides a detailed scope that sets it apart from tools like 'get_galera_status' or 'get_group_replication_status'.

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 it 'Works with both MySQL and MariaDB terminology,' which suggests when this tool is applicable. However, it does not explicitly state when to use this tool versus alternatives like 'get_galera_status' or 'get_group_replication_status,' nor does it provide exclusions or prerequisites. The guidance is present but limited to compatibility, lacking detailed comparative advice.

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

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

Annotations already indicate read-only, non-destructive, and idempotent behavior, but the description adds valuable context: it specifies that queries against MySQL system schemas are excluded, which is a key behavioral trait not covered by annotations. However, it doesn't mention potential rate limits or authentication requirements.

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

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

The description is well-structured and front-loaded with the core purpose, followed by details on returns, prerequisites, and exclusions. Every sentence adds value without redundancy, making it efficient and easy to parse.

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

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

Given the tool's moderate complexity, rich annotations, and full schema coverage, the description is largely complete. It explains what the tool does, when to use it, and key exclusions, though without an output schema, it could benefit from more detail on return format or error handling.

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

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

With 100% schema description coverage, the input schema fully documents all parameters. The description adds no specific parameter semantics beyond what's in the schema, so it meets the baseline of 3 without compensating for gaps.

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

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

The description clearly states the specific action ('Retrieve slow queries from MySQL performance_schema') and resource ('slow queries'), distinguishing it from siblings like 'get_active_queries' or 'get_statements_with_temp_tables' by focusing on performance metrics of the slowest queries rather than active queries or specific query patterns.

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

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

The description explicitly provides when to use this tool ('Requires performance_schema to be enabled') and when not to use it ('For older versions, use the slow query log instead'), offering clear alternatives and context for its applicability.

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

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

Annotations already provide readOnlyHint=true, destructiveHint=false, and idempotentHint=true, indicating safe, non-destructive operations. The description adds valuable behavioral context beyond annotations: it specifies the tool excludes queries against MySQL system schemas (mysql, information_schema, etc.) to focus on user/application analysis, which is important operational guidance not captured in annotations.

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

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

The description is efficiently structured with four sentences that each serve a distinct purpose: stating the core function, listing what it identifies, explaining the use case, and providing an important exclusion note. There's no wasted text, and the most critical information (what the tool does) appears first.

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

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

For a read-only tool with good annotations and 100% schema coverage, the description provides strong contextual completeness. It explains the tool's focus, use case, and important exclusions. The main gap is the lack of output schema, but the description compensates somewhat by indicating what information will be returned (error counts, warning counts, error rates).

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

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

Schema description coverage is 100%, with both parameters (limit, errors_only) well-documented in the schema. The description doesn't add any parameter-specific information beyond what's already in the schema, so it meets the baseline of 3 for high schema coverage without providing additional parameter semantics.

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

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

The description clearly states the tool's purpose: 'Get statements that produce errors or warnings' with specific criteria (error counts, warning counts, error rates). It distinguishes from siblings like 'get_slow_queries' or 'get_statements_with_full_scans' by focusing on problematic queries with errors/warnings rather than performance issues.

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

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

The description provides clear context about when to use this tool ('Helps identify problematic application queries') and includes an important exclusion note about MySQL system schemas. However, it doesn't explicitly mention when NOT to use it or name specific alternatives among the sibling tools.

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

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

Annotations already provide readOnlyHint=true, destructiveHint=false, and idempotentHint=true, establishing this as a safe read operation. The description adds valuable behavioral context beyond annotations: it explains the performance impact of full scans, specifies exclusion of system schemas, and clarifies the tool's focus on user/application queries. No contradictions with annotations exist.

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

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

The description is well-structured and efficiently written. It starts with the core purpose, explains the significance of full scans, lists identification criteria, states the optimization value, and adds an important exclusion note. Every sentence adds value without redundancy.

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

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

Given the tool's moderate complexity, comprehensive annotations (read-only, non-destructive, idempotent), and full parameter documentation, the description provides good contextual completeness. It explains the tool's focus, exclusions, and optimization purpose. The main gap is the lack of output schema, but the description compensates reasonably well for a diagnostic 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?

With 100% schema description coverage, both parameters are already documented in the input schema. The description doesn't add any parameter-specific information beyond what the schema provides about 'limit' and 'min_rows_examined'. The baseline score of 3 reflects adequate but not enhanced parameter documentation.

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

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

The description clearly states the tool's purpose: 'Get statements that perform full table scans' with specific criteria (queries without indexes or with non-optimal indexes). It distinguishes from siblings like 'get_slow_queries' or 'analyze_statements' by focusing specifically on full scan performance issues.

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

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

The description provides clear context about when to use this tool ('prime candidates for index optimization') and what it excludes (MySQL system schemas). However, it doesn't explicitly mention when NOT to use it or name specific alternative tools from the sibling list for different types of query analysis.

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

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

The description adds valuable behavioral context beyond annotations. While annotations indicate read-only, non-destructive, and idempotent operations, the description adds that it 'excludes queries against MySQL system schemas' and provides diagnostic guidance about what high file sort ratios indicate. This gives practical usage context that annotations alone don't provide.

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

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

The description is well-structured and appropriately sized. It starts with the core purpose, then details what it identifies, provides diagnostic guidance, and ends with an important exclusion note. Each sentence adds value, though the diagnostic guidance about file sort ratios could be considered slightly beyond the minimal required description.

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

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

For a read-only analysis tool with good annotations and full parameter documentation, the description provides good contextual completeness. It explains what the tool returns (statements with sorting operations), what types it identifies, diagnostic implications, and important exclusions. The main gap is the lack of output schema, but the description compensates reasonably well for this.

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

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

With 100% schema description coverage, the input schema already fully documents both parameters (limit and file_sorts_only). The description doesn't add any parameter-specific information beyond what's in the schema, so it meets the baseline of 3 where the schema does the heavy lifting for parameter documentation.

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

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

The description clearly states the tool's purpose: 'Get statements that perform sorting operations' with specific details about what types of sorting it identifies (file sorts, memory sorts, sort merge passes). It distinguishes from sibling tools by focusing specifically on sorting operations rather than other query analysis aspects like errors, full scans, or temp tables.

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

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

The description provides clear context about when to use this tool: for analyzing user/application queries with sorting operations, excluding MySQL system schemas. It mentions that 'High file sort ratios indicate need for index optimization or sort_buffer_size increase' which gives diagnostic context. However, it doesn't explicitly state when NOT to use it or name specific alternative tools among the siblings.

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

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

Annotations already indicate read-only, non-destructive, and idempotent behavior. The description adds valuable context beyond annotations: it explains why temporary tables are problematic (performance issues from disk creation, frequency, size) and that it excludes MySQL system schemas, which helps the agent understand the tool's focus and limitations without contradicting annotations.

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

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

The description is well-structured and front-loaded with the core purpose, followed by context on performance issues and exclusions. Each sentence adds value: the first defines the tool, the second explains why it matters, the third states the goal, and the fourth clarifies scope. No wasted words.

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

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

For a read-only analysis tool with good annotations and full schema coverage, the description is mostly complete. It provides purpose, context, and exclusions. However, without an output schema, it does not describe the return format (e.g., what fields are included in statements), leaving a minor gap in 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%, with clear documentation for both parameters (limit and disk_only). The description does not add any parameter-specific information beyond what the schema provides, such as explaining how 'disk_only' relates to the performance issues mentioned. Baseline 3 is appropriate given the schema handles parameter documentation fully.

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 ('Get statements that create temporary tables') and resource ('statements'), distinguishing it from siblings like get_slow_queries or get_statements_with_errors by focusing on temporary table creation. The title 'Temp Table Statements' reinforces this specificity.

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

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

The description provides clear context for when to use this tool: to identify queries that should be optimized due to temporary tables causing performance issues. It excludes MySQL system schemas to focus on user/application analysis, but does not explicitly mention when not to use it or name alternative tools among siblings.

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

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

Annotations provide readOnlyHint=true, destructiveHint=false, idempotentHint=true, and openWorldHint=false, indicating a safe, non-destructive read operation. The description adds valuable context beyond this: it specifies what data is shown (e.g., cache usage, hit rates, InnoDB buffer pool by table) and notes exclusions (e.g., MySQL system tables are excluded from buffer pool breakdown). This enhances understanding of the tool's behavior without contradicting annotations.

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

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

The description is well-structured with bullet points for clarity and a concluding sentence on purpose. It's appropriately sized, with each sentence adding value (e.g., listing what's shown and exclusions). However, the first sentence could be more front-loaded with key details, and some redundancy exists (e.g., 'Analyze memory usage' and 'Helps optimize' overlap slightly).

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

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

Given the tool's complexity (analyzing memory usage with multiple aspects), annotations cover safety and idempotency, and schema fully describes parameters. The description adds context on data scope and exclusions, which is helpful. However, without an output schema, it could benefit from more detail on return format or limitations, but it's largely complete for a read-only analysis tool.

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

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

Schema description coverage is 100%, with clear descriptions for both parameters (include_buffer_pool and top_n_tables). The description doesn't add significant meaning beyond the schema, as it only mentions buffer pool breakdown by table in the context of exclusions, which is already implied by the parameter name. Baseline score of 3 is appropriate given 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 analyzes memory usage for user tables and caches, specifying the verb 'analyze' and resource 'memory usage for user tables and caches'. However, it doesn't explicitly differentiate from siblings like 'calculate_memory_usage' or 'get_memory_by_host', which appear related but have unspecified 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 implies usage by stating 'Helps optimize table caching parameters', suggesting it's for performance tuning. However, it doesn't provide explicit guidance on when to use this tool versus alternatives like 'calculate_memory_usage' or 'analyze_buffer_pool', nor does it specify exclusions or prerequisites.

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

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

Annotations already provide readOnlyHint=true, destructiveHint=false, and idempotentHint=true, covering safety aspects. The description adds valuable behavioral context beyond annotations: it specifies the exclusion of MySQL system tables, describes the types of statistics returned, and mentions practical use cases for the output. No contradiction with annotations exists.

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

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

The description is well-structured with clear sections: purpose statement, detailed return information, use cases, and important note. Every sentence adds value without redundancy, and the information is front-loaded with the core purpose first.

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

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

Given the comprehensive annotations (readOnlyHint, idempotentHint, etc.) and full parameter documentation in the schema, the description provides good contextual completeness. It explains what the tool returns and why it's useful. The main gap is the absence of an output schema, but the description partially compensates by listing the types of statistics returned.

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

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

With 100% schema description coverage, the input schema already fully documents all 4 parameters. The description doesn't add any parameter-specific information beyond what's in the schema, so it meets the baseline expectation without providing extra value.

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

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

The description clearly states the specific action ('Get detailed statistics') and resource ('MySQL user tables'), with explicit scope boundaries. It distinguishes from siblings by specifying it analyzes user tables only, unlike tools like get_fragmented_tables or get_index_stats which focus on specific aspects.

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

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

The description provides clear context about when to use this tool ('Helps identify tables that may need optimization, index improvements, or partitioning consideration') and what it excludes (MySQL system tables). However, it doesn't explicitly mention when to choose alternative tools like get_fragmented_tables or get_index_stats for more specific analyses.

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

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

Annotations already provide readOnlyHint=true, destructiveHint=false, and idempotentHint=true, indicating a safe, non-mutating operation. The description adds valuable context beyond this: it specifies that the tool 'analyzes key performance-related settings' and 'compares against best practices and system resources,' clarifying its analytical nature and scope. No contradictions with annotations exist.

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

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

The description is well-structured and front-loaded with the core purpose. It uses bullet points efficiently to list analyzed settings, avoiding redundancy. Every sentence adds value, though it could be slightly more concise by integrating the bullet points into a single sentence.

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 analytical nature, annotations cover safety (read-only, non-destructive), and schema fully documents parameters, the description provides adequate context. It explains what the tool analyzes and its comparison methodology. However, without an output schema, it doesn't detail the format of recommendations, leaving a minor gap in completeness.

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

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

Schema description coverage is 100%, with clear descriptions for both parameters (category and include_all_settings). The description doesn't add specific parameter details beyond what the schema provides, such as explaining the 'replication' category or the implications of include_all_settings. However, it does imply the tool's focus on 'performance-related settings,' which aligns with the parameters' functionality.

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: 'Review MySQL configuration settings and get recommendations.' It specifies the verb 'review' and resource 'MySQL configuration settings' with the outcome 'get recommendations.' It distinguishes from siblings by focusing on configuration analysis rather than performance monitoring, query analysis, or health checks like other 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?

The description implies usage context by listing the specific settings analyzed (memory, InnoDB, connections, etc.), suggesting it's for performance tuning and best practices. However, it doesn't explicitly state when to use this tool versus alternatives like 'check_database_health' or 'analyze_query,' nor does it mention exclusions or prerequisites.

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