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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It only states that it modifies schema, but doesn't mention side effects, transactionality, commit behavior, permissions, or what happens on failure. This is insufficient 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 a single, concise sentence with no redundant words. It front-loads the core action and provides two clear examples. It earns its place with zero waste.

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

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

The tool involves schema mutation but is described minimally. With no output schema and no annotations, the description should clarify return values, error handling, or parameter usage patterns. It fails to explain how to construct the query or what response to expect, making it incomplete for the tool's complexity.

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

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

Schema description coverage is 100% (both parameters have descriptions), so the baseline is 3. The tool description adds no additional meaning to the parameters (query and connectionId) beyond what the schema already provides, so it stays at 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's purpose: 'Modify existing table schema' with illustrative examples ('add columns, rename tables'). This verb+object construction is specific and distinguishes it from siblings like create_table and drop_table, which deal with creating or removing 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 usage for schema modification but provides no explicit guidance on when to use this tool versus alternatives like execute_query, which could also run ALTER statements. It lacks exclusions or comparative notes, so the guidance is only implied.

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

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

With no annotations provided, the description must carry the behavioral transparency burden. It clearly indicates this is a mutating append operation, but it does not disclose return behavior, effects on existing memo content, or handling of tags/connection beyond what the schema already states.

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 filler or redundant information. Every word contributes to understanding the tool's 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?

This is a simple tool with three parameters and no output schema, so the description plus schema is largely sufficient for correct selection and invocation. It omits return-value or error details, but those are not critical for such a straightforward append operation.

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

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

Schema description coverage is 100%, so each parameter is already documented. The tool description adds the 'memo' destination but does not meaningfully elaborate on parameter semantics beyond the schema descriptions.

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 ('Add') with a clear resource ('business insight or analysis note') and destination ('to the memo'). This clearly distinguishes the tool from siblings like list_insights and the database operation tools.

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

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

The description provides no guidance on when to use this tool versus alternatives. It does not mention list_insights or any other sibling tool, nor does it state exclusions or preferred contexts.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It doesn't explain what happens after starting a transaction (e.g., whether it locks resources, how long it lasts, or that it must be explicitly committed or rolled back). This is a significant gap for a state-changing 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?

The description is a single, concise sentence that is front-loaded with the action. It earns its place with no wasted words, though it could benefit from a brief mention of the transaction lifecycle.

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 (starting a transaction) and the lack of annotations and output schema, the description is incomplete. It doesn't explain the transaction's scope, how it relates to other transaction tools, or what the agent should expect after calling it. The sibling tools suggest a workflow, but the description doesn't connect to it.

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

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

The schema description coverage is 100% for the single parameter (connectionId), so the schema already documents it. The description adds no additional meaning beyond what the schema provides, which is acceptable given the high coverage, but it doesn't clarify how the connectionId is used in the transaction 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 'Start a new database transaction' clearly states the action (start) and the resource (database transaction), which is specific enough to distinguish from siblings like commit_transaction and rollback_transaction. However, it doesn't explicitly mention the connection context, which is a key part of the tool's function.

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 that this is the first step in a transaction workflow, nor does it reference related tools like commit_transaction or rollback_transaction. The agent is left to infer usage from the name and sibling list.

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

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

With no annotations, the description carries full transparency burden; it omits side effects (such as making changes permanent), error conditions (if the transaction is invalid or already committed), and any return value or failure behavior.

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

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

The description is a single concise sentence with no unnecessary words or redundancy, achieving optimal 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?

Given the lack of output schema and annotations, the description is insufficiently complete; it fails to specify outcomes, success/failure conditions, or handling of edge cases like non-existent or already-committed transactions.

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 the parameter, but the tool description adds valuable origin information ('returned by begin_transaction'), enhancing the contextual understanding beyond the basic 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?

Clearly states the action (commit) and subject (active transaction), effectively distinguishing it from sibling tools like begin_transaction and rollback_transaction.

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?

Provides no explicit guidance on when to use this tool versus alternatives, nor does it reference the transaction lifecycle (e.g., after begin_transaction, before rollback).

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, and the description fails to disclose any behavioral implications such as whether the operation is read-only, requires special permissions, or has side effects like generating migration scripts. The user is left without information about the tool's impact.

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

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

