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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It describes the inputs and outputs but does not mention side effects, authentication needs, constraints (e.g., card must exist, dashboard must exist, or duplicate handling), or what happens on failure. This is adequate but minimal.

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

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

The description is efficiently structured as a docstring with a brief summary followed by Args and Returns sections. Each line is necessary, no fluff, and the information 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?

The tool has 6 parameters, an output schema, and moderate complexity. The description covers inputs and the returned object. It lacks details about the grid coordinate system bounds, error cases (e.g., invalid position), or behavior when card already exists. These are minor gaps but do not severely hinder usage.

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 provides meaningful explanations for all 6 parameters, including their role (e.g., 'Column position on the dashboard grid') and defaults. This adds significant value beyond the schema, which has 0% description coverage. Each parameter is clearly defined, enabling correct usage.

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 action: adding an existing card to a dashboard at a specified position and size. It distinguishes itself from siblings like create_card (which creates new cards) and get_dashboard_cards (which lists existing cards), making its 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?

The description provides clear parameter details and implies usage for adding cards to dashboards, but it does not explicitly state when to use this tool versus alternatives like update_card_display or context about prerequisites. However, the context is clear enough for an agent to infer appropriate usage.

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

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

No annotations provided, so description carries full burden. It states 'Create' (write operation) and lists required fields, but lacks details on permissions, side effects, idempotency, rate limits, or validation behavior. Returns the created object, but no error scenarios.

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 clear sections (Args and Returns) with no extraneous text. Each sentence serves a purpose. Highly efficient and front-loaded.

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

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

Given 6 parameters, 3 required, and no annotations, the description covers creation essentials but lacks behavioral context. Output schema exists (per context), so return description is sufficient. Could improve by noting that collection_id must exist, or that query must be valid SQL.

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%, but description provides brief explanations for each parameter (e.g., 'SQL query for the card', 'Optional description'). This adds meaning beyond the raw schema, though details like query syntax or visualization object format are absent.

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 clearly states 'Create a new question/card in Metabase' with specific verb 'Create' and resource 'card'. It distinguishes from siblings like 'create_mongodb_card' and 'add_card_to_dashboard' by focusing on standard SQL-based card creation.

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 tool versus alternatives. For example, it doesn't specify that this tool is for SQL-based queries and that 'create_mongodb_card' should be used for MongoDB. Missing exclusions or context.

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

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

With no annotations, the description bears full responsibility for behavioral disclosure. It only indicates creation, but lacks details on permissions, side effects, idempotency, or uniqueness constraints. The description is minimal for a mutation tool.

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 well-structured: a one-line summary followed by a bulleted Args list and a Returns line. Every sentence serves a purpose with no 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 create tool with an output schema, the description covers the action and return value adequately. However, it omits potential error conditions or uniqueness requirements, which would improve 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 input schema has no property descriptions (0% coverage), but the description explicitly explains each parameter's purpose (e.g., 'name: Name of the collection'). This adds meaningful context beyond the schema, though format or constraints are not detailed.

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 'Create a new collection in Metabase,' specifying the verb (create) and resource (collection). It distinguishes itself from sibling tools like list_collections and create_card, though it does not explicitly contrast them.

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

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

The description provides no guidance on when to use this tool versus alternatives, such as when to create a collection vs. a card. No prerequisites, limitations, or exclusions 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?

With no annotations provided, the description carries the full burden. It correctly states that the tool creates a new dashboard and returns the object, but does not disclose any side effects, authorization needs, rate limits, or persistence details. Basic, but adequate for a straightforward creation tool.

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 efficiently structured with a one-line purpose statement followed by clear Args and Returns sections. Every sentence adds value without redundancy. The front-loaded purpose immediately informs the agent.

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 moderate complexity (4 params, no annotations, but output schema exists), the description covers the essential aspects. It explains each parameter and the return value. Minor omissions include default behavior for collection_id and detailed parameter format, but overall 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?

