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 restates the create action and parameter labels, without explaining persistence, duplicate-name behavior, permissions, or what happens if work_group is omitted. The verb implies mutation but adds no useful context beyond it.

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 with the action, and the Args list is scannable. However, the parameter list largely duplicates information already present in the schema, so some of it is redundant rather than informative.

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 creation tool with three required parameters, no annotations, and no schema descriptions, this description is incomplete. It does not explain where the named query is stored, whether creating a duplicate name overwrites or fails, or what work_group/database values are valid. The presence of an output schema covers return values, but not these important operational details.

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

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

Schema description coverage is 0%, so the description must compensate. It lists all five parameters, but most entries merely paraphrase the schema titles ('name: Name of the query', 'database: Database for the query'). Only 'query_string: SQL query string' adds substantive meaning. No constraints, formats, or dependencies are described.

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 opening line 'Create a named query' specifies the exact verb and resource, making the tool's core action immediately clear. This also distinguishes it from sibling tools like list_named_queries, get_named_query, and delete_named_query, which use different verbs.

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 such as start_query_execution or list_named_queries. It also fails to mention prerequisites, like whether the database or work_group must already exist.

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 disclosing behavior. It only says 'Delete' without noting irreversibility, potential side effects on dependent resources, permissions required, or error conditions. This is thin for a destructive 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 compact and front-loaded with the action. The Args block is somewhat redundant with the schema but is not padded or verbose, so this is an appropriately concise definition for a simple one-parameter 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 destructive tool with no annotations, the description is too sparse. It lacks behavioral caveats, provenance of named_query_id, and any sense of what happens on success or failure. The output schema exists but is not included, so it does not compensate for the missing behavioral context.

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

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

Schema description coverage is 0%, and the description merely restates the parameter name as 'Named query ID', duplicating the schema title. It does not explain the format of the ID, how to find it, or any constraints 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 ('Delete') and resource ('named query'), making the tool's purpose immediately clear. It is distinguishable from sibling tools like get_named_query, create_named_query, and list_named_queries, though it does not explicitly contrast 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 guidance about when to use this tool versus alternatives, no prerequisites, and no mention of how to obtain the named_query_id. The only implicit context comes from the tool name and sibling list, which is not enough.

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 disclosure, but it only says 'Get details'. It does not state whether the call can fail on unknown IDs, what subset of fields is returned, whether any special permissions are required, or any other runtime behavior beyond the read-only implication.

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 no unnecessary fluff. The Args section is somewhat redundant with the schema, but it does not detract significantly from readability.

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 get-by-id tool, the description is minimally functional but incomplete. The presence of an output schema reduces the need to explain return fields, yet the lack of usage guidance, error behavior, and relationship to sibling tools like list_named_queries makes the context incomplete for an agent choosing among many Athena-related 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 description includes an Args section clarifying that named_query_id is the named query ID, which is minimally helpful. However, schema description coverage is 0%, and the description simply repeats what the schema title already conveys rather than adding context such as where the ID comes from or its format.

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 resource ('named query'), making the core action clear. However, it does not explicitly contrast with the sibling list_named_queries or indicate that this retrieves a single item by ID, so sibling differentiation is weak.

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 about when to use this tool instead of list_named_queries, get_query_execution, or other related siblings. There is no mention of typical workflows or how an agent should obtain a valid named_query_id.

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 only implies a read operation and does not disclose error conditions, required execution state, or whether result rows are excluded. The output schema covers return shape, not these behavioral aspects.

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 compact and front-loaded, with the main action in the first sentence and a short Args section afterward. No unnecessary detail is included, even though the Args line is somewhat redundant with the schema.

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

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

The output schema reduces the need to describe return values, but the description still lacks routing context among the many siblings. In particular, it does not clarify how get_query_execution differs from get_query_results or list_query_executions, so an agent could select the wrong 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 Args line says query_execution_id is a query execution ID, which largely restates the schema property title 'Query Execution Id.' With 0% schema description coverage, the description needed to provide more useful context, such as where the ID comes from or how to obtain it, but it does not.

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 clear verb and resource: 'Get details about a query execution.' It is not a tautology and identifies the operation. However, 'details' is broad and the description does not distinguish this from get_query_results or list_query_executions.

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

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

No guidance is given for when to use this tool versus alternatives. The description does not name sibling tools or state exclusions, leaving an agent to infer the right choice 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?

