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 return structure but doesn't cover critical aspects like authentication requirements, error handling details, transaction behavior, or whether this is a read-only or mutating operation. The description is insufficient for a tool that executes arbitrary database procedures.

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 (Args, Returns) and uses minimal but effective sentences. The procedure naming example is helpful without being verbose. However, the 'Returns' section could be more concise by leveraging the 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?

Given the complexity of executing stored procedures (which can be read-only or mutating), the description is incomplete despite having an output schema. It lacks crucial context about database connection requirements, transaction implications, and security considerations. The output schema helps but doesn't compensate for missing behavioral 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?

With 0% schema description coverage, the description compensates well by explaining both parameters: 'procedure' with naming convention examples and 'params' with dictionary format guidance. This adds significant value beyond the bare schema, though it could provide more detail about parameter types or validation.

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 'execute' and the resource 'stored procedure', making the purpose immediately understandable. However, it doesn't differentiate this tool from sibling tools like 'execute_query' or 'describe_stored_proc', which would require more specific context about when to use stored procedures versus direct queries.

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

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

The description provides no guidance on when to use this tool versus alternatives like 'execute_query' or 'describe_stored_proc'. There's no mention of prerequisites (e.g., needing an active database connection) or typical use cases for stored procedures versus direct SQL execution.

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 describes the configuration method (environment variables) and return details (status, host, database, timestamp), but lacks information on error handling, authentication needs, or rate limits. It adequately covers basic behavior but misses advanced operational traits.

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

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

The description is well-structured and front-loaded with the main purpose, followed by configuration details and return information. Each sentence adds essential information 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 (connection establishment with environment-based config) and the presence of an output schema, the description is mostly complete. It covers the purpose, configuration, and return overview, but could benefit from mentioning prerequisites or error scenarios to fully guide usage without relying on the output schema alone.

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

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

The input schema has 0 parameters with 100% coverage, so no parameter documentation is needed. The description appropriately focuses on configuration and return values, adding value beyond the empty schema by explaining how connection details are sourced from environment variables.

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 ('Establish connection') and resource ('SQL Server database'), distinguishing it from siblings like disconnect, list_connections, and switch_database. It precisely defines what the tool does without being vague or tautological.

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 that it connects to the database using environment variables, but it does not explicitly state when to use this tool versus alternatives like list_connections or switch_database. It provides clear setup requirements without naming specific alternatives or exclusions.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It describes the action ('Delete') and return values, including potential error status and rows affected, which adds context beyond basic functionality. However, it lacks details on permissions, side effects, or constraints like transaction handling or rate limits.

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 clear sections for Args and Returns. Each sentence earns its place by providing necessary information 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 a deletion tool with no annotations, the description is mostly complete: it covers purpose, parameters, and return values (with an output schema present). However, it could improve by addressing potential risks or prerequisites, such as confirmation steps or dependencies, to fully compensate for the lack of annotations.

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 significant meaning beyond the input schema, which has 0% coverage. It explains that 'table' can include schema (e.g., 'dbo.Users' or 'Users') and clarifies that 'id' is the 'Primary key value of the row to delete,' providing essential context not present in the schema's bare titles.

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 ('Delete a row by primary key') and identifies the resource ('row'), distinguishing it from sibling tools like 'update_row' or 'insert_row' by focusing on deletion rather than modification or creation.

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

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

The description implies usage by specifying 'by primary key,' which suggests when to use this tool (for targeted deletion) versus alternatives like 'execute_query' for more complex operations. However, it does not explicitly state when not to use it or name specific alternatives, such as 'update_row' for modifications instead of deletions.

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 implies a read-only operation by using 'Get,' but doesn't explicitly state safety aspects like whether it requires specific permissions, has side effects, or handles errors. The description adds some context by detailing the return structure, but lacks comprehensive behavioral traits.

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

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

