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

With no annotations provided, the description carries the full burden of behavioral disclosure. It mentions the action 'Create' and a success message return, but lacks details on permissions needed, whether the operation is idempotent, error conditions, or side effects. This is insufficient for a mutation tool with zero annotation coverage.

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

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

The description is well-structured with clear sections for Args and Returns, and is front-loaded with the main purpose. It's concise with no wasted words, though it could be slightly more efficient by integrating the parameter info into the main 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 complexity of a database creation tool with no annotations and no output schema, the description is incomplete. It lacks details on behavioral traits, error handling, and doesn't fully compensate for the missing structured data, making it inadequate for safe and effective use.

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

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

The schema description coverage is 0%, but the description adds the parameter 'database_name' with its type and purpose, providing basic semantics beyond the schema. However, it doesn't cover constraints like naming rules or length limits, leaving gaps in parameter understanding.

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

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

The description clearly states the verb 'Create' and resource 'database in the Mochow instance', making the purpose specific and understandable. However, it doesn't explicitly differentiate from sibling tools like 'use_database' or 'list_databases', which would require a 5.

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

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

The description provides no guidance on when to use this tool versus alternatives like 'use_database' or 'list_databases', nor does it mention prerequisites or exclusions. It's a basic statement of function without contextual usage 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?

With no annotations provided, the description carries full burden for behavioral disclosure. While it mentions the action ('Create') and return value ('A message indicating success'), it lacks crucial behavioral details: whether this requires specific permissions, if it's destructive to existing data, performance implications, or error conditions. For a database indexing operation with zero annotation coverage, this is insufficient.

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

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

The description is appropriately sized and well-structured with clear sections (purpose statement, Args, Returns). Every sentence earns its place by providing essential information. It could be slightly more concise by integrating the purpose statement with parameter explanations.

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

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

Given the tool's complexity (6 parameters, database indexing operation) and complete lack of annotations/output schema, the description provides adequate basic information but has significant gaps. It covers parameters well but lacks behavioral context, error handling, and detailed return format explanation beyond 'A message indicating success'.

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

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

With 0% schema description coverage, the description compensates well by explaining all 6 parameters in the Args section, including their data types, purposes, and supported values for 'index_type' and 'metric_type'. It adds meaningful semantics beyond what the bare schema provides, though it doesn't fully document the optional 'params' dictionary's structure.

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 ('Create a vector index') on a specific resource ('on a vector type field in the Mochow instance'). It distinguishes itself from sibling tools like 'drop_vector_index', 'rebuild_vector_index', and 'describe_index' by specifying it's for creation rather than deletion, rebuilding, or description.

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 parameter explanations (e.g., 'Supported values are "HNSW", "HNSWPQ", "HNSWSQ"'), but doesn't explicitly state when to use this tool versus alternatives like 'rebuild_vector_index' or 'drop_vector_index'. No explicit when-not-to-use guidance or prerequisites are provided.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It states the tool deletes rows, implying a destructive mutation, but doesn't cover critical aspects like permissions required, whether deletions are permanent or reversible, rate limits, or error handling. The return message is mentioned but not elaborated, leaving gaps in understanding the tool's behavior and 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 well-structured and concise, with zero wasted sentences. It starts with a clear purpose statement, followed by organized sections for Args and Returns, making it easy to scan and understand. Every sentence adds value, and the formatting enhances readability without unnecessary verbosity.

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 (destructive deletion with 2 parameters), lack of annotations, and no output schema, the description is incomplete. It covers the basic purpose and parameters but misses critical context like behavioral traits (e.g., permanence of deletions), usage guidelines, and detailed return values. For a mutation tool with no structured safety hints, this leaves significant gaps for an AI agent.

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

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

Schema description coverage is 0%, so the schema provides no parameter details. The description compensates by listing both parameters ('table_name' and 'filter_expr') with brief explanations in the Args section, adding basic semantics beyond the schema. However, it doesn't explain the format of 'filter_expr' (e.g., SQL-like syntax) or provide examples, which limits its helpfulness for correct invocation.

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: 'Delete rows with a filter expression in the Mochow instance.' This specifies the verb ('Delete'), resource ('rows'), and scope ('in the Mochow instance'), making it easy to understand what the tool does. However, it doesn't explicitly differentiate from sibling tools like 'drop_vector_index' or 'select_table_rows', which prevents a perfect score.

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

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

