Databricks

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

The annotations indicate no destructive or read-only behavior, and the description adds meaningful context about browser login, token handling, session-only vs permanent authentication, and the no-argument behavior of returning a link. It gives useful behavioral disclosure beyond the schema and 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 compact and front-loads the authentication action, with the key usage modes explained in three sentences. Minor awkwardness like 'MCP.AI for IDE agents' slightly weakens clarity, but no sentence is wasted.

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

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

For a simple tool with one optional parameter and no output schema, the description covers the essential flow: obtaining the link from the login, optional token input, and persistent config alternative. It is complete enough for an agent to make the right 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?

Even though the schema only lists 'token' with no description, the tool description explains that 'token' is a JWT to paste, and that omitting the token returns a login link. This compensates well for the lack of param descriptions.

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

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

The description clearly states the tool authenticates to the MCP server via a browser login and access token, with two concrete modes of use. It is specific about the action and resource, though it does not explicitly differentiate from the sibling 'connect' tool.

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

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

The description provides explicit usage guidance: prefer a config-level Authorization header for permanent login, or pass a token for session-only login, or call with no arguments to get the login link. It does not explicitly mention when not to use the tool, but the alternatives are well covered.

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 safety (readOnly, idempotent, non-destructive). The description adds conditional behavior (different outputs for connected vs missing credentials) and mentions URLs, which is extra context beyond annotations. It doesn't contradict anything.

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 purpose, then explains variations. No wasted words.

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

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

Despite no output schema, the description fully explains the return states (authenticated, pending, URLs) and the conditional behavior. With zero parameters secret is minimal, and the description covers all necessary info.

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?

Tool has 0 parameters, so baseline is 4. No parameter info needed.

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

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

Clearly states it returns connection status and URLs, with distinct descriptions for authenticated vs. pending states. The verb 'returns' and resource 'connection status and URLs' are specific. It distinguishes from siblings like 'authenticate' and 'toolkit_info' by focusing on status and URLs.

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

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

The description implies usage for checking connection status by describing what it returns under different conditions, but it does not explicitly name alternatives or state when not to use it. It gives clear context for when it reports authenticated vs. missing credentials, which is useful.

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 indicate readOnlyHint=false, destructiveHint=false, and idempotentHint=false, which suggest this is a mutating operation but not destructive. The description adds that it cancels statements, which implies a state change, but it does not disclose details like whether cancellation is irreversible, what happens to the statement's results, or any side effects. With annotations present, the description adds minimal extra context beyond the basic action.

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

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

The description is a single sentence, concise and front-loaded with the action. It includes the key parameter and its type. However, it could be slightly more structured by separating the parameter explanation, but it is efficient and free of fluff.

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

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

The tool has 2 parameters, no output schema, and minimal annotations. The description is too brief to be complete: it doesn't explain the 'account' parameter, doesn't mention any prerequisites (like authentication), doesn't describe the expected behavior when statements are not found or already completed, and doesn't indicate any error conditions. For a mutation tool with no output schema, this is insufficient.

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

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

Schema description coverage is 0%, so the description must compensate for parameter meaning. The description mentions 'statement_ids' but does not explain the 'account' parameter at all. It also doesn't clarify the format of statement IDs or whether the list can be empty. The description adds some value for statement_ids but leaves 'account' undocumented, which is a significant gap given the low schema coverage.

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

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

The description clearly states the tool cancels one or more running statements by ID, using the verb 'Cancela' (cancels) and specifying the resource (statements) and the key parameter (statement_ids). It distinguishes from siblings like databricks_get_statement and databricks_run_sql, 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?

The description implies usage: cancel running statements by providing their IDs. It does not explicitly state when to use this tool versus alternatives, nor does it mention any prerequisites (e.g., needing an active connection or authentication). The context is clear but lacks explicit guidance on when not to use 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=true and idempotentHint=true, so the description doesn't need to repeat that. It adds the implementation detail 'via SCIM Me' and the intended use of validating the token, which is useful but not essential. There are no hidden side effects disclosed, but the description covers the core behavior adequately without contradicting 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 two short sentences with no filler. The first sentence immediately states the purpose, and the second adds practical usage context. Every word earns its place, and it is front-loaded with the main action.

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

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