The description is appropriately sized and front-loaded, starting with the core purpose. The structured 'Args' and 'Returns' sections are efficient, but the use of a dictionary format in the return description could be slightly more concise. Overall, it avoids 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 moderate complexity (1 parameter, no annotations, but with an output schema), the description is fairly complete. It explains the parameter semantics and return values in detail, and the presence of an output schema reduces the need to fully document returns. However, it lacks context on usage relative to siblings or connection 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 adds significant meaning beyond the input schema, which has 0% coverage. It explains the 'procedure' parameter with examples (e.g., 'dbo.sp_GetUser' or 'sp_GetUser'), clarifying optional schema inclusion. This compensates well for the low schema coverage, though it doesn't cover all possible edge cases.

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

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

The description clearly states the tool's purpose as 'Get parameter information for a stored procedure,' which is a specific verb+resource combination. However, it doesn't explicitly differentiate from sibling tools like 'describe_table' or 'list_stored_procs,' which reduces the score from a perfect 5.

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

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

The description provides no guidance on when to use this tool versus alternatives. It doesn't mention sibling tools like 'describe_table' for table metadata or 'list_stored_procs' for listing procedures, nor does it specify prerequisites such as needing an active connection or database context.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It effectively describes the tool's behavior by detailing the return structure (dictionary with table, columns, primary_key, foreign_keys, indexes) and clarifies the table parameter's optional schema handling and default. However, it doesn't mention potential errors (e.g., if the table doesn't exist) or performance considerations.

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 a clear purpose statement, followed by specific details, and ending with return value documentation. Every sentence adds value: the first states the action, the second elaborates on retrieved information, and the Args/Returns sections provide essential usage and output details 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 (single parameter, no annotations, but with an output schema), the description is complete. It covers the purpose, parameter semantics, and return structure in detail. The presence of an output schema means the description doesn't need to explain return values exhaustively, and it adequately addresses the gaps from missing annotations and low schema coverage.

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% description coverage (no schema descriptions), so the description must fully compensate. It adds significant meaning beyond the bare schema by explaining the table parameter's format (optionally with schema like 'dbo.Users'), default behavior (defaults to 'dbo' schema if not specified), and providing an example. This fully documents the single parameter's 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 specific action ('Get detailed column information') and resource ('for a table'), distinguishing it from siblings like list_tables (which lists table names) or describe_stored_proc (which focuses on procedures). It precisely identifies what information is retrieved: column definitions, primary keys, foreign keys, and 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 implies usage by specifying what information is retrieved, but does not explicitly state when to use this tool versus alternatives. For example, it doesn't contrast with list_tables (which provides only table names) or read_rows (which fetches data rows), leaving the agent to infer context from the tool's purpose.

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. It discloses the action ('Close all connections') and return information ('Disconnection status and count of closed connections'), which helps understand the tool's behavior. However, it doesn't mention potential side effects (e.g., whether this affects active queries, requires specific permissions, or has rate limits).

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 with two sentences that each earn their place: the first states the action, the second describes the return value. It's front-loaded with the core purpose 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 has no parameters, an output schema exists, and no annotations are provided, the description covers the essential purpose and return information well. However, for a potentially destructive operation like closing all connections, additional context about prerequisites or side effects would enhance completeness.

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

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

The tool has 0 parameters with 100% schema description coverage, so the schema already fully documents the lack of inputs. The description appropriately doesn't add parameter information beyond what the schema provides, maintaining focus on the tool's purpose and behavior.

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 ('Close all connections') and target resource ('SQL Server database'), distinguishing it from sibling tools like 'list_connections' or 'connect'. It uses precise verbs and identifies the exact scope of operation.

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 (when you want to close database connections) but doesn't explicitly state when to use this versus alternatives like 'list_connections' for monitoring or 'connect' for establishing connections. It provides clear purpose but lacks explicit comparison to sibling tools.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It effectively describes key traits: the tool is read-only (implied by 'execute a read-only SQL query'), applies automatic row limits, caps rows by MSSQL_MAX_ROWS, and returns a structured dictionary. However, it doesn't mention error handling, performance implications, or authentication needs, leaving some 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 and front-loaded with the core purpose, followed by specific details on constraints, parameters, and return values. Every sentence adds value without redundancy, and it efficiently uses bullet points in the Returns section for clarity.

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

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

Given the tool's complexity (SQL execution with safety limits) and the presence of an output schema (implied by the detailed Returns section), the description is complete enough. It covers purpose, usage rules, parameter semantics, and return structure, addressing key aspects without needing to repeat schema details.

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

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

The schema description coverage is 0%, so the description must compensate. It adds meaningful context for both parameters: 'query' is described as a 'SQL SELECT statement to execute,' and 'max_rows' is explained as overriding the default limit and being capped by MSSQL_MAX_ROWS. This goes beyond the schema's basic type definitions, though it could provide more detail on query syntax or max_rows constraints.

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

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

The description clearly states the tool's purpose as executing a read-only SQL query and returning results, specifying 'only SELECT statements are allowed' which distinguishes it from sibling tools like insert_row, update_row, or delete_row that perform write operations. It uses specific verbs ('execute', 'return') and identifies the resource (SQL 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 description explicitly states 'Only SELECT statements are allowed,' providing clear guidance on when to use this tool versus alternatives like insert_row or update_row for write operations. It also mentions that 'The query will have a row limit applied automatically if not specified,' indicating usage context for result size management.

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. It discloses that the tool executes a SQL SELECT query and creates a file, but lacks details on permissions, error handling, file overwriting behavior, or rate limits. It adds some context (e.g., default delimiter) but is incomplete 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 well-structured and front-loaded with the core purpose, followed by organized sections for arguments and returns. Every sentence earns its place by providing essential information 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 (mutation with file creation) and no annotations, the description is fairly complete but has gaps. It explains parameters and return values (with an output schema implied), but lacks details on behavioral aspects like error conditions or side effects, which are important for a write operation.

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

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

Schema description coverage is 0%, so the description must compensate. It explicitly documents all three parameters ('query', 'filename', 'delimiter'), including the default value for 'delimiter' and clarifies that 'filename' can be relative or absolute. This adds significant meaning beyond the bare schema.

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

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

The description clearly states the specific action ('Export query results to a CSV file') and distinguishes it from siblings like 'export_to_json' by specifying the output format. It identifies the resource (query results) and the output (CSV file), making the purpose unambiguous.

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 exporting SQL query results to CSV, with no explicit guidance on when to use this versus alternatives like 'export_to_json' or other data manipulation tools. It provides clear context but lacks explicit exclusions or comparisons to sibling tools.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It effectively describes key behaviors: it creates a file (implied mutation/write operation), specifies the output format (JSON), and details the return structure. It doesn't mention permissions, rate limits, or error handling beyond status, but covers core functionality well.

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, followed by organized sections for Args and Returns. 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 (2 parameters, no annotations, but with an output schema), the description is complete enough. It explains the purpose, parameters, and return values in detail. Since an output schema exists, the description doesn't need to redundantly explain return values, and it adequately covers the tool's scope and behavior.

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 fully. It adds significant meaning beyond the basic schema by explaining that 'query' is an 'SQL SELECT query to execute' and 'filename' is the 'Output filename (relative or absolute path)', clarifying usage and context that the schema alone lacks.

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 ('Export query results to a JSON file') with the resource ('query results'), distinguishing it from siblings like export_to_csv (different format) and execute_query (no file output). It precisely defines the tool's function without ambiguity.

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

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

The description implies usage through the mention of 'SQL SELECT query' and 'query results', suggesting it's for exporting data from database queries. However, it lacks explicit guidance on when to use this tool versus alternatives like export_to_csv or execute_query, nor does it mention prerequisites or exclusions.

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

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

With no annotations provided, the description carries full burden for behavioral disclosure. It mentions the return structure but doesn't cover critical aspects like required permissions, whether the operation is atomic, error handling specifics, or constraints like foreign key relationships. The description is functional but lacks depth 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 well-structured and front-loaded with the core purpose, followed by clear sections for Args and Returns. 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 (a write operation with 2 parameters, no annotations, but with an output schema), the description is adequate but incomplete. The output schema covers return values, reducing burden, but the description lacks context on dependencies, error scenarios, or transactional behavior, leaving gaps for safe usage.

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

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

Schema description coverage is 0%, so the description must compensate. It effectively explains both parameters: 'table' as the table name with schema notation examples, and 'data' as a dictionary of column-value pairs. This adds meaningful context beyond the bare schema, though it could detail data type constraints or validation rules.

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 ('Insert a new row') and resource ('into a table'), making the purpose unambiguous. However, it doesn't explicitly differentiate from sibling tools like 'update_row' or 'read_rows' beyond the basic verb difference, which keeps it from a perfect score.

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

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

The description provides no guidance on when to use this tool versus alternatives like 'update_row' or 'execute_query', nor does it mention prerequisites such as needing an active connection or specific database context. It simply states what the tool does without contextual usage information.

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

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

No annotations are provided, so the description carries the full burden. It states the tool lists active connections and returns details, which implies a read-only operation, but doesn't disclose behavioral traits like error handling, permissions required, or rate limits. This is a basic level of transparency with clear 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 front-loaded with the main purpose in the first sentence, followed by return details. It's efficient with two sentences, but the return section could be slightly more structured (e.g., bullet points). Overall, it's concise with minimal 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 low complexity (0 parameters) and the presence of an output schema, the description is adequate but incomplete. It lacks usage guidelines and behavioral context, which are important for a tool in a database context with many siblings. It meets minimum viability but has clear gaps.

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

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

The input schema has 0 parameters with 100% coverage, so no parameter documentation is needed. The description doesn't add parameter details, which is appropriate. A baseline of 4 is given since it doesn't need to compensate for any schema gaps.

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

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

The description clearly states the tool's purpose: 'List all active database connections.' It uses a specific verb ('List') and identifies the resource ('active database connections'). However, it doesn't explicitly differentiate from sibling tools like 'list_databases' or 'list_tables,' 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 prerequisites, such as needing an established connection first, or compare it to similar tools like 'list_databases' or 'list_tables.' This leaves the agent without context for selection.

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

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

With no annotations provided, the description carries full burden and does well by disclosing key behaviors: it queries sys.databases, excludes system databases by default, respects a blocklist, and returns structured data. It doesn't mention authentication needs, rate limits, or whether it's read-only (though implied), leaving some 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 and front-loaded with the core purpose, followed by implementation details, parameter explanation, and return format. 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 low complexity (1 parameter), no annotations, and the presence of an output schema that documents return values, the description is complete. It covers purpose, behavior, parameter semantics, and output structure adequately without needing to explain return values in detail.

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 significant meaning beyond the input schema, which has 0% description coverage. It explains the include_system parameter's effect ('include system databases in the list'), compensating fully for the schema's lack of documentation and providing clear usage 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 specific action ('List all available databases') and resource ('on the SQL Server'), distinguishing it from siblings like list_tables or list_stored_procs. It provides precise scope details about system databases and blocklist exclusions.

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 what databases are excluded and when to use the include_system parameter. However, it doesn't explicitly state when to choose this tool over alternatives like list_connections or describe_table, nor does it mention prerequisites like requiring an active connection.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It effectively describes the tool as a read-only listing operation (implied by 'List'), specifies filtering capabilities, and details the return structure. However, it misses behavioral aspects like potential performance impacts, authentication requirements, or error handling. It adds value beyond the schema but doesn't fully cover all behavioral traits.

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

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

The description is appropriately sized and well-structured, with a clear purpose statement followed by dedicated 'Args' and 'Returns' sections. Each sentence earns its place by providing essential information without redundancy. It is front-loaded with the main purpose and efficiently organized for quick comprehension.

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

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

Given the tool's moderate complexity (2 parameters, no annotations, but with an output schema), the description is largely complete. It covers the purpose, parameters, and return values in detail. The output schema existence means the description doesn't need to explain return values, which it does anyway, adding clarity. However, it could improve by addressing usage context relative to siblings or behavioral nuances like error 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?

The schema description coverage is 0%, so the description must compensate fully. It does this excellently by explaining both parameters ('schema' and 'pattern') with clear semantics, examples (e.g., 'dbo', 'sp_%'), and usage context (filtering by schema name and SQL LIKE syntax). This adds significant meaning beyond the bare schema, making the parameters understandable and actionable.

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 ('List') and resource ('available stored procedures in the database'). It distinguishes itself from siblings like 'describe_stored_proc' (which provides details on a specific procedure) and 'list_tables' (which lists tables instead of procedures). The description is precise and unambiguous about what the tool does.

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 through the parameter explanations (e.g., filtering by schema or pattern), but it does not explicitly state when to use this tool versus alternatives. For example, it doesn't clarify if this should be used before 'describe_stored_proc' or how it differs from 'list_tables' in terms of database object types. The guidance is functional but lacks explicit context or exclusions.

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

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

With no annotations provided, the description carries full burden. It discloses that this is a read operation (listing) and describes the return format, but does not mention behavioral aspects like permissions needed, rate limits, or whether results are paginated. It adds some value but leaves gaps for a tool with no annotation coverage.

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

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

The description is well-structured with clear sections (purpose, args, returns), uses bullet points for readability, and every sentence adds value. It is appropriately sized and front-loaded with the core purpose.

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

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

Given the tool's moderate complexity, no annotations, and the presence of an output schema (which covers return values), the description is complete enough. It explains purpose, parameters, and return structure, providing sufficient context for an agent to use the tool effectively.

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

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

The schema description coverage is 0%, so the description must compensate. It provides detailed semantics for all three parameters (schema, include_views, pattern), including examples, default values, and filtering logic, adding significant meaning beyond the bare schema.

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

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

The description clearly states the specific action ('List all tables and views') and resource ('in the database'), distinguishing it from siblings like list_databases, list_stored_procs, and describe_table. It precisely defines scope without ambiguity.

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

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

The description implies usage for retrieving database metadata, but does not explicitly state when to use this tool versus alternatives like describe_table or list_stored_procs. It provides clear context about what it returns but lacks explicit comparison to sibling tools.

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

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

With no annotations provided, the description carries the full burden. It effectively discloses key behaviors: it's a read operation (implied by 'read'), supports multiple query methods, returns a dictionary structure with table name, rows, and count, and includes a max_rows limit for result control. It doesn't mention permissions, rate limits, or error handling, but covers core functionality well.

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: the first sentence states the purpose, followed by parameter guidance, a detailed Args section, and a Returns section. Every sentence adds value—no fluff. It efficiently covers complex functionality in a compact format.

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, read operation), no annotations, and an output schema provided, the description is complete. It explains all parameters thoroughly, details the return structure, and provides usage examples. The output schema likely defines the return dictionary, so the description doesn't need to duplicate that, focusing instead on practical guidance.

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

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