With no annotations, the description carries the behavioral burden. 'Get' signals read-only and 'completed query' gives a prerequisite, while next_token/max_results hint at pagination. However, it omits what happens with failed or cancelled queries, any limits on max_results, and the actual pagination mechanics.

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 purpose sentence followed by a compact, scannable parameter list. No words are wasted, and the key action 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?

The output schema covers return values, so that omission is acceptable. However, for a tool with no annotations, the description leaves important operational context unstated: the query must have succeeded (not merely 'completed'), and next_token should likely be looped until null. It is minimally viable 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 parameter descriptions must compensate. max_results and next_token get brief purpose statements, but query_execution_id is a near-tautology and no constraints, defaults, or pagination relationships are explained. This only partially compensates for the empty 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 names a concrete verb ('Get') and resource ('results from a completed query'), which clearly distinguishes it from status-oriented siblings like get_query_execution. It doesn't explicitly name an alternative, so it falls slightly 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?

'From a completed query' implies the tool should be used after query execution finishes, which is useful but implicit. It does not explicitly say when to use this tool versus get_query_execution or start_query_execution, nor does it tell the agent to verify query success first.

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

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

No annotations are present, so the description must carry the behavioral disclosure burden. It only says 'Get metadata,' which implies a read operation, but it does not state read-only behavior, required permissions, error conditions, catalog resolution, or what metadata is returned. The description is not misleading but is shallow on behavioral detail.

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

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

The description is short and front-loads the main purpose in the first line. However, the Args list duplicates information already present in the input schema and does not earn its place by explaining semantics or usage. The text is concise but not optimally structured because the redundant parameter block displaces space that could have been used for behavioral or usage guidance.

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?

Although an output schema exists and reduces the need to document return values, the tool has no annotations, no usage routing, and no behavioral context. For a metadata lookup over a catalog/database/table hierarchy, the description should at least mention the catalog default or relation to list_tables and list_data_catalogs. It is minimally viable but not complete enough for an agent to know the correct invocation context.

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

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

Schema description coverage is 0%, so the description must compensate, but the Args block only provides 'Name of the database/table/data catalog,' which essentially repeats the schema titles and property names. It adds no insight into the hierarchy between catalog, database, and table, nor does it mention that catalog_name defaults to AwsDataCatalog. The parameter documentation is minimal and only slightly more helpful than the schema alone.

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 first sentence states a specific verb and resource: 'Get metadata for a specific table.' It is clear and distinguishable from sibling list_tables, which enumerate tables rather than retrieve metadata for one table. However, it does not explicitly contrast itself with any sibling, so it stops short of full 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 guidance is provided about when to use this tool versus alternatives such as list_tables or get_work_group. The Args section only lists parameter names and does not mention prerequisites, typical call flow, or exclusions. The phrase 'specific table' hints at a use case but does not give actionable routing guidance.

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

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

With no annotations, the description carries the behavioral burden. 'Get details' clearly signals a read-only retrieval operation, but the description does not disclose error behavior, authorization needs, or what happens when the work group does not exist. It is not misleading, but it 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?

The description is short and the main action is front-loaded. The Args block duplicates schema information, but it is not bloated and the overall structure is easy to scan.

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 single-parameter getter with an output schema, the description is not fatally incomplete. However, it leaves out usage context relative to list_work_groups and does not clarify parameter semantics, so an agent has to do more inference than ideal.

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 needed to clarify the parameter. 'Work group name' mostly repeats the schema title and parameter name without adding a format, example, or source of valid values. It provides minimal meaning beyond the input 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 states a clear verb ('Get') and resource ('a work group'), and 'details' implies a single-item fetch, which distinguishes it from the sibling list_work_groups. However, it does not specify what 'details' means, so it stops short of being fully specific.

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

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

There is no guidance about when to use this tool instead of list_work_groups or any other sibling. The agent must infer the usage from the tool name and the minimal description, with no conditions, alternatives, or selection criteria.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It only restates the operation and parameter meanings; it does not mention that this is a read-only listing, how pagination behaves across calls, or any catalog prerequisites. The added behavioral context is minimal.

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

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

The description is compact and front-loaded with a clear one-line purpose followed by a concise arg list. Every element serves a purpose 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 simple listing operation with an output schema present, the essential invocation details are covered. It could add context about pagination interaction or explicitly confirm read-only behavior, but the current definition is sufficient for basic 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 0%, but the description compensates by defining all three parameters: catalog_name, max_results, and next_token. This adds meaningful semantics beyond the schema's titles and defaults.

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

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