The input schema has 0% parameter descriptions, yet the tool description provides one-line explanations for all four parameters (name, description, collection_id, parameters). This adds meaningful context beyond the schema types, though it could be more explicit about the format of '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 explicitly states 'Create a new dashboard in Metabase.' which is a clear verb-resource pairing. The tool name 'create_dashboard' aligns perfectly with this purpose, and it is well-distinguished from sibling tools like 'list_dashboards' and 'update_dashboard'.

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 creating a new dashboard but lacks explicit guidance on when to use this tool versus alternatives (e.g., when a dashboard already exists, or prerequisites like collection existence). No exclusions or contextual hints are provided.

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

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

No annotations exist, so the description carries full burden. It mentions the creation action and return of the model object, but does not disclose side effects, permissions, or error conditions.

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 well-structured with a brief opening, model explanation, and clearly separated Args/Returns sections. It is appropriately sized, though the explanation of models could be slightly more 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?

Given the presence of an output schema, the description adequately covers purpose, parameters, and returns. However, it lacks details on prerequisites, default behavior (e.g., collection placement), and limitations.

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 0% description coverage, but the tool description provides detailed explanations for all 7 parameters in the Args section, adding significant meaning 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 'Create a new model in Metabase' and explains that a model is a curated dataset, distinct from saved questions. This distinguishes it from sibling tools like 'create_card' and 'create_mongodb_card'.

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

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

The description explains that models serve as curated datasets and building blocks, providing context on when to use this tool. However, it lacks explicit 'when not to use' guidance or comparisons to 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?

No annotations are provided, so the description carries the full burden. It explains the creation action and return value but does not disclose side effects, permissions, idempotency, or error conditions. The behavioral transparency is adequate but not thorough.

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 efficiently structured with Args/Returns sections, covering all parameters and return value in a concise manner without superfluous information. Every sentence adds value.

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

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

Given the tool has 7 parameters and an output schema, the description covers the core purpose, parameters, and return value. However, it lacks details on error handling, prerequisites, or distinct use cases relative to sibling tools, leaving some 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?

With 0% schema description coverage, the description compensates by listing each parameter with a brief explanation (e.g., 'MongoDB query string (aggregation pipeline or query)'). The descriptions add meaning beyond the raw schema, though some could be more detailed (e.g., format of 'query').

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 'Create a new MongoDB question/card in Metabase,' specifying the verb (Create), resource (MongoDB question/card), and context (Metabase). This distinguishes it from sibling tools like 'create_card' which may target other databases.

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 creating MongoDB cards but does not explicitly compare with alternatives like 'execute_mongodb_query' (run without saving) or 'create_card' (generic). No 'when not to use' guidance is provided.

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

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

No annotations are provided, so the description carries full burden. It only states that results are returned, without disclosing side effects, authentication needs, rate limits, or whether card execution triggers mutations. The behavior beyond the basic action is opaque.

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 at 5 lines with clear Args and Returns sections. The first sentence is front-loaded with the core purpose. Minor redundancy exists (e.g., 'The ID of the card to execute' is implied), but overall 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?

With 2 parameters, no annotations, and an output schema (unseen), the description leaves gaps: it doesn't hint at the result structure (tabular, paginated) or when to use this tool vs. siblings. It is minimally adequate but not fully informative.

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 adds minimal value: 'card_id' is labeled as ID, 'parameters' are 'optional for card execution'—nearly repeating the schema types. No details on parameter structure or allowed values are given.

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 verb 'execute', the resource 'saved Metabase question/card', and the outcome 'retrieve results'. This specificity distinguishes it from sibling tools like 'execute_query' (raw SQL) and 'create_card'.

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

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

The description provides no guidance on when to use this tool versus alternatives. It doesn't mention when to prefer 'execute_card' over 'execute_query' or 'execute_mongodb_query', nor does it state prerequisites or exclusions.

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

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

With no annotations, the description carries full burden. It only says 'Execute' and returns results, but omits behavioral traits such as whether the query is read-only (likely safe), mutability, side effects, error handling, or performance considerations.

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, using a clear docstring format with Args and Returns sections. It front-loads the main purpose and avoids unnecessary 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?