Schema description coverage is 0%, so the description must compensate fully. It does so excellently: it explains each parameter's purpose (e.g., 'table: Table name', 'filter: WHERE clause without WHERE keyword'), provides examples ('dbo.Users', "status = 'active'"), clarifies defaults ('columns: default: all columns'), and notes constraints ('for composite keys, use filter'). This adds substantial meaning beyond the bare schema.

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

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

The description clearly states the tool's purpose: 'Read rows from a table by primary key or filter.' It specifies the verb ('read'), resource ('rows from a table'), and mechanism ('by primary key or filter'), distinguishing it from siblings like execute_query (general queries) or describe_table (metadata).

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 usage guidance: 'Provide one of: id (single row), ids (multiple rows), or filter (WHERE clause).' This helps the agent choose between parameters. However, it doesn't explicitly contrast with alternatives like execute_query for complex queries or list_tables for metadata, leaving some sibling differentiation implicit.

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 and does well by disclosing behavioral traits: it explains the action ('Changes the current database using the USE statement'), constraints (existence, online status, blocklist), and response structure. However, it lacks details on permissions, rate limits, or side effects on other tools.

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: the first sentence states the purpose, followed by key constraints, then structured Args and Returns sections. 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 (1 parameter, no annotations, but with output schema), the description is complete: it covers purpose, usage, constraints, parameters, and return values. The output schema exists, so the description needn't explain return values beyond what's provided, and it adequately addresses the context.

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

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