Description states exactly what the tool does: lists databases in a data catalog. The resource differs clearly from sibling tools like list_tables, list_work_groups, and list_data_catalogs, so an agent can distinguish it without opening the 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?

Usage is implied rather than explicit: the description suggests using this tool when databases within a data catalog are needed. It does not name alternatives, exclusion conditions, or when pagination becomes necessary, leaving some inference to the agent.

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 'List data catalogs', which implies a read-only operation but does not explicitly state side effects, authorization needs, pagination behavior beyond parameter names, or any other behavioral traits. The output schema covers return shape, but the description itself is extremely 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?

The description is short, front-loaded with the core purpose, and contains no fluff. The Args section is helpful because the schema lacks descriptions. It could be more structurally integrated, but it is appropriately 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?

The tool is simple, has zero required parameters, and an output schema exists, so the description does not need to explain return values. However, it lacks usage context, differentiation from sibling list tools, and any explicit note about pagination behavior beyond the parameter names. It is minimally adequate but leaves gaps for an agent.

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

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

The schema has no descriptions for parameters, so the description is the only source of parameter semantics. It provides useful meanings for both parameters: 'Maximum number of results to return' and 'Token for pagination'. This is minimal but sufficient for the two simple optional 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 states a clear verb and resource: 'List data catalogs'. It is easily understood and distinguishes the operation from sibling tools that target other resources like databases, tables, or work groups. However, it essentially restates the tool name and does not add any scoping or differentiating detail.

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 list_databases or list_tables. The description provides no context about what a data catalog is, when pagination is needed, or when a sibling tool 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?

No annotations are provided, so the description carries the full burden of behavioral disclosure. It hints at pagination through 'Token for pagination', but it never states that this is a read-only listing, how pagination works, whether results are ordered, or how the response should be consumed. For a tool with no annotation coverage, the behavioral details are too 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?

The description is tight and front-loaded: the operation statement appears first, followed by a minimal, focused Args block. There is no filler, repetition, or unnecessary detail; every line earns its place.

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

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

The operation is simple, all parameters are covered, and an output schema exists, so the return shape does not need to be explained. However, the description lacks context about what named queries are, how they relate to work groups, and when to choose this tool over sibling tools. It is minimally viable but not richly 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 0%, but the description compensates by giving a functional gloss for every parameter: work_group filters, max_results caps the returned count, and next_token handles pagination. These add meaning beyond the bare schema titles and types, though they remain brief and do not specify ranges, defaults behavior, or the source of next_token.

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 opens with 'List named queries', a clear verb+resource statement that tells the agent exactly what operation this is. It differentiates from sibling list tools like list_work_groups, list_tables, and list_query_executions by naming the resource, though it adds no context beyond what the tool name itself already communicates.

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 about when to use this tool instead of related siblings such as get_named_query, create_named_query, or list_query_executions. There are no exclusions, prerequisites, or selection criteria. The only content is the operation statement and terse parameter glosses.

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 carries the full burden. It reveals only that results are recent and paginated via next_token, but not ordering, what 'recent' means, whether work_group filters or is required, or any side-effect/read-only disclosure. This is somewhat more than the name alone but still minimal.

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

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

The description is compact and front-loaded: a one-sentence purpose followed by a terse Args listing. There is no filler or repetition of schema titles, though the Arg entries could have been integrated with usage guidance for higher 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?

For a simple list tool with an output schema and three optional parameters, the description is minimally adequate: it names the resource and covers all parameters. It still omits pagination mechanics, ordering, and the meaning of omitting work_group or max_results, leaving some ambiguity for an agent deciding how to call it repeatedly.

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 Args section compensates by giving a one-line meaning for each parameter: work_group filters, max_results limits count, next_token handles pagination. This is useful but shallow; it does not document constraints, defaults, or behavior when parameters are omitted, so it only partially compensates for the schema gap.

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 ('List recent query executions') and is clearly distinct from sibling tools such as get_query_execution and list_named_queries. However, it does not explicitly differentiate its scope from closely related get/start tools, and 'recent' is not defined.

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 about when to use this tool versus alternatives like get_query_execution or get_query_results; there are no exclusions, prerequisites, or alternative tool mentions. The intended use is only implied by the verb '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 provided, the description carries the behavioral transparency burden. The verb 'List' implies a read-only operation, and the mention of 'Token for pagination' hints at pagination behavior. However, it does not explicitly state that the operation has no side effects, or describe any permission or failure characteristics.

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 purpose sentence followed by a clean, well-organized Args list. Every line adds information without redundancy or filler. The purpose is front-loaded, and the parameter explanations are easy to scan.

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

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

