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

The description usefully surfaces that destructive actions are gated behind confirm=True, which is context beyond the bare confirm:boolean parameter. However, it doesn't resolve the tension with destructiveHint=false (the destructiveness comes from action_sql, not the tool) and says nothing about the alert's initial state after creation or required privileges. Annotations already carry the read/write and idempotency profile, so this is a modest add.

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 compact sentences with zero filler, and the core purpose is front-loaded ahead of the safety note. Brevity is appropriate for the size, though it comes at the cost of the missing semantics rather than through efficient compression.

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?

Placeholder.

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 only 44%, so the description must compensate, and it doesn't. It names schedule/condition_sql/action_sql but never explains that condition_sql is the evaluated query and action_sql the payload that runs, nor what comment, database, schema_name, or warehouse_name mean in context. 'Destructive actions require confirm=True' gives partial meaning to one of the nine 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?

States a specific verb and resource ('Create an alert') plus the three defining components (schedule, condition SQL, action SQL), which clearly separates it from siblings like alerts_describe_alert, alerts_list_alerts, and alerts_drop_alert. It doesn't explicitly name those siblings, so it stops 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?

No guidance on when to create vs. use an existing alert, no prerequisites (warehouse running, schema/database context, role privileges), and no mention of what state the new alert lands in. The only procedural note is the confirm=True gate for destructive actions.

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?

Annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false, so the safety profile is fully covered. The description adds only a list of returned attributes, which duplicates what the output schema already provides, and says nothing about behavior on a missing alert or cross-database resolution.

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 or redundancy. It is efficient but so terse that the enumeration of return fields is the only content, leaving no room for routing or prerequisite information.

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

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

For a read-only describe tool with an output schema, full schema coverage, and complete annotations, the definition is minimally sufficient. It does not cover name resolution across database/schema or failure modes, which an agent would need for the optional qualification parameters.

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%, with each of database, schema_name, and alert_name carrying quoting/casing guidance, so the baseline is 3. The description contributes no additional parameter meaning (e.g., whether alert_name alone is sufficient or must be qualified).

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 ("Describe") plus the resource (alert) and enumerates exactly what is retrieved: condition SQL, action SQL, schedule, and warehouse. That clearly separates it from alerts_list_alerts and the mutation siblings (create/drop/resume/suspend), though it never names those alternatives.

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

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

There is no statement of when to call this versus alerts_list_alerts or how to obtain a valid alert name first. Usage is only inferable from the verb "Describe"; no exclusions or prerequisites are given.

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

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

Annotations already declare destructiveHint=true, idempotentHint=false, and openWorldHint=true, so the safety profile is covered. The description adds the useful behavioral requirement that confirmation is needed, but does not say whether the drop is irreversible, whether confirm=false causes an error or a no-op, or what dependent objects (schedules/notifications) are removed.

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, front-loaded with the action and scope, with the confirmation requirement immediately following. No filler or redundancy.

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?

An output schema and rich annotations (destructive/not-idempotent) carry most of the load, and the description signals confirmation. But for a destructive DDL operation it omits the confirmation mechanics (does confirm=false fail or skip?) and irreversible consequences, which an agent needs before invoking.

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 75%; the schema documents database, alert_name, and schema_name quoting behavior. The only undocumented parameter is confirm, which the description gestures at ('Requires confirmation') without stating that it must be true to succeed, so the description adds limited value over the schema.

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

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

States a specific verb and resource ('Drop an alert in Snowflake'), which unambiguously distinguishes it from siblings like alerts_list_alerts, alerts_describe_alert, and alerts_create_alert. It does not explicitly name a sibling, but the drop/delete intent is unmistakable from the name and 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?

'Requires confirmation' implies the tool should be called with confirm set, which is a usage hint. However, it never states when to prefer dropping over suspending the alert (alerts_suspend_alert exists as a non-destructive alternative) or what prerequisites exist, leaving the agent to infer.

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?

Annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false, so the safety profile is covered structurally. The description adds that returned rows include condition queries, schedules, and state, but says nothing about pagination, result limits, or filter interaction—modest value beyond the annotations.

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

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

The first sentence is efficient and front-loaded. The second sentence spends its length describing quoted_name and quoted_qualified_name, which are return-value details already covered by the existing output schema—space that would have been better used on the undocumented 'pattern' parameter.

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?

Because an output schema exists, the row-shape explanation is largely redundant, and the description omits the things the schema cannot convey: how 'pattern' matches, whether filters combine with AND, and any paging behavior. Adequate for a simple read tool 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 67%: database and schema_name carry descriptions (about quoting), while the 'pattern' parameter is documented nowhere. The description does not compensate—it never mentions filtering by name pattern at all, so the most consequential parameter remains ambiguous.

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 configured alerts') and enumerates what each row carries (condition queries, schedules, state), so an agent knows this is the read-side counterpart to alerts_describe_alert. It does not explicitly name a sibling or exclusion, which keeps it at 4 rather than 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?

There is no guidance on when to use this versus alerts_describe_alert, no note that all three parameters are optional filters, and no statement of what happens when no filters are supplied. The agent must infer usage entirely from the verb.

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?

Annotations already declare a non-read-only, idempotent, non-destructive, open-world mutation. The description adds nothing beyond that: no statement about what resuming does to the alert's schedule/state, what permissions are needed, or whether it errors on an already-active alert.

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 short sentence with no waste, but it is underspecified rather than efficiently complete – nothing is front-loaded beyond the basic operation.

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

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

For a state-changing tool that acts on a specific alert within an optional database/schema, an agent would want to know the precondition (alert suspended) and effect. Output schema and annotations exist, but the description leaves the behavioral contract essentially empty.

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 all three parameters (alert_name, database, schema_name) are documented in the schema, and the baseline applies. The description does not add naming/quoting or scoping semantics beyond what the schema already says.

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 ('Resume ... alert'), which is unambiguous about the operation. It does not differentiate from the complementary sibling alerts_suspend_alert or explain how resuming relates to alert state.

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

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

No guidance on when to use this versus alternatives, no indication that the alert must currently be suspended, and no mention of any prerequisite or follow-up step.

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?

Annotations already declare that this is a non-read-only, idempotent, non-destructive operation with open-world behavior. The description adds the precondition that the alert must be active, which is useful context, but does not explain effects on alert scheduling, reversibility, or required permissions.

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

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

The description is a single, front-loaded sentence with no wasted words. It is efficient, though its brevity borders on under-specification for a mutation 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?

With an output schema and rich annotations, the description does not need to explain return values or safety. However, it leaves gaps around behavioral effects and alternatives that would help an agent use the tool correctly in context.

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

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

Schema coverage is 100%, so all three parameters (database, alert_name, schema_name) are fully documented in the schema. The description provides no additional parameter details, which is acceptable given the high coverage but does not add value.

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

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

The description states a specific verb ('Suspend') and resource ('an active alert'), making the operation clear. It does not explicitly distinguish itself from siblings like alerts_resume_alert or alerts_drop_alert, though the verb itself helps.

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 resuming or dropping an alert, nor any prerequisites beyond the implied 'active' state. The agent must 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?

