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

No annotations are provided, and the description does not disclose behavioral traits such as idempotency, side effects, permission requirements, or error handling. It states the action but not 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 a single, concise sentence (12 words) that front-loads the action and resource. Every word earns its place with no waste.

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

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

For a simple two-parameter tool with an output schema, the description adequately conveys the core operation. It lacks behavioral details, but the simplicity and presence of an output schema reduce the burden. Could mention that the schedule must already exist, but the phrase 'existing schedule' partially covers this.

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

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

Schema coverage is 0% and the description does not explicitly explain each parameter. However, parameter names (schedule_id, datasource_id) are self-explanatory, and the description clarifies that datasource_id refers to a data source's extract refresh. This adds some meaning but does not fully compensate for missing parameter 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 uses a specific verb ('Attach') and specifies the resource ('a data source's extract refresh') and target ('an existing schedule'). It clearly distinguishes from sibling add_workbook_to_schedule by naming data source rather than workbook.

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

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

No explicit guidance on when to use this tool versus alternatives. The description implies use for attaching datasources to schedules but does not mention when not to use it or mention the sibling add_workbook_to_schedule.

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

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

With no annotations, the description carries full responsibility for behavioral disclosure. It only restates the basic action and provides no information about side effects, permissions, error semantics, or whether the operation is idempotent. This is a minimal disclosure, falling below even the 'update_drive' example which listed specific fields.

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

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

The description is a single, front-loaded sentence with no wasted words. It is concise and easy to parse. However, it is so brief that it borders on under-specification, though for a simple action it remains appropriately compact.

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

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

The tool is a simple mutation with two required params and an output schema, but the description provides no context about preconditions, return values, or failure modes. It lacks sufficient detail to fully understand the tool's behavior in context, though the simplicity of the operation slightly mitigates the 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 0%, so the description must compensate. It does not explain what user_id or group_id refer to, whether they must correspond to existing entities, or any constraints. The description adds no semantic value beyond the schema's field names and types.

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

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

The description clearly states the action: 'Add a user to a group.' It uses a specific verb and resource, distinguishing it from siblings like 'remove_user_from_group' and 'create_group'. However, it doesn't explicitly call out alternatives or edge cases, so it falls slightly short of a 5.

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

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

No guidance is provided on when to use this tool versus alternatives. It doesn't mention prerequisites (e.g., user and group must exist), idempotency, or when not to use it. The description simply states the action without contextual usage advice.

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

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

There are no annotations, so the description carries the full burden of behavioral disclosure. While it clearly indicates a mutation-like operation ('attach'), it does not disclose side effects, error behavior, permission requirements, idempotency, or what happens if the schedule is not found. The phrase 'existing schedule' hints at a prerequisite but is not fully explicit.

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 compact sentence, front-loaded with the primary action and resources. Every word earns its place, with no filler or redundancy.

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

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

For a simple two-parameter tool, the description conveys the core purpose adequately. However, it lacks usage guidelines, behavioral transparency, and parameter semantics, making it minimally viable but not complete. The existence of an output schema reduces the need to describe return values, but the description still falls short on context.

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

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