The description is a single, clear sentence with no redundant words. It is appropriately concise and well-structured, conveying the core purpose efficiently.

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

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

The description is minimal and does not explain what the comparison result looks like (e.g., a diff report, a list of differences). While no output schema is provided, the absence of any mention of output format or behavior leaves the tool's complete functionality unclear.

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 covers all three parameters with descriptions (sourceConnectionId, targetConnectionId, includeMigrationScript). The description adds no extra meaning beyond the schema, so it meets the baseline for full coverage without enhancing understanding.

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

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

The description clearly states the tool's function with a specific verb ('Compare') and resource ('schemas between two database connections'). It is distinct from sibling tools like get_table_schema, which focuses on a single table's schema.

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

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

The description provides no guidance on when to use this tool versus alternatives (e.g., get_table_schema). It only states the action without context or conditions, leaving the agent to infer appropriate usage.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It only says 'Create new tables' without mentioning side effects (e.g., irreversible DDL, potential data loss if table exists), permission requirements, or impact on database state. This is insufficient for a schema-changing 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?

The description is one short, clear sentence ('Create new tables in the database') with zero waste. It's appropriately front-loaded and easy to parse, though it lacks any operational detail that might justify a longer description.

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

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

Given that this is a data definition operation with no output schema and no annotations, the description is too minimal. It does not cover error handling, idempotency, or the need for a valid connection. Sibling tools like drop_table have similar simplicity, but for a DDL tool, more context (e.g., impact on existing data, transaction support) is expected.

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 parameter semantics are largely defined by the schema. The description adds a tiny bit of extra clarity by naming 'tables' as the resource, but it doesn't elaborate on the format or constraints of the 'query' parameter beyond the schema. Baseline 3 applies, but the description's alignment with the schema justifies a 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 ('Create') and resource ('tables in the database'), clearly stating the action. It distinguishes from siblings like alter_table and drop_table, though it doesn't specify scope (e.g., within a connection) beyond the parameter.

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 execute_query or write_query, which could also run CREATE TABLE statements. It doesn't mention prerequisites, such as needing a valid connection or schema context, nor does it exclude cases where other tools would be more appropriate.

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 safety burden. It conveys that the operation is destructive ('Remove') and requires a safety confirmation, which is useful. However, it does not explicitly state irreversibility, side effects on dependent objects, or whether the command will fail if confirm is false, leaving important behavioral gaps.

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

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

The description is a single, compact sentence that expresses the essential purpose and safety feature with no filler. Each word contributes value, making it appropriately concise and front-loaded.

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, single-action tool with fully documented parameters, the description is adequate but not complete. It omits guidance on when to use, expected return behavior, and consequences of dropping a table, which would be valuable given the lack of annotations and output schema.

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

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

The input schema has 100% coverage, so the baseline is 3. The description adds no parameter-specific meaning beyond the schema; 'safety confirmation' merely echoes the confirm parameter's description. The schema already sufficiently explains connectionId, tableName, and confirm.

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 ('Remove a table from the database') and the resource being acted upon. It is specific and distinct from siblings like create_table, alter_table, and get_table_schema, so the agent can easily identify when this tool applies.

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 gives no guidance on when to use this tool versus alternatives, prerequisites, or safety checks beyond the confirm flag. It does not mention, for example, backing up data or checking relationships before dropping the table, so the agent lacks 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, the description must carry the full burden of behavioral disclosure, but it only says the query runs inside an active transaction. It does not explain whether the query can mutate data, whether it leaves the transaction open, what happens on failure, or how it interacts with commit/rollback.

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 filler or redundant wording. Every word earns its place and the structure is maximally 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?

This tool sits inside a transaction workflow with siblings begin_transaction, commit_transaction, and rollback_transaction, but the description does not explain how the query affects transaction state, whether multiple queries are allowed, or what the expected return behavior is. Without an output schema or annotations, the description is too sparse for reliable use.

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

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