Annotations already declare this as a read-only, idempotent, non-destructive, open-world operation. The description adds a summary of the returned attributes, but does not disclose errors, permissions, or other behavioral details beyond the annotated safety profile.

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

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

The description is a single front-loaded sentence with no wasted words. It immediately states the action and the information returned.

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

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

For a simple single-resource describe tool with rich annotations, a complete input schema, and an output schema, the description is nearly complete. Its main gap is the lack of explicit routing guidance relative to list_compute_pools.

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 schema documents the pool_name quoting requirement. The description adds no parameter meaning beyond what the schema already provides, so it meets the baseline for high 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 states a specific verb and resource: describe a compute pool. It also lists the fields revealed, which makes the purpose clear, but it does not explicitly distinguish this from list_compute_pools or describe siblings.

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

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

There is no explicit guidance on when to use this tool versus list_compute_pools or other compute-service tools. The purpose implies usage, but no conditions, alternatives, or prerequisites are stated.

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

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

Annotations already declare readOnly, idempotent, non-destructive, open-world behavior, so the safety profile is covered. The description usefully enumerates the returned attributes, but adds nothing about permissions needed, error behavior for missing Streamlit objects, or visibility scoping.

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 tight sentence that front-loads the verb and the key return attributes with zero filler. Nothing wasted and nothing ambiguous in 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?

An output schema exists and annotations cover the safety profile, so the description needn't explain return formatting. It names the three described attributes, which is sufficient for this simple read tool; minor gaps (error/not-found behavior) keep it from a 5.

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%, including the anyOf/default handling for database and schema_name, so the baseline of 3 applies. The description does not mention the parameters at all, adding no meaning beyond the schema's naming and quoting 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 (describe) and resource (Streamlit application) plus the exact fields returned: root location, stage, and query warehouse. It is clear what the tool does, though it does not explicitly contrast itself with siblings like compute_services_list_streamlits.

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 'describe' naming and the list/describe pair in siblings, but the description never states when to use this versus compute_services_list_streamlits or what prerequisites exist. Adequate but leaves selection 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?

Annotations already declare readOnly, idempotent, and non-destructive, so the safety profile is fully covered. The description adds that each row carries quoted_name and quoted_qualified_name, but this duplicates what the output schema presumably documents, so the extra value is modest.

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 with no filler, and the core purpose is front-loaded. The second sentence is slightly misplaced since it describes return fields already covered by the output 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?

With an output schema present, the description needn't explain return values, so its second sentence is redundant. The critical gap is the unexplained 'pattern' parameter, which is documented nowhere else.

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

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

The single parameter 'pattern' has 0% schema description coverage, so the description must carry its meaning — yet it never mentions pattern at all. An agent cannot tell whether it is a SQL LIKE pattern, a regex, or a name filter.

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: lists SPCS compute pools. The scope is clear, though sibling differentiation (e.g., vs. compute_services_describe_compute_pool) is only implied by the 'list' verb and not stated 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 guidance on when to use this versus compute_services_describe_compute_pool or how to filter results. The agent must infer that this is the enumeration call and that describe is for 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?

The annotations already declare readOnlyHint=true, idempotentHint=true, destructiveHint=false, and openWorldHint=true, so the safety profile is covered. The description adds a note about output columns (quoted_name, quoted_qualified_name) and quoting rules, which is helpful context. However, because an output schema exists, this note largely repeats return-value information, and the description still omits scope, pagination, and ordering behavior.

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

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

The description is two short sentences with no filler, and the core purpose is front-loaded. The second sentence about quoted names is somewhat awkwardly spliced on with "also has," but it stays brief.

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-only list tool with rich annotations and an output schema, the essential gaps are filter semantics and result scope. The description addresses the return-value shape but leaves unclear whether the tool lists account-wide or within the current database/schema, and whether results are limited or paginated.

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 never mentions the pattern, database, or schema_name parameters. Schema coverage is 67%, so the schema covers two parameters, but their descriptions only explain quoting and not what the parameters filter. With no compensating detail in the description, an agent cannot tell how the filters combine or what pattern matching means.

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 gives a specific verb and resource: "List OCI image repositories in Snowflake." This clearly distinguishes it from nearby siblings such as compute_services_list_services, compute_services_list_streamlits, and compute_services_list_compute_pools. However, it never explicitly says which sibling to choose for a related need.

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 a related tool. It also does not explain how the optional pattern/database/schema_name filters narrow the listing, or whether results are account-wide or context-scoped. An agent must infer usage entirely from the tool 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?

Annotations already declare readOnlyHint, idempotentHint, and destructiveHint=false, so the safety profile is covered without the description. The text adds the useful detail that each row carries quoted_name and conditionally quoted_qualified_name, but says nothing about permissions, pagination, or result limits.

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, purpose front-loaded, no filler. The second sentence is slightly awkwardly phrased but does carry real information about returned columns.

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?

An output schema exists, so explaining return columns is optional rather than required, and the safety profile is annotation-covered. The missing pieces are the unexplained `pattern` filter and any guidance on narrowing results by database/schema, which matter for a list tool with three optional parameters.

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 67%, and the description adds no filtering semantics at all. The most important gap is `pattern`, which has no description in the schema and is never mentioned in the text, leaving its matching behavior (regex? glob? LIKE?) completely unknown.

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 — listing container services on SPCS compute pools — which separates it from compute_services_list_compute_pools and compute_services_list_streamlits. It stops short of naming the alternative it is not, so it lands at 4 rather than 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?

There is no statement of when to use this versus a sibling list tool, no mention of prerequisites, and no indication of how the optional pattern/database/schema_name filters change the result set. The reader must infer all of this from the schema 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?

Annotations already declare readOnly=true, idempotent=true, destructive=false, openWorld=true, so the safety profile is covered. The description adds information about row contents (quoted_name, quoted_qualified_name), but that overlaps with the output schema rather than disclosing behavior such as filtering, pagination, or cross-database scope.

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 with the purpose front-loaded and no wasted preamble. The second sentence is a narrow implementation detail about quoted column names, which is marginal but not bloated.

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?

An output schema and annotations are present, so return values and safety need not be re-explained. However, for a list tool with three optional filters, the description leaves the filtering behavior and the meaning of 'pattern' entirely unexplained, which an agent needs to call it correctly.

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 67%: database and schema_name carry descriptions about quoting, but 'pattern' is completely undocumented in both schema and description. The description says nothing about any of the three filters, so it does not compensate for the gap on pattern.

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 Streamlit applications hosted in Snowflake.' That clearly separates it from compute_services_describe_streamlit, but it does not explicitly name the sibling or state the listing scope (account-wide vs database-scoped).

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 mention of when to prefer describe_streamlit over this tool, and no indication of how the optional pattern/database/schema_name filters are meant to be applied. The agent is left to infer that this lists everything unless filters are supplied.

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?

Annotations already declare idempotentHint=true, destructiveHint=false, and readOnlyHint=false, so the safety profile is well covered. The description adds the precondition that the pool must be idle or suspended, but does not disclose asynchronous behavior, required permissions, or expected post-resume state beyond what annotations imply.

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 zero wasted words. The operation and its precondition state are stated immediately.

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

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