For a simple read-only tool with good annotations, the description covers the purpose and use case. However, it lacks an explanation of the 'account' parameter and does not describe the return value (since there is no output schema). This is a moderate gap for a tool that likely returns user details, and the missing parameter documentation reduces completeness.

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

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

The schema has one optional parameter 'account' with no description (coverage 0%). The tool description does not mention this parameter at all, leaving the agent to guess its meaning. Given zero schema coverage, the description should compensate, but it fails to provide any guidance on what 'account' refers to or how to use it.

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

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

The description clearly states the tool's action ('Identifica o usuário do PAT no workspace') and specifies the method ('whoami via SCIM Me'). It is distinct from sibling tools which all focus on other resources like tables, warehouses, or SQL, so no ambiguity about what this tool does.

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

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

It explicitly states when to use it: 'Útil pra confirmar qual conta/host está conectado e validar o token.' This provides clear context for when this tool is appropriate, though it doesn't mention exclusions or alternatives (which are not needed given its unique purpose).

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 the polling behavior and the ability to handle multiple statement IDs, which is useful context beyond annotations. However, it doesn't describe response format or potential errors, so 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?

The description is a single, concise sentence that packs in the purpose, the use case, and the key parameter behavior. It's front-loaded with the main action and resource, and every word earns its place. No fluff.

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 (2 params, no output schema, no nested objects) and the strong annotations, the description is fairly complete. It covers the main use case (polling) and the key capability (multiple IDs). It could mention the 'account' parameter, but that's a minor gap. The description is adequate for an agent to understand when and how to use 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 description coverage is 0%, so the description must compensate. It explains that statement_ids is a list of IDs for statements to poll, which adds meaning beyond the schema. However, the 'account' parameter is not mentioned in the description, and with only 2 parameters, the description could have covered both. The description adds some value but doesn't fully compensate for the lack of schema descriptions.

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

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

The description clearly states the tool retrieves status and results for one or more statements by ID, specifically for polling long-running queries. It distinguishes itself from siblings like databricks_run_sql and databricks_cancel_statement by mentioning the polling use case and the ability to accept a list of statement IDs.

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 explicitly mentions when to use this tool: for polling queries that returned PENDING/RUNNING from run_sql. This provides clear context for usage, though it doesn't explicitly mention alternatives or when not to use it, which would be a 5.

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, destructiveHint=false, idempotentHint=true, so the agent knows this is a safe read. The description adds that it provides columns and types)Skip"; it does not contradict annotations. It lacks extra behavioral detail like pagination or error cases, but the annotations cover the safety profile, so 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?

Two sentences, front-loaded with the core purpose, and no filler. Every word contributes to understanding what the tool does and its main parameter. Highly concise.

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

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

The tool is a simple read operation with low complexity. The description covers the operation, the key parameter format, and what it returns (columns/types). No output schema exists, but the description sufficiently implies the return content. It's complete enough for an agent to select and use 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 0%, so the description must explain parameters. It explains that full_names is a list (array) and that the entries must be full names in `catalog.schema.table` format, which is essential. The optional 'account' parameter is not mentioned, but it's likely supplementary; overall, the description adds meaningful semantics beyond the raw schema.

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

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

The description clearly states the tool details tables (columns, types) by full name, which is a specific verb+resource. It differentiates from sibling databricks_list_tables by specifying 'full name' and the detail level (columns, types), though it doesn't explicitly name the alternative.

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

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

The description implies usage: use this when you need column and type details for specific tables by full name. It does not explicitly state when not to use it or mention alternatives like databricks_list_tables, but the context from siblings and the 'full name' requirement provide implicit guidance.

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

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

Annotations already declare readOnlyHint, idempotentHint, and destructiveHint, covering the safety profile. The description adds no extra behavioral context beyond what annotations provide, but it does not contradict them. Given the annotations, a score of 3 is appropriate as the description is not misleading, though it adds little value.

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 extremely concise: two short sentences with no filler. It is front-loaded with the core purpose and efficiently communicates the main functionality.

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 get-by-id tool, the description is adequately complete, but it omits the purpose of the 'account' parameter and does not clarify the return format (e.g., whether it returns an array for multiple IDs). Given the lack of schema descriptions, some additional context would be helpful.

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

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

Schema description coverage is 0%, so the description must compensate. It mentions 'ids' and clarifies it accepts a list, but it does not explain the 'account' parameter at all. Since there is no schema description, the failure to explain 'account' leaves a significant gap in param semantics.

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

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

