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

No annotations are provided, so the description carries the full disclosure burden. It does reveal the truncation behavior of invalid objects (first 20), but says nothing about whether the checks are read-only, their cost/latency on a live database, required privileges, or whether repeated calls are safe. For a tool that inspects sessions and wait events, that is a meaningful gap.

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

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

Front-loaded with the action and scope in one sentence, then a compact args block. The docstring-style Args section is slightly redundant in form but every line carries information, with no filler.

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 tool this is close to adequate, and the enumerated check categories give a rough sense of what comes back. However, with no output schema and no annotations, the description should have said more about the shape of the results and the operational cost of running the checks.

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

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

Schema description coverage is 0%, so the description must compensate, and it does: include_all_invalid is explained both directions (True returns all invalid objects, False limits to the first 20) plus the default. This is exactly the semantics an agent needs to set the flag correctly.

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+resource ('Perform comprehensive database health checks') and enumerates the exact check categories: tablespace usage, session status, wait events, invalid objects. That makes the purpose unambiguous and distinct from query-oriented siblings like read_query or explain_query, though it never explicitly contrasts itself with them.

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

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

There is no when-to-use guidance, no prerequisites, and no mention of alternatives. The agent must infer from the name alone that this is a diagnostic entry point rather than a data-access tool, which is exactly the kind of routing information the description should supply.

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 behavioral burden, and it discloses almost nothing: it doesn't say whether the call is read-only (implied but unstated), what the description contains, whether it fails on missing tables, or what permissions are needed. For a metadata read with zero annotation coverage this is thin.

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

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

One front-loaded sentence plus an argument line; nothing is padded or redundant. It is brief rather than verbose, though brevity here borders on under-specification.

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 one required parameter, no annotations, and no output schema, the definition is nearly adequate, but it never says what a 'description' returns (columns, types, nullability, constraints) or how failures surface. That is the one piece of context an agent needs and it is absent.

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 0%, so the description must compensate; it only restates that table_name is 'the name of the table to describe', adding no qualification, schema/catalog prefix, or case-sensitivity guidance. It identifies the parameter but adds no real meaning beyond the property name.

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?

States a specific verb (get a description) and resource (a table in the Oracle database), which is enough to separate it from list_tables and exec_ddl_sql. It does not, however, differentiate itself from the sibling get_object_details, which likely overlaps.

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 statement of when to use this versus alternatives such as list_tables (which tables exist) or get_object_details (metadata for arbitrary objects). The agent must infer the selection criteria entirely from the name.

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 for a high-risk mutation tool. It does not say that DDL is typically irreversible, whether the statement auto-commits, whether it can drop data, what privileges are required, or what the response looks like. For a destructive operation this is a substantial gap.

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

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

Two short sentences plus an args block, with the core action front-loaded and no filler. The Args section is slightly redundant given the one-parameter schema, but nothing is padded.

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

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

No annotations, no output schema, and a high-consequence DDL operation leaves the agent without risk, commit, or permission context. The parameter name mismatch against the schema compounds the incompleteness.

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

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

Schema description coverage is 0% for the single required parameter, and the description actively adds confusion: it documents the argument as 'query', while the schema requires a property named 'execsql'. It conveys only that the value is SQL to execute, with no dialect, length, or multi-statement guidance.

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 (execute) and resource class (create/drop/alter DDL against an Oracle database), which cleanly separates it from the sibling exec_dml_sql and exec_pro_sql. It does not name those siblings explicitly, so the differentiation is inferable from the tool name rather than spelled out in the text.

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?

Usage is implied by enumerating create/drop/alter, which tells an agent this is the DDL path as opposed to DML or stored procedures. There is no explicit when-to-use statement, no when-not-to-use, and no mention of prerequisites such as target schema or permissions.

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 entire behavioral burden. It never states transaction/commit behavior, whether changes are reversible, permission requirements, or what is returned (e.g. rows affected). Naming 'truncate' hints at a destructive, irreversible operation but no warning or confirmation semantics are disclosed.

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 text is short and the purpose sentence is front-loaded with no filler. The 'Args:' docstring block is boilerplate carried over from a code comment rather than agent-facing prose, a minor structural blemish.

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

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

For a destructive multi-operation write tool with no annotations and no output schema, the definition omits critical context: return value, error/rollback behavior, statement batching, and commit semantics. With one loosely documented parameter, an agent cannot confidently invoke it beyond a trivial single-statement guess.

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

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

Schema description coverage is 0%, so the description must compensate, and it instead introduces a naming inconsistency: the docstring calls the argument 'query' while the schema's required property is 'execsql'. This mismatch can actively mislead an agent building the call, though the phrase 'the sql to execute' does convey the intended payload.

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 ('Execute') and enumerates the exact resource operations (insert/update/delete/truncate) against an Oracle database, which is far more specific than a bare 'run SQL'. It does not, however, explicitly distinguish itself from the neighboring exec_ddl_sql, exec_pro_sql, or read_query tools, leaving the agent to infer the boundary from the operation list.

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

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