Given the complexity of MongoDB native queries and the presence of an output schema, the description covers basic parameters and return value. However, it lacks details on the query format, native_parameters usage, and typical response structure, which are important 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 coverage is 0%, so the description's parameter explanations add value. Each parameter (database_id, collection, query, native_parameters) is described in the docstring. However, the 'query' parameter format (aggregation pipeline or query object) is mentioned but could be more precise.

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 'Execute a MongoDB native query against a Metabase database,' specifying the verb (execute), resource (query), and context (MongoDB/ Metabase). This distinguishes it from siblings like execute_query (likely SQL) and execute_card (card execution).

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 defines parameters but does not explicitly state when to use this tool over alternatives like execute_query or create_mongodb_card. It implies MongoDB usage but lacks explicit when-to-use or when-not-to-use guidance.

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

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

With no annotations, the description carries full burden. It only states it executes SQL and returns results, without disclosing potential side effects (e.g., whether write operations are allowed), security implications, authentication needs, or rate limits. Critical behavioral context is missing.

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

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

The description is extremely concise: a one-line purpose, then clearly labeled Args and Returns sections. Every sentence adds value, and there is no redundancy. It is well-structured and easily parsed.

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 complexity of executing arbitrary SQL (3 parameters, potential write operations), the description lacks completeness. It does not explain return value structure (though output schema exists), error handling, or preconditions. However, it covers the basic purpose and parameters adequately for a simple 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 0% description coverage, so the description compensates by providing plain-language explanations for each parameter: database_id as 'The ID of the database to query', query as 'The SQL query to execute', and native_parameters as 'Optional parameters for the query'. This adds meaning beyond the bare types, though native_parameters could be more specific.

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 action ('Execute a native SQL query') and the resource ('Metabase database'), distinguishing it from siblings like execute_card (executes a saved card) and execute_mongodb_query (executes MongoDB queries).

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

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

The description provides no guidance on when to use this tool versus alternatives (e.g., execute_card, or specific query tools). It does not mention constraints, prerequisites, or typical use cases, leaving the agent to infer 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?

No annotations provided, so the description carries full burden. It implies a read operation but does not explicitly state non-destructiveness, authorization needs, or side effects. Minimal behavioral disclosure.

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?

Concise, well-structured with Args and Returns sections. Every sentence is informative, 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?

Tool is simple with one parameter and output schema exists. Description covers purpose and return fields well. Could mention error handling (e.g., invalid dashboard_id) but not critical.

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%; description adds 'The ID of the dashboard' for the only parameter. Adds basic meaning but no additional details like source or 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?

The description clearly states it retrieves cards and layout for a specific dashboard, listing returned fields. It distinguishes from siblings like list_cards (no dashboard context or layout).

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 tool versus alternatives (e.g., list_cards). The description does not mention when not to use it or provide context for 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?

With no annotations, the description carries full burden. It discloses the return type ('dictionary with field metadata') and truncation behavior, but lacks details on potential errors, authentication requirements, or performance characteristics. Minimal but adequate.

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, with two sentences and a formatted arg list. Every sentence adds value: purpose, parameters, and return behavior. 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?

Given the tool's simplicity (2 params, output schema exists), the description covers purpose, parameter details, return type, and truncation. However, it does not elaborate on what 'field metadata' includes or the exact behavior of truncation, leaving minor gaps.

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

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

Schema description coverage is 0%, so the description compensates by explaining 'table_id: The ID of the table' and 'limit: Maximum number of fields to return (default: 20)'. This adds meaningful context beyond the raw schema structure.

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 verb 'get' and the resource 'fields/columns in a specific table'. It distinctly differentiates from sibling tools like list_tables and list_databases by targeting table fields specifically.

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 guidelines on when to use this tool versus alternatives. Although the name and description imply it's for retrieving column metadata from a table, there is no mention of prerequisites, when to use list_tables first, or scenarios where other tools might be more appropriate.

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

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

No annotations are provided, so the description carries the full burden. It discloses the operation is a non-destructive read ('List'), and specifies the return format ('Dictionary containing all cards with their metadata'). This is sufficient for a simple tool.

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, front-loaded sentences with no superfluous information. Every sentence adds value: the first describes purpose, the second describes return value.

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

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