Given the tool's simplicity (one required parameter), an output schema, and strong annotations, the description is nearly sufficient. A minor gap is that it does not mention error behavior when the pool is not idle/suspended, but overall it is complete for 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%, and the single parameter pool_name already has quoting guidance in the schema. The description adds no parameter detail beyond the schema, 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?

States a specific verb (Resume) and resource (SPCS compute pool) with the qualifying state (idle or suspended), making the operation clear. It does not explicitly name sibling tools or differentiate from alternatives such as suspend/describe, but the purpose is 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 phrase 'idle or suspended' implies a precondition for use, which is helpful. However, there is no explicit guidance on when to choose this over siblings (e.g., suspend_compute_pool, describe_compute_pool) or what happens if the pool is in another state.

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?

Annotations already cover the safety profile: not read-only, idempotent, non-destructive, and open-world. The description adds the active-pool precondition and cost motivation, but it does not describe what happens to running services or workloads tied to the pool.

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 text. It communicates action, scope, and rationale efficiently.

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

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

Given the simple one-parameter schema, complete parameter documentation, annotations, and an output schema, the description is largely complete. A minor gap is that it does not explain the impact on workloads running in the compute pool.

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

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

The input schema has 100% description coverage and includes a specific quoting instruction for pool_name. The description adds no parameter-level detail beyond the schema, so the baseline score of 3 is appropriate.

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

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

The description states a specific verb and resource: suspend an active SPCS compute pool. It also adds the operational motivation, stopping node provisioning costs, and clearly distinguishes the action from the sibling resume_compute_pool.

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 clear usage context by specifying an active SPCS compute pool and the cost-saving purpose. It does not explicitly name resume_compute_pool as the alternative or state when not to use it, but the intended scenario is easy to infer.

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?

Annotations already declare readOnlyHint, idempotentHint, openWorldHint and destructiveHint=false, so the safety profile is covered. The description adds that queries run over semantic models via natural language, but does not disclose latency, model resolution, or what happens when semantic_model_path is absent.

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 is efficient, though the brevity comes at the cost of the missing detail noted elsewhere rather than being genuinely complete.

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?

An output schema exists so return values needn't be explained, but with 0% parameter coverage, no usage guidance, and an undefined optional parameter, the description is too thin for an agent to invoke this correctly in one shot.

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 carries the full burden. It only loosely implies the 'question' parameter and says nothing about semantic_model_path, its optional default, format, or what the model path should point to.

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 ('Ask') and resource ('natural language analytical question') and ties it to Cortex Analyst semantic models. This distinguishes it from raw-SQL siblings like queries_query, though it never explicitly names an alternative such as cortex_complete or queries_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?

The phrase 'natural language analytical question' implies the context but is not framed as explicit guidance. There is no when-to-use vs when-not-to-use, no mention of alternatives like queries_query for SQL, and no prerequisites such as needing a semantic model.

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?

Annotations already declare readOnlyHint, idempotentHint, openWorldHint and destructiveHint=false, covering the safety profile. The description adds nothing beyond that – no mention of cost/latency, model availability, token limits, or that temperature drives nondeterminism despite the idempotent claim. It repeats the tool name rather than disclosing behavior.

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

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

A single front-loaded sentence with no filler; the action is stated first and examples follow. It is terse rather than bloated, though it is arguably too short to do its job.

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?

An output schema exists so return values need not be described, but with 4 parameters at 0% schema coverage, no usage guidance, and no behavioral notes, the definition leaves an agent guessing about tuning parameters and appropriate invocation conditions.

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 carry all four parameters. It only implicitly documents the 'model' parameter by listing valid model names (useful given no enum), while prompt, max_tokens, and temperature are left completely unexplained.

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 and resource ('Run LLM completion using Snowflake Cortex AI') and grounds it with concrete model examples. It is clearly distinguishable from task-specific siblings like cortex_summarize or cortex_sentiment, though it never says so 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 when-to-use guidance, no conditions, and no mention of alternatives. An agent must infer on its own when to pick general completion over the specialized cortex_summarize/translate/extract_answer tools.

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?

Annotations already declare readOnlyHint, idempotentHint, destructiveHint=false, and openWorldHint, so safety and repeatability are covered structurally. The description adds only the fixed output dimensionality; it says nothing about cost, latency, model determinism, or whether the same text always yields the same vector beyond what idempotentHint implies.

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; the key fact (768-dimensional embeddings) appears immediately. Nothing is redundant with the title.

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?

An output schema exists, so return values need no explanation, and the tool surface is small. However, the unexplained 'model' parameter and total absence of usage context leave an agent unable to decide when this tool is the right choice over cortex_search or cortex_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%, so the description carries the full burden, yet it never mentions the 'text' input or explains the 'model' parameter (its default snowflake-arctic-embed-m, or what alternative models imply for dimensionality). With two undocumented parameters the description should compensate and 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?

States a specific verb ('Generate') plus a precise resource ('768-dimensional dense vector embeddings for text') and names the underlying service (Snowflake Cortex AI). The output dimensionality and modality are specific enough to separate it from siblings like cortex_complete, cortex_summarize, and cortex_search without opening any schema.

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

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

The description never says when to use embeddings versus the other Cortex tools (e.g., search for retrieval, complete for generation), nor any prerequisites such as an active warehouse or Cortex entitlement. It describes what the tool is, not when to reach for it.

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?

Annotations already declare readOnlyHint, idempotentHint, destructiveHint=false and openWorldHint=true, so the safety and determinism profile is covered by structured data. The description adds only the 'direct answer' framing (extraction vs. generation), but says nothing about model behavior, grounding, latency, or input size limits. With annotations carrying the main burden, this is adequate but 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?

A single front-loaded sentence with no filler or redundancy. It is efficient, though arguably too terse for a tool with zero schema documentation.

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?

An output schema exists, so return values need not be explained. But for an open-world Cortex AI function with no schema descriptions and no usage routing against its many Cortex siblings, the description leaves real gaps for 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%, so the schema itself documents nothing. The description partially compensates by naming both concepts — 'question' and 'unstructured source document/text' — which map onto the two required parameters. It still omits format details such as whether source_text is raw text or a document reference and any size constraints.

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

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

States a specific verb+resource: extract a direct answer to a question from unstructured source text. This is clearly distinguishable from mutation siblings like queries_execute_dml. However, it does not distinguish itself from the closest Cortex AI siblings (cortex_complete, cortex_search), so it stops 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?

There is no when-to-use guidance, no prerequisites, and no mention of alternatives such as cortex_search or cortex_complete for related NLP tasks. The agent must infer from the name alone when this tool is the right pick.

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?

Annotations already declare readOnlyHint=true, openWorldHint=true, idempotentHint=true, and destructiveHint=false. The description adds no behavioral context beyond that, such as authentication needs, pagination behavior, rate limits, or what kind of index 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 a single front-loaded sentence with no wasted words. However, its extreme brevity contributes to under-specification for a tool with four parameters and no schema descriptions.

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 exists, so return values do not need description. Still, for a search tool with four parameters and 0% schema description coverage, the description lacks enough usage and parameter detail for reliable 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% for four parameters, so the description carries the full burden of explaining parameter semantics. It only implies a query text and a target service, but does not explain service_name, limit, or columns.

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: querying a Snowflake Cortex Search Service index over unstructured text. This clearly separates it from sibling Cortex generative and structured-analysis tools, so an agent can identify its purpose 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?

