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

No annotations are provided, so the description must carry behavioral transparency. It does not disclose side effects, cost/heaviness of the analysis, required permissions, or which parameter combinations are valid. 'Analyze using query profile' implies read-only analysis but never explicitly states behavior beyond that.

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?

Two sentences, each nominally valuable. However, the first sentence is redundant ('analyze' and 'analyze result') and the second is a pointer rather than an essential part of this tool's own description. It is not bloated, but it could be tightened and front-load the instruction more clearly.

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 three optional parameters, no annotations, and no statement on how they combine, but an output schema exists. The description does not explain expected usage for the parameters or warn about possible non-determinism/dependencies on set_session_db. This is below the minimum an agent needs to correctly construct a call.

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%, so parameters are already documented. The description adds only 'query profile' context, not additional meaning like whether sql and uuid are mutually exclusive or how db relates to session defaults. It does not degrade below baseline, but it does not help further.

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 states 'Analyze a query and get analyze result using query profile', which names a verb and resource but is vague about what 'analyze result' means or whether it returns query metrics/plan. It does not clearly distinguish itself from siblings like read_query or analyze_slow_queries_topn, so it is a minimum-viable clarification.

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

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

It gives one hint about using set_session_db for the default database but provides no guidance on when to choose this tool over alternatives, nor does it clarify the relationship between the sql and uuid parameters. The agent is left to infer the intended invocation context.

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

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

With no annotations provided, the description carries the full burden for behavioral disclosure, but it only says 'analyze' and 'identify bottlenecks.' It does not state that the operation is read-only, what source data it uses, how results are ordered, whether it mutates anything, or what the output format will be.

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. It could earn a 5 by adding a quick usage hint or output note, but as written it is appropriately concise without being tautological.

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 relatively simple and parameters are fully described, but there is no output schema and the description does not explain what the analysis returns or how the results are presented. Given the wide sibling set and lack of annotations, the coverage is incomplete for confident 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?

Schema description coverage is 100%, so the parameters are already documented. The description's 'top N' and 'slowest' loosely map to top_n and min_execution_time_ms, but it adds no semantic detail beyond the 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 uses a specific verb and resource: 'Analyze top N slowest queries' and states an outcome ('identify performance bottlenecks'). It clearly communicates the tool's purpose, though it doesn't explicitly contrast with similar siblings like analyze_query or query_and_plotly_chart.

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 prefer this tool over the many diagnostic siblings present, nor any exclusions or scenario-based context. The phrase 'identify performance bottlenecks' only weakly implies a use case but does not instruct an agent when to select this vs analyze_query or top_bad_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?

