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

With no annotations provided, the description carries the full burden. It states the tool 'identifies missing indexes' but does not disclose if it is read-only, whether it modifies anything, or what the output contains. Lacks behavioral details beyond the core action.

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

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

The description is a single, clear sentence with no unnecessary words. It could include slightly more context without becoming verbose.

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 simple tool with one parameter and no output schema, the description is adequate but does not hint at the response format (e.g., list of indexes). Given no annotations, more completeness would help the agent anticipate the tool's return value.

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 coverage is 100%—the single 'sql' parameter is described in the schema. The description adds minimal extra meaning beyond 'analyze for missing indexes', which is similar to the schema description. Baseline 3 is appropriate.

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

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

The description clearly states the tool analyzes a SQL query to identify missing indexes, specifying the verb and resource. It distinguishes from siblings like analyze-query-performance and get-execution-plan by focusing specifically on index recommendations.

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

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

No explicit guidance on when to use this tool versus alternatives like analyze-query-performance or get-execution-plan. The purpose is implied from the description, but the agent lacks context on exclusions or prerequisites.

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

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

No annotations provided; description does not clarify whether the query is actually executed (with potential side effects), if it is safe for production, or if it only applies to SELECT queries. This is a significant gap.

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

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

Single sentence, front-loaded and efficient, with no wasted words.

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

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

With three parameters and no output schema or annotations, the description is too brief. It omits return values, error conditions, and the potential destructive nature of executing arbitrary SQL.

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

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

Schema description coverage is 100%, so the schema already documents all parameters. The description adds no extra semantic value beyond what is in the schema, meeting the baseline.

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

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

The description clearly states the tool analyzes SQL query performance via multiple executions and timing, distinguishing it from sibling tools like execute-query or get-execution-plan.

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, such as execute-query or get-execution-plan. No mention of 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, description carries full burden. It implies read-only analysis by stating 'analyzes,' listing row count, column statistics, and data distribution. However, it does not explicitly confirm non-destructive behavior, performance impact, or prerequisites.

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

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

Single sentence, front-loaded with verb 'Analyzes,' no unnecessary words. Efficient and clear.

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?

No output schema, and description does not mention return format, structure, or whether it returns a report or single value. Incomplete for understanding tool's full 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?

Schema coverage is 100% with parameter description 'Name of the table to analyze.' The tool description adds general context about statistics but does not clarify parameter specifics beyond schema. Baseline 3 is appropriate.

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

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