There is no explicit guidance on when to use this tool versus alternatives such as cortex_complete, cortex_analyst_query, or generic query tools. The description implies its domain but gives no conditions, exclusions, or prerequisite 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?

Annotations already declare readOnlyHint, idempotentHint, openWorldHint and destructiveHint=false, so the safety profile is covered. The description adds the output polarity range (-1.0 to 1.0), which is useful behavioral context, but says nothing about language support, input length limits, model latency/cost, or handling of mixed/neutral text.

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 sentence, zero filler, with the operation and the return-value scale both front-loaded. Nothing could be removed without losing information.

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

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

For a single-parameter, read-only tool with an output schema that already documents the return shape, this is nearly sufficient. The remaining gap is input-side detail (length limits, language coverage), which the description does not address.

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 sole required 'text' parameter, so the description carries the burden but only names the input implicitly. It adds no constraints such as maximum length, supported languages, or whether multiple strings are accepted, leaving the parameter under-documented.

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 ('Analyze sentiment of text') plus the output scale, so the agent immediately knows this is a sentiment classifier rather than a generator or search. It never explicitly positions itself against the other cortex_* text tools, but the purpose is inherently distinct from cortex_complete/summarize/translate.

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 is given. The description does not say when to prefer this over cortex_complete (which could also be prompted to judge sentiment) or whether it handles a single text or a batch. The agent must infer applicability 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?

Annotations already declare readOnlyHint, idempotentHint, and openWorldHint, so the safety profile is covered. However, the description adds nothing beyond the annotations: no input-size limits, no cost/latency note, no mention of the English-only constraint's implications.

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 tight sentence that is front-loaded with the verb and resource, with zero waste.

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

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

An output schema exists, so return values need not be explained, and annotations cover safety. But for an AI-backed summarization tool with openWorldHint, the description omits input constraints (length, language limitations) that an agent would need to invoke it correctly.

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?

Only one parameter (text) with 0% schema description coverage, so the description must compensate. It states the input is 'English text', giving minimal format/type guidance, but adds no length, encoding, or content constraints beyond what the schema 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?

States a specific verb (Summarize) and resource (English text) and names the underlying engine (Snowflake Cortex AI), distinguishing it from cortex_complete, cortex_sentiment, and cortex_translate. It's clear what it does, though it does not explicitly contrast with those siblings.

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

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

There is no guidance on when to use this tool versus alternatives like cortex_complete or cortex_extract_answer, nor any constraints on input (e.g., length limits, language). Usage is only implied.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, destructiveHint=false, and openWorldHint=true, so the safety profile is covered. The description adds essentially nothing beyond that: no note on supported language identifiers, model behavior, rate limits, or failure modes from Cortex.

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, well-formed sentence with the core action front-loaded and no filler. It is efficient, though its brevity comes at the cost of the missing semantics noted elsewhere.

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?

An output schema exists, so return values need not be explained. However, for a 3-required-parameter tool with zero schema descriptions, the language-code format and any constraints on the text input are left entirely unspecified, leaving an agent guessing on the fields most likely to cause an incorrect 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 description coverage is 0% across all three required parameters, so the description carries the burden. It restates the field names conceptually but never specifies the expected language format (e.g. ISO/BCP-47 codes like 'en' vs 'English') or how empty/unsupported language values behave.

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 (translate) and resource (text), plus the scoping detail that it runs on Snowflake Cortex AI. It is clearly distinguishable from siblings like cortex_summarize or cortex_sentiment, though it does not explicitly name an 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?

There is no when-to-use guidance, no mention of prerequisites, and no routing to sibling tools. An agent can infer the purpose but gets no help deciding between this and, say, cortex_complete for a translation-style task.

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

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

The annotations already declare readOnlyHint=false, destructiveHint=false, openWorldHint=true, and non-idempotency. The description's 'zero-copy' adds real value by explaining that no data is physically copied at creation and the target diverges only on later writes — a trait not captured in annotations. It still omits the failure mode of an existing target and required privileges.

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 zero filler; the key qualifier ('zero-copy') comes early. Nothing is redundant or buried.

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?

An output schema exists, so return values needn't be described, and the params are fully documented by the schema. However, for a non-idempotent mutation tool the description should mention that the target database must not already exist and that the clone requires source privileges — omissions that affect whether a call succeeds.

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 both parameters are required strings with quoting guidance already in the schema. The description adds nothing beyond what the schema states, 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?

States a specific verb and resource ('Create a zero-copy clone of a database'), and 'zero-copy' signals the Snowflake-specific semantics that separate this from databases_create_database. It doesn't name the sibling it substitutes for, but the operation is 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?

No when-to-use guidance at all: nothing about when to clone vs. create, whether the target must be empty/nonexistent, or what privileges (CREATE DATABASE on the source) are needed. The agent must infer all preconditions.

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?

Annotations already declare readOnlyHint=false, idempotentHint=false, destructiveHint=false and openWorldHint=true, so the safety profile is covered. The description adds nothing beyond that: it does not say what happens if the database already exists (even though if_not_exists defaults to true), what permissions are required, or how long the operation takes.

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 short sentence with zero waste and the core purpose front-loaded, but the brevity is achieved by omitting information rather than by efficient phrasing. It is minimally viable rather than well-structured.

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

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

An output schema exists so return values need no explanation, but for a create tool with three undocumented parameters and no notes on privilege requirements or the if_not_exists default, the description leaves significant gaps an agent would need in order to call it correctly.

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 only 25% — only 'name' is documented, while 'comment', 'if_not_exists', and 'data_retention_time_in_days' have no descriptions anywhere. The description does not compensate by explaining the semantics of these parameters, particularly the default-true if_not_exists behavior which materially changes outcomes.

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 ('Create a new database') with the platform named, so an agent knows exactly what operation is performed. It does not distinguish itself from the close sibling databases_clone_database, which is also a database-creating operation, so sibling differentiation comes only from the name.

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 databases_clone_database or schemas_create_schema, and no mention of prerequisites such as the CREATE DATABASE privilege or an active connection. The agent must infer all selection context from the tool 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?

Annotations already declare readOnlyHint, idempotentHint, destructiveHint=false, and openWorldHint, so the safety profile is fully covered. The description's only added behavioral signal is the set of properties returned, which is redundant with the output schema; it says nothing about permissions or failure modes.

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 compact sentence, front-loaded with the verb and resource, with no filler. It is slightly under-specified rather than over-long.

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 read with a full annotation set and an output schema, the description is sufficient: the agent knows what is described and what metadata comes back. The only missing piece is routing guidance against the DDL and list siblings.

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?

With a single parameter at 100% schema coverage, the schema already carries the meaningful guidance (quoting non-uppercase names exactly as list tools return them). The description adds no parameter semantics beyond what the schema provides, 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 uses a specific verb ('Describe') plus the resource ('database') and enumerates the returned facets (properties, owner, retention time, comment), so an agent knows exactly what metadata it yields. It does not explicitly distinguish itself from databases_get_database_ddl or databases_list_databases, which keeps it from 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?