Schema description coverage is 0%, so the description must compensate. It adds meaning by explaining 'database_name' as 'Name of the database to switch to' and detailing constraints in the main text, though it could specify format (e.g., case sensitivity) or examples.

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 verb ('switch') and resource ('active database context'), and distinguishes it from siblings like 'connect', 'disconnect', or 'list_databases' by focusing on context switching rather than connection management or listing.

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 ('switch the active database context') and includes prerequisites ('database must exist, be online, and not be in the blocklist'), but does not explicitly mention when not to use it or name specific alternatives 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?

With no annotations provided, the description carries full burden but only covers basic operation. It doesn't disclose critical behavioral traits like required permissions, whether updates are atomic/reversible, error handling beyond status codes, or constraints (e.g., data validation, triggers). The return format is described, but mutation risks and side effects are omitted.

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 organized sections for Args and Returns. Each sentence adds value: the first defines the operation, subsequent lines explain parameters, and the last details output. No redundant or verbose content.

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 mutation tool with 3 parameters, 0% schema coverage, no annotations, but an output schema, the description is partially complete. It covers parameters and return structure adequately, but lacks context on safety, error conditions, and operational constraints, leaving gaps for an agent to use it correctly in complex scenarios.

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: 'table' can include schema prefixes, 'id' is the primary key value, and 'data' is a dictionary of column-value pairs. This clarifies parameter roles beyond schema types, though it doesn't detail data format constraints or id type expectations.

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 ('Update an existing row'), target resource ('by primary key'), and distinguishes from siblings like 'insert_row' (creates new) and 'delete_row' (removes). It uses precise terminology that differentiates its function within the database operation toolset.

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 modifying existing rows identified by primary key, but doesn't explicitly state when to use this vs. alternatives like 'insert_row' for new rows or 'execute_query' for complex updates. No guidance on prerequisites (e.g., connection state) or exclusions is 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?