Given no parameters and a simple list-all behavior, the description fully covers purpose and output. The presence of an output schema is implied by the return description, and no additional context is needed.

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 no parameters (schema coverage is 100% trivially). The description adds no parameter info because none exist. Baseline for zero parameters is 4.

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 action as 'List' and the resource as 'saved questions/cards in Metabase'. It distinguishes itself from sibling tools like create_card or execute_card by focusing purely on retrieval.

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 as a simple listing tool but provides no explicit guidance on when to use it versus alternatives like get_dashboard_cards or search queries. The purpose is clear, but differentiation from similar tools is not addressed.

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

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

With no annotations provided, the description carries the full burden. It explicitly states that only collections the current user has read permissions for are returned, explains all four parameters (archived, exclude_other_user_collections, namespace, personal_only), and describes the return type. However, it does not disclose rate limits or error conditions.

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 concise paragraphs: one for purpose and one for parameters/returns. It uses a clear docstring-style list for Args and Returns, with no superfluous words. Every sentence adds value.

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

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

The tool has 4 optional parameters explained fully, an output schema exists (so return details are not required), and the description covers both input and output adequately. It provides enough context for an agent to invoke the tool correctly without ambiguity.

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 0% coverage (no descriptions in schema), so the description compensates fully by explaining each parameter in detail. The Args section provides clear semantics for 'archived', 'exclude_other_user_collections', 'namespace', and 'personal_only', which are absent from the schema.

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

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

The description clearly states the action ('List all collections') and the resource ('collections in Metabase') with a specific scope ('that the current user has read permissions for'). It distinguishes itself from sibling tools like 'create_collection' by being a read-only list 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?

The description implicitly indicates usage for listing viewable collections but does not provide explicit guidance on when to use this tool versus alternatives or when not to use it. No alternative tools are mentioned, though the sibling list includes related 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?

No annotations provided, but the description adds useful metadata about the return list (id, name, description, etc.). However, no disclosure of potential side effects, permissions, or performance considerations.

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, front-loaded with the main purpose. Could be slightly tighter, but no redundant 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 simple tool with no parameters and an output schema, the description adequately covers purpose and return format. However, missing usage context like whether it requires authentication or handles large result sets.

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 with 100% schema coverage; the description adds value by explaining the return fields, which the schema doesn't specify. This is informative beyond the schema.

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

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

The description clearly states 'List all dashboards' with a specific verb and resource, distinguishing it from siblings like list_cards and list_collections which list different entities.

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

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

No explicit guidance on when or when not to use this tool. The description implies a simple listing use case, but lacks exclusions or 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?

With no annotations, the description carries full behavioral disclosure. It states the return type (list of dashcards with layout and metadata), which is sufficient for a read operation. It does not mention error behavior or side effects, but for a simple list tool this is acceptable.

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, front-loading the purpose and then detailing args and returns with no extraneous 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?

For a simple two-parameter list tool with an output schema, the description provides all necessary information: what the tool does, input parameters with context, and return content. No gaps are apparent.

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 adds meaning to both parameters: dashboard_id is identified as the dashboard's ID, and tab_id is linked to 'list_dashboard_tabs' output. This goes beyond the bare schema which only shows type and requirement.

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 cards belonging to a specific tab on a dashboard, using specific verb 'list' and resource 'cards'. It distinguishes from siblings like 'get_dashboard_cards' which likely lists all cards on a dashboard without tab filtering.

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 when to use this tool by specifying the tab_id should come from 'list_dashboard_tabs', providing a clear context. However, it does not explicitly mention when not to use it or directly compare with alternatives like 'get_dashboard_cards'.

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

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

No annotations provided, but the description explains the return value (list of tab objects with id, name, position) and edge cases (empty list). It lacks information on error handling or 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 concise with two sentences and a structured Args/Returns section, front-loaded with the main purpose. No unnecessary 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?

Given the tool's simplicity (one parameter, no nested objects) and the presence of an output schema, the description covers input, output format, and edge cases completely.

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 adds meaning for the single parameter dashboard_id, explaining its role. This compensates for the 0% schema description 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 it lists all tabs on a dashboard, with a specific verb and resource. It distinguishes itself from siblings like list_dashboards and list_dashboard_tab_cards.

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 when needing to retrieve tab information, but does not explicitly state when to use it versus alternatives or provide prerequisites.

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?