The description clearly states the tool's purpose: it details SQL warehouses by ID, using the verb 'Detalha' (details) and specifies the resource (SQL warehouses). It distinguishes from list_warehouses, but could be more explicit about the contrast. It gives enough specificity to understand it's a get-by-id operation.

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

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

No guidance is provided on when to use this tool versus alternatives like databricks_list_warehouses. The description only says what it does, not when to use it or when not to. There is no mention of context, prerequisites, or alternative 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=true, idempotentHint=true, and destructiveHint=false, so the safety profile is clear. The description adds that it returns host and label, which is useful but minimal. It does not disclose any additional behavioral traits like pagination or filtering, but given the annotations cover the main safety aspects, 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?

The description is a single, concise sentence that front-loads the purpose and includes the key output fields. There is no wasted text, and it is appropriately sized for a simple list 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?

Given the tool's simplicity (one optional param, no output schema, read-only), the description is mostly adequate. However, the lack of parameter explanation and any mention of return format or filtering leaves some gaps, but it is not severely incomplete for a basic list tool.

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

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

The schema has one optional parameter 'account' with no description, and schema description coverage is 0%. The description does not explain what 'account' means or how it affects the results. Since the description must compensate for the lack of schema documentation but fails to do so, this scores low.

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

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

The description clearly states the tool lists Databricks workspaces connected to this install, including host and label. It uses a specific verb ('Lista') and resource ('workspaces Databricks'), which distinguishes it from sibling tools like databricks_list_catalogs or databricks_list_warehouses.

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

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

The description implies usage for viewing connected workspaces but does not explicitly state when to use this tool versus alternatives. It lacks guidance on when not to use it or mention of any prerequisites, though the context of listing workspaces is clear enough for basic selection.

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 provide the read-only, idempotent, non-destructive safety profile. The description adds context beyond annotations by noting that the returned catalogs are filtered by PAT visibility and by listing the fields returned (name, comment, owner). No behavioral contradictions 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?

The description is a single succinct, front-loaded sentence that covers action, scope, and output fields with no filler. It is appropriately concise for a simple read-only list 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 read-only list tool, the description covers the core resource, authorization scope, and returned fields, while annotations cover safety. However, the unexplained `account` parameter and lack of any output schema leave a meaningful gap in the overall completeness.

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

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

The single optional `account` parameter has no schema description (0% coverage), and the tool description never mentions `account` or how it should be used. An agent cannot tell whether `account` is an account ID, workspace identifier, or how it relates to the PAT. The property name provides only an implicit hint.

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 action verb ('Lista') and identifies the exact resource ('catálogos do Unity Catalog'), plus the authorization scope ('visíveis ao PAT') and returned metadata fields. This is unambiguous and clearly differentiates it from sibling tools like databricks_list_schemas and databricks_list_tables.

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

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

The description establishes clear context: use this tool when you need Unity Catalog catalogs accessible to the current PAT. It does not explicitly name alternatives or exclusions, but the resource and scope make the intended use clear enough for this simple list operation.

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 indicate readOnlyHint=true, idempotentHint=true, and destructiveHint=false, so the safety profile is known. The description adds the catalog-scoped listing behavior but does not provide additional behavioral context such as pagination, sorting, or error cases. It is consistent with annotations.

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

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

The description is one concise sentence with no filler. It front-loads the purpose and followswith the required input, making it easy to scan and act on.

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

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

For a simple, read-only list operation with strong annotations, the description provides the essential context: what is listed and what input is required. It does not document `account`, but the overall complexity is low and the output behavior is strongly implied by 'Lista os schemas'.

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

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

Schema description coverage is 0%, and the description only clarifies `catalog_name`, which is the required parameter. The optional `account` parameter receives no explanation, leaving part of the invocation surface undocumented. This is a clear gap in parameter semantics.

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

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

The description clearly states the tool's function: listing schemas (databases) within a Unity catalog. This is specific enough to distinguish it from sibling tools like databricks_list_catalogs and databricks_list_tables.

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

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

The description explicitly instructs the user to provide `catalog_name`, which is the essential prerequisite for correct invocation. It does not mention alternatives or when-not conditions, but the usage context is clear and unambiguous for this simple list operation.

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 description carries a lower burden. It adds useful context by specifying the return fields (name, table_type, data_source_format) and the required inputs, which goes beyond what annotations provide.

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

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