With no annotations, the description must carry the full behavioral burden. It discloses that output is large and requires special processing, but it does not mention side effects, permissions, resource cost, or what the dump/profile actually 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 short and front-loaded with the main action, but the comma-spliced, ungrammatical phrasing ('it's', 'need special tools') makes it read as a rough note rather than a polished definition. It is compact but awkwardly 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?

For a tool with no annotations and no output schema, the description should explain what a 'query dump and profile' are and how an agent should handle the very large output. It does not, so an agent may not know what to do with the result or how to distinguish this from similar analysis tools.

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 fully describes both parameters ('database' and 'query to execute'), so the description adds limited parameter-level meaning. It only reinforces that the query is executed and that output is large.

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 action ('Run a query') and the resulting artifacts ('query dump and profile'), so the basic purpose is clear. It does not explicitly differentiate this from siblings like analyze_query, but 'dump and profile' gives enough distinct identity.

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 warning that output is very large and needs special tools implies the tool is intended for raw collection followed by external processing. It does not name alternatives or state when not to use it, leaving the decision partially to inference.

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 convey behavior. It mentions 'Quickly' and the use of set_session_db for default database, but does not disclose caching behavior (despite a refresh parameter), potential performance impacts, or what happens with the limit. The description provides only partial behavioral 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 only two sentences, front-loaded with the primary purpose, and efficiently mentions the related tool for setting the default database. There is zero fluff; every sentence adds value.

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

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

The tool has an output schema (not shown) and three optional parameters. The description covers the core purpose and usage context (default db). It does not mention output format or edge cases, but the presence of an output schema mitigates that need. It is complete for a quick-summary 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 fully describes all three parameters (db, limit, refresh) with clear explanations, achieving 100% coverage. The description adds no extra semantic nuance beyond what the schema provides, so the baseline 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 tool's purpose: 'Quickly get summary of a database with tables' schema and size information.' This is a specific verb-resource pair that distinguishes it from siblings like top_hot_tables or analyze_query. It explicitly mentions what it provides (schema and size info) 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 indicates when to use the tool (for a quick database summary) and references set_session_db to set a default database, which provides context for its usage. However, it does not explicitly mention when not to use it or alternatives for detailed analysis, so it lacks explicit 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?

No annotations are provided, so the description carries full burden. It states the query-then-chart flow but omits whether the operation is read-only, any side effects, or error behavior. Disclosure is minimal beyond the basic purpose.

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 two sentences and front-loads the core purpose. The second sentence about set_session_db is a useful hint but not essential to the tool's core operation; still, the overall structure is 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?

For a tool with no annotations and no output schema, the description is thin. It covers the basic flow but lacks usage alternatives, behavioral details, and what the chart output actually looks like (though format param hints at options). Adequate but not comprehensive.

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 four parameters have schema descriptions, so the description adds little beyond naming query and plotly_expr. The format parameter's full behavior is in the schema, and the description doesn't expand on any parameter semantics. Baseline 3 applies due to 100% schema coverage.

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

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

The description clearly states the tool queries the database via SQL and generates a Plotly chart for UI display. It distinguishes itself as a combined operation, though it doesn't explicitly contrast with siblings like read_query or analyze_query.

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

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

No guidance is given on when to use this tool instead of the many sibling tools. The only note about set_session_db is a peripheral tip for setting a default database, not a condition for selecting this tool.

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 supplied, so the description carries the full burden of behavior. It does disclose that the tool executes result-returning commands and can write large results to disk, which are relevant side-effects. However, it does not cover auth, rate limits, error behavior, or definitively state that non-SELECT (write) commands are unsupported, leaving some transparency 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 short and front-loaded with the core purpose. The second sentence adds practical suggestions that relate to parameter usage, but it is slightly marred by a double period and could be tightened into cleaner separate clauses.

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 4-parameter tool is fully covered by an exhaustive schema, but with no output schema or annotations, the description still leaves room for incompleteness. It does mention output file behavior but doesn't describe what inline results look like overall, pagination, response size capture, or any limitations, which an agent may need before relying on this tool.

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

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

Schema description coverage is 100%, and the description adds no meaning beyond repeating output_file's disk-write behavior. Since schema handles parameter meaning, the baseline of 3 is correct: the description overlays nothing new for the 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 starts with a clear action, 'Execute a SELECT query or commands that return a ResultSet', which specifies the resource and differentiates this tool from write_query and analysis-tool siblings. The scoping to SELECT-like commands makes its read-oriented purpose unambiguous.

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

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

The description provides clear guidance on when to use output_file (large results) and points to set_session_db for per-session defaults. It doesn't explicitly say 'use write_query for writes', but the SELECT requirement implies a read-only context, giving agents enough direction though without an explicit exclusion.

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 clearly states that it sets a per-session override, how to clear it, how fallback works, and that it returns the new effective default. It doesn't mention any hidden side effects or persistence details beyond 'THIS MCP session', but for a simple setter this is adequate and non-contradictory.

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 three sentences with no redundancy. It front-loads the primary purpose, then explains the empty/null case and the return value. Every sentence earns its place; there is no filler or over-explanation.

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 one-parameter setter with a 100% schema coverage and an output schema present, the description provides all necessary context: what it sets, when it affects, how to clear, and what it returns. Nothing an agent needs to call it correctly is missing. The presence of an output schema also means return format is documented elsewhere, so the description needn't elaborate further.

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. The description adds value beyond the schema by explicitly explaining the session-scoped effect, the consequences of passing empty/null, and the fallback to the global default. This reinforces the parameter's meaning in context and clarifies the return behavior, which the schema alone doesn't provide.

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 states a specific action (set or clear) on a specific resource (default database for THIS MCP session). It distinguishes itself from sibling query tools by focusing on session-state configuration. The phrase 'subsequent tool calls' further clarifies its role, making it unmistakable which tool this is.

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 explains the effect on future calls ('without an explicit db argument will use this database'), which implicitly tells the agent when to use it (to establish a session default) and when not (when explicit db arguments are always provided). It also covers clearing with empty/null and fallback to the server default, providing complete usage semantics. No explicit alternatives are named, but for a session-state tool that's not necessary.

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 discloses caching behavior and the ability to bypass it with 'refresh=true'. However, it does not explain what happens if the table does not exist, or whether the operation is read-only, or potential rate limits. Some behavioral aspects are missing.

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 and front-loaded with the key outputs. Two sentences cover the essential behavior and a key usage tip, with no wasted words. The cache/refresh behavior is mentioned early, and the set_session_db tip is a useful addition.

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 simplicityhe has an output schema so return structure is likely documented elsewhere. The description includes cache behavior and default database handling, which are key context. It could mention prerequisites like needing to set a session database or handling non-existent tables, but overall it is fairly complete 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%, so the schema already explains both parameters in detail. The description adds minimal extra value by implying the 'refresh' flag toggles cache usage, but it doesn't provide substantial additional 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 clearly states the tool's purpose: getting an overview of a specific table with specific outputs (columns, sample rows, total row count). It distinguishes itself from siblings by focusing on table-level overview rather than queries or analyses, and the mention of cache and refresh is a unique trait.

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

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

The description provides clear context on when to use the tool: when needing an overview of a table. It mentions using 'set_session_db' to set a default database, but does not explicitly state when not to use this tool or direct to alternatives. Still, the sibling list shows other tools for queries and analyses, so the usage is fairly 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?

No annotations are present, so the description carries the full burden of behavioral disclosure. It only says results are top bad tables by health score; it does not state ordering direction, what 'bad' means, whether filters beyond the schema are supported, or what fields are returned. Much of the behavior is left to inference.

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 filler. It states the essential selection logic without unnecessarily repeating the title or schema fields.

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 three-parameter list tool with a complete schema, the description is usable but still has gaps: no definition of health score, no explicit statement of ordering or limit behavior beyond the schema cap, and no guidance on when this tool is preferable to sibling ranking tools. Adequate but not 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?

Schema description coverage is 100%, so the input schema already documents all three parameters, including defaults, nullability, and the cap on `top_n`. The description adds little beyond echoing the health-score concept, so the baseline 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 names a specific verb ('Get'), a resource ('top bad tables'), and a selection criterion ('table health score'), which is enough to understand the core function. It does not explicitly distinguish from sibling `top_hot_tables`, but the 'bad' vs 'hot' wording and the scoring criterion give implicit differentiation.

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 when-to-use or when-not-to-use guidance is provided. With siblings like `top_hot_tables`, `table_overview`, and `analyze_slow_queries_topn`, the agent must infer when a health-score-based 'bad table' ranking is preferred. No alternatives or exclusions are named.

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 behavioral disclosurecars. It only mentions the ordering basis (audit-log visit count) and does not state whether the operation is read-only, what the return shape is, whether there are limits or pagination effects, or how the time-range parameters interact. These omissions are significant for a tool with no annotation safety hints.

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 or repetitive phrasing. It is efficient, though it is under-specified rather than economically complete, which prevents 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?

For a tool with no annotations, no output schema, and five optional parameters, the description is too sparse. It omits the return shape, default and cap behavior, time-range coupling, and any guidance on when to choose this tool over siblings. The rich input schema covers parameters, but it cannot compensate for the missing usage and 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?

Schema coverage is 100% and each parameter is individually described with defaults, filtering semantics, and constraints. The description adds only the audit-log context, but it does not need to repeat parameter details because the schema already carries that information, so the 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 states a specific verb ('Get'), a resource ('top hot tables'), and an ordering criterion ('by audit-log visit count'), making the primary purpose clear. It does not explicitly name or differentiate sibling tools like top_bad_tables, but the 'hot' versus 'bad' distinction is inferable from the descriptions and names.

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 such as top_bad_tables, analyze_slow_queries_topn, or read_query. The description only states what the tool does, leaving an agent to infer when it should be selected.

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 behavioral disclosure responsibility. It identifies that commands are DDL/DML, which implies modification, but it never mentions that these commands can change or destroy data, what is returned (only that no ResultSet), or permissions/risks involved. The description does not explain the actual behavior of the command execution beyond the SQL, leaving the agent without safety expectations.

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 brief and to the point: it states the operation and directs session-db setup to a sibling. There is no filler. The grammar is slightly informal ('do not have' instead of 'do not return') but the sentence is easy to skim.

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 absence of an output schema and annotations means the description should carry the full weight of what the tool does. It covers that the tool has no ResultSet, but it omits the return/success format, the potential damage or side effects on data, and how db interacts with the session. The tool is probably simple, but for a write/DDL tool these details are necessary for safe and correct 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?

Schema description coverage is 100% – the schema already labels query as 'SQL to execute' and db as 'database'. The description adds the pointer to set_session_db for a default database, which provides additional context. But it does not clarify whether the db parameter overrides the session default, or how the optional db and session default interact.

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 states the tool executes DDL/DML or other StarRocks commands that do not return a ResultSet, and points to set_session_db for a per-session default database. This clearly identifies the verb and resource range and implies a distinction from read_query, though the phrasing 'other StarRocks command' is a bit broad and does not explicitly name the read alternative.

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 explains that set_session_db should be used for setting a per-session default database, and implies this tool is for commands without a ResultSet. However, it does not explicitly state when to use this as opposed to read_query, nor does it give clear when-not-to-use criteria or exclusions. The usage context is only implicitly conveyed.

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