There is no when-to-use statement, no prerequisites, and no mention of the sibling alternatives (get_database_ddl for DDL, list_databases for enumeration). The agent must infer that this is the metadata-inspection call from context 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?

Annotations already declare destructiveHint=true, readOnlyHint=false, idempotentHint=false, so the safety profile is known without the text. The description adds one genuinely new behavioral fact — that the call is gated behind a confirmation flag — but does not state irreversibility, what dependent objects are lost, or that recovery via undrop is possible.

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, front-loaded with the action and immediately followed by the guard condition; no filler. It is efficient, though the brevity edges toward under-specification for a destructive operation.

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

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

An output schema exists and annotations carry the destructive profile, so return-value explanation is not needed. However, for a permanent, irreversible Snowflake drop, the description omits the consequences (cascading loss of schemas/tables) and the undrop recovery path, which an agent should know before calling.

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 50%: the 'name' parameter is well documented including quoting rules, but 'confirm' has no schema description beyond a default of false. The sentence 'Requires confirmation flag' fills exactly that gap by conveying the flag must be set to true, adding real meaning beyond the structured 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 specific verb and resource — 'Drop a database in Snowflake' — which is unambiguous. It does not differentiate from the closely related siblings databases_undrop_database or databases_create_database, so an agent must infer the distinction from the names alone.

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?

'Requires confirmation flag' establishes a precondition for invocation, which is the strongest usage signal present. There is no guidance on when to prefer this over alternatives (e.g., undrop for recovery) or when not to use it, leaving usage largely 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?

Annotations already declare readOnly, idempotent, non-destructive, openWorld, so the safety profile is fully covered. The description adds only the qualifier 'exact', signaling the output is a verbatim server-side definition rather than a reconstructed one; it says nothing about failure modes for missing databases.

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 with zero filler. It is efficient but arguably under-specified rather than over-long, which is not penalized here.

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?

An output schema exists, so return values need not be explained, and the read-only annotations cover behavior. The remaining gap is routing: nothing in the description helps an agent decide between this and databases_describe_database in a large sibling set.

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 the single parameter's description already explains the quoting/case requirement for non-uppercase names. The description adds no parameter meaning beyond that, 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?

Names a specific verb (Retrieve) and a specific artifact (CREATE DATABASE DDL definition), which is distinct from describe_database's metadata view. It never explicitly contrasts the two, so the agent must infer the difference from the word 'DDL' alone.

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

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

No guidance on when to choose this over databases_describe_database, which is the nearest sibling and returns overlapping information. No prerequisites or exclusions are stated.

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

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

Annotations already declare readOnlyHint, idempotentHint, destructiveHint=false and openWorldHint, so the safety profile is covered. The description usefully adds that results are limited to the current role's accessible databases and explains the naming semantics of quoted_name/quoted_qualified_name, but it says nothing about whether the `pattern` parameter filters results 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 sentence is front-loaded and efficient, but the second sentence is a rambling aside about output columns that omits the only input parameter. Content priority is misallocated rather than merely verbose.

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

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

An output schema exists, so return values need not be explained, and the read-only annotations carry the safety story. However, for a filtered-list tool with one undocumented parameter, the description leaves the agent unsure what `pattern` does and whether it is required for scoped listing.

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 `pattern` parameter is an undescribed nullable string, so the description is the only place its meaning could be supplied — yet it is never mentioned. Instead, the description spends its only extra sentence on output column names, which does not compensate for the parameter 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?

States a specific verb and resource (list all available databases) plus a scope qualifier (accessible to the current role), so an agent can distinguish it from mutation siblings like databases_create_database or databases_drop_database. It does not explicitly contrast with databases_describe_database or schemas_list_schemas, but the list-vs-detail distinction is implicit in the verb.

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 never says when to choose this tool versus databases_describe_database, schemas_list_schemas, or governance_list_roles. The role-scoping phrase hints at the result set but offers no usage context, alternatives, or preconditions.

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?

Annotations already declare destructiveHint=false, readOnlyHint=false, and idempotentHint=false, so safety is largely covered. The description adds only "using Time Travel," leaving the retention window, permission requirements, and behavior when the name is re-taken or the window has expired unstated.

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 sentence, front-loaded with the action and resource, with zero filler. Nothing could be removed without losing information.

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

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

An output schema exists, so return-value explanation is unnecessary, and the annotations cover the safety profile. The remaining gap is the Time Travel retention caveat, which materially affects whether the call can succeed, but overall the definition is serviceable for a one-parameter restore.

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 the single `name` parameter is carefully documented in the schema (quoting non-uppercase names exactly as list tools return them). The description adds no additional meaning beyond that, so 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?

States a specific verb (restore) and resource (recently dropped database) plus the underlying mechanism (Time Travel), so the operation is unambiguous. It does not name siblings such as databases_drop_database or databases_create_database to differentiate, but the name and wording make the inverse-of-drop relationship obvious.

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?

"Recently dropped" hints at a Time Travel retention constraint but never states it, and there is no guidance on what to do if the retention window has expired or whether create_database/clone_database is the fallback. Usage is implied rather than directed.

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?

Annotations already declare readOnlyHint=true, idempotentHint=true and destructiveHint=false, so the safety profile is covered. The description adds useful context by listing the attributes returned (target lag, warehouse, query text), but says nothing about error behavior or the openWorldHint implications (cross-database resolution).

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 with no filler, and the enumerated fields come immediately after the verb. It is efficient, though the terseness leaves no room for routing or caveats.

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?

An output schema exists so return structure needn't be described, and the annotations plus full schema coverage handle safety and parameters. For a simple single-object describe tool the description covers the essentials, with only usage routing left implicit.

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?

With 100% schema description coverage across all three parameters, the schema already explains the quoting/uppercase convention. The description adds no further parameter meaning, which is the expected baseline when the schema does the work.

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?

Specific verb 'describe' with the resource 'dynamic table' and an enumeration of what is returned (definition, target lag, warehouse, query text). It is clearly distinct from dynamic_tables_list_dynamic_tables or refresh/suspend siblings, though it never names an 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?

Usage is only implied: an agent can infer this is the tool for inspecting one dynamic table's configuration. There is no statement of when to prefer it over list_dynamic_tables, no prerequisites, and no mention of what happens when the table doesn't 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?

Annotations already declare readOnlyHint=true, idempotentHint=true, destructiveHint=false, so safety is covered by structured data. The description adds only which metadata facets are returned, which partly duplicates the output schema; it gives no information about authorization requirements, behavior for malformed or missing tables, or latency.

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 is efficient, though it is arguably too thin for a tool whose name is triply redundant with its title and whose sibling set is large.

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?

An output schema exists and annotations cover safety, so the description doesn't need to explain return values. However, for a tool sitting among several describe-style siblings in a Snowflake-like catalog, the lack of any routing or prerequisite information leaves a real gap for 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% and each of the three parameters carries the quoting guidance, so the schema does the heavy lifting. The description contributes nothing about database/schema_name defaults or nullability semantics; 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?