The input schema already describes both parameters with 100% coverage: transactionId is identified as the ID from begin_transaction and query is described as the SQL query. The description adds no additional parameter meaning beyond the schema, so the baseline 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 'execute' and resource 'a query within an active transaction', which distinguishes it from sibling tools like execute_query by scoping execution to an open transaction. This is specific and immediately understandable.

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 phrase 'within an active transaction' implies the tool should be used after begin_transaction and before commit/rollback, but it does not explicitly name alternatives, exclude outside-transaction queries, or mention when not to use it. Usage context is implied rather than made 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, the description carries the burden of behavioral disclosure. It does disclose the read-only safety property, which is essential context. However, it says nothing about potential error behavior, transaction isolation, or results format. For a simple read-only tool, this is adequate but not rich.

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 is concise and front-loaded. It conveys the tool's action (execute), object (SQL query), scope (specific database connection), and safety characteristic (read-only) without any wasted words.

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

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

For a simple read-only query tool with no output schema and no annotations, this description covers the core: it names the resource, the action, and the key read-only constraint. It doesn't mention return format, but the presence of maxRows hints at pagination. The sibling list provides sufficient context for distinguishing from write/transaction tools. It could mention 'returns rows' explicitly, but overall it's complete enough.

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 baseline is 3 even without additional param info. The description adds no new meaning beyond what the schema already provides: it mentions 'SQL query' and 'database connection' which are also in the property descriptions. The 'read-only' qualifier is the only extra semantic, but it's about tool behavior, not 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 'Execute a SQL query on a specific database connection' with the crucial qualifier '(read-only queries)'. This specific verb plus resource (SQL query on a connection) combined with the read-only scope distinguishes it from siblings like write_query and mutation tools.

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

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

The read-only qualifier explicitly scopes usage to SELECT queries and implicitly excludes write operations. While it doesn't name an alternative like write_query, the sibling context and schema's 'SELECT statements only' reinforce the boundary. This is clear enough but lacks an explicit 'use write_query for writes' pointer.

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 of disclosing behavior. It says 'execution plan' but does not clarify whether the query is executed, how EXPLAIN ANALYZE affects behavior, or whether the operation is read-only. This is a significant gap for a tool that may run queries.

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

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

The description is a single, efficient sentence that immediately conveys the core purpose. There is no redundant or filler 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?

Given four parameters, no annotations, and no output schema, the description is too sparse. It fails to explain return values, whether the query executes, or how the analyze option changes behavior, leaving important context missing.

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

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

Schema description coverage is 100%, so the schema already documents all four parameters. The description adds no additional semantic context about parameters, resulting in a baseline score with no extra value.

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

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

The description clearly states the tool's function: obtaining an execution plan for a SQL query. This distinguishes it from siblings like execute_query and write_query, which perform different operations.

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 a SQL execution plan is needed, but it does not explicitly state when to choose this over execute_query or provide any exclusions. There is no explicit when/when-not guidance or mention of alternatives.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It only states 'Export query results' without explaining whether the query is executed, whether a file is written, what the return value is, or that only SELECT statements are allowed. No mention of the maxRows limit or potential mutating side effects leaves significant ambiguity.

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 and formats. It contains no fluff, but it could arguably earn its place more by including a critical constraint (e.g., SELECT-only or maxRows), though for pure conciseness it is well-structured.

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

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

This tool has 5 parameters, no annotations, and no output schema, yet the description offers only a high-level summary. It fails to explain what the tool returns (file path, raw bytes, success message), the SELECT-only restriction, the maxRows cap, or any behavioral nuances. For a tool with this complexity, the description is incomplete.

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

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

Schema description coverage is 100%, so the input schema already documents all parameters fully. The description adds no additional parameter semantics beyond what the schema provides (e.g., it mentions CSV/JSON, but the schema already enumerates these in the format field). 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 identifies the tool's function: 'Export query results to various formats (CSV, JSON, etc.)' with a specific verb (export) and resource (query results). It implicitly differentiates from siblings like execute_query by focusing on formatted output, but does not explicitly name or contrast with those alternatives.

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

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