The description is a single, front-loaded sentence that immediately states the action and scope. It includes only necessary information with 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?

For a simple read-only listing tool with strong annotations, the description provides sufficient context: what it does, what fields are returned, and which parameters are required. The only gap is the unexplained 'account' parameter, which is minor given its optional status and the tool's overall simplicity.

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 explicitly tells the user to inform catalog_name and schema_name, which matches the required parameters. However, the optional 'account' parameter is not mentioned at all, and with 0% schema description coverage, the description does not fully compensate for all three parameters.

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

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

The description uses a specific verb ('Lista') and resource ('as tabelas de um schema Unity'), clearly distinguishing it from sibling tools like databricks_list_schemas (lists schemas) and databricks_get_table (gets a single table). It also names the returned fields, making the purpose unambiguous.

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

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

The description implies the tool should be used when you need tables within a given catalog/schema, but it does not explicitly state when NOT to use it or mention alternatives like databricks_list_schemas or databricks_get_table. Clear context, but no exclusions or alternative references.

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, destructiveHint=false, idempotentHint=true, so the safety profile is known. The description adds that it lists warehouses with specific fields, but does not elaborate on response shape, pagination, or error conditions. It doesn't contradict annotations, so no red flag, but it adds minimal behavioral detail beyond 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?

Two concise sentences. The first states the exact output fields, the second provides actionable usage guidance. Front-loaded, no fluff, efficient.

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

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

The tool is simple (list warehouses) and the description covers output fields and integration with run_sql. It doesn't mention pagination or the output structure, but given the tool's simplicity and the presence of readOnly/IDEMPOTENT hints, it's sufficient. Minor gap is the unaddressed `account` parameter.

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

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

The only parameter `account` has 0% schema coverage and the description does not mention it at all. Since the description carries the burden for parameter meaning with such low coverage, this is a clear gap. The parameter is optional, but its purpose (likely selecting a Databricks account) is not explained and could cause confusion.

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

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

The description clearly states it lists SQL warehouses with specific fields (id, name, cluster_size, warehouse_type). It distinguishes this tool from siblings like databricks_get_warehouse (which fetches a single warehouse) and databricks_run_sql (which executes queries) by explicitly linking usage to run_sql.

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

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

It provides concrete usage guidance: use the returned `id` in databricks_run_sql, and notes that run_sql can automatically choose a RUNNING warehouse. It doesn't explicitly say when NOT to use this tool, but the context and pointer to run_sql makes the intended usage clear enough.

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

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

While annotations already indicate non-read-only and non-idempotent behavior (readOnlyHint=false, idempotentHint=false), the description adds valuable context: timeout behavior returns statement_id and state for polling, automatic warehouse selection when warehouse_id is omitted, and the mutability risk of arbitrary SQL. This goes beyond annotation hints without contradiction.

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

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

The description is concise and front-loaded with the main purpose, followed by usage guidance and bulk support note. Two short paragraphs with no filler, though slightly longer due to multiple guidance points.

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 10 parameters and no output schema, the description covers the core behaviors, timeout handling, parameterization, and bulk execution. It doesn't detail every parameter but provides enough operational context for an agent to use the tool correctly. Reasonably complete for the complexity.

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

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

Schema description coverage is 0%, so the description must compensate. It explains the purpose of warehouse_id, wait_timeout, parameters, and warehouse_ids, but omits details for schema, account, catalog, row_limit, and on_wait_timeout. Partial compensation; some key parameters remain undocumented.

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

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

The description clearly states the tool executes a SQL statement on a SQL warehouse via the Statement Execution API, and distinguishes itself from the sibling databricks_get_statement which is used for polling. It also mentions bulk support, making the purpose specific and 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?

Provides explicit guidance: use this tool to run SQL and get results within wait_timeout, and fall back to databricks_get_statement for polling. It also instructs preferring parameterized queries over interpolation for SQL injection protection and warns to confirm before mutating data since DML/DDL is allowed. Clear context and alternatives.

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

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

The description discloses that writes (install/uninstall/subscribe/cancel) require workspace owner/admin, and that invoke can run uninstalled MCPs while returning connect/checkout links when needed. This goes beyond the annotations and gives critical operational context.

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

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

The description is a single dense paragraph covering many concepts. While logically ordered, it is lengthy and lacks bullet points or sections, making it harder to scan. Every sentence adds value, but better structure would improve readability.

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

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