There is no guidance on when to choose this tool over exec_ddl_sql, exec_pro_sql, or read_query, and no exclusions or prerequisites stated. The agent must guess whether this accepts a single statement or a batch, and whether DDL mixed with DML is permitted.

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

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

No annotations are provided, so the description carries the full burden. It implies arbitrary code execution but discloses nothing about permissions required, transaction/commit behavior, side effects, or error handling — critical omissions for a tool that runs stored procedures and anonymous blocks.

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?

Front-loaded with the capability statement followed by a compact Args block; appropriately sized with no padding. The Args restatement is slightly redundant with the schema but harmless.

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 an arbitrary-code-execution tool with no annotations and no output schema, the description should at minimum cover execution context, permissions, and response/error shape. None of that is present, leaving significant gaps for an agent to call it safely.

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

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

Schema description coverage is 0%, so the description must compensate, but it only restates the parameter as 'the PL/SQL code block to execute'. It adds the useful hint that the input is PL/SQL rather than plain SQL, but gives no format, size, or delimiter guidance.

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?

States a specific verb ('Execute') and resource scope ('PL/SQL code blocks including stored procedures, functions and anonymous blocks'), which is more informative than a bare name restatement. However, it never distinguishes itself from siblings like exec_dml_sql, exec_ddl_sql, or read_query, which sit in the same execution family.

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 when-to-use guidance, no exclusions, and no mention of the alternative exec_dml_sql/exec_ddl_sql tools. An agent must guess when a stored procedure call belongs here versus in the sibling executors.

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 behavioral burden and falls short: it doesn't say whether the query is actually executed (a key distinction for EXPLAIN variants), whether it is read-only, or what permissions are required. Only the bare operation is stated.

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 one-line purpose is front-loaded and concise, but the 'Args:' block is boilerplate that duplicates the schema without adding information. Short overall, though the second half earns little.

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

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

No annotations, no output schema, and 0% parameter coverage leave the agent without guidance on execution side effects, required permissions, or the shape of the returned plan. For a diagnostic tool with a potentially expensive operation, this is a significant gap.

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

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

Schema description coverage is 0% and the single parameter is undocumented in the schema, so the description must compensate—but 'The SQL query to explain' merely restates the parameter name and type. No detail on whether multiple statements, parameters, or DDL/DML queries are accepted.

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?

States a specific verb+resource: 'Get the execution plan for a SQL query'. An agent can tell it apart from read_query (which runs queries) at a conceptual level, though the description never names a sibling or scope boundary explicitly.

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 indication of when to use this versus read_query, get_top_queries, or describe_table, and no mention of prerequisites such as needing an existing schema or permissions. The agent must infer usage entirely 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?

No annotations are provided, so the description carries the full behavioral burden. It does not state that this is a read-only operation, what kind of details are returned, whether permissions are required, or what happens for invalid object types. Only the parameter list is included, adding minimal behavioral context.

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

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

The description is short, front-loaded, and structured with a clear Args section. Every line earns its place with no redundancy or filler.

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 annotations, no output schema, and 0% schema description coverage, the description should do more. It omits what 'detailed information' includes, whether it is a read-only operation, and when to prefer it over siblings like describe_table. It covers parameters but leaves significant gaps.

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

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

Schema description coverage is 0%, so the description must compensate. It documents both parameters and usefully lists possible object_type values (TABLE, VIEW, SEQUENCE) and the default (TABLE), which the schema does not provide. However, object_name is only described as 'the name of the object' with no format or qualification details.

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

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

The description states a specific verb ('Get') and resource ('detailed information about a database object'), making the core purpose clear. However, it does not differentiate this tool from siblings like describe_table or list_objects, so it falls short of a 5.

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

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

The description provides no guidance on when to use this tool versus alternatives such as describe_table, list_objects, or explain_query. It only documents the arguments, leaving the agent to infer usage from the name alone.

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

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

No annotations are provided, so the description carries the full burden. It discloses only the ordering metric (elapsed time) but says nothing about the time window the measurements cover, permissions required, whether the query is cheap or expensive to run, or the shape of the 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?

The purpose sentence is front-loaded and tight, and the Args block is minimal. The docstring scaffolding ('Args:') is slightly heavy for a single optional parameter but costs little space.

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 annotations, the description is the only source of behavioral detail, and it omits what the returned rows contain and over what period 'elapsed time' is measured. Adequate for the minimal parameter surface but leaves real gaps for an agent interpreting results.

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

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

Schema description coverage is 0%, but there is only one parameter and the description explains it fully: 'limit (int, optional): Number of queries to return. Default is 10'. It adds the optionality and restates the default, though the schema already encodes type and default.

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?

States a specific verb ('Get') and resource ('slowest queries') plus the ranking criterion ('based on elapsed time'), so the agent knows it returns a ranked list. It does not, however, distinguish itself from siblings like explain_query or analyze_db_health that also touch query performance.

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 when-to-use guidance, no prerequisites, and no mention of alternatives such as explain_query for drilling into a specific slow query. The agent must infer the use case from the name alone.

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

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