The description provides no guidance on when to use this tool versus alternatives. It mentions a filter expression but doesn't explain when deletion is appropriate compared to other operations like 'select_table_rows' for viewing data or 'drop_vector_index' for removing indexes. There's no mention of prerequisites, risks, or typical use cases, leaving the agent with minimal context for decision-making.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It states the tool returns a string with index details, but lacks critical information such as whether this is a read-only operation, what format the details are in, or if there are any error conditions. For a tool with zero annotation coverage, this leaves significant gaps.

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

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

The description is appropriately sized and front-loaded, with the core purpose stated first, followed by structured sections for arguments and returns. It avoids unnecessary fluff, though the 'Args' and 'Returns' labels could be more integrated into the flow.

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 (2 parameters, no annotations, no output schema), the description is incomplete. It covers the basic purpose and parameters but lacks details on usage context, behavioral traits, and output format, making it inadequate for an agent to fully understand how to invoke it correctly.

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

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

The description includes an 'Args' section that lists and briefly describes the two parameters ('table_name' and 'index_name'), adding meaning beyond the input schema, which has 0% description coverage. However, it doesn't provide examples, constraints, or context for these parameters, so it only partially compensates for the schema gap.

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

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

The description clearly states the tool's purpose as 'Describe index details in the Mochow instance,' which is a specific verb ('describe') applied to a resource ('index details'). It distinguishes from siblings like 'describe_table' by focusing on indexes rather than tables, though it doesn't explicitly contrast them.

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

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

