CustomerDashboard

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

Beyond the annotations, the description reveals the important behavioral consequence that customerId is bound to :customer_id in every widget query, and clarifies that no access is granted by adding a customer. It also discloses the plan-limit constraint. It does not mention duplicate-add behavior or error conditions, but the annotations already signal non-idempotent, non-readonly behavior.

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

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

The description is four short sentences, each earning its place: the core action, the customerId matching constraint and its consequence, the access caveat with an alternative, and the plan-limit condition. There is no fluff or repetition.

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 three-parameter create-like tool with no output schema, the description covers the purpose, the critical identifier binding, the access boundary, and the plan limit. It does not describe duplicate customerId handling or success/error output, but these are minor for an agent deciding whether and how to call 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?

The input schema already covers all three parameters at 100%, so the baseline is 3. The description adds meaningful extra semantics for customerId—it must exactly match a value in the caller's own database and is bound to :customer_id in widget queries. The other parameters rely on their already-sufficient 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 states a specific action and resource: 'Add one of your customers to a multi-customer dashboard.' It also distinguishes itself from the sibling add_customer_user by explicitly noting that adding a customer does not grant access, so the agent can tell them apart.

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 gives clear context for when to use the tool, names the alternative for access-granting ('use add_customer_user for that'), and states an eligibility condition ('Subject to your plan's customer limit'). This is explicit when/when-not/alternatives 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?

The description adds useful behavioral detail beyond the annotations: password generation behavior, one-time return of the generated password, and the plan's users-per-customer limit. It does not cover every edge case, such as duplicate email or idempotency, but it meaningfully informs the agent.

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, front-loaded with the core action, and every sentence earns its place. It states purpose, a key behavioral nuance, and a constraint without any filler.

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

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

For a write operation with no output schema, the description is remarkably complete: it explains the purpose, the needed input context, password behavior, one-time return, and plan limitation together with fully described parameters. An agent has enough information to invoke this tool correctly.

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

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

Schema description coverage is 100%, so all four parameters are already documented. The description's note about password generation largely repeats the schema's 'Leave empty to have a strong password generated' text, adding no new per-parameter meaning.

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-resource pair ('Create a login for one of your customers') and explains the benefit: the customer can sign in to the published dashboard and see their own data. This clearly distinguishes it from add_customer and delete_customer_user.

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

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

The description clearly establishes when to use the tool: when a customer needs login access to a published dashboard. It does not explicitly name alternatives or state when not to use it, but the context is strong enough that an agent can select it correctly.

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 reveals critical behavior beyond the annotations: credentials are saved regardless of whether the connection test succeeds, and the operation is subject to plan limits. This materially changes how an agent should invoke the tool, so the disclosure is valuable.

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?

Three short sentences, each earning its place: the purpose, the critical testing caveat, and the plan-limit constraint. 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 create-style tool with a nested config object and no output schema, the description covers the essential operational context: test first, settings persist even on failure, and plan limits apply. The schema handles parameter details, so nothing critical is missing.

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

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

Schema description coverage is 100%, so the input schema already documents name, type, and config. The description adds no parameter-specific semantics beyond the high-level mention of databases and spreadsheets, which is consistent with the baseline for full schema coverage.

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

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

The description states a specific action and resource: connect a new database or spreadsheet to your workspace. This clearly distinguishes it from sibling tools like get_data_source, update_data_source, and delete_data_source by signaling that it creates a new connection.

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 names the alternative test_data_source_connection and instructs the agent to use it first, warning that add_data_source saves settings even if they don't work. It also notes the plan data source limit, giving a clear condition on when adding may fail.

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?

Beyond the annotations, the description discloses two important behaviors: a Default view is created automatically, and creation is subject to the plan's dashboard limit. These are real behavioral details not visible in the schema or annotations. The description is consistent with readOnlyHint=false and destructiveHint=false.

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?

Three sentences, each earning its place: the first states the core action, the second explains the crucial type distinction, and the third discloses side effects and constraints. No filler or repetition.

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 two parameters, the description is largely complete: it explains purpose, parameter choice, automatic view creation, and a limit that may prevent success. It does not describe the response shape, but given the low complexity and no output schema, this is a minor gap rather than a blocking one.

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 already covers both parameters at 100%, so the baseline is 3. The description adds meaningful value by explaining what the 'customer' type actually does at runtime — each customer signs in and sees only their own rows — and by noting the plan limit, which affects whether the operation may fail. This goes beyond the schema's shorter enum 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 creates a dashboard and immediately distinguishes the two dashboard types with concrete behavioral consequences: 'customer' gives each customer login-gated access to only their own rows, while 'internal' is a single shared view. This goes beyond the bare title and gives an agent enough to know what operation is being performed.

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 guidance on when to choose 'customer' versus 'internal', which is the main usage decision for this tool. It does not explicitly name alternative tools like create_view or update_dashboard, but the context is clear enough for an agent to select and configure this tool appropriately.

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

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

The description adds useful behavior beyond the annotations: new views are appended after existing ones, and creation is subject to the plan's view limit. This gives the agent important context about side effects and constraints that the boolean annotations alone do not convey.

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

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

The description is compact and front-loaded: the core purpose is in the first sentence, followed by two concise, high-value behavioral notes. Every sentence earns its place 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 two-parameter create operation, the description covers the essential context: what is created, where it is placed, and a key constraint. It does not describe return values or failure behavior, but given the simplicity and full schema coverage, the description is sufficiently complete.

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

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

Schema coverage is 100%, and both parameters (dashboardId, name) already have descriptions in the schema. The tool description does not add additional parameter-level meaning, so the baseline score of 3 is appropriate.

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

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

The description clearly states the action ('Add') and the resource ('a view (tab) to a dashboard'), distinguishing it from creating dashboards or widgets. It is unambiguous, though it does not explicitly name a sibling tool or draw a contrast with update_view or reorder_views.

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: when you need to add a new tab to a dashboard. It also notes the plan's view limit, which is a relevant precondition, but it does not explicitly say when to use alternatives like update_view or reorder_views.

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 are minimal (all false hints), so the description carries the burden and it delivers: it discloses the plan widget limit as a potential failure, the mandatory :customer_id filter on customer dashboards, and required precursor calls. No contradiction with annotations — readOnlyHint=false aligns with the write nature of "Add".

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

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

Three sentences with zero filler: purpose is front-loaded first, prerequisites in the second sentence, and constraints in the third. Every sentence 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 tool with 8 parameters and no output schema, the description covers prerequisites, constraints, and limits well; the schema handles layout and allowSharedAcrossAllCustomers details. The one gap is that the return value (e.g., created widget id needed to chain into set_widget_layout or update_widget) is never stated, and there is no output schema to fill that void.

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 high at 88%, so the baseline is 3. The description adds genuine cross-tool semantics beyond the schema: it maps visualizationConfig to list_widget_types and query to run_query_preview, telling the agent how to correctly populate two complex 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?

"Add a chart, table or KPI to a view" uses a specific verb plus resource enumeration and names the target container. This clearly differentiates create_widget from sibling create_dashboard and create_view without needing to open the schema.

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

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

The description gives explicit workflow guidance: call list_widget_types for visualizationConfig keys and run_query_preview first to validate query columns. It also states when the tool applies (multi-customer dashboards require :customer_id filtering) but stops short of explicitly naming when-not alternatives such as update_widget.

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 mark this as destructive, but the description adds meaningful behavioral context: permanent removal, cascading deletion of all logins, immediate loss of access, preview-without-confirm behavior, and irreversibility. This goes well beyond the structured annotations and fully discloses the tool's consequences.

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 four tightly constructed sentences with no filler. Each sentence adds essential information: scope, immediacy, preview behavior, and irreversibility, with the most important consequence 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?

For a destructive tool with no output schema, the description adequately covers the confirmation workflow, the cascading deletion, and irreversibility. It does not spell out what the preview response contains or explicitly mention the need to echo confirmName from the preview, but the schema already documents confirmName's source, making this a minor gap.

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

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

Schema description coverage is 100%, so the schema already documents all four parameters and their roles, including confirm and confirmName semantics. The description reinforces the preview/confirm behavior but does not add substantial parameter-level meaning beyond what the schema already provides.

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 a specific action and resource: permanently removing a customer from a multi-customer dashboard along with all their logins. It also communicates the behavioral scope ('lose access immediately') and irreversibility, which distinguishes this from delete_customer_user and other delete_* siblings.

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

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

The description gives clear procedural guidance on the two-step confirm flow: calling without confirm returns a preview, and deletion requires confirmation. It does not explicitly name alternatives like delete_customer_user, but the scope 'along with all of their logins' implicitly clarifies when this tool is 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?

Annotations already carry destructiveHint=true, and the description adds rich context beyond it: permanence ('Permanently remove'), the observable outcome for the user ('They can no longer sign in'), and a non-destructive preview mode when confirm is absent. It also scopes the blast radius by stating what survives deletion, which is exactly the kind of context a destructive tool needs.

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

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

Four short sentences, each earning its place: core purpose, consequence, preview behavior, and blast-radius boundary. The decision-relevant fact that this is destructive is front-loaded, and the confirmation requirement is stated early rather than buried.

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

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

For a destructive 5-parameter tool, the description covers purpose, the safe invocation flow, permanence, and what is not deleted, while the 100%-covered schema handles parameter semantics and the annotations handle safety flags. The one gap is that no output schema exists and the description never says what the preview response actually contains, though confirmName's 'copied from the preview' hints at its content.

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

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

Schema description coverage is 100%, with all five parameters (userId, confirm, confirmName, dashboardId, customerRecordId) already documented. The description's preview statement is redundant with the confirm parameter's schema text and adds no new parameter-level meaning, so the high-coverage baseline of 3 applies.

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

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

States a specific action ('Permanently remove one login from a customer') with a concrete consequence ('They can no longer sign in'). The closing sentence ('The customer itself and their data access rule remain') differentiates it from the sibling delete_customer, so an agent can pick the right deletion tool even without inspecting the schema.

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

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

Gives clear operational context: calling without confirm returns a preview, pointing to the two-call preview-then-confirm flow that the confirm/confirmName params enforce. It implies a boundary against customer-level deletion but never explicitly names delete_customer as the alternative when the entire customer must be removed.

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 only declare destructiveHint=true, but the description adds materially richer behavior: the two-phase preview-before-delete flow, the cascading scope ('everything on it'), the exact-name matching requirement, and irreversibility ('cannot be undone'). These are critical safety behaviors an agent must know before invoking. No contradiction 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?

Three short sentences, each earning its place: the core destructive action, the two-phase confirmation flow, and the irreversibility warning. The most important fact (permanent deletion) is front-loaded first.

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

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

For a destructive, two-phase tool with annotations and a 100%-covered schema, the description covers the essential workflow. Minor gaps: the preview's return structure is not described (no output schema exists), and the failure behavior when confirmName does not match is left implicit. These are small given the schema already instructs the agent to copy the name from the preview.

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

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

Schema description coverage is 100%, and the schema already documents confirm, confirmName, and dashboardId in detail. The description's mention of 'confirm plus the dashboard's exact name' mirrors the schema rather than adding new semantic information, so the baseline 3 applies.

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

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

The description states a specific verb ('permanently delete'), a resource ('dashboard'), and a scope ('and everything on it'). This clearly differentiates it from siblings like delete_view, delete_widget, update_dashboard, and unpublish_dashboard, which either target sub-resources or non-destructive modifications.

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

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

The description gives clear operational guidance: calling without confirm returns a preview, and real deletion requires confirm plus the exact dashboard name. It also warns that the operation cannot be undone, serving as an implicit gate. However, it does not explicitly name alternatives or state when not to use it (e.g., 'use delete_view to remove only a single view').

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 goes well beyond the annotations: it discloses that the operation is permanent, that it can be refused due to widget dependencies, that an unconfirmed call returns only a preview, and that the underlying database is untouched. These are important behavioral details that the annotations alone do not provide, and they align with destructiveHint=true and readOnlyHint=false.

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?

Three tight sentences with no filler. The core destructive action is front-loaded, followed by the key blocking condition and the safety preview behavior. Every sentence 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 destructive confirmed delete operation, the description covers the essential context: permanence, widget-use refusal, the unconfirmed preview, and the guarantee that the database is untouched. Together with the detailed schema and annotations, the agent has enough to call the tool safely and correctly.

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

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

Schema description coverage is 100%, so the input schema already documents dataSourceId, confirm, and confirmName clearly. The description reinforces the confirm/preview flow but does not add substantial parameter-level meaning beyond what the schema states. Baseline 3 is appropriate here.

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

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

The description opens with a precise verb and resource: 'Permanently delete a data source connection.' This clearly distinguishes the tool from siblings like get_data_source, list_data_sources, test_data_source_connection, and update_data_source. It also clarifies scope by noting the deletion removes the connection, not the underlying database.

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

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

The description gives practical usage context: deletion is refused while widgets still use the data source, and deleting requires a two-step confirm flow. This implies when to use the tool and what prerequisites must be met. It does not explicitly name alternatives such as update_data_source or explain when to choose them, so it stops short of full exclusion 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?

Beyond the annotations (destructiveHint=true), the description discloses the cascading deletion of every widget, the irreversibility ('cannot be undone'), and the preview behavior when confirm is not set. This gives the agent critical behavioral context that annotations alone do not 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?

Three sentences, each earning its place: the first states the destructive scope, the second explains the preview/confirm flow, and the third emphasizes irreversibility. It is front-loaded and concise with no filler.

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

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

For a destructive tool with no output schema, the description fully covers what will be deleted, the confirmation safeguard, and permanence. The schema handles the parameter details, so nothing essential is missing for an agent to invoke this tool 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 100%, so the schema already documents all parameters including confirm and confirmName. The description reinforces the confirm behavior but does not add meaning beyond the schema; baseline 3 is appropriate.

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

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

The description opens with a specific verb and resource: 'Permanently delete a view and every widget on it.' This clearly distinguishes it from sibling tools like delete_widget, delete_dashboard, and update_view by stating the exact scope of destruction.

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 the tool via its resource scope, but it does not explicitly name alternatives or state when not to use it. For example, it doesn't say 'use delete_widget to remove only a widget.' The confirmation flow is described, but not the selection among sibling delete operations.

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

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

The description adds meaningful behavioral detail beyond the destructiveHint annotation: calling without confirm returns a preview, deletion is permanent, and it cannot be undone. This is exactly the kind of context an agent needs before invoking a destructive operation.

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

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

Two short, information-dense sentences. The most critical safety information (permanence and preview behavior) is front-loaded, with no filler or redundant content.

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

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

Given the destructive annotation, the schema fully documents parameters, and no output schema is expected, the description covers the essential operational flow: preview first, confirm explicitly, irreversible deletion. The agent has enough context to invoke this tool correctly.

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

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

Schema description coverage is 100%, and the schema already explains the confirm parameter and the preview behavior. The description does not add additional parameter-level meaning beyond what the schema provides, so the baseline score of 3 is appropriate.

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

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

The description uses a specific verb ('permanently delete') and resource ('a widget'), clearly distinguishing this from sibling delete tools for other entities like views or dashboards. The irreversibility is stated up front, reinforcing the purpose.

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: use this when deleting a widget. However, the description does not explicitly name alternatives or state when not to use it, relying on the resource-specific name rather than offering direct guidance against using sibling delete tools.

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

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

Annotations already declare readOnlyHint, idempotentHint, and destructiveHint, so the description does not need to repeat those. It adds useful context by noting 'No sign-in required,' which is not present in the annotations, and clarifies the action is purely instructional.

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?

Three sentences, each earning its place: the first states the purpose, the second gives the usage condition, and the third covers authentication expectations. Information is front-loaded and there is no filler.

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

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

For a zero-parameter, no-output-schema explanatory tool, the description is complete. An agent knows what the tool explains, when to call it, and that no sign-in is needed. Nothing essential is missing.

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

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

The tool has zero parameters and schema description coverage is 100%, making the schema trivially complete. The description adds no parameter detail because none is needed; the no-parameter baseline of 4 applies.

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

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

The description states a specific verb ('Explain') and resource ('how to write widget queries so each customer only sees their own rows on a multi-customer dashboard'). It clearly differentiates this from the sibling action tools by framing it as an explanatory step rather than a mutation or validation 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 gives explicit timing guidance: 'Call this before writing any query for a customer type dashboard.' This tells an agent exactly when to invoke it, though it does not mention when not to use it or point to validate_customer_filtering as a complementary alternative.

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

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

Annotations already declare readOnlyHint, idempotentHint, and non-destructive behavior. The description adds useful context about requiring an authenticated session and being the first call to establish workspace context, which supplements the annotations without contradicting them.

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

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

Two tight sentences: the first front-loads the return contents, the second gives invocation guidance. No filler or repetition of structured data.

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

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

With no output schema, the description adequately serves as the return-value contract by listing all relevant data: identity, workspace, plan, allowances, and usage. It also covers when to call it, making the tool fully actionable for an agent.

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

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

The tool has zero parameters, so parameter semantics are inherently satisfied. The baseline of 4 applies, and the description appropriately focuses on return content rather than nonexistent inputs.

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

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

States a specific verb and resource: 'Get the signed-in CustomerDashboard account'. It enumerates exact contents (name, email, workspace, current plan, plan allowances and usage), making it unambiguous and distinguishable from sibling tools like list_customers or get_platform_overview.

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 when to call: 'Call this first in an authenticated session'. It also gives the contextual reason—'to learn the workspace you are working in'. It does not explicitly enumerate exclusions versus siblings, but the usage context is clear.

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 signal readOnly, idempotent, and non-destructive behavior. The description adds meaningful behavioral context by specifying the full response scope: settings, theme, publishing state, every view, every widget, and widget queries. There is no contradiction with the annotations.

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

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

Two sentences with no filler. The first sentence front-loads the tool's full scope, and the second provides a concise usage rationale. 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?

Even without an output schema, the description enumerates the major return contents in detail: settings, theme, publishing state, views, widgets, and queries. Combined with full input-schema coverage and supportive annotations, an agent has enough context to invoke the tool appropriately.

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

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

Schema description coverage is 100%, so both dashboardId and includeWidgets are already documented in the input schema. The description's mention of 'every view and every widget' aligns with includeWidgets' default of true but adds no new parameter-level semantics 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 states a specific verb and resource: 'Get one dashboard in full', then enumerates exactly what is included: settings, theme, publishing state, views, widgets, and widget queries. This clearly differentiates it from sibling tools like list_dashboards (which lists many dashboards) and update_dashboard (which changes a 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 second sentence, 'This is the fastest way to understand an existing dashboard before changing it', gives a clear decision context for using the tool. It does not explicitly name alternatives or state when not to use it, so it stops short of a full 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 read-only and idempotent, so the description only needs to add behavioral context. It contributes the key edge-case behavior: private dashboards return nothing to share, and output includes both URL and viewer scope. This goes beyond the structured 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 short sentences, front-loaded with the core purpose and then a concise edge-case caveat. No filler or repetition of schema properties.

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

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

For a single-parameter read-only tool, the description covers what it returns (public URL, who can open it) and the private-dashboard edge case. Since no output schema is present, slightly more structure detail would be ideal, but the description is adequate 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?

Input schema fully describes dashboardId ('Dashboard id.') at 100% coverage, so description doesn't need to add param detail. The description neither repeats nor enhances the parameter definition, matching the schema-coverage baseline of 3.

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

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

States a specific verb ('Get'), the resource ('public URL of a published dashboard'), and adds a scope qualifier ('and who can open it'). This distinguishes it from sibling get_dashboard (which retrieves dashboard details) and from publish/unpublish actions.

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?

Description implicitly defines the correct context: the dashboard must be published. It tells users that private dashboards yield nothing to share, implying the publish_dashboard sibling must be used first. It doesn't explicitly name alternatives or exclusions, so not 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 this operation read-only, idempotent, and non-destructive. The description adds meaningful behavioral detail beyond those annotations: it explicitly states that non-secret connection settings are included and that credentials are never included, which is important security-relevant behavior not captured by the annotation hints.

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 target, then adds one crucial qualifier about credentials. Every word earns its place, with no redundancy or filler.

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

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

For a simple get-by-id operation with one well-documented parameter and annotations covering safety, the description provides sufficient context. It tells the agent what will be returned (non-secret settings) and what will not be returned (credentials), which is enough to call the tool 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?

The only parameter, dataSourceId, is fully described in the input schema with 'Data source id.' and schema coverage is 100%. The description does not add additional parameter semantics, but the baseline of 3 applies because the schema already carries the parameter documentation burden.

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 and resource ('Get one data source by id') and clearly distinguishes this from list operations by specifying singular retrieval by identifier. It also differentiates from schema-related tools by noting it returns 'non-secret connection settings', and the 'Credentials are never included' clause adds a precise scope boundary.

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 makes it clear this is for retrieving a single data source by id, but it does not explicitly state when to choose this over sibling tools like list_data_sources or get_data_source_schema. The context is implied rather than stated, so an agent must infer the appropriate alternative based on the tool name and sibling list.

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

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

Annotations already cover read-only, idempotent, open-world, and non-destructive behavior. The description adds useful context by specifying that the tool lists tables/columns and naming the supported data sources, though it does not discuss edge behavior such as unsupported source errors or output formatting.

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 sentences with no filler, front-loading the action and purpose before listing supported connectors. Every clause contributes useful 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?

With no output schema, the description still communicates the return concept ('tables and columns') and the supported connector scope. Minor details like error behavior or how the optional table parameter affects the response are not described, but the schema covers optionality and the annotations cover safety.

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

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

The input schema has 100% description coverage for both parameters, so the description adds little beyond the schema. The description's purpose statement relates generally to data source schema but does not provide extra meaning about the optional table parameter or dataSourceId format.

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

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

The description uses a specific verb ('List') and resource ('tables and columns in a connected data source') and includes a clear purpose ('so you can write correct widget queries'). It does not explicitly contrast with sibling tools like get_data_source or list_data_sources, so it lacks explicit sibling differentiation.

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

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

The phrase 'so you can write correct widget queries' provides a clear when-to-use context, and the supported connector list gives an additional applicability signal. It does not mention exclusions or alternative tools, so it falls short of explicit 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?

Annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false, so the safety profile is covered. The description adds genuine value beyond that: 'No sign-in required' discloses an authentication trait the annotations do not convey, and the verb 'Explain' signals that the return value is conceptual prose rather than structured records. No contradiction 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?

Three short sentences, each earning its place: purpose, when-to-call, and auth requirement. The purpose is front-loaded before the usage guidance, and no filler or redundant restatement of the title exists. This is tight, efficient writing.

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

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

For a zero-parameter, no-output-schema informational tool, the description covers everything needed to invoke it correctly: what it returns conceptually, when to call it, that it requires no authentication, and that it is non-destructive per annotations. The only slight gap is that the exact output format (e.g., markdown text vs. plain string) is unspecified, but the explanatory verb sets adequate expectations.

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 and the schema is an empty object, so there is nothing for the description to clarify. Per the 0-param baseline of 4, the description appropriately spends no space on parameter details, and the tool's scope is already clear from the purpose sentence.

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 ('Explain') tied to a clear resource: what CustomerDashboard.io is and how its core entities fit together. It is immediately distinguishable from all 40+ siblings, which are CRUD/action tools on specific resources like customers, dashboards, and widgets. The 'Call this first when unfamiliar' phrasing further cements its unique role as the platform-overview 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 gives explicit when-to-use guidance: 'Call this first when you are unfamiliar with the product.' It implies the inverse condition (skip when familiar) and the tool's conceptual role naturally excludes it from data-mutation tasks that siblings handle. It does not name specific alternative tools, but given there is no true sibling overlap, this is a minor gap.

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

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

Annotations already cover the safety profile with readOnlyHint=true, idempotentHint=true, and destructiveHint=false. The description adds a meaningful behavioral note ('No sign-in required') and clarifies that the tool returns guidance rather than performing an operation, which goes beyond the structured 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?

A single, information-dense sentence with a clear front-loaded verb and no filler. Every phrase earns its place: what is explained, the scope of the explanation, and the no-sign-in constraint.

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

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

For a zero-parameter informational tool with safety annotations, the description covers the main purpose and a key access note. It does not explicitly describe the response format, but that is easily inferred from 'Explain', so no significant gap is present.

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 and the schema is empty, so schema coverage is trivially 100%. With no parameters to document, the baseline of 4 applies, and the description correctly does not attempt to invent parameter information.

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 a specific verb ('Explain') and a specific resource: the sign-up flow, connecting the MCP server to a CustomerDashboard account, and the order of steps for a first multi-customer dashboard. This is readily distinguishable from sibling tools like 'explain_customer_filtering' because it targets onboarding rather than filtering semantics.

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

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

The description gives clear context—first-time setup and building a first dashboard—but it does not explicitly state when to prefer this tool over a sibling like 'explain_customer_filtering' or 'list_plans_and_limits'. No alternatives or exclusions are named, so the usage guidance is implied rather than explicit.

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, so the safety profile is covered. The description adds useful behavioral context about the output contents, but does not disclose potential error conditions, pagination, or how includeUsers affects the response.

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, focused sentence that conveys the tool's purpose and primary output fields without redundancy. Every clause 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?

For a simple read-only list operation with full schema parameter documentation and helpful annotations, the description is mostly complete. It could be improved by mentioning the includeUsers parameter's effect or returning structure, but this is not critical given the schema covers 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 100%, so parameters are already well documented in the schema. The description does not add meaning beyond the schema, except for emphasizing the multi-customer dashboard context, which is a minor addition.

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, 'List', identifies the resource as customers on a multi-customer dashboard, and clarifies the returned data includes customerId and login counts. This clearly differentiates it from sibling list tools such as list_dashboards, list_data_sources, and list_views.

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 context that this tool applies to multi-customer dashboards, which helps an agent understand when it is relevant. It does not explicitly state when to prefer a sibling tool, such as list_dashboards, but the context is sufficient for most selection decisions.

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

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

Annotations already declare readOnlyHint, idempotentHint, and destructiveHint false, so the safety profile is covered. The description adds behavioral value by specifying the fields returned and the exhaustive scope ('every dashboard'), which is useful beyond the annotations.

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

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

A single sentence that immediately states the resource, scope, and returned fields. There is no redundancy or filler; every part of the description 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 parameterless list tool, the description covers the essential return information and scope. It does not mention pagination, ordering, or explicit ID/name inclusion, but these are minor gaps given the simplicity of the tool and the lack of an output schema.

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 parameter semantics are trivially satisfied. The baseline of 4 applies here because there is nothing for the description to clarify beyond the empty input schema.

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

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

The description uses a specific verb ('List') and resource ('every dashboard in your workspace'), and clearly identifies the returned fields: type, publishing state, and share URL if published. This makes it easy to distinguish from sibling tools like get_dashboard or list_views.

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

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

There is no explicit guidance on when to use this tool versus alternatives such as get_dashboard or list_views. The scope 'in your workspace' implies the intended use case, but no exclusions or alternative routing 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?

Annotations already communicate read-only, idempotent, non-destructive behavior. The description adds a meaningful security guarantee ('Connection credentials are never included') and exhaustiveness ('every data source'), which go beyond the annotations.

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

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

Two concise sentences with no fluff. The action is front-loaded and the second sentence adds a valuable safety detail 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?

For a zero-parameter list operation with annotations covering safety, the description is nearly complete. It lacks explicit return-format details, but the absence of an output schema and the simplicity of the operation make this a minor gap.

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

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

The tool has zero parameters and 100% schema coverage, so there is no parameter gap to compensate for. The baseline of 4 applies; the description correctly focuses on behavior rather than nonexistent 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 clearly states a specific verb ('List') and resource ('data source connected to your workspace'). It distinguishes itself from siblings like get_data_source (singular retrieval) and list_supported_data_connectors (supported vs. connected sources).

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 getting an overview of connected data sources, but it does not explicitly compare with alternatives or say when not to use it. No sibling exclusions or alternative routing 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?

The annotations already cover read-only/idempotent/non-destructive behavior, and the description adds useful context beyond those annotations: no sign-in is required and the response exposes pricing and limit configuration. It does not contradict any annotation.

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?

Three compact sentences: the primary action and result, the motivating use case, and the auth requirement. Every sentence earns its place and the main operation is front-loaded.

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

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

For a no-argument read-only tool with rich annotations, this is complete: it states what is returned, why an agent would call it, and the auth expectation. No output schema exists, but the description itself conveys the output content (plans, prices, limits).

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 zero parameters, the schema leaves no ambiguity and the description does not need to document parameter meaning. The 0-parameter baseline of 4 applies; the description's content about returned data is helpful but not parameter-related.

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

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

The description names a specific verb ('List'), a precise resource ('CustomerDashboard's subscription plans'), and the fields returned (monthly price, resource limits). This clearly distinguishes it from sibling list tools like list_customers or list_dashboards, which target 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?

It gives a concrete use case ('explaining why a create operation was blocked') that tells an agent when to call it. There is no direct sibling alternative for plans, so explicit exclusions are unnecessary; a small 'when not to use' note would have made it fully explicit.

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

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

Annotations already declare this to be a safe, idempotent, read-only operation. The description adds valuable context beyond the annotations by stating that no sign-in is required and clarifying the scope of the response (supported types only, with settings and capability flags). This is meaningful behavioral disclosure for an unauthenticated listing 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 entire description is one tight sentence that front-loads the primary action and resource, then efficiently enumerates the returned information fields. The final note about sign-in is the only extra piece and it earns its place by clarifying access requirements.

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

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

For a zero-parameter, read-only listing tool with no output schema, the description fully specifies the scope of the list and the attributes included for each connector. An agent can correctly set expectations for the response and knows no authentication is required, leaving no critical gap for invoking this 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 description correctly avoids any parameter-specific guidance. The claim that it lists 'every data source type' and the details included help the agent understand what kind of data it will receive, which is the only semantic context needed for a no-parameter tool.

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

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

The description states a specific verb ('List') and a clear resource ('every data source type CustomerDashboard can connect to'), and goes further by enumerating exactly what is returned for each connector: settings, widget queryability, and schema introspection. This clearly distinguishes it from sibling tools like list_data_sources or get_data_source_schema, which operate on configured data sources rather than supported types.

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 clearly implies when to use the tool: any time an agent needs to know which data source types are available and what configuration each requires. It also notes that no sign-in is required, which is useful access context. It does not explicitly name sibling alternatives or state when not to use it, so it stops short of 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 mark it as read-only, idempotent, and non-destructive. The description adds value by disclosing the display-order behavior and the widget-count payload, which are not present in 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?

A single sentence, front-loaded with verb and resource, with only two relevant qualifiers (display order and widget count). No filler or repetition.

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

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

For a one-parameter read-only list with no output schema, the description covers the main return value (views in display order with widget counts). It leaves minor ambiguity about the exact shape of each view item, but the core call and response are clearly specified.

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 dashboardId parameter is fully described in the input schema ('Dashboard id.'), so schema description coverage is 100%. The tool description only reiterates the dashboard context and adds no format, validation, or lookup guidance.

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

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

The description states a specific verb ('List'), a clear resource ('views (tabs) on a dashboard'), and adds ordering plus widget-count detail. This clearly separates it from siblings like list_widgets, create_view, or reorder_views.

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 clear context: the tool is for retrieving the tabs of a dashboard in display order with widget counts. It does not explicitly name alternatives or exclusion cases, but the resource and output are specific enough to make the intended use obvious.

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 and idempotentHint, so the safety profile is covered. The description adds behavioral value by disclosing that the result includes each widget's query and visualization configuration, which is useful context given there is no output schema.

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, front-loaded sentence that communicates the operation, scope, and result contents without filler. Every word contributes to the agent's understanding.

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

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

For a simple single-parameter read-only list operation, the description provides sufficient context: what to provide (viewId implied) and what to expect in return. It does not cover pagination or ordering, but these are not critical for this tool's basic invocation.

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

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

Schema description coverage is 100%, with viewId already described as 'View id.' The description does not add meaning beyond echoing the relationship between the view and the widgets. This meets the baseline for schema-supported parameters but adds no new semantic 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?

The description states a specific verb (list), a clear resource (widgets on a view), and the scope (per view), which distinguishes it from siblings like list_widget_types and list_views. It also adds what is included, the query and visualization configuration, making the tool's purpose precise.

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 clearly implies this tool is for retrieving widgets belonging to a specific view, establishing the context for use. It does not explicitly name alternatives or exclusion conditions, but the sibling differentiation is reasonably clear from the wording.

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 establish read-only, idempotent, non-destructive behavior. The description adds valuable context by stating no sign-in is required and clarifying that the tool returns visualization types along with their configuration key requirements, going beyond what annotations express.

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?

Three short sentences, each carrying distinct useful information: what the tool returns, when to call it, and the authentication requirement. No wasted words, and the core purpose is front-loaded.

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

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

For a zero-parameter, read-only reference tool with no output schema, the description fully covers what the agent needs: the content returned, the intended timing of use, and the auth context. Nothing essential is missing.

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

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

The tool has zero parameters, and the schema description coverage is 100%, so there is no parameter ambiguity for the description to resolve. The baseline of 4 for zero-parameter tools applies.

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

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

The description uses a specific verb ('List') and identifies the exact resource ('every visualization a widget can use') plus the detail that it includes required and accepted configuration keys. This clearly distinguishes it from siblings like list_widgets or create_widget.

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 tells the agent to call this before creating widgets, giving clear usage context. It does not name alternatives or state when not to use it, but the guidance is sufficient for correct invocation.

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 convey that this is a write operation (readOnlyHint=false) and that it is idempotent. The description adds useful behavioral context beyond that: publishing returns a share URL, customer dashboards are always login-gated, and internal dashboards support public/protected access. It does not fully describe all side effects, but the annotations cover the core safety profile.

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

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

Three tight sentences deliver purpose first, followed by the access-mode distinction. There is no redundant filler, and each sentence 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?

With no output schema, the description correctly states the key return value (share URL). It also clarifies the access model, while the schema fully documents parameters. The idempotentHint annotation covers the republishing case. The agent has enough context to invoke the tool correctly.

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

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

Schema description coverage is 100%, so the baseline is 3. The description adds value by explaining the access parameter's real-world meaning: customer dashboards ignore access, while internal dashboards choose between public and protected. This supplements the enum descriptions rather than repeating them.

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

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

The first sentence names a specific verb ('Publish'), the resource (dashboard), and the outcome (returns its share URL). This clearly distinguishes publishing from related siblings such as get_dashboard_share_url or unpublish_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 provides concrete context for when to use the tool and how access modes work: customer dashboards are always login-gated, while internal dashboards can be public or protected. It does not explicitly name alternative tools, but the access-mode guidance is clear and actionable.

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 mark this as non-readonly and idempotent. The description adds that the order is also used for wall display rotation and that every view id must be passed, making the replacement semantics explicit. No contradiction 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?

Two tightly written sentences; the primary action is front-loaded, and the wall-display detail provides useful extra context without bloat.

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 two-parameter operation with no output schema and no nested objects, the description provides the key details: what the order means, the requirement to pass all view ids, and the side effect on wall displays. Minor omission is error behavior, but not critical for this 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 input schema has 100% coverage, with viewIds already described as 'Every view id on this dashboard, in the order you want.' The description essentially repeats this instruction without adding new parameter-level details, so baseline 3 is appropriate.

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

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

The description uses a specific verb ('Set') and resource ('tab order of a dashboard's views'), and clarifies that the order also affects wall display rotation. This clearly distinguishes the tool from siblings like update_view or list_views.

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 gives clear context on when to use the tool (to set view tab order) and how to use it ('Pass every view id in the order you want them shown'). It doesn't explicitly name alternatives or exclusions, so it stops short of 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 and non-destructive behavior, and the description adds the important 100-row cap plus the preview semantics. No contradiction with annotations exists, and the customer-context requirement 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 three sentences with zero filler: it states the purpose, the result cap, and the key conditional requirement. Information is front-loaded and every sentence earns its place.

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

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

The description covers the invocation context, return behavior, result size limits, and special customer-context handling. Combined with the fully described parameters and safety annotations, this is sufficient for reliable use, even without an output schema.

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

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

Schema description coverage is 100%, so the baseline applies. The description restates the customerId/dashboardId conditional and the row cap, but it does not add new parameter semantics beyond what the schema already documents.

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

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

The description states a specific action: run a query against a connected data source and return the first few rows to confirm it works before placing it on a widget. This clearly distinguishes it from sibling tools like test_data_source_connection or get_data_source_schema by tying it to previewing query results.

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 tells the agent when to use the tool: before putting a query on a widget. It also gives clear conditional guidance for queries containing :customer_id, requiring customerId or dashboardId. It does not explicitly name sibling alternatives or exclusions, but the usage context is clear.

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 idempotency and non-destructiveness, so the bar is lower. The description adds the useful behavioral context that widgets can override the formatting, but it does not disclose whether existing formatting is replaced or merged, or clarify how defaults apply across different widget types.

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 sentences with no filler. The primary function is front-loaded, and the widget-override clarification is a valuable addition without extra verbosity.

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 9 parameters, nested objects, no output schema, and only 44% schema coverage, the description is too thin. It does not explain how to construct the formatting objects, whether the call replaces all existing formatting, or any other operational details an agent would need to invoke it correctly.

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

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

Schema description coverage is only 44%, and the description does not compensate for the undocumented nested objects (date, number, datetime, duration, percentage). It only lists the parameter names without explaining their structure or expected values, which is insufficient 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 states a specific action ('Set') and the exact resource (default locale and number/currency/percentage/duration/date/datetime formatting for a dashboard). It also distinguishes scope from per-widget formatting by noting widgets can override these defaults, which separates it from sibling tools like set_widget_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?

The description provides clear context that this sets dashboard-level defaults and that widgets can override them, implying it should be used when configuring dashboard-wide formatting rather than individual widgets. However, it does not explicitly name alternative tools or mention 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?

The description adds meaningful behavioral context beyond the annotations: the theme is stored as one object and all fields must be passed, implying a full replacement rather than a partial update. The 'All colours are hex values' note also clarifies the accepted format. The annotations already indicate idempotence and non-destructiveness, so the description supplements them well 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 two sentences with no wasted words. It front-loads the core operation, then lists the affected color categories and the critical usage constraint about passing every field.

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 straightforward mutation operation, the description plus the fully documented schema is sufficient for an agent to invoke the tool correctly. It covers what is set, the full-replacement behavior, and the colour format. A minor gap is the lack of explicit guidance on how this relates to set_dashboard_formatting, but this is not essential for correct invocation.

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

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

Schema description coverage is 100%, with each parameter already documented by name and purpose. The description adds only a general statement about hex values and the need to pass every field, which does not materially extend the schema's parameter-level explanations. Baseline 3 is appropriate.

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

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

The description clearly states the verb ('Set') and the resource ('the colour theme of a dashboard'), and enumerates what it covers: backgrounds, text colours, brand colours, and chart series palette. It is unambiguous about the tool's purpose, though it does not explicitly contrast itself with the closely named sibling set_dashboard_formatting.

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

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

The description gives an important usage requirement: 'Pass every field, since the theme is stored as one object.' This tells the agent how to invoke the tool correctly, but it does not provide explicit when-to-use guidance or mention any alternatives, such as update_dashboard or set_dashboard_formatting.

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

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

Annotations already declare readOnlyHint=false, destructiveHint=false, and idempotentHint=true, so the base behavioral safety profile is covered. The description adds useful batch context ('several widgets at once' and 'whole view'), but it doesn't disclose whether unspecified widgets are preserved or whether layouts are fully replaced. No contradiction with annotations exists.

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 exactly two sentences with no filler. The primary action and grid constraint are front-loaded, and the usage alternative is stated economically in the second sentence. 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 batch layout mutation with two well-documented parameters and no output schema, the description provides sufficient context: what the tool does, when to use it, and the grid model. The main missing piece is a note on response behavior or error semantics, but that is minor given the simplicity and rich schema.

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

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

Schema coverage is 100%, and the schema already contains meaningful descriptions for both parameters, including the grid constraints on x/y/width/height. The description reinforces the 12-column grid concept but does not add substantive parameter-level detail beyond the schema, so the baseline score of 3 is appropriate.

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

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

The description states a specific verb ('Reposition'), a clear resource ('several widgets on a view'), and a key constraint ('on the 12-column grid'). It also distinguishes itself from the alternative of moving widgets one at a time, which directly separates it from sibling tools like update_widget.

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 says 'Use this to lay out a whole view rather than moving widgets one at a time,' which provides clear when-to-use guidance and contrasts against a single-widget alternative. However, it does not name the alternative sibling tool explicitly, so it falls just short of a perfect 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 cover idempotency and non-destructiveness. The description adds that this is a test-only check rather than a save operation, and the config parameter notes that credentials are encrypted at rest and never returned by read tools. It does not describe the result/return format, but this is partially mitigated by the annotations.

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

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

Two sentences with no filler. The first sentence front-loads the core purpose, and the second sentence efficiently lays out the two invocation modes. Every clause earns its place.

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

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

The description covers the main branching logic and safety characteristics needed to invoke the tool correctly. The lack of an output schema means the return format is not described, but for a simple connectivity test the success/failure semantics are reasonably inferable from 'Check whether... works.'

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

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

Schema coverage is 100%, so the baseline is 3. The description adds meaningful parameter relationship semantics: pass an existing dataSourceId to retest a saved connection, or pass type and config to test new settings. This clarifies the mutually exclusive use cases beyond what the individual property descriptions provide.

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

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

The description states a specific verb and resource: 'Check whether a set of connection settings actually works, before saving them.' It also distinguishes the tool from add/update/list operations by emphasizing pre-save validation and by describing both retesting an existing dataSourceId and testing new type/config settings.

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 usage context: use this tool before persisting connection settings, and choose between retesting a saved connection with dataSourceId or testing new settings with type+config. It does not explicitly name sibling alternatives, but 'before saving them' implies it should precede add_data_source or update_data_source.

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 goes well beyond the annotations by disclosing concrete behavioral consequences: the share link stops working immediately, shared username and password are cleared, and widgets/data remain untouched. This aligns with destructiveHint=false and idempotentHint=true, adding valuable context about side effects.

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

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

The description is compact and front-loaded, with two purposeful sentences. Every sentence adds distinct information: the main action, immediate access consequences, and reassurance that data is unaffected. 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?

For a simple tool with one required parameter, no output schema, and helpful annotations, this description is complete. It explains the important side effects an agent must know before invoking it, and nothing critical is missing.

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

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

Schema description coverage is 100% because dashboardId is documented as 'Dashboard id.' The description adds no additional parameter semantics, but the schema already fully covers the single parameter. Baseline 3 is appropriate.

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

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

The description clearly states the tool's purpose: 'Make a dashboard private again.' This is a specific verb and resource. It differentiates from related tools like publish_dashboard by describing the inverse action, though it does not explicitly name sibling alternatives.

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

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

The opening sentence implies when to use the tool: when a dashboard should be made private again. However, it does not explicitly state when not to use it or mention alternatives such as publish_dashboard or delete_dashboard. Usage context is implied rather than directly instructed.

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 goes beyond annotations by warning that changing customerId immediately affects which rows the customer sees and instructs the agent to confirm with the user. This is valuable behavioral context not present in structured 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 with no filler. The critical warning about customerId is front-loaded and directly actionable.

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 update tool, the description is sufficient: it identifies the two mutable fields, emphasizes the consequence of one, and mentions a required confirmation. Missing details like return value are not critical since there is no output schema.

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 high, so the schema already explains most parameters. The description adds light context for name and customerId but does not significantly expand beyond the schema's own 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 states a specific verb and resource ('Rename a customer or correct the customerId'), which clearly identifies what the tool does. It also distinguishes this tool from sibling update tools by naming the exact mutable fields.

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 the tool: when renaming or correcting a customer identity. However, it does not explicitly compare with sibling tools such as add_customer or delete_customer, or state 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 carry the safety profile (readOnlyHint=false, idempotentHint=true, destructiveHint=false) and the description does not contradict them. The description adds context about which aspects of the dashboard change (name, rotation, test customer), but discloses nothing beyond the operation scope itself—no effects on live displays, propagation behavior, or permission requirements. With annotations present, the bar is lower and this adds modest 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?

Two sentences with zero filler. The first sentence front-loads the three distinct operations, and the second immediately routes to the correct sibling tools for colors and sharing. Every clause 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 mutation tool with annotations covering idempotency and non-destructiveness, the description covers all three update operations and disambiguates against the closest siblings. Minor gaps remain: it doesn't clarify whether rotation changes apply to currently-running wall displays or note any side effects of changing the test customer on existing previews, but these are edge concerns given no output schema is expected.

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

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

Schema coverage is 75%, so the schema documents three of four params. The description compensates for the gap by explaining the undocumented 'name' param via 'Rename a dashboard,' and adds plain-language context for the others (auto-rotation on a screen, preview test customer). This goes beyond baseline schema restatement, though much of the semantic load is still carried by the schema's own 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 names a specific verb (rename/set) on a specific resource (dashboard) and enumerates exactly three operations: renaming, configuring auto-rotation timing, and setting the preview test customer. It explicitly distinguishes itself from siblings by naming set_dashboard_theme and publish_dashboard as the tools for adjacent concerns, so an agent can tell them apart without opening schemas.

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

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

The description gives explicit routing: 'Use set_dashboard_theme for colours and publish_dashboard for sharing,' which provides clear when-not-to-use guidance for the two most confusable siblings. It clearly implies when to use this tool (rename, rotation, preview customer), though it doesn't enumerate alternatives like set_dashboard_formatting or reorder_views among the many dashboard-related siblings.

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 show destructiveHint=false, idempotentHint=true, and readOnlyHint=false, so the mutation behavior is already signaled. The description adds valuable transparency by warning that the config replaces the stored one entirely—a potentially destructive aspect for an agent to know. It also benefits from the schema note that credentials are encrypted and never returned by read tools, which covers a behavioral concern beyond basic 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 sentences, front-loaded with the main actions, then the critical replacement warning. No filler or repetition of what the schema already states.

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 mutation tool with no output schema, the description covers the key behavioral context: what it changes, how config replacement works, and the security note in the schema. It doesn't mention idempotency or prerequisites, but the annotations already cover idempotency, and no output schema means return behavior isn't expected. Minor gap: it doesn't state that name is optional or that only dataSourceId is required, but the schema covers that.

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

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

Schema coverage is 67%, with only dataSourceId and config having descriptions. The description explains the config parameter's replacement semantics and the name parameter's purpose implicitly, while the schema adds a concrete example for config and a useful security note. The only gap is that 'name' is not explicitly described in the description, but it is straightforward from context.

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 two distinct operations: rename a data source or replace its connection settings. It names the resource (data source) and uses specific verbs (rename, replace) that distinguish it from sibling tools like test_data_source_connection or get_data_source.

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 context on when to use the tool: when renaming or updating connection settings. It also includes a crucial usage warning that the config replaces the stored one entirely, which guides correct invocation. It doesn't explicitly name alternatives, but the sibling list makes the context reasonably clear.

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 communicate readOnly=false, destructive=false, and idempotent=true, so the safety profile is covered. The description adds the core rename behavior and the boundary that reordering is handled elsewhere, but it doesn't disclose extra behavioral details like rename consequences or return behavior. A 3 is appropriate given the annotation coverage.

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

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

Two short sentences with no filler. The primary operation is front-loaded, and the alternative routing is a single clear follow-up sentence.

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?

This is a simple tool with fully documented parameters, clear annotations, and a description that explains the operation and its boundary with a sibling. No output schema is required for a rename operation, and nothing essential is missing 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?

The input schema covers all three parameters with clear descriptions and 100% coverage. The tool description adds no extra parameter-level meaning, but the schema already carries that burden.

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

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

The description states the exact operation: 'Rename a view.' It uses a specific verb and resource, and the second sentence distinguishes it from reorder_views, a sibling that handles tab order. This makes the tool's 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 explicitly directs users to reorder_views when the intent is to change tab order, and implies update_view is for renaming only. This is clear, actionable guidance for choosing between siblings.

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 establish that the tool is non-read-only, non-destructive, and idempotent. The description adds a valuable behavioral trait beyond those annotations: only the fields explicitly passed are changed, which prevents an agent from assuming whole-object replacement. There is no contradiction with the annotations.

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

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

Two short, information-dense sentences with no filler. The editable-field scope is front-loaded, and the critical merge behavior is stated clearly in the second sentence.

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 9-parameter mutation tool with nested objects, the description plus schema and annotations provide the essential invocation details: required IDs are in the schema, layout and configuration semantics are in the schema descriptions, and partial-update behavior is in the description. Return values are not described, but no output schema exists and the mutation side effects are adequately disclosed.

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 56% schema description coverage, the description compensates by mapping common terms like title, query, visualization type, configuration, data source, and position to the schema's parameter names. It also states the partial-update semantics that apply to all parameters. It omits allowSharedAcrossAllCustomers, but that parameter has a detailed description in 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 identifies the action ('Change') and resource ('a widget'), and enumerates the major editable fields: title, query, visualization type, configuration, data source, and position. It does not explicitly distinguish itself from the overlapping sibling set_widget_layout, but the broader field list makes the tool's scope reasonably clear.

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

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

No guidance is given on when to use this tool versus alternatives such as set_widget_layout or create_widget. The partial-update sentence explains behavior, but not selection conditions 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?

Beyond the readOnlyHint and idempotentHint annotations, the description explains what the audit checks and what it reports: widgets whose queries would leak the same data to every customer. It adds meaningful context about the tool's behavior without contradicting any 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 tool's purpose and the second states when to run it. Every sentence earns its place with no redundant wording or repetition of 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?

For a simple one-parameter audit tool with readOnly and idempotent annotations, the description is nearly complete. It covers what the tool does and when to use it; the only minor gap is that it doesn't specify the exact output format, but 'report any widget' gives enough guidance.

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 is only one parameter and the schema already describes it fully with 100% coverage. The description adds the context that the dashboard is a multi-customer dashboard, but does not need to add more because the schema already handles 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 names a specific action ('Audit a multi-customer dashboard') and a concrete outcome ('report any widget whose query would show the same rows to every customer'). This clearly distinguishes it from nearby tools like explain_customer_filtering by emphasizing validation and detection rather than explanation.

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

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

The description gives explicit timing guidance: run before publishing a customer dashboard and any time its queries change. It does not mention alternatives or exclusions, but the stated use cases are clear enough for an agent to decide when to invoke this tool.

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