Schema coverage is 0%, and the description does not add meaningful detail about the parameters. It implicitly maps 'workbook' to workbook_id and 'schedule' to schedule_id but provides no guidance on how to obtain these IDs, what formats are expected, or any relationship between 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 description uses a specific verb ('Attach') and clear resources ('workbook's extract refresh', 'existing schedule'), making the tool's purpose unambiguous. It also distinguishes itself from the sibling tool add_datasource_to_schedule, which targets datasources instead of workbooks.

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 attaching a workbook's extract refresh to a schedule) but provides no explicit exclusions, prerequisites, or alternatives. It does not mention the need to verify the schedule exists or direct users to sibling tools like list_schedules or add_datasource_to_schedule.

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

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

No annotations are present, so the description carries the full burden. It reveals the tool's arbitrary nature and path construction, but does not disclose potential side effects, authentication requirements, or error behavior, leaving safety considerations unspecified.

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

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

The description is concise and front-loaded, with three sentences each serving a distinct purpose: stating the function, explaining the path format, and giving usage guidance. No unnecessary 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?

The description covers the core purpose and path base, and an output schema exists to document return values. However, it lacks parameter semantics for method, params, and json_body, and provides no error or safety context, making it only partially complete for a generic API caller.

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

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

The input schema has 0% description coverage, so the description must compensate. It only explains the 'path' parameter with examples, leaving 'method', 'params', and 'json_body' meanings unclear. 'method' as HTTP verb and 'params' vs 'json_body' distinction are not specified.

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

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

The description clearly states this tool calls an arbitrary Tableau Pulse REST endpoint, which is a specific action and resource. It distinguishes itself from sibling tools by noting it covers endpoints not handled by higher-level Pulse tools.

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

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

Explicit guidance is provided: use this tool for Pulse endpoints not covered by higher-level tools, or for debugging non-conforming endpoints. This implies using higher-level tools for standard, covered endpoints.

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

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

With no annotations provided, the description carries full responsibility for disclosing behavioral details. It only states the action and the job states ('pending or in-progress') but does not explain consequences of cancellation, edge cases (e.g., if the job is already completed), or error conditions. This is a significant gap for a mutating 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 single-sentence description is succinct and front-loaded with the main action, but it omits context that could be expected. It is not excessively verbose, but it also lacks structured guidance, earning a moderate score.

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

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

The tool is simple, but with no annotations, no parameter guidance, and no description of outcomes or side effects, the description is incomplete. The existence of an output schema mitigates the need to explain return values, but state transitions, reversibility, and error handling remain unaddressed.

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

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

The schema has one required parameter, job_id, with no description (0% coverage). The description does not mention job_id or provide any guidance on how to obtain or format it, so it fails to compensate for the lack of schema description. This is a complete absence of 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 uses the specific verb 'cancel' and identifies the resource as a 'background job', clearly distinguishing it from sibling tools like get_job and wait_for_job. It also specifies the applicable job states ('pending or in-progress'), adding useful scope.

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

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

The description implies usage when one wants to stop a job, but it does not explicitly say when to use this tool versus alternatives like wait_for_job or get_job, nor does it mention any prerequisites or exclusions. Usage 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?

With no annotations, the description carries full burden. It discloses key behaviors: charts are rendered from real data with an anti-fabrication rule, scatter is capped at three series, a ninth series is folded into 'Other', and the tool returns a file path. This gives agents clear expectations about limitations and output.

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

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

The description is well-organized, starting with the core action, then a clear warning, usage differentiation, parameter explanations, and rendering notes. Each section earns its place and the format improves scannability, though the anti-fabrication point is stated twice.

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 purpose, usage, alternatives, data integrity, parameter semantics for core inputs, and rendering limitations. Since an output schema exists, the description appropriately focuses on behavior rather than return structure. This provides a complete picture for an agent to select and invoke the 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?

Schema coverage is 0%, so the description must explain parameters. It thoroughly explains `chart_type` with valid values and usage tips, and `labels`/`series` with an example. However, it does not describe optional parameters like `theme`, `title`, `x_label`, or `y_label`, leaving some ambiguity for their accepted values.

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+resource: 'Render a PNG chart from data you already have and return its file path.' It distinguishes itself from siblings by clarifying 'this builds a *new* chart' and contrasting with `export_view_image` for existing Tableau vizzes.

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 guidance: 'Use this to visualize numbers a tool returned' and provides an alternative for existing visualizations ('To get a picture of a viz that already exists in Tableau, use `export_view_image` instead'). It also instructs when not to invent data and to fetch real data first (e.g., via `export_view_csv`).

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

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

With no annotations, the description carries full responsibility for behavioral disclosure. It only states the basic action, lacking important details such as uniqueness requirements, permission needs, potential errors on duplicates, or side effects. For a write operation, this is insufficient.

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

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

The description is a single, front-loaded sentence with no redundant wording. It efficiently conveys the core purpose, making it highly concise.

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

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

Despite low complexity and an output schema, the description omits key context such as whether the group name must be unique, whether administrator rights are required, and what happens on failure. Given the absence of annotations, this leaves the agent under-informed for a mutating tool.

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

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

The schema already documents 'minimum_site_role' with an enum and default, and 'name' is self-explanatory. The description adds no additional parameter context. Since schema description coverage is 50% (not high), a baseline of 3 is appropriate—the schema does the heavy lifting, and the description does not conflict.

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 'Create a new group on the current site' uses a specific verb ('create'), a clear resource ('group'), and a scope ('current site'). It distinguishes itself from sibling tools like add_user_to_group, delete_group, and list_groups by explicitly stating the creation action.

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

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

There is no guidance on when to use this tool versus alternatives such as add_user_to_group or delete_group. The description does not mention prerequisites (e.g., site privileges) or any exclusions, leaving the agent without context for selection.

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

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

No annotations are provided, so the description carries the full burden. It discloses a key behavioral requirement (permission/role) and the optional parent nesting behavior. While it doesn't detail side effects or outcomes, 'create' inherently implies a mutating action, and the permission note adds useful transparency beyond the 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 two sentences long, immediately states the core action, and adds a single important prerequisite. No unnecessary words 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?

The output schema is present, so return values need not be described. However, for a mutation tool with four parameters and an enum, the description leaves significant gaps: no explanation of content_permissions, no usage alternatives, and no mention of the effect of description. It is adequate but not fully complete.

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

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

Schema description coverage is 0%, so the description must compensate. It only hints at parent_id with 'optionally nested under a parent project' but provides no natural-language meaning for name, description, or content_permissions. The enum values for content_permissions are left entirely unexplained.

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

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

The description clearly states the action 'Create a new Tableau project' and specifies optional nesting under a parent project. This distinguishes it from sibling tools like create_group, update_project, and delete_project.

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 mentions a prerequisite (site role with content management), which gives clear context for when the tool can be used. However, it does not explicitly describe when not to use it or mention alternatives like update_project or delete_project, so usage is only implied.

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

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

With no annotations provided, the description bears the full burden of behavioral disclosure. It makes the mutating nature explicit through the verb 'Add' and adds the 'current site' scope, which is useful. However, it does not disclose required permissions, side effects, failure conditions, or reversibility, leaving a clear gap in behavioral transparency.

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 conveys the essential information without any redundant or irrelevant content. It is concise and well-structured, making it easy for an agent to parse quickly.

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

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

While an output schema exists and covers return values, the description is too minimal for the tool's complexity. With low schema coverage and no annotations, it fails to provide context about required parameters beyond the schema, potential prerequisites, or special behavior. It does not fully enable an agent to understand when and how to use the tool effectively.

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 low (25%, only site_role has a description). The description mentions 'given site role' which adds meaning to the site_role parameter, but it does not compensate for the lack of explanation for 'email' and 'auth_setting'. The description adds little beyond the schema for these 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 the action ('Add a new user'), the resource (a new user), and the scope ('to the current site'). It also specifies the key parameter ('with the given site role'), which distinguishes it from sibling tools like add_user_to_group (adds existing users to groups) and update_user (modifies existing users).

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

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

The description implies the tool is for creating new users, but it does not explicitly mention when to use it instead of alternatives or provide exclusion criteria. The context is clear for a create operation, but there is no explicit guidance about alternatives like update_user or remove_user, so it remains at the 'implied usage' level.

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

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

With no annotations provided, the description carries the full burden of disclosing behavior. It explicitly states the irreversibility ('This cannot be undone') and targets 'published data source', which is key. It does not mention permissions or side effects, but the core destructive nature 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 two short sentences, front-loaded with the action and resource, and every word adds value. No fluff or redundancy.

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

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

For a single-parameter delete operation, the description covers the essential information: what it deletes, that it is permanent, and that it targets published datasources. An output schema exists, so return values need not be described. It could mention prerequisites or consequences but is largely 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?

The description does not explain the `datasource_id` parameter. Schema description coverage is 0%, so the description should compensate, but it adds no parameter semantics beyond what the schema already provides in the property name and type.

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

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

The description uses a specific verb ('delete'), a clear resource ('published data source'), and emphasizes permanence ('cannot be undone'). It clearly distinguishes this tool from sibling delete tools for other resources (e.g., delete_workbook, delete_group).

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 use case is obvious: this tool deletes a datasource. However, it provides no explicit exclusions, prerequisites, or guidance on when to use it versus alternative tools. The context is clear, but there is no mention of when not to use it or what to do first.

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

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

No annotations are provided, so the description carries the full burden. It does disclose an important behavioral trait: members are not removed from the site, only from the group. However, it omits other potentially relevant details such as whether the deletion is permanent, requires certain permissions, or has cascading effects on group-related resources.

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 fluff. It is front-loaded with the primary action and then adds one clarifying detail. 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 simple deletion tool with one parameter and an output schema, the description covers the core purpose and a key side effect. It could mention that deletion is irreversible or require permissions, but the description is adequate for basic usage. Since annotations are absent, a bit more risk-related context would be ideal, but overall it is reasonably 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?

The schema has 0% description coverage for the single parameter group_id. The description does not elaborate on what group_id means or how to supply it. While the parameter name is self-explanatory and it's the only parameter, the description adds no semantic value beyond the schema, failing to compensate for the lack of schema descriptions.

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

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

The description begins with 'Delete a group,' which is a specific verb and resource. It also distinguishes itself from related operations like remove_user_from_group by clarifying that members are not removed from the site, only from the group. 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 clearly implies when to use the tool (when you want to delete a group) and provides behavioral context that differentiates it from removing individual members. However, it does not explicitly name alternative tools or state when not to use it, relying on inference.

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

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

With no annotations provided, the description carries full responsibility for behavioral disclosure. It clearly states the operation is permanent, cannot be undone, and deletes everything nested in the project—critical consequences for a destructive operation.

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

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

The description is extremely concise—two short sentences—with the key information front-loaded. Each sentence adds essential value and there is no redundancy or fluff.

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

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

For a simple delete operation, the description adequately covers the most important contextual details: permanence and recursive deletion. Since an output schema is present, return values are documented elsewhere, so the description need not explain them.

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 a single required parameter, project_id, with no description (schema coverage 0%). The description does not explain what project_id is or how to obtain it, leaving the agent to infer its meaning from the tool name alone.

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

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

The description clearly states the tool's function: 'Permanently delete a project and everything nested inside it.' The verb 'delete' and resource 'project' are specific, and the scope 'everything nested inside it' distinguishes it from related delete tools like delete_workbook or delete_datasource.

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

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

The usage is implied by the description and name; it is obvious that this tool is for deleting projects. However, there is no explicit mention of when to use it versus alternatives, nor any caveats about prerequisites or 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?

With no annotations provided, the description carries the full burden of behavioral disclosure. It explicitly states the action is permanent and irreversible, which is critical for a destructive operation. It does not mention permissions or side effects, but the core risk is well communicated.

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

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

The description is extremely concise, just two short sentences, with the action front-loaded. Every word earns its place, and it avoids unnecessary detail.

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 delete tool with a single parameter, the description covers the essential fact of irreversibility. However, it lacks any mention of return values, permissions, or usage context, and the lack of output schema leaves some ambiguity about the result. It is adequate but minimal.

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

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

The schema has 0% description coverage and the description does not mention the workbook_id parameter or explain how it identifies the target workbook. While the single required parameter is self-explanatory from the schema, the description adds no additional 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 ('delete') and resource ('workbook'), making the tool's purpose unmistakable. It distinguishes itself from sibling tools like delete_datasource and delete_group by explicitly naming the resource type.

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 implied usage is clear: use this tool to delete a workbook. However, it provides no explicit guidance on when to choose this over alternatives or any prerequisites or exclusions, leaving the agent to infer based on the resource name alone.

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

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

With no annotations, the description carries the full burden. It discloses the file format (.twbx), that extracts are included, and the local directory destination. However, it omits important behavioral details such as permissions, overwrite behavior, and whether the download creates directories or has other 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 a single, front-loaded sentence with no wasted words. 'Download a workbook's .twbx file (including extracts) to a local directory' efficiently conveys the core action and key details.

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 tool, the description provides the basic purpose and destination but lacks usage context and behavioral specifics. An output schema exists but is not referenced. Overall, it is adequate for a simple download but leaves gaps in guidance for an agent deciding when to invoke it.

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

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

Schema description coverage is 0%, so the description must compensate. The phrase 'to a local directory' hints at destination_dir, but it does not explain workbook_id nor the default value for destination_dir. The description adds minimal meaning beyond the schema field names.

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 specifies the action ('Download') and the resource ('a workbook's .twbx file (including extracts)') with a destination ('to a local directory'). This distinguishes it from sibling tools like get_workbook (metadata retrieval) and export_view_excel (view-level export).

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 intended use is implied by the verb and resource, but the description offers no explicit guidance on when to use this tool versus alternatives like export_view_csv or export_datasource_extract. There are no exclusions or mention of alternative tools for different scenarios.

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

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

With no annotations, the description takes on the burden of disclosing behavior. It clearly states the tool does not modify the prompt ('without changing it'), returns estimated values, and lists the specific return fields. It doesn't mention potential side effects like network calls or rate limits, but for a measurement tool the core safety and expectations are covered.

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, front-loaded with the main action, followed by usage guidance and return details. Every sentence adds value without redundancy, making it highly efficient.

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

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

Given the tool's complexity (5 parameters, output schema exists), the description covers the key aspects: purpose, usage, returns, and compatibility with `optimize_tokens`. It doesn't explain every parameter but the output schema and self-explanatory parameter names fill some gaps. Minor missing edge-cases like error handling, but overall complete enough for a measurement 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?

Schema description coverage is 0%, so the description must compensate. It explains the `messages` parameter by referencing the same shape as `optimize_tokens`, and mentions `max_input_tokens` in the return description. However, it leaves `model`, `system`, and `max_output_tokens` undefined, relying on the parameter names and defaults. This is adequate but not thorough.

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 ('measure') and resource ('prompt's token cost'), and explicitly notes it does so 'without changing it', distinguishing it from optimization tools like optimize_tokens. This makes the tool's unique purpose immediately 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?

The description gives explicit usage context: 'Use this before deciding whether optimization is worth it, or to check whether a prompt fits a model's context window.' It also references optimize_tokens for the messages shape, implying when to use that alternative instead.

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

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

With no annotations provided, the description carries the full transparency burden. It discloses error behavior (raw GraphQL error list) but fails to warn about the potential destructive impact of mutations, despite explicitly mentioning 'mutation'. It also does not mention authentication, rate limits, or any side effects beyond the immediate execution, leaving a significant gap for a tool that can alter metadata.

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

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

The description is concise and well-structured, with the core purpose in the first sentence and usage guidance in the second paragraph. Every sentence adds value, and there is no wasted text. It is front-loaded and easy to parse.

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

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

Given the tool's complexity (arbitrary GraphQL), the description covers purpose, usage, and error behavior, and the presence of an output schema mitigates the need to explain return values. However, it omits safety warnings for mutations and doesn't elaborate on variables, which are notable gaps for a tool that can execute any operation. Overall, it is fairly 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?

The schema has 0% description coverage, so the description must compensate. It clarifies the 'query' parameter by stating it accepts an arbitrary GraphQL query or mutation, but it does not explain the 'variables' parameter at all. The schema itself is minimal (string + optional object), so the description partially compensates but lacks details on how to structure variables or pass 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 description clearly states the tool executes arbitrary GraphQL queries or mutations against the Tableau Metadata API, using a specific verb and resource. It differentiates from sibling tools by explicitly naming higher-level tools (get_workbook_lineage, get_datasource_fields, get_table_columns) that cover certain metadata questions, making the scope distinct.

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 states when to use this tool: for metadata questions not covered by the higher-level tools, and names those alternatives. It also gives a clear context: the query must be valid against Tableau's published Metadata API schema, with a note about error handling for malformed queries.

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

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

With no annotations, the description must disclose behavioral traits, but it only states the action (download). It does not mention potential prerequisites (e.g., datasource accessibility), whether the download is synchronous, file size implications, or error conditions. This lack of detail could mislead an agent about the tool's side effects or resource intensity.

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

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

The description is a single sentence of 14 words, front-loaded with the action ('Download') and resource. Every word contributes to meaning, and it avoids redundancy, making it highly efficient and easy to parse.

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

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

The tool has one simple parameter and an output schema, but no annotations. The description covers only the core purpose. It omits usage guidelines, parameter semantics, and behavioral nuances, making it incomplete for an agent to invoke reliably without additional context.

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

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

The schema has one required parameter (datasource_id) with 0% description coverage. The description does not explain what datasource_id means, where to find it, or any expected format. This is a significant gap for a single-parameter tool, forcing the agent to rely on the parameter name alone.

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

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

The description clearly states the tool's function with a specific verb ('Download'), the resource ('a data source's Hyper extract'), and the target location ('to local disk'). It also provides the intended use case ('for inspection or offline use'), which distinguishes it from sibling tools like preview_hyper_extract and export_view_image/csv.

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

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

The description implies the tool is for inspection or offline use but provides no explicit guidance on when to use this tool over alternatives (e.g., preview_hyper_extract). It does not mention exclusions or compare with related export/preview tools, leaving the selection decision entirely to the agent.

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

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

With no annotations, the description carries the full burden for behavioral disclosure. It only states what the tool does, not how the export is delivered, whether it is synchronous, what data is included, or any permissions/limits. This is insufficient for a tool with no 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?

The description is a single, well-structured sentence that is concise and front-loaded. It contains no redundant information and is easy to parse.

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

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

The tool is simple (one parameter, no nested objects) and an output schema exists, so return values are covered. However, the description lacks parameter elaboration and behavioral context, leaving gaps that are not filled elsewhere. It is minimally adequate but not 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 0%, so the description must compensate, but it does not explain the 'view_id' parameter at all. The only hint is the word 'view' in the description, which implies it refers to a view's ID, but this is not explicit and does not clarify how to obtain it.

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

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

The description clearly states the action ('Export'), the resource ('the underlying data of a view'), and the format ('as CSV'). It also clarifies that 'view' includes both worksheets and dashboards, distinguishing it from sibling tools like export_view_image and export_view_excel.

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 use when CSV data from a view is needed, and the mention of 'underlying data' and format distinguishes it from image/Excel exports. However, it does not explicitly list alternatives or state when not to use it, so it falls short of full guidance.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It adds value by describing the formatting details (frozen header, auto-filter, auto-fit) and the sheet_name default behavior. While it doesn't explicitly state read-only or permission requirements, 'export' implies a non-mutating operation, and the description is sufficiently transparent for this tool.

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

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

The description is three sentences long, front-loaded with the primary purpose, efficiently contrasts with the sibling tool, and ends with parameter guidance. Every sentence earns its place with no redundancy or fluff.

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

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

The tool is simple (2 params, no nested objects) and has an output schema, so return values need no description. The description covers the key aspects: what it does, why it differs from CSV, and the optional parameter behavior. It is complete for the tool's complexity.

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

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

Schema description coverage is 0%, so the description must compensate. It explains the 'sheet_name' parameter well (purpose and default), but does not explicitly explain 'view_id'. However, 'view_id' is obvious from the tool name and context ('view's underlying data'), so the gap is minor. Partial compensation for the low coverage warrants a 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?

The description clearly states the tool's function with a specific verb and resource: 'Export a view's underlying data as a formatted .xlsx workbook.' It also distinguishes itself from the sibling tool 'export_view_csv' by explaining the exact differences (bold frozen header, auto-filter, auto-fitted columns), making the purpose unambiguous.

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

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

The description explicitly names the alternative tool 'export_view_csv' and provides a clear comparison, implying when to use this tool (when a formatted spreadsheet is needed) versus the CSV export. This gives explicit usage guidance without needing further elaboration.

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

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

No annotations are provided, so the description carries the burden. It explains the filter behavior and its equivalence to Tableau URL parameters, which is helpful. However, it does not disclose potential prerequisites, permissions, or any side effects (e.g., whether a saved view is required or if results are time-limited).

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 action, followed by a concise parameter clarification. No wasted words; the example is directly useful.

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

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

With an output schema present, return value details are covered. The description covers the tool's core purpose and key parameter semantics. It lacks explicit usage boundaries (e.g., PDF vs PNG differences), but overall it's adequate for an export tool with 3 parameters.

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

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

The schema has 0% description coverage, but the description significantly compensates by explaining the non-obvious 'filters' parameter with an example and mapping to Tableau URL semantics. The other parameters (format, view_id) are self-explanatory from the schema's enum and required field, so the added value is solid.

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 exports a view (worksheet or dashboard) as PNG or PDF, which is a specific verb+resource+format. It implicitly distinguishes from sibling tools like export_view_csv and export_view_excel by format type.

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 a clear context for when to use (export to image/PDF with optional filters) but does not explicitly mention alternatives or when not to use it. Usage is implied rather than explicitly contrasted with sibling export 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?

With no annotations provided, the description carries the full burden. It discloses the return payload, the effect of include_screenshot, and even the behavior when export permissions are missing (metadata still returned, screenshot_error explains absence). No annotations to contradict.

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

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

The description is well-structured in three paragraphs, front-loading the core purpose, then usage guidance, then parameter specifics. Every sentence adds meaningful information without 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?

Given the tool's moderate complexity and the existence of an output schema, the description covers all necessary operational context: what it returns, when to use it, how parameters disambiguate, and edge-case behavior. It feels complete for an agent to select and invoke 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 0%, so the description compensates by explaining dashboard (name or view id), workbook/project as disambiguators, and include_screenshot's role. However, high_resolution is not mentioned at all, leaving one of five parameters undocumented. The others are well-explained.

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 starts with a specific verb and resource ('Get everything about a dashboard') and enumerates the exact outputs (metadata, URL, screenshot). It clearly distinguishes from siblings like get_workbook, get_dashboard_screenshot, and export_view_image by combining multiple data types into one call.

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 states when to use this tool: 'Use this as the default when the user asks to "analyze", "look at", "explain", or "tell me about" a dashboard.' It also explains how workbook/project disambiguate and notes the permission edge case, providing clear context for tool selection.

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

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

With no annotations provided, the description carries the burden of disclosing behavior. It explains how the dashboard parameter works (name or view id), how to disambiguate with workbook/project, and what the return value contains. It does not mention error handling or edge cases, but for a simple read-only link retrieval this is adequate.

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

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

The description is concise, front-loaded with the primary action, and includes a practical example. Every sentence adds value, with no filler.

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

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

For a simple tool, the description is complete: it explains inputs, outputs, and usage context. However, it does not differentiate itself from the sibling get_dashboard_links, nor mention potential errors or ambiguous-name behavior, which could lead to confusion in a tool listing with many related tools.

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

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

The description adds significant meaning to all three schema parameters: dashboard as name or view id, and workbook/project as optional name substrings for disambiguation. This goes well beyond the bare schema types and defaults.

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

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

The description clearly states the tool gets a direct, clickable Tableau URL for a dashboard or worksheet, using a specific verb and resource. It also includes an example and distinguishes itself from dashboard discovery tools like search_dashboards.

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 to call this whenever the user asks for a link or address, and provides disambiguation guidance for non-unique names via workbook/project. It does not explicitly mention when not to use it or contrast with sibling get_dashboard_links, 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?

With no annotations, the description carries the full burden. It details that Tableau's API returns fragments and that the tool assembles them into openable URLs, and it explains name-resolution behavior including error handling for duplicate names. This is helpful context beyond the mere existence of the tool.

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

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

The description is concise and well-structured, with three sentences each serving a distinct purpose: definition, usage trigger, and technical note. It is front-loaded with the core purpose and earns its length without fluff.

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

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

For a single-parameter tool with an output schema, the description covers all essential aspects: what it does, when to use it, parameter semantics, and a behavioral nuance (fragment assembly). No gaps remain for an agent 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?

The input schema only says 'workbook' can be string or integer, but the description adds substantial meaning: it may be name or id, names are resolved automatically, and duplicate names produce an error listing suggestions. This fully compensates for the 0% schema description coverage.

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

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

The description opens with a specific verb and resource: 'Get shareable browser URLs for a workbook and ALL its dashboards/sheets.' It clearly distinguishes from the sibling 'get_dashboard_link' by emphasizing the plural 'ALL,' making the tool's scope 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 states when to use the tool: 'Use this when the user asks for the link(s) to a *workbook* or "all the dashboards in <workbook>"' and provides an example. However, it does not explicitly mention when not to use it or point to an alternative for single-dashboard links, so it misses the 'when-not/alternatives' part 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?

With no annotations, the description carries the full burden. It discloses that the tool produces a rendered image, returns a file path, that the web UI renders that path inline, and what output fields are returned. It also notes optional behavior changes via high_resolution and as_pdf. It does not mention file lifetime or permissions, but is stronger than typical tool descriptions.

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 organized into clear sections: action/outcome, when-to-call with examples, parameter explanations, and return values. Every sentence adds value, and there is no redundant fluff.

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

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

For a 5-parameter tool with no annotations, the description is complete: it covers purpose, trigger conditions, all parameters, output contents, and format options. It is easy for an agent to select and invoke 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 0%, so the description compensates fully. It explains every parameter: dashboard as 'name or view id', workbook/project for disambiguation, high_resolution for sharper image, and as_pdf for PDF output. This adds meaningful semantics beyond the raw schema.

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

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

The description opens with a specific verb+resource: 'Capture a rendered image of a dashboard and return its file path.' It also provides concrete examples like 'show me the Sales dashboard' and differentiates from sibling export tools by focusing on an inline-rendered screenshot/PDF. This clearly serves the user-facing preview use case.

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 states when to call the tool: 'Call this when the user wants to see, preview, or get a picture/PNG of a dashboard.' It gives example phrasing and explains parameter disambiguation. It does not name sibling alternatives when not to use it, but the 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?

With no annotations, the description carries the full burden. The verb 'Get' implies a read-only retrieval with no side effects, and 'published' scopes the resource, but it does not disclose error behavior for nonexistent or unpublished IDs, permissions needed, or any rate limits.

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

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

The description is a single concise sentence of seven words, immediately front-loading the action and object. Every word contributes meaning, with no filler or redundancy.

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

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

For a simple getter with one required parameter and an output schema, the description covers the essential purpose and parameter usage. It does not need to explain return values due to the output schema, and it notes that the source must be published. Missing details are limited to error/permission behavior, which are less critical for a basic retrieval.

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

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

The sole parameter datasource_id has 0% schema description coverage. The description's 'by id' adds some meaning by indicating the parameter is a unique identifier, but it adds little beyond the parameter name and does not specify the ID format (e.g., LUID, name).

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 the specific verb 'Get' with the resource 'published data source' and specifies retrieval by id. This clearly differentiates it from sibling tools like list_datasources and search_datasources that return multiple 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?

No guidance is provided on when to use this tool over alternatives such as list_datasources or search_datasources. The phrase 'by id' implicitly requires a known datasource_id, but there is no explicit context on prerequisites or alternative selection.

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

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

With no annotations, the description carries the full burden. It adds useful context about the Metadata API and calculated fields, but does not disclose any side effects, permission requirements, or error behavior. Since this is a read operation, the lack of such details is less critical, but still a gap.

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

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

One concise sentence that front-loads the verb and resource. No wasted words or redundancy.

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

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

The tool is simple (one parameter, output schema present) and the description covers its core purpose. Missing details like connection prerequisites are minor given the output schema and sibling context. It earns a 4 for being nearly 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?

The schema has zero description coverage, leaving the description to clarify the parameter. The description implies datasource_luid refers to the published data source's LUID, but does not explicitly define it or explain its format/scope. This adds marginal value over the schema.

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

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

The description clearly states the tool lists fields of a published data source, including calculated fields with formulas, via the Tableau Metadata API. This distinguishes it from sibling tools like get_datasource or get_table_columns by focusing on field-level metadata.

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 context (listing fields on a published datasource) but provides no explicit guidance on when to choose this over alternatives like get_datasource or get_table_columns, nor any exclusions or prerequisites.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It only states the action without mentioning side effects, permissions, error handling, or whether the operation is read-only. This minimal description offers no added behavioral context beyond the basic function.

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 is clear and free of unnecessary words. Every part contributes directly to understanding the tool's function and input.

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 tool with an output schema, the description covers the essential function and input adequately. It does not explain return values since the output schema exists, but it lacks explicit comparison with sibling tools and any behavioral details, which keeps it from a perfect score.

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

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

The schema has one parameter 'job_id' with no description (0% coverage). The description says 'by id', which merely echoes the parameter name and does not add meaningful detail such as where to obtain the id, format, or examples. The added value over the schema is minimal.

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

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

The description clearly states the tool's action ('Get'), the resource ('status and progress of a background job'), and the method ('by id'). It effectively distinguishes this tool from siblings like list_jobs, wait_for_job, and cancel_job by focusing on retrieving details for a specific job.

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

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

The description implies usage for checking a specific background job by its id, but it does not explicitly state when to use this tool versus alternatives such as list_jobs or wait_for_job. No exclusions or alternative tool references are provided, so the guidance is only implicit.

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

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

No annotations are provided, and the description offers no additional behavioral context beyond the verb 'Get'—it does not mention permissions, not-found behavior, or side effects. The read-only implication is minimal.

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

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

The description is a single, focused sentence with no redundancy, perfectly sized for a simple getter.

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

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

With an output schema present and only one required parameter, the description provides sufficient context to understand the tool's scope. It omits error or edge-case behavior, but for a straightforward lookup this is likely acceptable.

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

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

The description maps the single parameter (project_id) to 'its id', giving basic semantic context. However, it doesn't elaborate on the ID format or any restrictions, so only marginal value beyond the schema.

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

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

The description uses a specific verb ('Get') with a specific resource ('a single Tableau project') and identifies the lookup key ('by its id'), clearly distinguishing it from sibling tools like list_projects or search_projects.

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

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

The description implies the tool is for fetching a known project by its unique ID. It provides clear context for when to use it (when you have the project ID), though it doesn't explicitly discuss alternatives or exclusions.

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

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

With no annotations, the description must carry the burden of behavioral disclosure. It states a read-only lookup but adds little beyond the tool name, omitting details such as authentication needs, rate limits, and how this resource differs from a metric definition or insights. The word 'Get' is minimally informative.

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

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

The description is a single, front-loaded sentence with no filler words. This is appropriately concise for a one-parameter lookup tool, even though it sacrifices contextual richness.

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

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

Given the simple signature and presence of an output schema, the description is mostly adequate for invoking the tool with a known metric_id. However, the lack of usage guidance and confusion with related Pulse metric tools mean the description is not fully complete for safe tool selection in a large sibling set.

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

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

The phrase 'by id' maps metric_id to its role as the identifier, and the schema marks it as a required string. However, the description does not explain how to obtain the id or any format expectations, leaving the parameter semantics only partially clarified.

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

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

The description uses a specific verb ('Get') and identifies the resource as 'a single Tableau Pulse metric' with an id. It is clear, but it does not explicitly distinguish this from the sibling get_pulse_metric_definition, which could be confused for the same action.

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 usage guidance is provided. The description does not mention when to use this tool instead of list_pulse_metrics, get_pulse_metric_definition, or get_pulse_metric_insights, nor does it give any exclusions or alternative recommendations.

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

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

There are no annotations, so the description carries the full burden. The verb 'get' implies a read-only operation, but the description does not explicitly state whether the operation is safe, what happens for invalid IDs, or any authentication requirements. However, for a simple retrieval tool, the action is reasonably 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 a single sentence with zero wasted words. It front-loads the verb and resource, making the purpose immediately clear.

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

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

The tool is simple and has an output schema, so return values are documented elsewhere. However, given the many related Pulse tools listed as siblings, the description does not clarify the relationship between 'metric definition' and 'metric', nor does it provide any usage context or restrictions. It is minimally adequate for a straightforward get-by-id operation.

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

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

Schema description coverage is 0%, but the description directly mentions 'by id', which explains the purpose of the sole parameter definition_id (it is the identifier used to fetch a single definition). This provides minimal but sufficient meaning for a simple ID parameter, though it does not elaborate on ID format or origin.

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 'Get a single Tableau Pulse metric definition by id' uses a specific verb ('get'), resource ('metric definition'), and scope ('by id'), clearly distinguishing it from siblings like list_pulse_metric_definitions (which lists all) and get_pulse_metric (which retrieves a metric, not a definition).

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

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

The description provides no guidance on when to use this tool versus alternatives, nor does it mention exclusions or prerequisites. There are no references to related tools like list_pulse_metric_definitions or get_pulse_metric, leaving the agent without explicit selection criteria.

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

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

With no annotations, the description carries the full burden. It transparently explains what the tool returns and how bundle_type affects generation depth, including the default behavior. However, it does not disclose potential costs, required permissions, error conditions, or any side effects. This is a partial disclosure, not a comprehensive one.

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

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

The description is concise and well-structured: the first sentence states the tool's primary purpose, the second details parameter options. No redundant or filler content. It is front-loaded with the most important information 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?

Given that an output schema exists (though not shown), the description doesn't need to explain return values. It covers the tool's purpose, main output components, and parameter behavior, which is sufficient for a tool of moderate complexity. The only notable gap is the lack of explicit comparison to sibling tools, but this does not undermine overall completeness.

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

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

Schema description coverage is 0%, so the description must compensate. It adds significant meaning for bundle_type by listing valid values and explaining the default ('ban') and what each output includes. metric_id is not explicitly described, but its name and the context ('for a metric') make it self-evident. The description adds value beyond the raw schema.

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

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

The description uses a specific verb ('Get') and clearly identifies the resource ('Tableau Pulse's generated insight bundle for a metric') and what it includes (current value, period-over-period change, narrative). This effectively distinguishes it from sibling tools like get_pulse_metric (which likely returns raw metric data) and list_pulse_metrics.

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 accessing generated insights and explains the bundle_type options, but it does not explicitly state when to prefer this tool over alternatives such as get_pulse_metric or list_pulse_metrics. No exclusion or alternative-selection guidance is provided, leaving it to the agent to infer.

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

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

No annotations are provided, so the description must convey behavioral traits. It discloses that the table must be 'known to Tableau's metadata graph' and lists the returned metadata fields, but it does not mention potential errors, permissions, or whether it is a read-only operation.

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

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

The description is a single, front-loaded sentence that immediately states the purpose and key details. It contains no filler or redundant content, making it highly concise and well-structured.

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

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

Given the tool's simplicity and the presence of an output schema, the description sufficiently covers the purpose and scope. It could mention error cases or prerequisites, but for a single-parameter metadata getter, it is reasonably 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?

There is one parameter, table_luid, with no schema description (0% coverage). The description indirectly implies table_luid identifies the upstream table, but it does not explicitly define the parameter or provide examples. This is adequate but leaves some interpretation.

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

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

The description clearly states the tool's function: 'Get column-level metadata (name, remote type, description)'. It specifies the resource type ('upstream database table') and the context ('known to Tableau's metadata graph'), which distinguishes it from sibling tools like get_datasource_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 provides clear context: it is for tables already known to the metadata graph. However, it does not explicitly mention when to use this tool over alternatives or exclude other scenarios, such as tables not in the metadata graph.

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

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

With no annotations, the description carries the full burden. It states what the tool does and that the result includes the site role, but it does not disclose potential error behavior, authentication requirements, or any side effects. The read-only nature is implied by 'get', and the description is not misleading, but it lacks explicit safety or limitation information.

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, short sentence (10 words) that directly states the core functionality. There is no redundancy, filler, or unnecessary detail. Every word contributes to the meaning.

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 tool with one parameter and an existing output schema, the description covers the essential purpose and a key output characteristic (site role). The output schema presumably details the return structure, so that is not a gap. However, it lacks any usage guidance or explicit read-only assurance, which prevents a perfect score.

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

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

The schema has one parameter, user_id, with no description (0% coverage). The tool description only says 'by id', which adds no meaning beyond the parameter name itself. It does not clarify the type or format of the id (e.g., UUID, email) or any constraints, so the description fails to compensate for the missing schema descriptions.

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

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

The description clearly states the verb ('Get') and resource ('user by id'), and adds a specific detail ('including their site role'). This distinguishes it from siblings like list_users (which lists all users), create_user, update_user, etc. The purpose is unambiguous and specific.

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

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

The description implies the usage: fetch a single user by id. It provides clear context for when to use this tool (when you need one user's details) without explicitly naming alternatives like list_users for fetching all users. There are no exclusions stated, but the scope ('single user') gives sufficient guidance.

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

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

No annotations are provided, so the description carries the full burden. It adds valuable context that the response includes worksheets/dashboards (views), which is a behavioral detail beyond the basic 'get by id'. It does not discuss permissions or error conditions, but for a read-only getter this is acceptable.

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

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

The description is a single, direct sentence, front-loaded with the action and resource. It includes a useful extra detail about views without any unnecessary words.

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

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

For a simple getter with one parameter, the description communicates the purpose and the key additional detail (inclusion of views). The output schema covers the return structure, making the description sufficiently complete for correct use.

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

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

The schema has one parameter (workbook_id) with no description, and the description only says 'by id' without explaining the ID format or how to obtain it. With 0% schema coverage, the description does not compensate, leaving room for ambiguity.

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 ('Get') and the resource ('a workbook by id'), with an explicit note that the response includes worksheets/dashboards (views). This distinguishes it from sibling tools like list_workbooks or get_workbook_lineage.

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

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

The description implies usage when a workbook ID is known, but it does not explicitly mention alternatives or exclusions. It relies on the reader to infer that it is for single-item retrieval rather than listing or searching.

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

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

With no annotations, the description carries the burden and does well by explicitly stating it uses the Tableau Metadata API and focuses on upstream lineage. It implies a read-only operation without explicitly saying so, but the 'get' verb and metadata scope make the behavior clear. No contradictions.

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 announces the functionality, the second clarifies the key parameter. Every word earns its place, and the structure is front-loaded with the main purpose.

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

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

The tool is simple (one required parameter, output schema present), and the description provides the core purpose, scope, and parameter provenance. This is sufficient for reliable invocation without needing extra detail.

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 provides no parameter descriptions (0% coverage), but the description fully compensates by defining `workbook_luid` as the workbook's LUID and pointing to get_workbook/list_workbooks for obtaining it. This resolves all ambiguity.

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

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

The description clearly states the tool retrieves upstream data lineage for a workbook, specifying what that includes (published data sources and database tables) and the underlying API. This distinguishes it from sibling tools like get_workbook or list_datasources.

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

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

The description establishes the use case clearly (get upstream lineage) without explicitly naming alternatives or exclusions. The context is sufficient for an agent to decide when to invoke it, though it could better contrast with related lineage/field tools like get_datasource_fields or get_table_columns.

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

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

With no annotations, the description carries the transparency burden. It discloses key behavioral constraints: only published datasources visible to the signed-in user are returned, and results are paginated. This adds meaningful context beyond the tool name, though it omits potential details like ordering or error 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 a single, front-loaded sentence with no filler, efficiently stating the verb, resource, and scope.

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 paginated list tool with an output schema, the description covers the essential context: published status, user visibility, and pagination. It stops short of being fully complete by not differentiating from search_datasources, but the core information 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 schema provides no property descriptions (0% coverage), so the description must compensate. It only says 'paginated' without explaining how page_size and page_number affect results, leaving the parameters under-documented despite their simple names.

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

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

The description clearly states the action ('List'), the resource ('published data sources'), and the scope ('visible to the signed-in user, paginated'), distinguishing it from sibling list tools like list_jobs or list_workbooks.

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 enumerating paginated datasources accessible to the current user, but it does not explicitly mention alternatives such as search_datasources or get_datasource, nor does it state when not to use this tool.

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

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

With no annotations, the description carries the full burden. It adds a scope ('on the current Tableau site') but does not disclose pagination behavior, which is relevant given the page_size and page_number parameters. It also does not state whether it is read-only or if any filtering applies. The minimal description leaves key behavioral traits undocumented.

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

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

The description is a single, front-loaded sentence with no filler. Every word contributes meaning, and it is appropriately sized for a simple list operation.

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

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

The tool has a simple list operation with an output schema, so return values need not be described. However, the description omits pagination behavior, which is essential given the schema parameters. The 'current Tableau site' scope is a useful context, but the missing pagination guidance leaves it incomplete.

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

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

Schema description coverage is 0%, and the description provides no explanation of page_size or page_number. The tool description does not compensate for the absence of parameter descriptions, leaving the agent to infer pagination semantics solely from parameter names and defaults.

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

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

The description uses a specific verb ('List'), names the resource ('groups'), and scopes it ('on the current Tableau site'). This clearly distinguishes it from siblings like list_projects or list_users, and from group management tools like create_group or delete_group.

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 its use: to list groups on the current site. However, it does not explicitly state when not to use it or mention alternatives. The context of being a list operation alongside create/delete/modify group tools gives some implied usage guidance, but no explicit exclusions or alternative suggestions 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?

With no annotations, the description carries the burden. It clearly indicates a read-only listing operation and scopes to local .hyper files, but it does not disclose error behavior, file existence requirements, or that no modifications occur. This is minimal but not misleading.

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

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

The description is a single, front-loaded sentence with no redundant words. Every word contributes to clarifying what the tool does and its scope.

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

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

For a simple list tool with one parameter and an output schema, the description is mostly sufficient. It clearly states the input is a local .hyper file and the output is tables/columns, though it lacks explicit note about error handling or comparison to sibling tools.

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

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

Schema description coverage is 0%, so the description must compensate. It indirectly clarifies that file_path is a path to a local .hyper extract file, but it does not explicitly describe the parameter format, path requirements, or potential validation. Some meaning is added beyond the bare string 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 clearly identifies the resource ('tables (and their columns)') and scope ('contained in a local .hyper extract file'). This distinguishes it from siblings like preview_hyper_extract or get_table_columns by scoping to local extract files.

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 inspecting local .hyper extract files, but it provides no explicit when-to-use guidance or alternatives. It does not mention how this tool relates to preview_hyper_extract or get_table_columns, so the context is present but not fully articulated.

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

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

No annotations are present, so the description carries the full burden. It states what jobs are listed but does not disclose pagination behavior, read-only nature, or any side effects. The examples of job types add some context, but critical behavioral details like the use of page_size/page_number are absent.

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

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

The description is a single concise sentence that front-loads the action and resource. Every word earns its place, with no redundant information 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 list tool with an output schema, the description is adequate in stating what is listed and gives site scope ('on the site'). However, it lacks any note about pagination or how to access later pages, leaving the agent to rely on the schema. The output schema covers return values, so this is not a major gap, but the missing pagination note prevents a higher score.

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

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

Schema coverage is 0% and the description does not mention page_size or page_number. The description adds no meaning beyond the schema's field names and defaults. An agent must infer pagination semantics entirely from the parameter names, which is insufficient given the low 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 uses a specific verb 'List' and resource 'background jobs', and further clarifies the resource with examples: 'extract refreshes, publishes, subscriptions'. This clearly distinguishes it from sibling tools like get_job (singular) and list_schedules (a different resource type).

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

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

The description does not mention when to use this tool versus alternatives like get_job or list_schedules. There is no guidance on pagination, filtering, or exclusions. Usage is only implied by the verb 'List', but no explicit context or alternative tool references are provided.

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

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

No annotations are provided, so the description carries the full burden. It discloses the tool's read-only nature by using 'List' and details the output fields (name, description, order, lowest enabling level), which adds meaningful behavioral context beyond a bare statement of purpose.

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

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

The description is concise and well-structured: a one-sentence main purpose followed by a single explanatory sentence. Every word contributes to understanding the tool's function and 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?

With no parameters and a likely output schema, the description covers the essential context: what is listed, the fields shown, and the decision support use case. It is fully adequate for a simple list operation.

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

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

The tool takes zero parameters, and the input schema is empty (100% coverage). The description adds value by explaining what the output contains, fulfilling the baseline for zero-parameter tools.

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

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

The description clearly states the tool's purpose: 'List the token-optimization strategies this server can apply.' It identifies a specific resource (optimization strategies) and a specific action (list), and distinguishes itself from sibling tools like optimize_tokens and estimate_tokens by focusing on enumerating available strategies.

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

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

The description explains when the tool is useful: 'useful for deciding which level to ask for, or which strategies to disable.' This provides clear context for use, though it does not explicitly exclude alternative tools 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?

With no annotations provided, the description discloses important behavioral traits: the results are scoped to the signed-in user and the output is paginated. The term 'List' implies a read-only operation, but this is not explicitly stated. Despite that, the description adds meaningful context beyond the name.

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 conveys purpose, scope, and pagination without any wasted words. It is appropriately concise.

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

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

For a simple list tool with an output schema, the description covers the essential aspects: what is listed, for whom, and that pagination is used. The lack of explicit alternative usage guidance is a minor gap, but overall it is sufficiently complete for an agent to select and invoke the 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 two parameters (page_size, page_number) with defaults, but the description only says 'paginated' without explaining how these parameters control pagination or what values are expected. Since schema description coverage is 0%, the description should compensate but does not add parameter-level 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 clearly specifies the action ('List') and the resource ('Tableau projects (folders)'), and distinguishes from sibling tools like get_project (singular) and search_projects (search-based). The scope ('visible to the signed-in user') adds precision.

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 for when to use the tool (to list projects visible to the user) but does not explicitly mention alternatives like search_projects for filtering or get_project for a single project. No exclusions or when-not-to-use guidance is given, so it falls 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?

With no annotations, the description carries the full burden. It discloses token-based paging behavior, including the `total_available` and `next_page_token` fields, which is a non-obvious behavioral detail. It does not explicitly state read-only nature or permission requirements, but 'List' implies a safe read operation and the paging detail adds value beyond what the schema provides.

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 composed of three short, focused paragraphs. The first sentence states the action and resource, the second clarifies the domain concept, and the third explains paging. Every sentence earns its place, and the most important information is front-loaded. 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?

An output schema exists, so return values are documented. The description covers the core purpose, the definition concept, and paging mechanics, which is sufficient for a list operation. Slight gaps: no explicit mention of permission context, and no comparison to related metric tools, but these are not critical given the clarity and the presence 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 input schema has 0% description coverage, so the description must compensate. It explains `page_token` clearly by describing the `next_page_token` mechanics, but `page_size` is left to inference. This is partial compensation, but not complete parameter documentation. The term 'page_size' is self-explanatory, but the description could have noted defaults or limits.

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 starts with a specific verb and resource: 'List Tableau Pulse metric definitions on the site.' It clearly explains what a metric definition is (a reusable template), distinguishing this from the sibling list_pulse_metrics which lists individual metrics. This is a clear, differentiating purpose statement.

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 by explaining the conceptual role of metric definitions vs. metric instances, implying when this tool should be used. However, it does not explicitly name alternatives or state when not to use it. Most list tools in the sibling set have implicit usage contexts, and this one is clear enough without explicit exclusions.

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

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

With no annotations, the description carries the transparency burden. It adds useful context: each metric applies the definition's measure to a filtered scope and appears as a card in the UI. However, it does not mention pagination behavior (page_size/page_token), whether the operation is read-only (though 'List' implies it), or any access constraints. Some behavioral context is provided, but not a complete picture.

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 the first stating the core function clearly and the second adding valuable context about what the metrics represent and how they relate to definitions. No extraneous words; the structure is front-loaded and efficient.

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

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

An output schema exists, so return values are handled. The description adds useful domain context about the definition-to-metric relationship and UI representation. However, it does not mention pagination parameters or explicitly tie definition_id to the required input. For a simple list operation, it is adequate but leaves minor gaps.

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

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

Schema description coverage is 0%, so the description must compensate for the lack of parameter documentation. It clarifies the role of definition_id (identifies the metric definition), but completely omits page_size and page_token. For a 3-parameter tool with no schema descriptions, this is insufficient.

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

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

The description clearly states the action ('List') and the exact object: 'individual Pulse metrics instantiated from a metric definition.' This distinguishes it from sibling tools like list_pulse_metric_definitions (which lists definitions) and get_pulse_metric (which gets a single metric). The 'instantiated from a metric definition' qualifier removes ambiguity.

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

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

The description implies when to use the tool: when you need the per-scope metric cards derived from a specific definition. It contrasts these metrics with the definition itself and notes they appear in the Pulse UI. However, it does not explicitly name alternatives or state when not to use it, so it stops short of fully explicit usage guidance.

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

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

No annotations are provided, so the description carries the full burden. It states a read-only list operation but does not disclose pagination behavior or any other side effects. However, the simplicity of a list operation makes this adequate, though not rich.

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

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

The description is a single sentence that directly states the tool's purpose with no filler or redundancy. It is front-loaded with the verb 'List' and immediately identifies the resource.

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

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

For a simple list tool with an output schema, the description is mostly complete. It conveys the resource type and scope. However, it omits pagination context, which is relevant given the schema parameters, but this is a minor gap for such a straightforward operation.

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 description coverage is 0%, and the description does not mention page_size or page_number at all. The parameter names and defaults provide some semantics, but the description does not compensate for the lack of schema descriptions, leaving pagination behavior ambiguous.

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

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

The description explicitly states the tool lists extract-refresh and subscription schedules on the server, providing a specific verb and resource. It clearly distinguishes from sibling list tools (e.g., list_jobs, list_workbooks) by focusing on schedules.

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—anytime schedule information is needed—but does not explicitly mention alternatives or exclusion scenarios. It lacks explicit comparison to other list tools, though the resource type makes the usage fairly evident.

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

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

No annotations are provided, so the description must disclose behavioral traits. It mentions the admin role requirement, which is useful, and implies read-only operation. However, it does not describe pagination behavior or that the tool returns a list of users with fields. The description is minimal but not misleading.

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

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

The description is a single concise sentence that is front-loaded with the core action. It does not waste words and is easily parseable.

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

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

Given the tool's simplicity (two optional integer params, output schema present), the description provides essential context: scope (current site) and permission (admin role). However, it omits explicit guidance on pagination or alternatives, so completeness is adequate but not thorough.

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

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

The schema has two parameters (page_size, page_number) with 0% description coverage, and the description does not mention them or explain pagination. The parameter names are self-explanatory, but the description fails to clarify that results are paginated, which is a key semantic gap for an agent.

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

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

The description clearly states the tool lists users on the current Tableau site, using a specific verb and resource. It distinguishes from sibling tools like list_groups (different resource) and get_user (single user), and the scope 'current Tableau site' adds clarity.

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 includes a prerequisite (administrative site role), which implies when it should be used. However, it does not explicitly mention alternatives or contrast with get_user or search_workbooks. The usage context is present but not fully developed.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It discloses the visibility scope ('visible to the signed-in user') and pagination, which are useful behavioral traits. However, it does not mention sorting, default page size behavior beyond schema defaults, or whether it returns summary or full workbook objects. This is adequate but not richly transparent, warranting a 3.

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

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

The description is a single sentence of nine words, directly stating the action, resource, scope, and pagination. It is front-loaded with the verb and contains no redundant information. Every word earns its place, making it exceptionally concise and well-structured.

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

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

For a simple list tool with two optional, defaulted parameters and an output schema, the description covers the essential context: what is listed and that it is paginated. Since an output schema exists, return values are described elsewhere. The description is complete enough for the tool's simplicity, though it could add a note about typical use cases or permissions, but that is already implied. A score of 4 is justified.

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

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

Schema description coverage is 0%, and the description does not compensate. It only says 'paginated,' which hints at pagination parameters but does not explain page_size or page_number semantics. The schema offers only type and default, leaving the agent to infer the meaning. The description adds minimal value for understanding parameters, so a score of 2 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 lists Tableau workbooks visible to the signed-in user, with pagination. The verb 'List' plus the resource 'workbooks' and scope 'visible to the signed-in user' precisely conveys its function and distinguishes it from sibling tools like search_workbooks or get_workbook.

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: it lists all workbooks accessible to the current user, with pagination. While it does not explicitly mention alternatives or exclusions, the scope and pagination hint at its typical use case. It implies usage rather than explicitly stating when to use it over search_workbooks, but the clarity of the description earns a solid 4.

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

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

With no annotations provided, the description bears full responsibility for conveying safety and behavior. It only states the action ('List'), implying a read-only operation, but does not explicitly confirm it is read-only, nor does it mention potential filtering, pagination, or whether hidden views are included. This lack of behavioral disclosure is a gap.

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

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

The description is a single sentence, front-loads the action and resource, and contains no superfluous information. It is highly concise and structured effectively.

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

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

For a simple list tool with an output schema and a single obvious parameter, the description covers the core purpose. However, it lacks supplementary context such as when to use it versus alternatives and any caveats about behavior (e.g., read-only or hidden views). The overall completeness is adequate but not detailed.

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 one parameter, workbook_id, with no description (schema coverage 0%). The description does not elaborate on the parameter's meaning or format, only indirectly referencing 'a workbook' in the purpose. This adds minimal value beyond the schema's parameter name and type.

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 that the tool lists worksheets and dashboards (views) within a workbook. It uses a specific verb ('List') and resource ('workbook views'), and clarifies that 'views' includes both worksheets and dashboards, distinguishing it from sibling tools like list_workbooks (which list workbooks) and export_view_image (which export individual 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 no explicit guidance on when to use this tool versus alternatives such as get_workbook or export_view_*. The purpose itself implies it is for retrieving the list of views in a specific workbook, but no alternatives or exclusions are mentioned.

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

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

With no annotations, the description carries full burden and does an excellent job: it lists the exact ambiguities checked, discloses return value ('issues found, a refined phrasing, and suggested tools'), and clarifies it's 'analysis, not an answer'. This provides rich behavioral context beyond what schema alone offers.

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 yet information-dense, with a clear first sentence stating the core purpose, followed by concise usage guidance, behavioral specifics, and a final expectation-setting statement. Every sentence contributes value without fluff.

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

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

Given the simple schema (1 parameter), no annotations, and the presence of an output schema, the description is remarkably complete: it covers input, output, behavior, limitations, and post-conditions. It fully equips an agent to decide when and how to invoke 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?

With 0% schema description coverage for the sole parameter 'question', the description fully compensates by explaining the parameter's purpose (a vague Tableau question), what makes it ambiguous (examples), and how the tool processes it. This adds significant meaning beyond the bare 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 ('sharpen') with a clear resource ('vague Tableau question') and states the outcome ('can be answered precisely'). It distinguishes itself from sibling tools by positioning itself as a pre-processing/analysis step that identifies underspecified aspects and suggests tools.

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 states when to call ('when a request is ambiguous'), when in the workflow ('before running a broad search'), and what to do with the result ('ask a better question or confirm intent'). It also implies alternatives by noting it helps identify 'which tools fit', making the usage context very 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?

With no annotations provided, the description carries the full burden of disclosing behavior. It is exceptionally transparent: it states what is returned (optimized prompt plus detailed token accounting), the exact structure of 'messages' and 'context_blocks', the behavior of each optimization level, and that an unknown model id degrades to estimates rather than failing. It also warns that context blocks are filtered by relevance, which is a significant behavioral trait.

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 yet dense, organized by parameter with clear code-style formatting. Every sentence adds value: it front-loads the purpose, then systematically explains messages, context_blocks, level, and budget. There is no filler, and the structure makes scanning easy.

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

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

Given the tool's complexity (8 parameters, three levels, multiple optimization modes) and the presence of an output schema, the description is mostly complete but has gaps. It thoroughly explains the core parameters and behavior, but omits 'system', 'query' (beyond a passing reference), and 'max_output_tokens', which would be needed for full autonomous invocation.

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

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

Schema description coverage is 0%, so the description must compensate. It does so for 'messages' (full object structure, required fields, pinned flag), 'context_blocks' (structure and relevance filtering), 'level' (three modes with meanings), 'max_input_tokens' (hard budget semantics), and 'model' (tokenizer/pricing, fallback behavior). However, it leaves 'query', 'system', and 'max_output_tokens' undefined, and it references 'query' without explaining it, which is a gap.

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

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

The description opens with a specific verb and resource: 'Shrink a prompt's token cost while preserving its meaning.' It clearly distinguishes this from sibling tools like estimate_tokens (which likely only counts tokens) and optimize_prompt (which may optimize for other goals) by focusing on token-cost reduction and returning a full accounting of savings.

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: it explains how to mark a live question with 'pinned: true' to prevent trimming, which level ('low', 'medium', 'high') to choose based on safety vs. aggressiveness, and the role of 'max_input_tokens'. It does not explicitly name alternative tools or exclusions, but the level descriptions effectively serve as guidance for when to use more or less aggressive optimization.

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

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

No annotations are provided, so the description must carry the transparency burden. It clearly indicates a non-destructive read operation and limits scope to local .hyper files with a row cap. However, it does not disclose ordering, behavior when table_name is null, error handling, or whether the returned rows follow any particular ordering.

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

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

The description is a single, front-loaded sentence with no wasted words. It states the action, the object, the scope, and the motivating use case efficiently.

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

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

An output schema exists, so return-value details are handled elsewhere. The description sufficiently covers the tool's purpose, file scope, row limit, and common use case. The main gap is the undocumented `table_name` parameter and its relationship to sibling tools like list_hyper_tables, but overall the description is complete enough for a simple preview 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?

Schema description coverage is 0%, so the description must compensate. It explicitly defines `limit` as a row cap and `file_path` as the local .hyper location, but `table_name` is completely unexplained. This leaves one of three parameters underspecified, though the most critical parameters are covered.

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: 'Read up to `limit` rows from a local .hyper extract file'. It clearly distinguishes this from sibling tools by focusing on row-level preview of a local extract, and the use case of inspecting contents without opening Tableau Desktop.

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 a concrete context for use by example: 'e.g. one just downloaded via export_datasource_extract'. It explains why the tool is useful (inspect without opening Tableau Desktop), but it does not name alternatives or explicitly 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?

With no annotations provided, the description must convey behavioral traits. It only states the basic action without disclosing side effects (e.g., upload to server), requirements (e.g., authentication), or the meaning of the 'overwrite' parameter. This leaves significant behavioral ambiguity.

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 leads with the verb and specifies the exact action and resource. It contains no unnecessary words 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?

Despite having an output schema, the description lacks essential context for a publish operation: no usage guidance, no parameter explanations, and no behavioral disclosures. Given the tool's complexity (4 parameters, 2 required) and lack of annotations, the description is too sparse to be fully 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?

The schema has 0% description coverage, and the description does not explain any of the four parameters. It mentions file types, which hints at file_path, but does not clarify the roles of name, overwrite, or project_id, leaving the agent to infer their semantics from names alone.

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

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

The description clearly states the action ('Publish'), the resource ('data source'), and the input types ('.tds/.tdsx/.hyper file'). The word 'new' distinguishes it from update operations, and the resource type differentiates it from sibling tools like publish_workbook.

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

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

The description provides no guidance on when to use this tool versus alternatives, such as update_datasource or export_datasource_extract. There is no mention of prerequisites, use cases, or exclusions, leaving the agent without situational context.

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

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

Since no annotations are provided, the description carries the disclosure burden. It reveals the role requirement and the overwrite behavior (replace existing workbook), giving insight into side effects. It does not mention potential failure modes or long-running uploads, but the essential behavior 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?

Two concise sentences perfectly front-loaded with the primary action, followed by a permission note and overwrite guidance. Every sentence adds value 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?

Core action, role requirement, and overwrite semantics are covered, and presence of an output schema means return values are handled. However, several optional parameters remain unexplained and there are no explicit error conditions or prerequisites beyond the role, making the description adequate but incomplete for a 6-parameter 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?

With 0% schema description coverage, the description adds meaning for file_path (local .twbx/.twb), project_id (given project), and overwrite (replacement). However, it does not explain name, show_tabs, or skip_connection_check, leaving half the parameters semantically undocumented.

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

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

The description clearly states the action: 'Publish a local .twbx/.twb file to Tableau Server/Cloud under the given project.' This uses a specific verb and resource, and distinguishes it from sibling tools like download_workbook, update_workbook, or delete_workbook.

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

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

Provides clear guidance on prerequisites ('Requires Creator-level...') and when to set overwrite=True for replacing an existing workbook. It does not explicitly name alternative tools for updating or deleting, but the publishing context is unambiguous.

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

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

No annotations are provided, so the description bears the full burden. It discloses the async trigger behavior and the return of a job id, which is useful. However, it omits potential side effects (e.g., overwriting existing extracts), permission requirements, or behavior when a refresh is already in progress, leaving transparency incomplete.

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: two sentences, no redundant information, and the key action is front-loaded. Every word contributes to understanding the tool's purpose and usage.

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

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

The tool is relatively simple, and the description conveys the core flow (trigger and poll via get_job). The output schema likely defines the return structure, but the lack of parameter details and annotations means the agent may miss nuances like the meaning of 'incremental' or prerequisites. It is adequate but not fully comprehensive.

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

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

Schema coverage is 0%, and the description does not mention either parameter. 'datasource_id' is reasonably self-explanatory, but 'incremental' lacks explanation about what an incremental refresh entails versus a full refresh. The description adds no semantic value beyond the schema's property names, which is insufficient for parameters with potential ambiguity.

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 ('Trigger an extract refresh') and the resource ('a data source'). It distinguishes from sibling tools like refresh_workbook and export_datasource_extract by specifying the data source context and the async job id return, which directly supports the use case.

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 the asynchronous workflow by stating 'Returns the async job id to poll via get_job', guiding the agent to use get_job for follow-up. It does not explicitly contrast with other refresh/export tools, so it lacks exclusions, but the primary 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?

With no annotations, the description carries the full burden. It clearly discloses the asynchronous nature of the operation and the return of a job id, which is essential for the agent to know. It does not, however, disclose potential side effects like whether the refresh overwrites data or if there are rate limits, but for a simple trigger this is reasonably 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 two concise sentences that front-load the core action and then state the return value. Every word earns its place, with 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?

Given the tool's low complexity (one parameter) and the presence of an output schema, the description suffices by stating the action and the critical async behavior. It could be more complete by mentioning what the poll via get_job yields or any prerequisites, but the existing details cover the essential workflow.

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

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

The schema has one required parameter, workbook_id, with zero description coverage. The parameter name is self-explanatory and aligns with the tool's purpose ('for a workbook'), so the agent can infer its meaning. Yet the description does not add any explicit meaning beyond the schema, and the low coverage means some compensation is expected, which is minimal.

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 the specific verb 'Trigger' with the resource 'extract refresh for a workbook', which precisely states the tool's function and distinguishes it from sibling refresh_datasource. The addition of returning an async job id for polling via get_job further clarifies 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?

The description explicitly instructs the agent to poll the returned job id via get_job, providing a clear follow-up action. However, it does not mention any conditions for when to use this tool over other refresh options, though the sibling refresh_datasource is implied as the alternative for datasource-level refreshes.

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

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

With no annotations, the description carries the full burden. It discloses a key behavioral trait: it does not delete the server-level account. However, it does not mention reversibility, permissions required, or effects on group memberships. This is a meaningful but incomplete disclosure.

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

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

The description is a single, concise sentence that front-loads the action and immediately provides a crucial clarification. Every word 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?

The tool is simple (one parameter) and has an output schema, so the description need not explain return values. It covers the core action and the key non-destructive nuance. It is sufficiently complete for a low-complexity tool, though it could benefit from noting the 'site' context more explicitly.

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

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

The schema has 0% description coverage and the description does not mention the user_id parameter. The parameter name is self-explanatory, but no additional context is provided about what kind of ID is expected or where it comes from. The description fails to compensate for the lack of schema documentation.

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

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

The description uses the specific verb 'Remove' with the resource 'user from the current site,' immediately clarifying the action and scope. It also distinguishes from sibling tools like remove_user_from_group by specifying 'current site,' and the note about not deleting the server-level account further refines 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?

The description provides clear context that this tool removes a user from a site but not from the server, which implicitly tells the agent when to use this tool vs. a hypothetical server-level deletion tool. While it doesn't explicitly name alternatives, the exclusion is a useful guidance.

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

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

With no annotations, the description carries the full burden of behavioral disclosure, but it only states the action without mentioning side effects, permission requirements, or the outcome if the user is not in the group. This is minimal for a mutation tool.

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

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

The description is a single, direct sentence that is appropriately concise and front-loaded. It wastes no words and communicates the core action immediately.

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

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

The description is extremely minimal and omits important contextual details such as prerequisites, side effects, or behavior for edge cases (e.g., non-existent user or group). While the tool is simple, the lack of context could lead to incorrect usage by an agent.

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