States a specific verb (Describe) and a precise resource (Iceberg table) plus the facets returned: schema, catalog integration, external volume. This distinguishes it from generic table describers by naming the Iceberg-specific content, though it never explicitly contrasts with tables_describe_table or dynamic_tables_describe_dynamic_table.

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

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

The usage context is only implied: call this to inspect an Iceberg table's structure and storage wiring. There is no statement of when to prefer it over tables_describe_table, dynamic_tables_describe_dynamic_table, or the list_iceberg_tables sibling, and no prerequisites (e.g., catalog integration 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?

The description adds valuable context regarding the returned data structure. It informs the agent about specific output fields like 'quoted_name' and 'quoted_qualified_name,' which is behavioral information beyond the standard safety annotations like 'readOnlyHint'.

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 two sentences are necessary: the first defines the resource, and the second defines the data format of the result. Both sentences are concise and efficiently convey unique information.

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

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

The description is reasonably complete regarding the resource content and naming conventions. However, the lack of input parameter semantics (specifically for the 'pattern' parameter) prevents a higher score, as a functional piece of information 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?

Schema description coverage is 0%, yet the description offers no guidance on the input parameter 'pattern.' It does not explain if 'pattern' requires a regex, a partial string match, or an exact value, making the input semantics impossible to determine from the text.

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 is highly specific, listing exactly what is being listed (catalog integrations) and which platforms are included (Polaris, AWS Glue, Object Storage). This leaves no ambiguity about the resource.

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

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

The description implicitly defines the usage: use this tool when you need a list of integrations. While it does not explicitly state when NOT to use it (e.g., comparing it to a 'describe' tool), the purpose is highly clear within its domain.

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?

Annotations already declare readOnlyHint, idempotentHint, and destructiveHint=false, so the safety profile is covered structurally. The description adds useful row-level context (quoted_name and when quoted_qualified_name is populated), but says nothing about result volume, pagination, or ordering — the practical concerns for an openWorld list call.

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, front-loaded with the core list operation and the fields returned. The second sentence is a bit dense around quoting, but it is relevant to consuming the output and contains 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?

An output schema exists so return values needn't be explained, yet the description still spends its second sentence on output naming while leaving all three input parameters — including the undocumented `pattern` filter — unexplained. For a list tool whose main use is scoped discovery, the filtering story 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?

The `pattern` parameter is undocumented in both schema and description, so the agent cannot know it is a name-matching filter. The database/schema_name schema descriptions discuss name quoting rather than the filtering semantics, and the description does not clarify them either, leaving gaps at 67% 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?

States a specific verb and resource ("List dynamic tables") plus the attributes exposed on each row (lag targets, refresh mode, last refresh status). An agent can tell it is a listing tool distinct from dynamic_tables_describe_dynamic_table, though it does not name that sibling 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?

There is no guidance on when to choose this over dynamic_tables_describe_dynamic_table or the other dynamic_tables list variants (list_iceberg_tables, list_external_volumes). Nothing says whether results are account-wide or scoped, or that filters are optional.

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?

Annotations already declare readOnlyHint, idempotentHint, and openWorldHint, so the safety profile is covered. The description adds that rows carry quoted_name and quoted_qualified_name, but that is return-shape detail rather than behavioral context; it says nothing about scope, filtering behavior, or whether all volumes are returned regardless of catalog.

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 compact sentences, with the core purpose front-loaded. The second sentence about quoted column names is somewhat expendable given an output schema exists, but it is short and not harmful.

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?

Because an output schema exists, the description needn't explain return values, and annotations cover safety. However, the unexplained pattern parameter and the absence of any when-to-use context leave real gaps for a tool whose siblings include several similar list operations.

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 sole parameter 'pattern' has 0% schema description coverage and is never mentioned in the description, so an agent gets no hint that it is a name filter or what syntax it accepts. With one undocumented parameter, the description fails to compensate 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?

States a specific verb and resource: list external cloud storage volumes for Apache Iceberg tables. That clearly separates it from dynamic_tables_list_iceberg_tables and the other dynamic-table siblings. It stops short of explicitly naming an alternative, but the purpose is 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?

There is no guidance on when to call this versus dynamic_tables_list_iceberg_tables or dynamic_tables_list_catalog_integrations, and no mention of what the optional pattern argument filters. The agent must infer the use case entirely.

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?

Annotations already declare readOnlyHint, idempotentHint, openWorldHint, and destructiveHint=false, so the safety profile is covered. The description adds only a note about quoted_name and quoted_qualified_name output fields and does not discuss permissions, pagination, or other operational behavior.

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

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

Two tight sentences with the purpose front-loaded and no filler. The second sentence is useful but partially redundant with the available output 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 description covers the listing scope and output-field quirks, and annotations plus the output schema carry much of the remaining burden. However, it leaves the pattern parameter unexplained and gives no selection guidance against sibling listing 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 only 67%, and the description says nothing about any of the three parameters, including the undocumented pattern parameter. It therefore does not compensate for the coverage 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 Apache Iceberg tables) and scopes it to account, database, or schema. This distinguishes it from generic table-listing siblings by resource type, though it does not explicitly call out dynamic-table siblings.

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

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

Usage is implied by the resource scope, but there is no explicit when-to-use guidance, no when-not-to-use conditions, and no named alternatives such as tables_list_tables or dynamic_tables_list_dynamic_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?

Annotations already declare readOnlyHint=false, idempotentHint=true, destructiveHint=false and openWorldHint=true, so the safety profile is covered. The description only adds that the refresh is immediate and manual, saying nothing about whether the call blocks, costs compute, or fails on a suspended table.

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 short sentence, action front-loaded, no filler. It is under-specified rather than verbose, which is penalized elsewhere.

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?

Output schema and annotations cover returns and safety, and params are fully described, but an agent still lacks essentials for a mutation trigger: sync vs async behavior, prerequisite state, and compute cost implications.

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 quoting guidance is already in every parameter description, so the schema carries the burden. The description adds no naming or qualification semantics beyond what the schema provides; 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?

Specific verb (trigger refresh) plus resource (dynamic table), and 'immediate manual' distinguishes it from the scheduled automatic refresh behavior. It is clearly separable from siblings like dynamic_tables_resume_dynamic_table or describe, though it doesn't explicitly name 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?

No statement of when to use this versus resume/suspend or letting the schedule handle it, no preconditions (e.g., table must be resumed/active before refresh). The agent must infer call conditions.

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?

Annotations already declare readOnlyHint=false, idempotentHint=true, destructiveHint=false and openWorldHint=true, so the safety profile is covered. The description adds nothing beyond that: it does not state the required prior state, permission needs, side effects on refresh history, or what 'lag monitoring' entails, which matters for a state-changing operation.

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

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

A single front-loaded sentence with no filler. It is efficient, though its brevity is partly the source of the ambiguity noted elsewhere rather than a stylistic strength.

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?