Descriptively states the return value (dictionary with metadata), providing behavioral context beyond the empty input schema, though no annotations exist to supplement.

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?

Extremely concise: two sentences with front-loaded action and minimal 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?

For a simple list tool with no parameters and an output schema, the description is adequate, but could optionally include more detail about metadata fields.

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?

No parameters exist, so schema coverage is 100%; baseline for 0 params is 4, and description adds no additional parameter detail.

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 lists all databases in Metabase, which is specific and distinguishes from sibling tools like list_cards or 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?

No explicit guidance on when to use vs alternatives; the tool name and description imply usage for retrieving database list, but no when-not 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?

The description discloses the return format (formatted markdown table) and specifies the required input. While read-only behavior is implied, the lack of annotations makes this acceptable for a simple list operation.

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

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

The description is brief and well-structured, including purpose, args, and returns in a clean format with no unnecessary 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?

The description covers the core functionality, input, and output format. However, it lacks details on error handling or behavior with invalid database IDs, which would enhance 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?

With 0% schema description coverage, the description compensates by explaining that database_id is 'the ID of the database to query', adding semantic meaning beyond the schema's type-only constraint.

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 verb 'list' and resource 'tables' scoped to a specific database, distinguishing it from sibling tools like list_databases or list_cards.

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 tool versus alternatives such as get_table_fields or list_databases. The description provides no exclusions or context for 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?

Despite no annotations, description fully discloses atomic update behavior, that omitted fields retain current values, and return value (updated dashboard object). No conflict or missing behavioral traits.

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?

Description is brief yet comprehensive, with clear sections (overview, Args, Returns). Every sentence adds value, and critical info is front-loaded in the first two sentences.

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 only two parameters, presence of output schema, and detailed description covering purpose, usage, parameters, and returns, the description is fully complete for this tool's complexity.

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

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

Input schema has 0% description coverage, but description explains both parameters in detail, including sub-fields of positions (dashcard_id, col, row, size_x, size_y) and their optionality, far exceeding schema's minimal info.

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 clearly states 'Reposition and/or resize multiple cards on a dashboard in a single update', uses specific verb-resource pairing, and distinguishes from sibling tools like update_dashboard_card_position by emphasizing bulk atomic update.

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?

Explicitly says 'Use this to rearrange a dashboard layout atomically' and describes behavior for omitted cards. Lacks direct comparison to alternative single-card tool, but context signals sibling list includes update_dashboard_card_position, aiding inference.

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

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

With no annotations, the description fully explains behavior: it details merging vs replacing via the 'merge' parameter, notes that existing fields are preserved when merge=True, and states it returns the updated card object. No destructive effects are hidden.

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 informative and well-structured with clear sections ('Args:', 'Returns:'), but it is somewhat lengthy. However, every sentence adds value and it avoids 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?

Given the tool's complexity (nested objects, 3 parameters, merge behavior, output schema exists), the description is complete: it covers all parameters, behavior, and return values, leaving no 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?