The description provides no guidance on when to use this tool versus alternatives. It doesn't mention when to choose 'describe_index' over 'describe_table' or other siblings, nor does it specify prerequisites like needing to know the table and index names beforehand.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It states the tool returns 'a string containing the details of the table,' which gives some insight into output format. However, it doesn't cover important aspects like whether this is a read-only operation (likely, but not stated), error conditions (e.g., if the table doesn't exist), or performance characteristics. For a tool with zero annotation coverage, this is insufficient.

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

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

The description is well-structured and concise. It starts with a clear purpose statement, followed by dedicated 'Args' and 'Returns' sections that efficiently document inputs and outputs. 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?

Given the tool's moderate complexity (single parameter, no annotations, no output schema), the description is partially complete. It covers the basic purpose and parameter semantics adequately, but lacks usage guidelines and full behavioral transparency. The absence of an output schema means the description should ideally explain return values more thoroughly, which it does only at a high level.

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

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

The schema description coverage is 0%, so the description must compensate. It explicitly documents the single parameter 'table_name' with its type and purpose, which adds meaningful context beyond the bare schema. However, it doesn't provide examples, constraints (e.g., case sensitivity), or format details, leaving some gaps in understanding.

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

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

The description clearly states the tool's purpose: 'Describe table details in the Mochow instance.' It specifies the verb ('describe') and resource ('table details'), making it easy to understand what the tool does. However, it doesn't explicitly differentiate from sibling tools like 'list_tables' or 'stats_table', which prevents a perfect score.

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

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

The description provides no guidance on when to use this tool versus alternatives. It doesn't mention when to choose 'describe_table' over similar tools like 'list_tables' (which might list table names) or 'stats_table' (which might provide statistical information). There's also no mention of prerequisites, such as whether a database needs to be selected first using 'use_database'.

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

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

With no annotations provided, the description carries full burden for behavioral disclosure. It states this is a destructive operation ('Drop'), implying mutation, but doesn't specify permissions required, whether the action is reversible, rate limits, or error conditions. The return message format is mentioned but not detailed. For a destructive tool with zero annotation coverage, this leaves significant gaps.

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

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

The description is efficiently structured with a clear purpose statement followed by parameter and return sections. Every sentence adds value: the first states the action, and the subsequent lines document inputs/outputs. It could be slightly more front-loaded by integrating parameter context into the main 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 destructive tool with 2 parameters, 0% schema coverage, no annotations, and no output schema, the description is incomplete. It lacks critical context: error handling, side effects, dependencies (e.g., whether the database must be in use), and detailed return values. The agent would struggle to use this safely without additional information.

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

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

Schema description coverage is 0%, so the description must compensate. It lists both parameters with brief explanations ('Name of the table', 'Name of the vector index to drop'), adding basic semantics beyond the schema's titles. However, it doesn't provide format examples, constraints, or relationships between parameters, leaving room for ambiguity.

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

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

The description clearly states the action ('Drop') and resource ('vector index in the Mochow instance'), making the purpose immediately understandable. It distinguishes from siblings like 'create_vector_index' and 'rebuild_vector_index' by specifying deletion rather than creation or maintenance. However, it doesn't fully differentiate from all siblings (e.g., 'delete_table_rows' also removes data).

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

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

The description provides no guidance on when to use this tool versus alternatives. It doesn't mention prerequisites (e.g., whether the index must exist), consequences (e.g., impact on queries), or when to choose this over other deletion tools like 'delete_table_rows'. The agent must infer usage from context alone.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It mentions BM25 similarity and scalar filtering but doesn't cover critical aspects like performance characteristics, error conditions, authentication requirements, rate limits, or what happens when no results are found. For a search tool with 6 parameters, this leaves significant gaps.

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

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

The description is well-structured with a clear purpose statement followed by organized Args and Returns sections. Every sentence earns its place, and there's no redundant information. The formatting makes 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 (6 parameters, no annotations, no output schema), the description provides good parameter documentation but lacks behavioral context and usage guidance. The Returns section is minimal ('A string containing the full text search results'), which doesn't help understand the output format. For a search tool, this leaves the agent with incomplete information about what to expect.

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

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

The description provides clear documentation for 5 out of 6 parameters (table_name, index_name, search_text, limit, output_fields) in the Args section, adding meaningful context beyond the schema's 0% coverage. However, it completely omits the 'filter_expr' parameter, which is a notable gap given its potential importance for scalar filtering mentioned in the purpose.

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 'full text search combining BM25 similarity and scalar attribute filtering in the Mochow instance,' which is a specific verb+resource combination. However, it doesn't explicitly differentiate from sibling tools like 'select_table_rows' or 'vector_search,' which might also retrieve data from 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 no guidance on when to use this tool versus alternatives like 'select_table_rows' or 'vector_search.' It mentions BM25 and scalar filtering but doesn't explain when this approach is preferred over other search methods available in 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?

No annotations are provided, so the description carries the full burden of behavioral disclosure. It states the tool lists databases and returns a string of names, but lacks details such as whether this requires specific permissions, how the string is formatted (e.g., comma-separated, newline-separated), if there are rate limits, or if it's a read-only operation. This leaves significant gaps for an agent to understand the tool's behavior.

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

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

The description is front-loaded with the core purpose in the first sentence, and the second sentence adds necessary return value information. Both sentences earn their place by providing essential details without redundancy or fluff, making it appropriately sized and well-structured.

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

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

Given the tool's low complexity (0 parameters, no output schema, no annotations), the description covers the basic purpose and return value adequately. However, it lacks completeness in usage guidelines and behavioral details, such as formatting of the return string or interaction with sibling tools, which could help an agent use it more effectively in context.

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

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

The input schema has 0 parameters with 100% coverage, so no parameter information is needed. The description appropriately doesn't discuss parameters, which is efficient. However, it could have mentioned that no parameters are required, but this is minor given the schema's clarity.

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

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

The description clearly states the verb ('List') and resource ('all databases in the Mochow instance'), making the purpose specific and understandable. However, it doesn't explicitly differentiate from sibling tools like 'list_tables' or 'use_database', which would require mentioning it's for databases specifically rather than tables or other resources.

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

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

The description provides no guidance on when to use this tool versus alternatives. For example, it doesn't mention if this should be used before 'use_database' to select a database, or how it relates to 'list_tables' for listing tables within a database. There's no explicit when/when-not or alternative tool references.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It states the action ('List all tables') and return type ('A string containing the names of all tables'), but doesn't disclose important behavioral traits like whether this requires specific permissions, how tables are ordered, if hidden/system tables are included, what format the string uses (e.g., comma-separated, newline-separated), or if there are any rate limits. For a tool with zero annotation coverage, this leaves significant gaps in understanding its behavior.

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

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

The description is perfectly concise and well-structured: one sentence states the action, and a separate 'Returns:' section clarifies the output format. Every sentence earns its place by providing essential information without redundancy. The two-sentence structure is front-loaded with the primary purpose, 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 simplicity (no parameters, no annotations, no output schema), the description is adequate but could be more complete. It covers the basic action and return type, but lacks context about behavioral aspects (e.g., permissions, ordering, format details) and usage guidelines relative to siblings. For a zero-parameter tool, it meets minimum viability but doesn't fully leverage the opportunity to provide richer guidance.

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

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

The tool has zero parameters, and schema description coverage is 100% (though empty). The description appropriately doesn't waste space discussing nonexistent parameters. Since there are no parameters to document, the description focuses correctly on the tool's action and return value, meeting the baseline expectation for parameterless tools.

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

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

The description clearly states the verb ('List') and resource ('all tables in the current database'), making the purpose immediately understandable. It doesn't explicitly differentiate from sibling tools like 'list_databases' or 'describe_table', but the specificity of 'tables' vs 'databases' provides implicit distinction. The description avoids tautology by not just restating the tool name.

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

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

The description provides no guidance on when to use this tool versus alternatives like 'describe_table' (for table details) or 'list_databases' (for listing databases). It doesn't mention prerequisites such as needing a current database selected via 'use_database', nor does it indicate when this tool would be preferred over other listing or querying tools. The usage context is implied but not explicitly stated.

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

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

With no annotations provided, the description carries full burden but lacks behavioral details. It mentions 'initiation' in the return, hinting at an asynchronous operation, but doesn't clarify if this is destructive to existing data, requires specific permissions, has performance impacts, or involves rate limits. More context on these aspects is needed for a mutation tool.

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

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

The description is appropriately sized and front-loaded with the core purpose in the first sentence. The Args and Returns sections are structured but could be more integrated; however, there's no wasted text, making it efficient overall.

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 a mutation tool with no annotations, 0% schema coverage, and no output schema, the description is incomplete. It doesn't explain the implications of rebuilding (e.g., downtime, data integrity), error conditions, or detailed return values beyond a success message. More context is needed for safe and effective use.

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

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

Schema description coverage is 0%, so the description must compensate, but it only lists parameter names without adding meaning beyond the schema's titles. The Args section repeats what's in the input schema without explaining what 'table_name' or 'index_name' refer to (e.g., existing tables/indexes). Baseline is 3 due to low coverage but minimal added 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 action ('Rebuild') and target ('vector index in the Mochow instance'), providing a specific verb+resource combination. However, it doesn't explicitly differentiate from sibling tools like 'drop_vector_index' or 'create_vector_index' which might be alternatives for index management, leaving room for improvement.

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

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

No guidance is provided on when to use this tool versus alternatives like 'drop_vector_index' followed by 'create_vector_index', or whether prerequisites such as existing indexes or specific database states are required. The description only states what it does, not when it should be used.

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

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

With no annotations provided, the description carries full burden but lacks critical behavioral details. It doesn't disclose whether this is read-only (implied by 'Select' but not explicit), authentication requirements, rate limits, error handling, or pagination behavior beyond the 'limit' parameter.

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?

Well-structured with a clear opening sentence followed by parameter and return value sections. The description is appropriately sized, though the 'Returns' section could be more informative given no output schema.

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 4-parameter tool with no annotations and no output schema, the description covers basic functionality but lacks completeness. It doesn't explain the return format beyond 'a string containing the selected rows', missing details on structure, error cases, or interaction with other tools like 'use_database' for context.

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

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

Schema description coverage is 0%, but the description adds meaningful context for all parameters: 'table_name' as the table to query, 'filter_expr' for filtering data, 'limit' for result maximum, and 'output_fields' for specifying returned fields. However, it doesn't explain filter expression syntax or field naming conventions.

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

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

The description clearly states the action ('Select rows') and resource ('in the Mochow instance'), specifying it uses a filter expression. It distinguishes from siblings like 'delete_table_rows' (deletion) and 'describe_table' (metadata), but doesn't explicitly contrast with 'fulltext_search' or 'vector_search' for filtering alternatives.

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

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

No guidance on when to use this tool versus alternatives like 'fulltext_search' or 'vector_search' for filtering, or 'list_tables' for broader queries. It mentions a filter expression but doesn't specify when filtering is appropriate versus other selection methods.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It mentions that it returns 'a string containing the table statistics', which gives some output information, but doesn't cover important aspects like whether this is a read-only operation, potential performance impacts, error conditions, or what specific statistics are included.

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

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

The description is efficiently structured with a clear purpose statement followed by Args and Returns sections. Every sentence serves a purpose, though the 'Returns' section could be more specific about what 'table statistics' actually means.

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 single-parameter tool with no annotations and no output schema, the description provides basic functionality and parameter documentation. However, it lacks important context about what 'table statistics' includes, how this differs from other table inspection tools, and any behavioral constraints or requirements.

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

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

The description explicitly documents the single parameter 'table_name' with its type and purpose, which is valuable since schema description coverage is 0%. However, it doesn't provide additional context like valid table name formats, examples, or constraints beyond what's minimally stated.

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

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

The description clearly states the action ('Get') and resource ('table statistics'), making the purpose understandable. However, it doesn't differentiate this tool from potential siblings like 'describe_table' or 'select_table_rows', which might also provide table information.

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

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

No guidance is provided on when to use this tool versus alternatives like 'describe_table' or 'select_table_rows'. The description only states what it does, not when it should be chosen over other table-related tools in the sibling list.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It states the action ('Switch to a different database') and mentions a success message return, but lacks critical details: whether this affects subsequent operations, if it requires specific permissions, potential side effects, or error conditions (e.g., invalid database name).

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

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

The description is efficiently structured with a clear purpose statement followed by formatted Args and Returns sections. Every sentence adds value without redundancy, making it easy to scan 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 moderate complexity (a state-changing operation with no annotations or output schema), the description is minimally adequate. It covers the basic action and parameter but lacks details on behavioral impact, error handling, and integration with sibling tools, leaving gaps 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?

The description adds meaningful context for the single parameter 'database_name' by explaining it's the 'Name of the database to use,' which clarifies its role beyond the schema's basic title. With 0% schema description coverage and only one parameter, this adequately compensates, though it could specify format constraints (e.g., case sensitivity).

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 ('Switch') and resource ('database'), making it immediately understandable. However, it doesn't explicitly differentiate from sibling tools like 'list_databases' or 'create_database', which would be needed for a perfect score.

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

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

The description provides no guidance on when to use this tool versus alternatives. It doesn't mention prerequisites (e.g., needing an existing database), exclusions, or relationships to sibling tools like 'list_databases' (which might be needed first to see available databases).

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

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

With no annotations provided, the description carries full burden for behavioral disclosure. It mentions what the tool does but lacks critical behavioral details: authentication requirements, rate limits, error conditions, performance characteristics, or what happens when no results match. The return type is mentioned but without format details.

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

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

The description is efficiently structured with a clear purpose statement followed by parameter documentation. Every sentence adds value, though the 'params' parameter is vaguely documented as 'Additional vector search parameters' without specifics.

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 6-parameter search tool with no annotations and no output schema, the description covers the basic operation and parameters adequately. However, it lacks details about the return format (beyond 'string'), error handling, performance implications, and how vector similarity is calculated.

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

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

With 0% schema description coverage, the description compensates well by documenting all 6 parameters with clear explanations of their purpose and defaults. It adds meaningful context beyond the bare schema, explaining what each parameter controls in the search operation.

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 'vector similarity search combining vector similarity and scalar attribute filtering' in a specific system (Mochow instance). It specifies both the similarity search and filtering aspects, though it doesn't explicitly differentiate from sibling tools like fulltext_search or select_table_rows.

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

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

The description provides no guidance on when to use this tool versus alternatives like fulltext_search or select_table_rows. It mentions the tool's capabilities but offers no context about appropriate use cases, prerequisites, or exclusions.

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