An output schema exists, so return values need not be explained, and the parameter set is fully documented. However, for a state-changing lifecycle operation, the description omits the preconditions and effects an agent would want before invoking it, leaving it only minimally sufficient.

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 database, table_name and schema_name are already documented with quoting guidance. The description adds no further meaning about how these identify the table, 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 ('Resume') and resource ('a dynamic table'), so it is clearly distinguishable from the sibling dynamic_tables_suspend_dynamic_table. The phrase 'scheduling and lag monitoring' adds a hint of what resuming restores, though it is slightly ambiguous as to whether the tool resumes the table or merely reports lag.

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 versus alternatives, nor any prerequisite such as the table needing to be in a suspended state. The obvious alternative (dynamic_tables_suspend_dynamic_table) is never mentioned, leaving the agent to infer the suspend/resume pairing.

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?

Annotations already declare readOnlyHint=false, idempotentHint=true, and destructiveHint=false, so the safety profile is largely covered. The description adds useful scope detail — that both automated refresh and lag evaluation stop — but says nothing about reversibility (resume), permission requirements, or billing/state effects.

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

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

A single front-loaded sentence with no filler. It is efficient but arguably under-sized for a mutation tool, which is penalized under contextual completeness rather than here.

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?

An output schema exists, so return values need not be explained, and annotations cover the safety profile. However, for a state-changing operation the description omits prerequisites, confirmability of the suspended state, and the natural pairing with resume_dynamic_table.

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 all three parameters (database, schema_name, table_name) are documented in the schema with quoting guidance. The description contributes no additional parameter meaning, 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?

States a specific verb ('Suspend') and resource ('a dynamic table') plus what is being suspended (automated refresh and lag evaluation). An agent can distinguish it from dynamic_tables_resume_dynamic_table by name inference, but the description never names the counterpart 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?

Usage is implied by the verb: suspend when you want to pause refresh and lag evaluation. There is no explicit guidance on prerequisites (table must be active), what happens to downstream consumers, or when to prefer refresh_dynamic_table or resume_dynamic_table instead.

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?

Annotations already declare readOnlyHint=false, openWorldHint=true, idempotentHint=false, destructiveHint=false, so the safety profile is covered structurally. The description adds nothing beyond that — it doesn't mention required privileges, account-level effects, or the role-naming convention the schema hints at.

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 short sentence with no padding, but its brevity comes at the cost of under-specification rather than tightness. It is front-loaded correctly but 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?

An output schema exists so return values needn't be explained, but for a write tool with three parameters and 33% coverage, the description omits the if_not_exists default, naming/quoting rules, and permission requirements an agent needs 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 coverage is only 33%: role_name is documented, but comment and if_not_exists (which defaults to true, meaning silent no-op on conflict) are unexplained in both schema and description. Given low coverage, the description should compensate but does not, leaving the default-idempotency behavior invisible.

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 (Create) and resource (role) scoped to Snowflake, which is more than a tautology of the name. It does not, however, distinguish itself from governance_describe_role or governance_drop_role, nor mention any role-listing side effects.

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 governance_list_roles or governance_describe_role, no prerequisites (privileges needed to create roles), and no note on what to do if the role already exists. Usage is only implied by the verb.

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?

Annotations already declare this is a non-read-only, non-destructive, non-idempotent, open-world mutation, so the safety profile is covered. The description adds nothing about required privileges, whether a password is mandatory, or what happens on name collision (relevant given if_not_exists defaults to true), which is exactly the context a caller of a mutation tool needs.

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, so nothing is wasted. It is efficient but arguably too terse for a mutation tool with six parameters.

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?

An output schema exists, so return values need not be explained, but for a user-creation mutation with an optional password and a silently-defaulted if_not_exists flag the description leaves out the operational facts an agent needs to invoke 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 only 50%: only user_name, default_role, and default_warehouse carry descriptions (all the same quoting note). The description names 'default role and warehouse' but says nothing about password, comment, or the if_not_exists default of true, so it fails to compensate for the uncovered 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?

States a specific verb and resource (create a new Snowflake user) plus the key configuration it applies, which separates it from governance_list_users / governance_describe_user / governance_create_role. It does not explicitly name a sibling, 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?

There is no statement of when to use this instead of governance_create_role or governance_list_users, no prerequisites (e.g., USERADMIN/ACCOUNTADMIN privileges), and no note on what to do if the user already exists. The agent must infer all of that.

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

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

The description adds a crucial implementation detail: the input role name must match exactly, even if quoted, specifically referencing 'a list row's quoted_name'. This behavioral constraint adds significant value beyond the general read-only hint provided in the annotations.

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

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

The description is brief and directly addresses the functional constraints ('A name in double quotes... must match exactly'). Every sentence serves to clarify the behavior of the input parameter.

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

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

Given that the tool is read-only, idempotent, and idempotent, and its function is clear, it is largely complete. The description successfully clarifies the specific input formatting requirement which is the only major behavioral gap left to fill.

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%, meaning the description must carry all weight. It specifies that the input 'role_name' is case/format sensitive by requiring an exact match with potential quoting, which is a critical semantic detail not conveyed by the type definition.

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 explicitly states the function: 'Describe role properties and assigned grants.' This is highly specific (verb + resource + detail) and easily distinguishable from sibling tools like `governance_list_roles` or `governance_list_grants_to_user`.

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 tool provides some contextual guidance regarding the naming convention (quotes must match exactly), but it doesn't specify functional usage constraints, success criteria, or explicitly state when it should be preferred over alternatives like `governance_list_grants_to_role`.

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?

Annotations already declare this as a safe, read-only, idempotent operation. The description adds value by naming the returned fields (email, disabled status, default warehouse/role), but does not mention permissions required or behavior when the user does not exist.

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 sentence that front-loads the verb and resource with zero wasted words. Every clause adds useful detail about what is returned.

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 an output schema present, the description need not explain return structure. The enumerated fields provide helpful context beyond what annotations and schema alone convey. Minor gap: no mention of error behavior for missing users.

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 the single parameter is fully documented in the schema itself, including the quoting rule. The description adds no additional parameter semantics, so the baseline of 3 applies.

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

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

States a specific verb ('Describe') and resource ('user'), and enumerates the properties returned. It is clearly distinct from governance_list_users by virtue of singular description, though no sibling is named 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?

Implied usage is clear: fetch detailed properties for a single user. However, there is no explicit guidance on when to use this versus governance_list_users, nor any mention of prerequisites or error conditions.

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?

Annotations already declare destructiveHint=true, readOnlyHint=false and idempotentHint=false, so the safety profile is covered. The description adds a confirmation gate, but does not disclose the real consequences an agent needs: what happens to grants held by the role, whether owned objects block the drop, or that the operation is irreversible (unlike databases/schemas/tables, there is no governance_undrop_role).

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, action first, prerequisite second, with zero filler. Nothing needs to be trimmed.

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?

An output schema exists so return values need not be described, but for an irreversible destructive operation the definition is thin: confirmation mechanics are implied rather than specified, and side effects on grants/dependents are unaddressed. Minimum 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 coverage is 50%: role_name is well documented in the schema (quoting rules), while confirm has no schema description. The description's 'Requires confirmation' partially compensates by signalling that confirm matters, but it does not state the expected value or behaviour on default false.

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 ('Drop a role in Snowflake'), which cleanly distinguishes it from governance_create_role, governance_list_roles and governance_describe_role. It does not explicitly name the sibling alternatives, but the destructive verb makes the intent 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?