Despite 0% schema description coverage, the description thoroughly explains each parameter: card_id, template_tags (including nested structure with allowed keys), and merge (default/behavior). This adds significant meaning beyond the schema, compensating fully.

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 identifies the tool's purpose: 'Set or update the template tags on a card's native SQL query.' It specifies the resource (card's native SQL query) and action (set/update), effectively distinguishing it from sibling tools like update_card or create_card.

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

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

The description explains when to use the tool, such as changing a tag's type or setting display name/default/required. It provides clear context but does not explicitly state when not to use it or mention 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?

No annotations exist, so description fully covers behavior. States preservation of existing inline_parameters unless replace=True, unaffected dashcards, and no effect on value mappings. Clearly non-destructive and scoped.

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?

Well-structured with bullet points and clear sections. Slightly verbose but each sentence adds necessary detail. Could be trimmed slightly but remains efficient for the complexity.

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 output schema exists (not shown but referenced), description handles return value expectation. References sibling tools for related operations, ensuring agent understands full workflow. Complete for effective use.

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 has 0% description coverage, but description fully explains all three parameters: dashboard_id, inline_parameters structure (dashcard_id, parameter_ids), and replace default/replacement behavior. Adds meaning beyond schema types.

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 clearly states action: 'Attach dashboard filters inline to specific dashcards.' It distinguishes from sibling tools like set_dashcard_parameter_mappings by explaining that inline placement only affects widget rendering, not value wiring.

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 when-to-use context: moving filter widgets from header to specific cards. References prerequisites (get_dashboard_cards, update_dashboard) and complementary tool (set_dashcard_parameter_mappings). Explains behavior with replace flag.

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

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

No annotations are provided, so the description fully carries the burden. It discloses key behavioral traits: preservation vs. replacement of mappings, handling of optional fields like `kind` and `target`, and the effect on dashcards. It could add note on permissions or idempotency, but overall is transparent.

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 fairly long but well-structured with sections for parameter details and Args/Returns. It is front-loaded with the main action and uses bullet points for clarity. A slightly more concise phrasing could be used, but it's efficient and scannable.

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 complexity (3 parameters, nested objects in mappings) and the presence of an output schema, the description covers all necessary aspects. It explains parameter relationships, optional fields, and behavioral nuances like `replace` and `target` override. No gaps are apparent.

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%, yet the description thoroughly explains each parameter. For `mappings`, it details required fields (dashcard_id, parameter_id, template_tag) and optional fields (kind, card_id, target) with their semantics and effects. This adds significant meaning beyond the minimal schema.

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

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

The description clearly states the tool's purpose: 'Wire dashboard parameters to card template tags on specific dashcards.' It uses a specific verb-wire-and specifies the resource-dashboard parameters and card template tags. The action is distinct from siblings like set_dashcard_inline_parameters and update_dashboard.

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

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

The description explains when to use the tool, including the effect of the `replace` parameter and that untouched dashcards are left as-is. It provides clear context for usage but does not explicitly mention alternative tools for cases where inline parameters or other mappings are needed, though siblings are listed separately.

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 includes important behavioral details about template tag preservation when updating the query. However, it omits other traits like side effects of archiving or update permissions, and there are no annotations to supplement.

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 well-structured with a concise summary, a behavioral note, a clear arg list, and a return statement. Every sentence adds value without 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 description covers key parameter semantics and critical behavior (template tag preservation). With an existing output schema, return details are sufficient. Missing minor context like partial update semantics or error 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?

With 0% schema description coverage, the description adds full meaning for all 10 parameters, e.g., 'database_id: New database ID (required if changing query).' This compensates for the schema's lack of parameter documentation.

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 'Update properties of a saved question/card in Metabase,' specifying the verb (update) and resource (saved question/card). It distinguishes from sibling tools like create_card or list_cards.

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 does not provide explicit guidance on when to use this tool versus alternatives such as update_card_display or set_card_template_tags. It lacks context for when-not-to-use or prerequisites.

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

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

With no annotations, the description carries full burden. It discloses that the tool updates display type and optionally accepts visualization settings, but does not mention side effects, permissions, destructive behavior, or error cases.

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 structured with clear Args and Returns headers. It is concise, with no extraneous text; every sentence serves a purpose in explaining the tool's function and 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?

Given the tool has 3 parameters and an output schema exists, the description adequately covers inputs and states the return type. However, it omits potential error conditions and behavioral details that would be useful for an AI 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?

Input schema has 0% description coverage, so the description must compensate. It effectively explains all three parameters: card_id (ID to update), display (with multiple examples), and visualization_settings (optional). This adds meaning beyond the schema's type-only definitions.

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 updates the display type of a saved card in Metabase, using specific verb and resource. It distinguishes from siblings like create_card (create vs update) and execute_card (execute vs update).

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, nor any prerequisites like card existence or permissions. The description does not mention exclusions or 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?

Despite no annotations, the description details the merge behavior (replace vs. merge by id/slug) and explains the role of parameters in dashboard wiring. It does not cover auth or error conditions, but the key behavioral traits are disclosed.

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

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

The description is well-structured with a clear purpose statement, explanatory context, and an Args section. It is slightly lengthy but every sentence adds value. Front-loading ensures the agent grasps the core quickly.

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 tool's operation, merge modes, and parameter structure. Given the complexity of the parameters array and the absence of an output schema, it provides sufficient information for an agent to use the tool correctly, though error handling and permissions are omitted.

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 0% schema description coverage, the description fully compensates by detailing card_id, parameters (including common keys like id, name, slug, type, target), and merge with its default behavior. This adds meaning far beyond the raw JSON 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 begins with a specific verb+resource: 'Set the card-level `parameters` list on a saved question.' This clearly identifies the primary action and object, distinguishing it from sibling tools like update_card, which handles broader card updates.

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

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

The description explains when to use the tool (to set parameters for filter widgets) and provides insight into why it's necessary (e.g., for date pickers). However, it does not explicitly mention when not to use it or compare with alternatives like set_card_template_tags.

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?

Without annotations, the description carries the full burden. It discloses that parameters undergo a full replacement ('Full replacement list') and for archived: 'Set true to archive, false to unarchive.' It also specifies the return value. However, it does not mention authorization needs or whether other fields are partially updated.

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 well-structured with a summary sentence, a detailed block about parameters, an Args list, and a Returns line. It is front-loaded with the main purpose, though the parameter explanation is somewhat lengthy but justified by complexity.

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 all six parameters and the return value. Given the complexity and presence of an output schema, it provides sufficient detail. It does not cover error cases or permissions, but that is acceptable for this context.

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

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

Schema description coverage is 0%, so the description adds crucial meaning. It explains each parameter in the Args block, including the detailed structure of the parameters dict with allowed types and optional keys. This goes well beyond the bare schema types.

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 'Update properties of a dashboard', listing specific properties such as name, description, collection_id, parameters, and archived. This distinguishes it from sibling tools like create_dashboard (create) and list_dashboards (list).

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

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

The description explains how to use the parameters field in detail, but does not explicitly state when to use this tool versus alternatives like add_card_to_dashboard or create_dashboard. It lacks explicit when-to-use or when-not-to-use 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?

No annotations provided. The description explains that omitted fields retain current values, which is a behavioral trait. However, it does not disclose permissions, rate limits, or potential side effects. For a mutation tool, more transparency would be beneficial.

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 structured with a clear purpose, then Args and Returns sections. It is somewhat lengthy but not overly verbose. It could be more concise, e.g., by omitting obvious parameter names that match the schema.

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

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

Given the presence of an output schema (as per context signals), the description mentions returning the updated dashboard object, which is sufficient. It covers all parameters and behavior for a single card update operation. No gaps identified.

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%, but the description includes an Args section that explains all six parameters (dashboard_id, dashcard_id, col, row, size_x, size_y). This adds meaning beyond the schema types and defaults, compensating 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 'Reposition or resize a single card on a dashboard.' It uses specific verbs (reposition, resize) and resource (single card, dashboard). This distinguishes from siblings like 'reposition_dashboard_cards' (bulk) and 'add_card_to_dashboard'.

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 notes that only provided fields are updated, implying partial updates. However, it does not explicitly state when to use this tool over alternatives like 'reposition_dashboard_cards' for bulk operations. No exclusion or prerequisite 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?

No annotations are provided, and the description does not disclose behavioral traits such as side effects, permission requirements, rate limits, or whether updates are destructive. It only lists parameters without explaining the behavior beyond that.

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

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

The description is concise and well-structured: a one-line summary, an Args list with each parameter explained, and a Returns statement. No extraneous 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 covers the tool's purpose, parameters, and return value. However, it lacks usage guidelines and behavioral transparency. Given the complexity (9 parameters, mutation) and no annotations, it is adequate but has gaps.

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

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

Schema description coverage is 0%, so the description must compensate. It provides detailed explanations for each parameter, including constraints like 'database_id' being required if changing query, and notes on result_metadata keys. This adds significant meaning 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 'Update an existing model in Metabase,' which is a specific verb+resource combination. It distinguishes itself from sibling tools like create_model, update_card, etc., by being specific to models.

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 tool's purpose and parameters, but there is no explicit guidance on when to use this tool versus alternatives like update_card. No prerequisites or exclusions are mentioned.

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