No guidance is provided on when to use this tool versus siblings such as execute_query, write_query, or explain_query. The description does not mention prerequisites, limitations (SELECT-only, maxRows), or scenarios where this tool is preferred or discouraged.

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 the full burden. It says 'Get detailed information' which implies a read-only operation, but it does not disclose whether special permissions are needed, whether it tests/accesses the database, or what information is considered 'detailed.' This is thin behavioral 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, front-loaded sentence with no wasted words. It is easy to parse, but it is too terse to provide meaningful behavioral detail, which keeps it from a perfect score.

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 annotation context, the agent does not know what 'detailed information' actually includes. Given related sibling tools like get_database_stats and test_connection, the description leaves the boundaries of this tool's output ambiguous, making it incomplete.

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

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

The schema already describes connectionId as 'The ID or name of the database connection' with 100% coverage, leaving little room for interpretation. The tool description adds no additional parameter meaning 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 uses a specific verb plus resource—'Get detailed information about a specific database connection'—making clear this is a single-connection lookup. It broadly differentiates from list_connections (which lists connections) and test_connection (which tests), but does not explicitly name those alternatives.

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

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

The phrase 'specific database connection' implies it should be used when you have a connectionId and need details about that one connection. However, no explicit guidance is given for when this should be used instead of test_connection, get_database_stats, or get_ssh_tunnel_info.

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, and the description does not explicitly state whether the operation is read-only or has side effects. It does not contradict any assumed behavior but lacks explicit transparency about safety.

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 unnecessary words. It is well-structured 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 detail what statistics or information will be returned. Without an output schema, this is a notable gap that could lead to misunderstandings about the tool's capabilities.

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 connectionId is clearly described as 'The ID or name of the database connection', which fully explains its purpose and usage. No ambiguity remains.

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 statistics and information about a database, which distinguishes it from connection-level operations like get_connection_info. However, it is somewhat broad as it doesn't specify what kind of statistics (e.g., table counts, sizes, performance metrics).

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-level stats but does not explicitly mention when to use this over other sibling tools like get_connection_info or list_tables. No alternative guidance 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?

No annotations are present, so the description must fully disclose behavior. It only says 'get' which implies a read operation, but does not specify whether it is side-effect-free, what kind of statistics are returned, or any requirements (e.g., active connection). Without annotation, this is insufficient for an agent to gauge safety and expected results.

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

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

A single concise sentence that directly states the tool's verb and target. No fluff or redundant phrasing, and the key information is front-loaded.

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 or annotations, so the description must convey what the function returns and any relevant context. It only states 'connection pool statistics' without elaborating on the specific metrics, format, or any prerequisites, leaving the agent under-informed for a stats-retrieval 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 provides 100% coverage of the single parameter (connectionId) with a clear description. The description adds nothing beyond that, so the baseline 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 uses a specific verb ('Get') and a clear resource ('connection pool statistics') with a scope ('for a connection'). It distinguishes from siblings like get_database_stats (which likely returns overall stats) and get_connection_info (which returns metadata, not pool statistics).

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 that this tool is used when you need per-connection pool statistics, but it does not explicitly state when to use it over alternatives such as get_database_stats or get_connection_info. No exclusions or alternative guidance 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?

The description explicitly states that secrets are redacted, which is a critical behavioral note. It also advises using test_connection to verify the tunnel actually connects, adding transparency about the tool's output limitations. No contradictions with annotations.

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

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

The description is concise, consisting of two clear sentences. It avoids unnecessary detail and directly conveys the tool's purpose, usage context, and important behavioral notes.

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 description is complete for this tool: it explains what is returned (the SSH tunnel profile), notes that secrets are redacted, and provides guidance on how to verify connectivity. No output schema exists, so no return value explanation is required.

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 connectionId is fully described in the schema as 'The ID or name of the database connection'. The description adds no additional semantic detail beyond what the schema already 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 clearly states the action (Get), the resource (SSH tunnel / jump host profile), and the association with a database connection. It distinguishes this tool from siblings like get_connection_info by focusing specifically on the SSH tunnel configuration.

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 context for when to use the tool (to retrieve SSH tunnel configuration) and suggests using test_connection to verify connectivity. It could be more explicit about when not to use this tool, but the alternative is 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 carries the full burden. 'Get schema information' implies a read-only operation, but it doesn't explicitly state that no data is modified, require permissions, or note performance implications. It's a safe read operation but lacks explicit behavioral 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?