For a read-style listing tool with an output schema present, the description is largely sufficient: it states the purpose, lists all five parameters, and includes pagination-related parameters. It could be more complete with explicit usage context, but nothing essential for invoking the tool is 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?

Since schema description coverage is 0%, the description compensates by defining every parameter: database_name, catalog_name, expression, max_results, and next_token. Each definition adds meaning beyond the bare schema titles, though it stays at a surface level without deeper constraints or usage notes.

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: 'List tables in a database.' This clearly identifies the operation and distinguishes it from sibling tools like list_databases and get_table_metadata. No ambiguity about what the tool does.

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

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

The description provides no guidance on when to use this tool versus alternatives, such as list_databases for databases or get_table_metadata for a single table. It only states the basic action, leaving the agent to infer usage from the tool name and parameters.

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 for behavioral disclosure. It only says 'List all Athena work groups' and does not mention pagination behavior, result ordering, response contents, or whether any permissions are required. The pagination arguments are present but their behavioral implications are not described.

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, followed by a compact Args section. Every sentence earns its place, and 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?

For a simple list operation with two optional parameters and an output schema, the definition is nearly complete: purpose and parameters are covered. It loses one point because it lacks explicit guidance on when to use this vs. get_work_group and does not describe pagination behavior beyond the token parameter.

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

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

The schema has 0% coverage, but the description's Args section explains max_results as 'Maximum number of results to return' and next_token as 'Token for pagination,' adding meaning the schema itself lacks. This is minimal but sufficient for these two straightforward optional 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 states a specific verb ('List') and resource ('all Athena work groups'), making the tool's purpose immediately clear. It also distinguishes itself from sibling tools like get_work_group, which targets a single workgroup, and list_databases/list_tables, which target different Athena resources.

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 context is implied rather than explicit: 'List all Athena work groups' suggests this is for enumerating workgroups, and the sibling get_work_group implies the alternative for fetching a single workgroup. However, the description does not explicitly state when to choose this over related tools or mention any prerequisites or exclusions.

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

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

With no annotations provided, the description carries the full transparency burden. It only says 'execute' and does not disclose that Athena query execution is asynchronous, that the tool likely returns a query execution ID, or that subsequent polling/retrieval is required.

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 a clear action sentence. The Args list is organized, though it largely duplicates schema information, which slightly reduces its 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?

For an operation that starts an async Athena query, the description omits essential context: it does not mention that results are not returned directly, that callers should use get_query_results or get_query_execution to monitor status, or that work_group and output_location can affect execution.

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

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

The schema has 0% description coverage, so the description must compensate, but the Args list merely restates the parameter names with generic phrases like 'Database to run query in' and 'S3 location for query results.' It adds no meaningful detail about defaults, optionality, or parameter interactions.

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 core action: 'Execute a SQL query in Athena.' This is a specific verb and resource that distinguishes it from siblings like get_query_execution and stop_query_execution, though it does not explicitly contrast 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 guidance on when to use this tool versus alternatives such as get_query_execution, get_query_results, or create_named_query. The usage is only implied by the verb 'execute,' and no workflow or precedence information 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?

There are no annotations, so the description carries the full burden of behavioral disclosure. It says only that the query execution is stopped, but does not disclose whether this is irreversible, what state the query transitions to, whether already-completed queries can be stopped, or what side effects occur. For a cancellation tool, this is a significant gap.

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

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

The description is very short and front-loads the core purpose in the first sentence. The separate Args block is somewhat redundant with the input schema, but the overall structure is clean and does not contain unnecessary 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 tool with no annotations and only a single sentence, the description is too thin to be complete. It fails to explain important operational details such as whether the query must currently be running, what happens if it has already finished, and how to discover valid query_execution_id values from sibling 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?

Schema description coverage is 0%, so the description must compensate for the undocumented parameter. It merely echoes the schema property title by saying 'query_execution_id: Query execution ID' and adds no new meaning about how to obtain the ID, its format, or its relationship to sibling tools.

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

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

The description states a specific action and resource: 'Stop a running query execution.' This is a clear verb+resource pairing and is distinct from siblings like start_query_execution and get_query_execution, so an agent can identify the tool's role without ambiguity.

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

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

The phrase 'a running query execution' implies this tool is for cancelling queries that are currently in progress, which provides minimal context for when to use it. However, it does not explicitly mention when not to use it or point to alternatives like get_query_execution for checking status, so usage 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.