The description clearly states it analyzes statistical information including row count, column statistics, and data distribution. This distinguishes it from siblings like describe-table (schema) or get-table-data (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?

No guidance on when to use this tool versus alternatives like analyze-missing-indexes or analyze-query-performance. The description implies statistical analysis but fails to set context or exclude cases.

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

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

No annotations provided, so description must carry the burden. It mentions parallel execution but omits side effects, error handling, permissions, or that it is read-only. Insufficient disclosure for a batch operation.

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

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

Single sentence efficiently conveys purpose and key differentiator. Front-loaded with verb and object, no extraneous 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?

Missing essential details like return format or error behavior, especially since no output schema exists. The description does not fully inform an AI agent 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?

Schema coverage is 100% with descriptions for both parameters. Description adds no deeper meaning beyond what schema provides, achieving baseline for high coverage.

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

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

Description clearly states 'Gets the detailed schema of multiple tables in parallel for improved performance', specifying verb, resource, and the parallel aspect that distinguishes it from the sibling tool 'describe-table'.

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?

Implies usage for multiple tables when performance is key via 'for improved performance', but does not explicitly state when not to use or directly name alternative 'describe-table' for single tables.

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 indicates a read operation via 'Gets' and discloses the source-code behavior, but it does not mention permission requirements, error behavior, or what happens for non-PSQL functions.

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 one concise, front-loaded sentence that immediately states the action and key detail. Every word earns its place.

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

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

For a simple one-parameter tool with no output schema, the description adequately covers purpose and the notable source-code behavior. It does not explain return format or error cases, but these are not critical for a basic describe operation.

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

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

Schema description coverage is 100%, and the single parameter functionName is already described as 'Name of the function to describe'. The tool description adds only the phrase 'specific function', which does not materially enhance 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 tool 'gets detailed information about a specific function' and adds a distinctive detail about returning source code for PSQL functions. This distinguishes it from sibling tools like list-functions and describe-procedure.

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 the tool should be used when you need detailed information about a specific function, including source code. It does not explicitly name alternatives or exclusions, but the context is clear enough for a simple describe operation.

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

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

No annotations are provided, so the description bears full responsibility for behavioral disclosure. It implies a read-only describe operation and specifies return content (header and body), but omits any mention of errors, performance, or side effects, which is acceptable for a simple read tool but not richly transparent.

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?

A single, front-loaded sentence with no redundant information. It effectively communicates purpose and content in under 20 words.

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

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

For a tool with a single parameter and no output schema, the description adequately covers purpose and return details. It is sufficiently complete for its simplicity, though it could mention error scenarios or required permissions.

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 already fully describes the packageName parameter (100% coverage), and the description's reference to 'specific package' adds minimal extra meaning beyond what the schema states.

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 specifies the verb+resource: 'Gets detailed information about a specific package' and highlights what is included (header and body source), distinguishing it from siblings like list-packages and describe-procedure.

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

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

No explicit guidance on when to use this vs alternatives, but the phrase 'specific package' conveys intent for a single package lookup. Absence of exclusions or alternative references leaves room for ambiguity.

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 exist, so the description must reveal behavior independently. It states 'gets detailed information' which clearly implies a read-only, non-destructive operation. It does not mention any prerequisites, side effects, or access requirements, but for a read operation that may be sufficient. There is no contradiction with any annotations (since none exist). This is a step above a purely vague statement, but it could be more explicit about the nature of the 'detailed information.'

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

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

The description is a single, clear sentence that front-loads the action ('Gets detailed information') and specifies the key attributes. No filler, no ambiguity, no irrelevant details. Excellent structure.

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

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

The tool has one parameter bind absence of output schema and annotations. The description tells what it does and what it includes (source code and parameters), but does not specify the exact output structure, any error conditions, or the context required (e.g., database connection, permissions). Given it's a describe operation, it could benefit from mentioning that the procedure must exist or what happens if not found. However, for a simple read tool, it's reasonably complete.

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 already provides a description for the single parameter (procedureName: 'Name of the stored procedure to describe'), covering 100% of parameters. The tool description adds no new semantic detail beyond 'get info' and 'specific procedure.' It doesn't clarify any constraints (e.g., case sensitivity, schema qualification, existence check). Thus, the description provides baseline value but no enhancement over the 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 uses a specific verb ('Gets'), a specific resource ('specific stored procedure'), and specifies the scope ('including its source code and parameters'). This clearly differentiates from siblings like list-procedures (which lists) and describe-table, making it immediately obvious what this 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 implicitly indicates when to use this tool—when you need detailed info on a single stored procedure vs. listing all (list-procedures). However, it does not explicitly state alternatives or exclusions, such as 'use list-procedures to discover names' or 'not for modifying procedures.' There is no contraindication or when-not guidance.

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 present, so the description must carry full behavioral disclosure. It correctly implies a read-only operation but does not mention permissions, side effects, or error handling. For a simple read, the description is minimally adequate.

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 consists of a single, well-structured sentence that directly states the tool's purpose without extraneous words or repetition.

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

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

Given no output schema and no annotations, the description does not explain the return format (e.g., whether it returns column names, data types, constraints). It is adequate but lacks detail on output structure or error scenarios, which would help an AI agent handle the tool effectively.

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

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

Schema coverage for the single parameter is 100% (tableName has a description). However, the tool description adds no further meaning beyond the schema's parameter description, offering no additional context like formats or 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 verb 'Gets' and the resource 'detailed schema (columns, types, etc.) of a specific table', distinguishing it from sibling tools like list-tables (which only lists table names) and describe-batch-tables (which handles multiple 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 implies use when schema details of a single table are needed, but does not explicitly state when to avoid this tool or mention alternatives like get-field-descriptions or list-tables. No use-case exclusions or prerequisites are provided.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It implies a read-only operation via 'gets', but does not explicitly state safety, permission requirements, or error behavior. This is adequate but thin for a 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 a single, tight sentence that efficiently packs the action, target, and key details. There is zero waste and the content is front-loaded with the verb and subject.

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

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

For a tool with one parameter and no output schema, the description is sufficiently complete. It enumerates the key returned fields, giving the agent a good preview of what to expect, though it omits typical caveats like pagination or error handling, which are not critical for this simple case.

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 single parameter 'triggerName' is fully described in the schema (100% coverage) as 'Name of the trigger to describe'. The tool description adds no additional meaning or format details, so the baseline score of 3 applies.

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 'gets' and the resource 'specific trigger' while enumerating the returned details (source code, type, sequence, status). This directly distinguishes it from sibling describe tools (e.g., describe-table, describe-procedure) by focusing on triggers.

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 list-triggers or describe-package. The description neither qualifies usage context nor excludes any cases, offering no direction 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?

Adds 'in parallel' which is a key behavioral trait. However, with no annotations, description fails to disclose error handling, transaction behavior, or result format. Partial credit for parallelism disclosure.

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

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

Single sentence, no fluff. Perfectly concise and front-loaded with the action.

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?

Lacks critical context for a batch execution tool. No mention of output format, error handling, or transactionality. With no output schema, description should cover return 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?

Schema covers all parameters with descriptions (100% coverage). Description adds no additional meaning beyond summarizing the overall action. Baseline 3 is appropriate.

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

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

Clearly states it executes multiple SQL queries in parallel. Distinguishes from sibling 'execute-query' which is for single queries. Verb 'executes' and resource 'batch queries' is specific.

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

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

No explicit guidance on when to use vs alternatives. Only implies parallelism for performance, but does not mention when not to use or provide comparative context with sibling tools like 'execute-query'.

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

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

With no annotations, the description carries full burden of behavioral disclosure. It only mentions pagination via FIRST/ROWS but fails to indicate that arbitrary SQL may be executed, including destructive DML, or to warn about permissions and side effects. This is a significant gap for a mutation-capable tool.

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

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

The description is extremely concise: one sentence stating the core purpose and one sentence adding a key behavioral detail. Every part earns its place with no redundancies.

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 absence of an output schema and the tool's ability to execute potentially complex queries, the description lacks crucial information such as return format, error behavior, or supported SQL types. It is not complete for an AI agent to safely and effectively use the tool.

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

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

The schema already describes both parameters thoroughly (sql with pagination hint, params for injection prevention). The description adds only the pagination hint, which is already in the schema. Thus, the description provides minimal additional semantic value beyond the 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 action (executes) and resource (SQL query) with the specific database (Firebird). It also hints at pagination. However, it does not explicitly distinguish from the sibling tool 'execute-batch-queries' which executes multiple queries, leaving some ambiguity for an AI agent.

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-batch-queries or get-table-data. It does not mention any constraints, prerequisites, or contexts where this tool is appropriate or inappropriate.

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 exist, so the description must fully disclose behavior. However, it only states that information is retrieved without describing what 'general information' includes, potential side effects, or required permissions.

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?

A single, front-loaded sentence that efficiently communicates the tool's purpose with no extraneous 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 lack of annotations and output schema, the description is too vague. It does not specify what 'general information' encompasses, leaving the agent to guess or rely on trial and error.

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

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

The tool has zero parameters, so the input schema fully defines the interface. The description adds no parameter information, which is acceptable per the baseline score of 4 for 0-parameter 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 action ('Retrieves') and the resource ('general information about the connected Firebird database'), making the purpose specific and distinguishable from sibling tools like 'get-server-info'.

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

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

No guidance is provided on when to use this tool versus siblings such as 'get-server-info' or 'system-health-check'. The agent receives no context for appropriate invocation.

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 disclosing behavioral traits. It only states the purpose ('to understand how the database will execute it') but does not indicate whether the operation is read-only, modifies the database, or has any side effects. This is insufficient for a tool that likely involves query parsing.

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

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

The description is a single concise sentence with no extraneous words. However, it could be restructured to front-load key information or include a brief example without sacrificing brevity.

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

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

There is no output schema, so the description should explain what the execution plan looks like (e.g., JSON, text). It fails to do so, leaving the agent uncertain about the return format. More completeness is needed for an analytical tool.

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

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

Schema coverage is 100% and both parameters ('sql', 'params') have descriptions in the schema. The description adds no additional meaning beyond what the schema provides, so a baseline score of 3 is appropriate.

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

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

The description uses the specific verb 'Gets' and clearly identifies the resource as 'execution plan for a SQL query'. It distinguishes the tool from siblings like 'execute-query' and 'analyze-query-performance' by focusing on plan retrieval rather than execution or analysis.

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

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

The description provides no guidance on when to use this tool versus alternatives, nor does it mention prerequisites (e.g., required permissions) or scenarios where it should not be used. This lack of context leaves the agent without decision criteria.

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

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

With no annotations, the description carries full burden but only states it gets descriptions if they exist. It does not disclose what happens when descriptions are absent (e.g., empty result vs error), nor any behavioral traits like read-only nature, auth needs, or side effects.

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

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

The description is a single concise sentence with no fluff, but it could be structured to add more details without increasing length significantly, e.g., by including result 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?

For a read tool with one parameter and no output schema, the description should clarify return format and behavior for missing descriptions. It does not, leaving the agent uncertain about expected response.

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 coverage is 100% with a well-described 'tableName' parameter. The tool description adds no further parameter meaning beyond the schema, so baseline 3 is appropriate.

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

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

The description clearly states the tool retrieves stored field descriptions for a specific table, with the qualifier 'if they exist'. This is a specific verb-resource pair and distinguishes it from siblings like describe-table which may provide broader table info.

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

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

No guidance on when to use this tool over alternatives such as describe-table or get-table-data. The description does not mention use cases, prerequisites, or when field descriptions are available.

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

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

There are no annotations, so the description must disclose behavioral traits. It only states that the tool 'gets information', which implies a read-only operation, but it does not specify what information is returned, whether authentication is required, or any other behavioral details. The description is too vague to provide meaningful transparency.

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

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

The description is a single, concise sentence that front-loads the action ('Gets information'). It is succinct and to the point with no wasted words.

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

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

With no output schema and no parameters, the description is the only source of context. It gives a high-level idea of what the tool does, but it omits details about the exact nature and structure of the returned information. Given the tool's simplicity, this is minimally viable but has 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 tool has zero parameters, so the parameter semantics baseline is 4. The description does not need to explain parameters, and no parameter information is missing.

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 uses a specific verb ('Gets') and identifies the resource ('information about the Firebird MCP server and its available tools'). It clearly states the tool's function, but it overlaps somewhat with sibling tools like 'list-available-tools' and 'get-database-info', so it doesn't strongly distinguish itself.

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. The description does not mention any conditions, prerequisites, or contrast with sibling tools, leaving the agent to infer usage context.

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

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

With no annotations, the description carries the full burden. It implies a read-only operation, but does not disclose response shape, pagination limits, ordering behavior, permissions, or any side-effect safety beyond the word 'Retrieves'.

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

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

The description is a single front-loaded sentence with no redundant wording; every word contributes to stating the core function.

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

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

Given the lack of annotations/output schema and the presence of many closely related sibling tools, the description is too sparse to fully route an agent: it omits usage boundaries, default behavior, and relationship to execute-query or list-tables.

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 80%, so the schema already documents most parameters. The description adds only high-level references to filtering, pagination, and ordering, which are evident from the parameter names; it does not enrich the meaning of individual parameters.

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

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

The description names a specific verb ('Retrieves') and resource ('data from a specific table'), and notes optional filtering, pagination, and ordering. It is clear enough to distinguish from most table-metadata siblings, though it does not explicitly call out alternatives like execute-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?

There is no guidance on when to choose this tool over execute-query or other retrieval/query tools. The description implies general data retrieval but provides no exclusion criteria or alternative routing.

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 'gets detailed information', implying a read-only operation, but does not specify what kind of information is returned, whether it requires specific permissions, or whether network calls are made. For a simple help tool, this is acceptable, but it could be more explicit about the nature of the information (e.g., schema, usage, parameters) and limitations.

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

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

The description is a single, concise sentence that immediately conveys the tool's purpose without fluff or repetition. It is front-loaded and every word earns its place. This is exemplary conciseness.

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

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

Given the tool's simplicity (one parameter, no output schema, no annotations), the description is adequate to convey its purpose. It does not need to explain return values because there's no output schema, and the tool's function is self-contained. However, a bit more detail on what 'detailed information' includes (e.g., parameters, examples, annotations) would round it out, but with no annotations, the description does its job sufficiently.

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 has 100% coverage for its single parameter 'toolName', with description: 'Name of the tool to get help for.' The tool description adds no additional meaning beyond the schema. According to the rubric, when schema description coverage is high (>80%), the baseline is 3, so this is appropriate. The parameter is straightforward and self-explanatory.

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 function: 'Gets detailed information about a specific tool.' It uses a specific verb 'gets' and resource 'detailed information about a specific tool', which distinguishes it from sibling tools that list tools (list-available-tools) or describe data objects like tables, procedures, etc. However, it doesn't explicitly contrast with sibling tools within the description itself, which is a minor differentiation gap.

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 a general sense of when to use the tool (when you need details about a tool), but it does not explicitly discuss when to use it versus alternatives. Siblings like 'list-available-tools' obviously serve a listing purpose, but there are no exclusions or explicit guidance on choosing this over other exploration tools. The utility is fairly obvious given the tool name and description, but the guidance is implied rather than stated.

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

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

No annotations are provided, so the description carries full responsibility for behavioral disclosure. It only states the action ('Lists') without mentioning read-only nature, permissions, return format, or any side effects. This is a minimal disclosure for a tool that likely performs a database query.

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

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

The description is a single, concise sentence that front-loads the core action and resource. No filler words or redundant information.

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

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

For a simple list tool with no parameters and no output schema, the description covers the essential purpose. It could add detail about the output format or mention that it returns a list of event names, but the current clarity is sufficient for basic use.

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

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

The tool has zero parameters, so there is nothing to explain. The baseline of 4 applies, and the description appropriately does not attempt to describe nonexistent parameters.

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

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

The description clearly states it lists native events (POST_EVENT) within database triggers and procedures, using a specific verb and resource. It distinguishes itself from sibling tools like list-triggers and list-procedures by focusing on event types rather than the objects themselves.

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

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

The description implies usage when you need to know available events for triggers/procedures, but it does not explicitly state when to use this tool versus alternatives like list-triggers or list-procedures. No exclusions or alternative suggestions 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 burden of signaling safety and side effects. 'Lists all tools' reasonably implies a read-only operation, but it does not clarify output format, whether category filtering changes the return shape, or any potential pagination/limitations.

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

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

One extremely concise sentence states the tool's purpose with zero filler or redundancy. It is front-loaded and scannable.

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 simple, optional-parameter listing tool, this description is nearly complete. It explains the tool's scope, and the schema covers the parameter. It could mention that return data is a catalog of tool names/metadata, but 'lists all tools' is adequate 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 schema fully documents the single `category` parameter with examples, so the baseline is 3. The description adds no parameter-specific semantics beyond the schema's existing description.

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

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

The description uses a specific verb ('Lists') and clear resource ('all tools available on the MCP server'), which distinguishes this broad enumeration tool from sibling list-tools that focus on particular item types (e.g., list-tables, list-packages, list-functions).

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 use case is implied: call this when you need the full catalog of MCP server tools. However, it does not explicitly mention alternatives like get-tool-help for specific tools or state when not to use the category filter.

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

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

With no annotations, the description carries the full burden. It clarifies the scope (UDFs and PSQL) but does not disclose potential behavior such as whether system functions are included, ordering, or any side effects. For a simple list operation, this is sufficient but minimal.

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

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

The description is a single, clear sentence with no unnecessary words. It is front-loaded with the action verb and immediately clarifies the scope in parentheses. Perfectly concise.

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

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

Given the tool's zero-parameter input and read-only listing nature, the description is adequately complete. It explains what the list contains. Though it could mention output ordering or system vs. user objects, these are minor for such a straightforward 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?

The tool has zero parameters, and the schema confirms this with 100% coverage. Per the rubric, a baseline of 4 applies when there are no parameters. The description adds no parameter information, but none is needed.

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 uses a specific verb ('Lists') and resource ('all functions in the database') and adds valuable scope clarification ('UDFs and PSQL functions'). This clearly differentiates it from sibling tools like list-procedures and list-tables, making it 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 when to use this tool (when you need to list database functions) and the scoping hints at function-specific use cases. However, it does not explicitly mention alternatives or exclusion criteria. It relies on the contrast with sibling tool names, which is adequate but not explicit.

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

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

With no annotations provided, the description must carry the burden of behavioral disclosure. It states the scope and version support, and 'lists' implies a read-only operation, but it does not explicitly mention return format, whether system packages are included, or that no side effects occur. This is adequate for a simple list operation but lacks richer behavioral context.

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

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

The description is a single focused sentence, front-loading the core behavior ('Lists all packages') and then adding the only relevant qualifier (Firebird 3.0+). Every word adds value, and there is no filler or repetition.

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

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

For a zero-parameter, simple enumeration tool, the description is effectively complete: it states exactly what is returned, the scope ('all packages'), and a version prerequisite. There is no output schema, but the description does enough to set expectations for the agent without needing elaborate 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 tool has zero parameters and the schema already covers 100% of them, so the description does not need to explain parameters. The baseline for a no-parameter tool is 4, and the description appropriately remains concise without blocking on parameter details.

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 uses a specific verb ('Lists') and resource ('all packages in the database'), making the tool's core behavior immediately clear. It also implicitly distinguishes this enumeration tool from sibling tools like describe-package, which provide detailed information about a single package.

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 clearly tells the agent this returns a complete package listing and adds an important environment prerequisite ('available in Firebird 3.0+'). It does not explicitly state when not to use it or name alternatives, but for a zero-parameter listing tool the intended context is fairly obvious.

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 transparency burden. It clearly communicates a read-only enumeration operation and describes the returned content: all stored procedures plus their input and output parameter information. It does not mention caveats like permissions or ordering, but for a simple list tool the core behavior is transparent.

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?

A single, front-loaded sentence that immediately names the operation and resource, then adds useful output detail without redundancy. Every word contributes to agent understanding.

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

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

Given the tool's low complexity, zero parameters, and absence of annotations or output schema, the description covers the essential information: what is listed, the scope, and the parameter detail included. It could expand on result shape or potential limitations, but these are not critical for successful 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 tool has zero parameters and an empty input schema, so no parameter-level explanation is required. The description already states what information is returned, which is sufficient; baseline for zero-parameter tools is 4.

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 uses a specific verb ('Lists') and resource ('stored procedures'), clearly states the scope ('all stored procedures in the database'), and adds return-relevant detail ('with input and output parameter information'). This distinguishes it from sibling tools like list-tables, list-functions, and list-triggers by naming the exact resource type.

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

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

No guidance is given for when to use this tool versus alternatives such as describe-procedure or list-functions. The only usage signal is the inherent meaning of 'List' — there are no exclusions, prerequisites, or explicit comparative direction.

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

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

No annotations are provided, so the description carries the full burden. It accurately describes a read-only listing operation, which is inherently non-destructive. However, it could mention that the operation is safe and has no side effects, though the description is adequate for a simple list.

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

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

The description is a single, concise sentence that front-loads the key action ('Lists') and resource. No unnecessary words, 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?

While the tool is simple, the description does not specify what information is returned (e.g., just table names or full schema details). Given the lack of an output schema, a bit more detail on the output format would improve completeness.

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

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

The input schema has zero parameters, and schema description coverage is 100%. With no parameters, the description does not need to add parameter information, earning a baseline score of 4.

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?

Description clearly states the tool lists all user tables in the current Firebird database. It uses a specific verb ('Lists') and resource ('user tables'), and distinguishes from siblings like 'describe-table' which focuses on a single table.

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

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

No explicit guidance on when to use this tool versus alternatives like 'describe-table' or 'get-table-data'. The usage is somewhat implied (list tables before querying a specific one), but the description lacks explicit context or exclusion criteria.

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 should convey behavioral traits. It only states it lists triggers with associated attributes, but doesn't mention any side effects, resource usage, ordering, or safety characteristics. It's minimal and lacks transparency beyond the basic action.

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

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

Single sentence, front-loaded with verb and resource, no fluff. Perfectly concise.

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

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

For a list-triggers tool with no parameters and no output schema, the description covers the main purpose but doesn't mention any additional context like ordering, filtering (it says 'all' implies no filtering), or whether it includes only user-defined triggers or system triggers. Slight ambiguity, but given simplicity, it's adequate. Not complete as it doesn't specify if it's read-only, but again, no annotations. I'd say 3.

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

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

There are 0 parameters, so the description doesn't need to explain them. Baseline 4 applies since no parameters to document. The description correctly omits parameter details.

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 uses a specific verb ('Lists') and a clear resource ('all database triggers'), and specifies what is included (associated table, trigger type, status). This distinguishes it from siblings like describe-trigger, which presumably focuses on a single trigger.

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

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

The description implies this is the tool for listing all triggers, but it doesn't explicitly state when to use it versus alternatives, nor when not to use it. It's clear it's an overview tool, but no explicit exclusions or alternatives are mentioned.

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

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

No annotations are provided, so the description must carry full behavioral disclosure. The description only mentions 'subscribe to receive proactive notifications' but does not explain how the subscription works (e.g., persistence, unsubscribe mechanism, or what 'proactive notifications' entail).

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

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

The description is a single sentence that directly conveys the core functionality. It is concise and front-loaded with the key action and event type. However, it could include additional structure (e.g., a note about usage).

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 low complexity (one parameter, no output schema), the description is adequate but could be more complete by mentioning the subscription lifecycle or how to stop it. The lack of behavioral details reduces completeness.

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

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

The input schema already provides a clear description for the single parameter 'eventName', including examples. Schema coverage is 100%, so baseline is 3. The description adds no extra parameter information.

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

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

The description clearly states the action ('subscribe to a Firebird event') and specifies the event type (POST_EVENT) and outcome ('receive proactive notifications'). It distinguishes the tool's purpose from, say, listing events, but does not explicitly compare to siblings.

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

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

No explicit guidance on when to use this tool versus alternatives. The context implies it's for subscribing to events to get notifications, but lacks instructions on preconditions or alternatives like 'list-available-events'.

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 transparency burden. It indicates a read-oriented 'checks' operation, but it does not disclose what connectivity test is performed, whether any side effects occur, what failure modes look like, or what the returned health status contains.

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

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

The description is a single compact sentence with no filler or repetition. It front-loads the action ('Checks') and immediately identifies the checked resources, making it appropriately sized for a zero-parameter diagnostic tool.

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

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

For a no-parameter diagnostic tool, the description gives the basic scope of the operation, but with no output schema and no annotations it should explain what the caller receives or how to interpret the result. The phrase 'system health and database connectivity' is adequate but vague, leaving return-value semantics and failure behavior unspecified.

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 an empty input schema, so the description needs to provide no parameter semantics. The 0-parameter baseline of 4 applies here because there is nothing for the schema or description to document.

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 uses the specific verb 'Checks' and names two concrete resources: 'system health' and 'database connectivity'. It clearly states what the tool does, though it doesn't explicitly differentiate itself from sibling diagnostics like get-server-info or get-database-info.

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

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

There is no guidance about when to use this tool versus alternative diagnostic tools, no mention of prerequisites, and no contextual hint about the best use case. The description simply states the action without any 'when to use' or 'when not to use' direction.

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

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

With no annotations, the description carries the burden. It discloses the prerequisite of a native driver, but does not explain error behavior if the driver is missing or the output format. The simplicity of the tool mitigates some need for detail.

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

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

The description is a single, concise sentence that clearly conveys purpose and a key prerequisite. No extraneous information is present.

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?

While the description covers the core function and a requirement, it does not specify the return value or output format. Given the simplicity, this is a minor gap but still leaves an agent guessing 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 tool has zero parameters, so the baseline is 4. The description adds no parameter information, but none is needed. The empty schema is fully covered.

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 checks wire encryption on the current database connection. It uses a specific verb ('verifies') and resource, and is distinct from sibling tools which focus on analysis, backup, or 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 implies usage for verifying encryption, but does not provide explicit guidance on when to use or when not to use, nor does it mention alternatives. The requirement for a native driver is noted, but context for exclusion is missing.

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