With no annotations provided, the description carries the full burden of behavioral disclosure. It effectively describes what the tool does (validates queries against specific criteria like statement types and blocked commands) and outlines the return structure. However, it doesn't mention potential limitations such as rate limits, authentication needs, or system-specific constraints, leaving some behavioral aspects uncovered.

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 a clear purpose statement followed by bullet points for validation criteria and structured sections for args and returns. Every sentence adds value without redundancy, making it efficient and easy to parse for an AI agent.

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 (validation with multiple criteria), no annotations, and an output schema that details the return structure, the description is complete enough. It covers the purpose, usage, validation aspects, parameter semantics, and return values, providing all necessary context for effective tool selection and invocation.

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 significant meaning beyond the input schema, which has 0% description coverage. It explains that the 'query' parameter is an 'SQL statement to validate', clarifying its purpose and format. This compensates fully for the schema's lack of documentation, providing essential context for the single parameter.

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 ('check if a query is safe to execute') and resource ('a query'), distinguishing it from siblings like execute_query (which runs queries) and other database tools. It explicitly differentiates by stating 'without running it', making the distinction unambiguous.

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 explicit guidance on when to use this tool: to validate SQL queries for safety before execution. It implies an alternative (execute_query for actual execution) and specifies use cases like checking statement types, blocked commands, and compliance issues, making it clear this is for pre-execution validation rather than running queries.

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