No annotations are provided, so the description carries the burden. It does disclose a useful operational detail (default limit of 100), but it says nothing about permission requirements, result ordering, pagination, or what happens when the limit is exceeded — real gaps for a listing tool with zero annotation coverage.

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

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

Front-loaded with the one-line purpose, then a clean Args block; every sentence earns its place. The triple-quoted docstring formatting is slightly noisy but not wasteful.

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, the description could reasonably say what a returned object looks like (name/type/schema), but it stops at the input contract. For a simple zero-required-parameter read tool this is borderline adequate, not rich.

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

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

Schema description coverage is 0%, so the description must compensate, and it largely does: all three parameters get meaning beyond their names, including the fallback behavior for schema_name, the filterable type values for object_type, and the default value for limit. It stops short of 5 because the accepted object_type strings differ from the enum absent from the schema, but they are at least enumerated here.

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?

States a specific verb and resource ('List database objects') and enumerates the object kinds covered, which lets an agent distinguish it from exec_* and describe_table siblings. It does not explicitly differentiate itself from the near-identical sibling list_tables, keeping it short of a 5.

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

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

Gives implied usage through the default behavior ('if not provided, lists objects from current user's schema') and the filtering semantics of object_type. However, it never states when to prefer this over list_tables, list_schemas, or get_object_details, leaving the routing decision 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?

No annotations are provided, so the description carries the full burden. It implies a read but never states it is non-destructive, nor does it describe the return shape, ordering, or whether the result can be large. For a zero-annotation tool this is a real gap.

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

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

The core sentence is front-loaded and efficient, but the trailing 'Args: None' block is boilerplate that restates the empty schema and earns no space. Slightly padded for a one-sentence tool.

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

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

For a simple, no-param listing tool with no output schema, the description is minimally adequate. It should still say something about the return (e.g., list of schema names) since there is no output schema to fall back on.

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

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

The tool takes no parameters, so there is nothing to document beyond confirming that, which the 'Args: None' line does. Baseline 4 applies for a zero-parameter tool.

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?

States a specific verb (Get/list) and resource (schemas in the oracle database), so the agent knows exactly what is returned. It does not, however, differentiate itself from siblings like list_tables or list_objects, which an agent could plausibly confuse for schema enumeration.

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 guidance, no prerequisites, and no mention of alternatives. The agent gets no signal about whether this is the right tool versus list_objects or get_object_details.

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 behavioral burden, but it only covers pagination defaults and pattern case-insensitivity. It says nothing about read-only guarantees, ordering of results, whether system/schema tables are included, permission requirements, or how large result sets behave.

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 purpose is front-loaded in a single clear sentence, followed by a compact Args block. The structure is efficient and easy to scan, with little wasted language.

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 list tool with no output schema, the essentials are present, but the agent still lacks context on what a returned table entry contains, whether results are scoped to a schema/owner, and result ordering. Adequate but with clear gaps.

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

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

Schema description coverage is 0%, so the description must compensate, and it does: all three parameters are documented with meaning, optionality, and defaults (pattern is a case-insensitive name filter, limit defaults to 50, offset defaults to 0). Only minor gaps remain, such as any upper bound on limit or the pattern matching syntax.

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 and resource ('Get a list of all tables in the oracle database') plus scope modifiers (filtering/pagination), so the agent knows exactly what the tool returns. It does not, however, distinguish itself from close siblings like list_schemas or list_objects, which also enumerate database entities.

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 versus list_objects, list_schemas, or describe_table. Usage is only implied by the tool name and the word 'tables'; no prerequisites, exclusions, or alternative-routing advice is 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?

With no annotations provided, the description carries the full behavioral burden. It discloses that the tool is for SELECT-only reading and that max_rows defaults to 100, but it omits permissions requirements, read-only enforcement details, transaction behavior, and error handling.

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

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

The description is front-loaded with the core action and then uses a compact Args section for parameters. It is appropriately sized and has no filler, though the Args block slightly duplicates the schema structure.

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

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

The tool has no annotations, no output schema, and 0% schema description coverage, so the description must be complete enough on its own. It leaves return format, SQL dialect, read-only enforcement, permissions, and error behavior unspecified, which is a significant gap for a database query 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 0%, so the description must compensate, and it does document both parameters: query as the SELECT query to execute and max_rows as an optional row limit with default 100. The semantics are shallow, however, with no SQL dialect, format, or constraint details beyond what the schema already implies.

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 (Execute) and resource (SELECT queries against the oracle database), and the word SELECT implicitly distinguishes it from siblings like exec_dml_sql and exec_ddl_sql. It stops short of naming alternatives explicitly, so it is clear but lacks full sibling 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?

Usage is implied by the phrase 'Execute SELECT queries to read data', which tells an agent this is for read-only querying. However, there is no explicit when-to-use guidance, no exclusions, and no mention of sibling tools such as get_top_queries or explain_query.

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