The description thoroughly covers the marketplace flow, install vs invoke nuances, permission requirements, and the prompt library. However, the complete absence of parameter guidance for a 23-parameter schema is a major gap that prevents full operational completeness.

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

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

Schema description coverage is 0%: the description does not explain any of the 23 parameters, even the central 'action' enum. Although it references actions conceptually, it gives no guidance on how to populate fields like query, mcp_id, tool_id, or arguments, leaving the agent to guess entirely.

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

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

The description clearly states this is the official mcp.ai marketplace for discovering and running MCPs/tools, with specific actions (search, describe, invoke, install, etc.). It distinguishes itself from sibling databricks tools by focusing on catalog discovery and execution orchestration.

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?

Explicit guidance is provided: 'prefer invoke for a single/occasional use', 'use install only to make an MCP PERMANENT', and clear direction on when to use search vs describe. It also explains the auth/credential flows and distinguishes between installed versus one-off execution.

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 provide idempotent, non-destructive, and non-read-only hints. The description adds no behavioral context beyond this; the conversation array mention is about input format, not tool behavior. No side effects, response, or post-conditions are disclosed.

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

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

Two sentences, front-loaded with purpose and critical usage note. No filler or redundancy. Every word earns its place.

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

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

For a simple 3-parameter report tool with no output schema, the description covers the core purpose and the one non-obvious parameter (conversation). However, it omits context and doesn't indicate what happens after reporting, leaving gaps for the agent.

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

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

Schema description coverage is 0%, so the description must compensate. It implies 'message' is the bug/feedback text and 'conversation' is an array for reproduction, but does not mention 'context' at all. This partial guidance provides some value but leaves one parameter undefined.

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 'report' with clear resources: bug, missing feature, or feedback. This distinctly separates it from sibling tools that are all databricks operations or authentication utilities.

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 purpose implies usage for reporting issues, but no explicit when-to-use or exclusions are given. The instruction to include the conversation array is content guidance, not usage context. No alternatives are mentioned.

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

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

The description aligns with the annotations (readOnlyHint, idempotentHint, destructiveHint) but adds no additional behavioral context beyond stating 'Show'. It does not describe return format or any potential side effects, though annotations cover the safety profile. This is adequate but not enriching.

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

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

The description is a single concise sentence with no superfluous words. It is well-structured and front-loaded, immediately conveying the tool's function.

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 (no parameters, no output schema, and annotations covering safety), the description adequately explains the action. It could mention what the version output looks like, but the core purpose is clear and complete for a version check tool.

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

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

The tool has zero parameters, so the baseline score is 4 per the rubric. The description correctly avoids parameter details, and the schema already indicates no properties.

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

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

The description clearly states the tool's purpose with a specific verb ('Show') and resource ('current MCP platform and adapter versions'), distinguishing it from sibling tools focused on authentication, SQL, or table operations.

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

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

No explicit guidance is given on when to use this tool versus alternatives. The purpose implies use when version information is needed, but there is no mention of exclusions or alternative tools, so it meets only the 'implied usage' level.

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, covering the safety profile. The description adds valuable behavioral detail about the exact return content (installed MCPs, status, accounts, tool counts), which goes beyond minimal annotation coverage and gives agents an accurate expectation of the tool's output.

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, compact sentence that front-loads the verb 'Returns' and immediately lists the key data points. Every element adds value and there is no fluff 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?

The tool is simple (no parameters, no output schema) and the description fully covers what it does and what it returns. It includes all needed context for an agent to know when to use it—getting an overview of connections and tool availability—and it is sufficiently detailed for this zero-parameter info tool.

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

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

There are zero parameters, so the baseline is 4. The description adds no parameter-specific meaning because none exist; the input schema is empty and the description fully clarifies that the tool takes no inputs and simply describes the toolkit state.

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

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

Description uses a specific verb 'Returns' with a clear resource 'current toolkit state' and enumerates the exact contents (installed MCPs, connection status, accounts, catalog tool counts), making it fully distinct from sibling tools like databricks_get_warehouse or show_version.

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

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

The description implies usage by stating what it returns (toolkit state, connections, accounts), which tells an agent this is the go-to for an overview before other operations. It doesn't explicitly state when not to use it or name alternatives, but the purpose is self-evident and no exclusions seem necessary.

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