'Requires confirmation' hints that a confirm flag must be set, but never says which parameter, what value, or what happens if it is omitted (the schema default is false). There is no guidance on prerequisites such as revoking grants or transferring ownership before dropping, and no mention that no undrop sibling exists for roles.

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?

Annotations already declare readOnly, idempotent, non-destructive, openWorld, and an output schema exists. The description confirms it reads session state but adds no behavioral context beyond the annotations, such as whether it requires a live session or reflects server-side defaults.

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 well-formed sentence that front-loads the verb and resource and lists the returned fields 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 zero-param read tool with full annotations and an output schema, the definition covers what is needed. The only minor gap is the absence of any note on when in a workflow to call it versus sibling listing 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?

Zero parameters, so baseline is 4. Schema coverage is 100% with an empty object, leaving nothing for the description to clarify.

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 ('Retrieve') and resource ('current active session context'), then enumerates the exact fields returned (user, role, warehouse, database, schema, account). An agent can immediately distinguish this from schema/role listing tools like governance_list_roles or governance_describe_user.

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 word 'current' implies this is a session-state read used before acting on the active context, but no explicit when-to-use or when-not-to-use guidance or named alternative is given. Usage is implied rather than stated.

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

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

Annotations already declare readOnlyHint, idempotentHint, destructiveHint=false and openWorldHint, so the safety profile is covered. The description adds real context beyond that: the data source is a local config file path, and the output includes the active profile indicator.

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; the what (list profiles) and the where (config path) come first, with the active-profile behavior as a brief clause.

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

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

For a zero-parameter read tool with an output schema, the description supplies essentially everything an agent needs (resource, source location, active-profile detail). The only omission is explicit routing guidance to governance_use_connection as the follow-on action.

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 zero parameters, so the schema is trivially complete and the description has no parameter semantics to carry. Baseline of 4 applies for a no-argument 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 (list) plus the exact resource (connection profiles in ~/.snowflake/connections.toml) and adds the side effect of surfacing the active profile. It is clearly distinguishable from governance_use_connection (which switches) but never names that sibling explicitly, so a small differentiation gap remains.

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 only implied: an agent can infer this is the discovery step before calling governance_use_connection, but the description contains no explicit when-to-use or when-not-to-use guidance and no named alternative.

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?

Annotations already declare readOnlyHint=true, idempotentHint=true, destructiveHint=false, so the safety profile is fully covered. The description adds nothing beyond 'list' — no note on whether results include inherited role grants, pagination, or scope. With annotations carrying the burden, a 3 is appropriate.

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 efficient sentence with no waste and the resource front-loaded. Slightly thin rather than padded, but perfectly concise.

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

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

Output schema exists so return values need no explanation, annotations cover safety, and the sole parameter is documented. Adequate for a simple read-only lister, though noting the relationship to list_grants_to_user would complete it.

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

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

Schema coverage is 100% and the role_name parameter is well documented including the quoting rule, so the schema does the heavy lifting. The description adds no parameter detail beyond what is in the schema, making baseline 3 correct.

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?

Clear specific verb 'List' plus resource 'privileges granted to a specific role'. Distinct from siblings like governance_list_roles and governance_list_grants_to_user by resource, though it never explicitly contrasts with the closest sibling (list_grants_to_user).

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 name and description, but there is no explicit when-to-use guidance, no mention of when to prefer governance_list_grants_to_user, and no stated prerequisites such as privileges needed to inspect grants.

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?

Annotations already declare read-only, idempotent, open-world, and non-destructive behavior, so the safety profile is covered. The description adds no scope detail such as whether inherited grants are included, but it does not contradict annotations and the output schema covers return values.

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 short sentence, front-loaded with the verb and resource. There is no filler, and the length is appropriate for a simple read 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 one-parameter read tool with full schema coverage, rich annotations, and an output schema, the description is sufficient. A slightly richer statement about direct versus inherited grants would close the remaining 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 coverage is 100%, and the single parameter is documented in the schema with quoting guidance. The description mentions the user target but adds no syntax beyond the schema, 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?

States a specific verb and resource ('List roles granted') scoped to a specific user, which implicitly distinguishes it from governance_list_grants_to_role. It does not explicitly name the sibling or explain the difference, 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 gives no when-to-use guidance, prerequisites, or alternatives. An agent can infer the basic use case, but it is not told when to choose this over governance_list_grants_to_role or governance_list_roles.

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?

Annotations already declare readOnlyHint=true, idempotentHint=true, destructiveHint=false, and openWorldHint=true, so the safety profile is covered. The description adds that each row carries quoted_name and quoted_qualified_name, which is minor output-shape context rather than behavioral disclosure; it says nothing about result volume, pagination, or pattern matching semantics.

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, front-loaded with the purpose, which is good. But the second sentence is a dense, comma-heavy clause about output column names that duplicates information already present in the output schema, while the one input parameter goes undocumented.

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?

An output schema exists, so return values need not be explained, and this is otherwise a simple one-parameter read tool with full annotation coverage. The one real gap is the unexplained 'pattern' filter — the description is nearly complete but misses the only thing an agent must decide before calling.

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

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

The single parameter 'pattern' has 0% schema description coverage, so the description carries the full burden — yet it never mentions the parameter at all. An agent cannot tell whether pattern is a SQL LIKE pattern, a regex, a case-sensitive prefix, or how it affects the listing.

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 gives a specific verb and resource — listing roles in the Snowflake account — which is unambiguous. It does not differentiate from the near-name-colliding siblings (governance_describe_role, governance_list_grants_to_role), leaving the agent to infer which role-related tool fits when.

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 mention of alternatives such as governance_describe_role for details or governance_list_grants_to_role for grants, and no statement about when the pattern argument should be supplied. The agent must infer usage 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?

Annotations already declare readOnly, idempotent, non-destructive and openWorld, so the safety profile is covered. The description adds the shape of returned fields (quoted_name, conditional quoted_qualified_name), but says nothing about scope, result size, pagination, or filtering — and an output schema already exists, so the return-field detail is partly duplicative.

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 compact sentences, front-loaded with the core purpose. The second sentence spends disproportionate space on quoted_name formatting nuances rather than on the undocumented filter parameter.

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?

Purpose and returned data are adequately described. The main gap is filter semantics, but with annotations and an output schema in place, the description covers what the agent needs to call it correctly for its core listing use case.

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

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

One parameter ('pattern') exists with 0% schema description coverage, and the description never mentions it. An agent cannot tell whether it is a regex, a SQL LIKE pattern, a substring match, or what happens when it is null. This is the definition's largest functional 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?

States a specific verb and resource ('List users in the Snowflake account') plus the notable fields returned (login status, default roles), so an agent can tell this apart from governance_list_roles or databases_list_databases. It stops short of explicitly contrasting with the closest sibling, governance_describe_user.

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

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

No guidance on when to use this versus governance_describe_user (single user detail) or governance_list_grants_to_user. The use case is only implied by the tool name; no prerequisites, exclusions, or alternatives are named.

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