The description is a single, direct sentence with no waste. It is appropriately concise for a simple read tool and gets straight to the point.

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

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

With no output schema and three parameters, the description is too minimal. It doesn't specify what schema information includes (e.g., columns, types, constraints) or that includeIndexes defaults to true. It also doesn't mention that a valid connectionId is required. Given sibling tools like compare_schemas, more context about return structure and prerequisites would be helpful.

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

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

Schema coverage is 100% (all three parameters have descriptions), so the baseline is 3. The description adds no additional meaning or context beyond what the schema already provides. The parameters are straightforward and well-documented in 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 verb 'Get' and the resource 'schema information for a specific table', which distinguishes it from siblings like list_tables (which lists all tables) and get_connection_info. However, it doesn't explicitly name alternatives or scope nuances beyond 'specific table', so there's slight room for differentiation but it's clear.

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

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

No guidance is provided on when to use this tool versus alternatives. It doesn't mention scenarios like 'use when you need the structure of one table' or contrast with list_tables or compare_schemas. The description offers no exclusions or alternative suggestions.

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 must disclose behaviors, but it only states a simple list operation. It doesn't mention that the includeDetails parameter alters output, nor any side effects, permissions, or return format. For a read-only list, this is minimal but lacks richness.

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 conveys the core purpose without wordiness. It is front-loaded and efficient.

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 is simple with one optional parameter and no output schema. The description covers the basic action but omits context about how includeDetails affects results or whether any prerequisites exist. It is adequate but not thorough, especially given 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 schema description covers 100% of the single parameter (includeDetails with a default and description). The tool description adds no additional meaning beyond the schema, so this meets the baseline of 3.

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

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

The description clearly states the action (list) and resource (all available database connections), distinguishing it from siblings like get_connection_info which targets a specific connection. It is specific and unambiguous, though it doesn't mention the parameter.

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 get_connection_info, test_connection, or list_tables. The context of listing all connections is implied but no explicit comparisons or exclusions are given.

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 merely says 'list all' without indicating read-only nature, return format, pagination, or any side effects. It does not add any context beyond what the schema already provides for parameters, and does not disclose how filters affect the result set.

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 and resource, with zero wasted words. It is appropriately minimal for a simple listing operation.

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 two optional parameters and no output schema, the description is fairly complete. It covers the core purpose and implies the result is a list of insights. While it could mention that it respects optional filters, this is already in the schema. Given the tool's simplicity, it is adequately contextual.

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

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

The schema description coverage is 100% for both parameters (tags and connection), each with its own description. The tool description adds no additional meaning to these parameters, so the baseline of 3 applies. It does not explain parameter interplay or provide 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 uses a specific verb 'list' and identifies the resource as 'all stored business insights and analysis notes'. It clearly conveys the tool's function and is unambiguous. It naturally distinguishes from the sibling 'append_insight' which is for adding, so no confusion about its role.

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

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

The description implies when to use the tool (to retrieve insights) but does not explicitly state when not to use it or mention alternatives. There is no guidance on comparing with other list tools (e.g., list_connections) or on prerequisites. The function is obvious enough, but lacks explicit usage notes.

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 context. It only says 'List all tables' and gives no information about filtering scope (e.g., all schemas by default), whether views are excluded by default (though the schema hints at it with includeViews=false), or any side effects or performance implications. The description is not misleading but is too sparse to be 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?

The description is a single, front-loaded sentence that states exactly what the tool does with no extraneous words. It is appropriately sized for the tool's simple 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 simplicity and that the schema documents its parameters thoroughly, the description is minimally sufficient. However, it does not mention return format, pagination, or any edge-case behavior (e.g., behavior with no tables), and since there is no output schema or annotations, a bit more context could 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?

All parameters have schema descriptions covering 100% of the fields, so the baseline is 3. The description adds no parameter-specific meaning beyond the schema, nor does it compensate for any gaps. It neither enhances nor detracts from the schema's clarity.

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

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

The description 'List all tables in a database' uses a clear verb (List) and resource (tables) with scope (in a database). It is distinct from siblings like get_table_schema or create_table, though it doesn't explicitly call out alternatives.

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

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

There is no guidance on when to use this tool versus alternatives. It does not mention any prerequisites, when not to use it, or suggest sibling tools like list_connections or get_table_schema. The description merely restates the tool's basic function.

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 disclose behavioral traits on its own. It fails to mention that rollback discards all changes, that the transaction must be active, that it ends the transaction, or any side effects. The description is too minimal to inform the agent of the operational impact.

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

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

The description is a single, succinct sentence with zero extraneous words. It is front-loaded with the essential verb and object, and is appropriately sized for such a simple 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?

While the tool is simple and has only one parameter, the description does not explain what happens after rollback (e.g., discarding changes, invalidating the transaction), nor does it mention prerequisites like the transaction being active. Without annotations or an output schema, the description carries the full burden of contextual completeness, which it does not fulfill.

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 covers the sole parameter comprehensively, stating it is 'The transaction ID returned by begin_transaction'. Since schema coverage is 100%, the baseline is 3; the tool description adds no further semantic detail beyond the schema, which is acceptable given the schema's completeness.

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

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

The description clearly states the action ('Rollback') and the resource ('an active transaction'), leaving no ambiguity about its purpose. It also distinguishes itself from sibling tools like commit_transaction and begin_transaction by indicating it reverses a transaction rather than initiating or finalizing one.

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 does not explicitly state when to use this tool versus alternatives, but the purpose is clear enough that an agent can infer rollback is for aborting a transaction when changes should be discarded. It lacks any mention of exclusions or alternatives, so guidance is implied rather than explicit.

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

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

There are no annotations, so the description must carry the burden. It conveys that the tool tests connectivity, implying a read-only check, but does not disclose what happens on failure (e.g., error messages, side effects). It provides minimal but useful context, so a 3 is appropriate as it adds some transparency beyond the literal name.

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

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

The description is a single, clear sentence with no fluff. It is front-loaded and efficient, earning a perfect score for 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 simplicity (one parameter, no output schema, no annotations), the description is minimally adequate but lacks guidance on interpretation of results (e.g., what does a successful test return?). It is complete enough for a basic tool but could be improved with output 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 already describes the parameter as 'The ID or name of the database connection to test' (100% coverage), so the description doesn't need to add much. The description doesn't clarify the expected format (ID vs name) beyond the schema, so it stays at baseline 3.

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

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

The description uses a clear verb ('Test') and specific resource ('connectivity to a database connection'), making the purpose clear. It doesn't explicitly differentiate from siblings like get_connection_info, but the action is distinct enough.

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 or when not to use it. For example, it doesn't say 'Use this tool to check if a connection is alive before running queries' or contrast with get_connection_info.

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 of disclosing behavioral traits. It does not state that this tool modifies data, that it may have destructive effects (especially DELETE), that it requires a specific connection, or that it is not safe for read-only purposes. The word 'write' in the title hints at mutability, but the description lacks explicit warnings.

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, short and to the point. It is front-loaded with the action and the allowed query types. No fluff, but it could be more structured with explicit warnings or usage context.

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 is a mutation tool (INSERT/UPDATE/DELETE) with no annotations and no output schema. It is part of a large set of siblings that includes many other query execution tools. The description is thin: it does not explain the behavioral implications (e.g., data modification, irreversible changes), prerequisites (e.g., an existing connection), or how it differs from 'execute_query' or 'execute_in_transaction'. Given the safety implications of write queries, this is incomplete.

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

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

Schema coverage is 100% for both parameters (query, connectionId). The description adds no extra meaning beyond what the schema already provides, so the baseline of 3 applies. It does not mention that the query must be a write query or any additional constraints like transaction handling.

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 specifies the verb (Execute) and the resource (INSERT, UPDATE, DELETE queries on a specific database connection). It is clear but does not explicitly distinguish itself from siblings like 'execute_query', 'execute_in_transaction', or 'explain_query', which might also execute SQL statements.

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 states what the tool does (execute write queries) but gives no guidance on when to use it versus alternatives like 'execute_query' (which might handle reads) or 'execute_in_transaction' (which handles transactional execution). It does not mention any exclusions or alternative tools.

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